falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
Browse Source

avfilter: add afirsrc filter

tags/n4.3
Paul B Mahol 5 years ago
parent
0f0f2ab0c3
commit
ae5a435300
6 changed files with 372 additions and 1 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +1
    -0
      Changelog
  2. +38
    -0
      doc/filters.texi
  3. +1
    -0
      libavfilter/Makefile
  4. +1
    -0
      libavfilter/allfilters.c
  5. +330
    -0
      libavfilter/asrc_afirsrc.c
  6. +1
    -1
      libavfilter/version.h

+ 1
- 0
Changelog View File

@@ -34,6 +34,7 @@ version <next>:
- Argonaut Games ASF demuxer
- xfade video filter
- xfade_opencl filter
- afirsrc audio filter source


version 4.2:


+ 38
- 0
doc/filters.texi View File

@@ -5857,6 +5857,44 @@ aevalsrc="0.1*sin(2*PI*(360-2.5/2)*t) | 0.1*sin(2*PI*(360+2.5/2)*t)"

@end itemize

@section afirsrc

Generate a FIR coefficients using frequency sampling method.

The resulting stream can be used with @ref{afir} filter for filtering the audio signal.

The filter accepts the following options:

@table @option
@item taps, t
Set number of filter coefficents in output audio stream.
Default value is 1025.

@item frequency, f
Set frequency points from where magnitude and phase are set.
This must be in non decreasing order, and first element must be 0, while last element
must be 1. Elements are separated by white spaces.

@item magnitude, m
Set magnitude value for every frequency point set by @option{frequency}.
Number of values must be same as number of frequency points.
Values are separated by white spaces.

@item phase, p
Set phase value for every frequency point set by @option{frequency}.
Number of values must be same as number of frequency points.
Values are separated by white spaces.

@item sample_rate, r
Set sample rate, default is 44100.

@item nb_samples, n
Set number of samples per each frame. Default is 1024.

@item win_func, w
Set window function. Default is blackman.
@end table

@section anullsrc

The null audio source, return unprocessed audio frames. It is mainly useful


+ 1
- 0
libavfilter/Makefile View File

@@ -144,6 +144,7 @@ OBJS-$(CONFIG_VOLUME_FILTER) += af_volume.o
OBJS-$(CONFIG_VOLUMEDETECT_FILTER) += af_volumedetect.o

OBJS-$(CONFIG_AEVALSRC_FILTER) += aeval.o
OBJS-$(CONFIG_AFIRSRC_FILTER) += asrc_afirsrc.o
OBJS-$(CONFIG_ANOISESRC_FILTER) += asrc_anoisesrc.o
OBJS-$(CONFIG_ANULLSRC_FILTER) += asrc_anullsrc.o
OBJS-$(CONFIG_FLITE_FILTER) += asrc_flite.o


+ 1
- 0
libavfilter/allfilters.c View File

@@ -138,6 +138,7 @@ extern AVFilter ff_af_volume;
extern AVFilter ff_af_volumedetect;

extern AVFilter ff_asrc_aevalsrc;
extern AVFilter ff_asrc_afirsrc;
extern AVFilter ff_asrc_anoisesrc;
extern AVFilter ff_asrc_anullsrc;
extern AVFilter ff_asrc_flite;


+ 330
- 0
libavfilter/asrc_afirsrc.c View File

@@ -0,0 +1,330 @@
/*
* Copyright (c) 2020 Paul B Mahol
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/

#include "libavutil/eval.h"
#include "libavutil/opt.h"
#include "libavutil/tx.h"
#include "audio.h"
#include "avfilter.h"
#include "internal.h"
#include "window_func.h"

typedef struct AudioFIRSourceContext {
const AVClass *class;

char *freq_points_str;
char *magnitude_str;
char *phase_str;
int nb_taps;
int sample_rate;
int nb_samples;
int win_func;

AVComplexFloat *complexf;
float *freq;
float *magnitude;
float *phase;
int freq_size;
int magnitude_size;
int phase_size;
int nb_freq;
int nb_magnitude;
int nb_phase;

float *taps;
float *win;
int64_t pts;

AVTXContext *tx_ctx;
av_tx_fn tx_fn;
} AudioFIRSourceContext;

#define OFFSET(x) offsetof(AudioFIRSourceContext, x)
#define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM

static const AVOption afirsrc_options[] = {
{ "taps", "set number of taps", OFFSET(nb_taps), AV_OPT_TYPE_INT, {.i64=1025}, 9, UINT16_MAX, FLAGS },
{ "t", "set number of taps", OFFSET(nb_taps), AV_OPT_TYPE_INT, {.i64=1025}, 9, UINT16_MAX, FLAGS },
{ "frequency", "set frequency points", OFFSET(freq_points_str), AV_OPT_TYPE_STRING, {.str="0 1"}, 0, 0, FLAGS },
{ "f", "set frequency points", OFFSET(freq_points_str), AV_OPT_TYPE_STRING, {.str="0 1"}, 0, 0, FLAGS },
{ "magnitude", "set magnitude values", OFFSET(magnitude_str), AV_OPT_TYPE_STRING, {.str="1 1"}, 0, 0, FLAGS },
{ "m", "set magnitude values", OFFSET(magnitude_str), AV_OPT_TYPE_STRING, {.str="1 1"}, 0, 0, FLAGS },
{ "phase", "set phase values", OFFSET(phase_str), AV_OPT_TYPE_STRING, {.str="0 0"}, 0, 0, FLAGS },
{ "p", "set phase values", OFFSET(phase_str), AV_OPT_TYPE_STRING, {.str="0 0"}, 0, 0, FLAGS },
{ "sample_rate", "set sample rate", OFFSET(sample_rate), AV_OPT_TYPE_INT, {.i64=44100}, 1, INT_MAX, FLAGS },
{ "r", "set sample rate", OFFSET(sample_rate), AV_OPT_TYPE_INT, {.i64=44100}, 1, INT_MAX, FLAGS },
{ "nb_samples", "set the number of samples per requested frame", OFFSET(nb_samples), AV_OPT_TYPE_INT, {.i64 = 1024}, 1, INT_MAX, FLAGS },
{ "n", "set the number of samples per requested frame", OFFSET(nb_samples), AV_OPT_TYPE_INT, {.i64 = 1024}, 1, INT_MAX, FLAGS },
{ "win_func", "set window function", OFFSET(win_func), AV_OPT_TYPE_INT, {.i64=WFUNC_BLACKMAN}, 0, NB_WFUNC-1, FLAGS, "win_func" },
{ "w", "set window function", OFFSET(win_func), AV_OPT_TYPE_INT, {.i64=WFUNC_BLACKMAN}, 0, NB_WFUNC-1, FLAGS, "win_func" },
{ "rect", "Rectangular", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_RECT}, 0, 0, FLAGS, "win_func" },
{ "bartlett", "Bartlett", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BARTLETT}, 0, 0, FLAGS, "win_func" },
{ "hanning", "Hanning", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_HANNING}, 0, 0, FLAGS, "win_func" },
{ "hamming", "Hamming", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_HAMMING}, 0, 0, FLAGS, "win_func" },
{ "blackman", "Blackman", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BLACKMAN}, 0, 0, FLAGS, "win_func" },
{ "welch", "Welch", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_WELCH}, 0, 0, FLAGS, "win_func" },
{ "flattop", "Flat-top", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_FLATTOP}, 0, 0, FLAGS, "win_func" },
{ "bharris", "Blackman-Harris", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BHARRIS}, 0, 0, FLAGS, "win_func" },
{ "bnuttall", "Blackman-Nuttall", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BNUTTALL}, 0, 0, FLAGS, "win_func" },
{ "bhann", "Bartlett-Hann", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BHANN}, 0, 0, FLAGS, "win_func" },
{ "sine", "Sine", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_SINE}, 0, 0, FLAGS, "win_func" },
{ "nuttall", "Nuttall", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_NUTTALL}, 0, 0, FLAGS, "win_func" },
{ "lanczos", "Lanczos", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_LANCZOS}, 0, 0, FLAGS, "win_func" },
{ "gauss", "Gauss", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_GAUSS}, 0, 0, FLAGS, "win_func" },
{ "tukey", "Tukey", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_TUKEY}, 0, 0, FLAGS, "win_func" },
{ "dolph", "Dolph-Chebyshev", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_DOLPH}, 0, 0, FLAGS, "win_func" },
{ "cauchy", "Cauchy", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_CAUCHY}, 0, 0, FLAGS, "win_func" },
{ "parzen", "Parzen", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_PARZEN}, 0, 0, FLAGS, "win_func" },
{ "poisson", "Poisson", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_POISSON}, 0, 0, FLAGS, "win_func" },
{ "bohman" , "Bohman", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BOHMAN}, 0, 0, FLAGS, "win_func" },
{NULL}
};

AVFILTER_DEFINE_CLASS(afirsrc);

static av_cold int init(AVFilterContext *ctx)
{
AudioFIRSourceContext *s = ctx->priv;

if (!(s->nb_taps & 1)) {
av_log(s, AV_LOG_WARNING, "Number of taps %d must be odd length.\n", s->nb_taps);
s->nb_taps |= 1;
}

return 0;
}

static av_cold void uninit(AVFilterContext *ctx)
{
AudioFIRSourceContext *s = ctx->priv;

av_freep(&s->win);
av_freep(&s->taps);
av_freep(&s->freq);
av_freep(&s->magnitude);
av_freep(&s->phase);
av_freep(&s->complexf);
av_tx_uninit(&s->tx_ctx);
}

static av_cold int query_formats(AVFilterContext *ctx)
{
AudioFIRSourceContext *s = ctx->priv;
static const int64_t chlayouts[] = { AV_CH_LAYOUT_MONO, -1 };
int sample_rates[] = { s->sample_rate, -1 };
static const enum AVSampleFormat sample_fmts[] = {
AV_SAMPLE_FMT_FLT,
AV_SAMPLE_FMT_NONE
};

AVFilterFormats *formats;
AVFilterChannelLayouts *layouts;
int ret;

formats = ff_make_format_list(sample_fmts);
if (!formats)
return AVERROR(ENOMEM);
ret = ff_set_common_formats (ctx, formats);
if (ret < 0)
return ret;

layouts = avfilter_make_format64_list(chlayouts);
if (!layouts)
return AVERROR(ENOMEM);
ret = ff_set_common_channel_layouts(ctx, layouts);
if (ret < 0)
return ret;

formats = ff_make_format_list(sample_rates);
if (!formats)
return AVERROR(ENOMEM);
return ff_set_common_samplerates(ctx, formats);
}

static int parse_string(char *str, float **items, int *nb_items, int *items_size)
{
float *new_items;
char *tail;

new_items = av_fast_realloc(NULL, items_size, 1 * sizeof(float));
if (!new_items)
return AVERROR(ENOMEM);
*items = new_items;

tail = str;
if (!tail)
return AVERROR(EINVAL);

do {
(*items)[(*nb_items)++] = av_strtod(tail, &tail);
new_items = av_fast_realloc(*items, items_size, (*nb_items + 1) * sizeof(float));
if (!new_items)
return AVERROR(ENOMEM);
*items = new_items;
if (tail && *tail)
tail++;
} while (tail && *tail);

return 0;
}

static void lininterp(AVComplexFloat *complexf,
const float *freq,
const float *magnitude,
const float *phase,
int m, int minterp)
{
for (int i = 0; i < minterp; i++) {
for (int j = 1; j < m; j++) {
const float x = i / (float)minterp;

if (x <= freq[j]) {
const float mg = (x - freq[j-1]) / (freq[j] - freq[j-1]) * (magnitude[j] - magnitude[j-1]) + magnitude[j-1];
const float ph = (x - freq[j-1]) / (freq[j] - freq[j-1]) * (phase[j] - phase[j-1]) + phase[j-1];

complexf[i].re = mg * cosf(ph);
complexf[i].im = mg * sinf(ph);
break;
}
}
}
}

static av_cold int config_output(AVFilterLink *outlink)
{
AVFilterContext *ctx = outlink->src;
AudioFIRSourceContext *s = ctx->priv;
float overlap, scale = 1.f, compensation;
int fft_size, middle, ret;

s->nb_freq = s->nb_magnitude = s->nb_phase = 0;

ret = parse_string(s->freq_points_str, &s->freq, &s->nb_freq, &s->freq_size);
if (ret < 0)
return ret;

ret = parse_string(s->magnitude_str, &s->magnitude, &s->nb_magnitude, &s->magnitude_size);
if (ret < 0)
return ret;

ret = parse_string(s->phase_str, &s->phase, &s->nb_phase, &s->phase_size);
if (ret < 0)
return ret;

if (s->nb_freq != s->nb_magnitude && s->nb_freq != s->nb_phase && s->nb_freq >= 2) {
av_log(ctx, AV_LOG_ERROR, "Number of frequencies, magnitudes and phases must be same and >= 2.\n");
return AVERROR(EINVAL);
}

for (int i = 0; i < s->nb_freq; i++) {
if (i == 0 && s->freq[i] != 0.f) {
av_log(ctx, AV_LOG_ERROR, "First frequency must be 0.\n");
return AVERROR(EINVAL);
}

if (i == s->nb_freq - 1 && s->freq[i] != 1.f) {
av_log(ctx, AV_LOG_ERROR, "Last frequency must be 1.\n");
return AVERROR(EINVAL);
}

if (i && s->freq[i] < s->freq[i-1]) {
av_log(ctx, AV_LOG_ERROR, "Frequencies must be in increasing order.\n");
return AVERROR(EINVAL);
}
}

fft_size = 1 << (av_log2(s->nb_taps) + 1);
s->complexf = av_calloc(fft_size * 2, sizeof(*s->complexf));
if (!s->complexf)
return AVERROR(ENOMEM);

ret = av_tx_init(&s->tx_ctx, &s->tx_fn, AV_TX_FLOAT_FFT, 1, fft_size, &scale, 0);
if (ret < 0)
return ret;

s->taps = av_calloc(s->nb_taps, sizeof(*s->taps));
if (!s->taps)
return AVERROR(ENOMEM);

s->win = av_calloc(s->nb_taps, sizeof(*s->win));
if (!s->win)
return AVERROR(ENOMEM);

generate_window_func(s->win, s->nb_taps, s->win_func, &overlap);

lininterp(s->complexf, s->freq, s->magnitude, s->phase, s->nb_freq, fft_size / 2);

s->tx_fn(s->tx_ctx, s->complexf + fft_size, s->complexf, sizeof(float));

compensation = 2.f / fft_size;
middle = s->nb_taps / 2;

for (int i = 0; i <= middle; i++) {
s->taps[ i] = s->complexf[fft_size + middle - i].re * compensation * s->win[i];
s->taps[middle + i] = s->complexf[fft_size + i].re * compensation * s->win[middle + i];
}

s->pts = 0;

return 0;
}

static int request_frame(AVFilterLink *outlink)
{
AVFilterContext *ctx = outlink->src;
AudioFIRSourceContext *s = ctx->priv;
AVFrame *frame;
int nb_samples;

nb_samples = FFMIN(s->nb_samples, s->nb_taps - s->pts);
if (!nb_samples)
return AVERROR_EOF;

if (!(frame = ff_get_audio_buffer(outlink, nb_samples)))
return AVERROR(ENOMEM);

memcpy(frame->data[0], s->taps + s->pts, nb_samples * sizeof(float));

frame->pts = s->pts;
s->pts += nb_samples;
return ff_filter_frame(outlink, frame);
}

static const AVFilterPad afirsrc_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_AUDIO,
.request_frame = request_frame,
.config_props = config_output,
},
{ NULL }
};

AVFilter ff_asrc_afirsrc = {
.name = "afirsrc",
.description = NULL_IF_CONFIG_SMALL("Generate a FIR coefficients audio stream."),
.query_formats = query_formats,
.init = init,
.uninit = uninit,
.priv_size = sizeof(AudioFIRSourceContext),
.inputs = NULL,
.outputs = afirsrc_outputs,
.priv_class = &afirsrc_class,
};

+ 1
- 1
libavfilter/version.h View File

@@ -30,7 +30,7 @@
#include "libavutil/version.h"

#define LIBAVFILTER_VERSION_MAJOR 7
#define LIBAVFILTER_VERSION_MINOR 74
#define LIBAVFILTER_VERSION_MINOR 75
#define LIBAVFILTER_VERSION_MICRO 100




Write Preview
Loading…
Cancel
Save