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

avfilter/af_firequalizer: add fft2 option 

2-channels convolution using complex fft
improves speed significantly

not sure if it should be enabled by default
so disable it by default

Signed-off-by: Muhammad Faiz <mfcc64@gmail.com>
tags/n3.3
Muhammad Faiz 8 years ago
parent
8a8902f221
commit
b4e9252ae3
3 changed files with 88 additions and 4 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +4
    -0
      doc/filters.texi
  2. +79
    -1
      libavfilter/af_firequalizer.c
  3. +5
    -3
      tests/filtergraphs/firequalizer

+ 4
- 0
doc/filters.texi View File

@@ -2585,6 +2585,10 @@ Set file for dumping, suitable for gnuplot.
@item dumpscale
Set scale for dumpfile. Acceptable values are same with scale option.
Default is linlog.

@item fft2
Enable 2-channel convolution using complex FFT. This improves speed significantly.
Default is disabled.
@end table

@subsection Examples


+ 79
- 1
libavfilter/af_firequalizer.c View File

@@ -69,6 +69,7 @@ typedef struct {
RDFTContext *analysis_irdft;
RDFTContext *rdft;
RDFTContext *irdft;
FFTContext *fft_ctx;
int analysis_rdft_len;
int rdft_len;

@@ -97,6 +98,7 @@ typedef struct {
int scale;
char *dumpfile;
int dumpscale;
int fft2;

int nb_gain_entry;
int gain_entry_err;
@@ -132,6 +134,7 @@ static const AVOption firequalizer_options[] = {
{ "loglog", "logarithmic-freq logarithmic-gain", 0, AV_OPT_TYPE_CONST, { .i64 = SCALE_LOGLOG }, 0, 0, FLAGS, "scale" },
{ "dumpfile", "set dump file", OFFSET(dumpfile), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, FLAGS },
{ "dumpscale", "set dump scale", OFFSET(dumpscale), AV_OPT_TYPE_INT, { .i64 = SCALE_LINLOG }, 0, NB_SCALE-1, FLAGS, "scale" },
{ "fft2", "set 2-channels fft", OFFSET(fft2), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
{ NULL }
};

@@ -143,7 +146,9 @@ static void common_uninit(FIREqualizerContext *s)
av_rdft_end(s->analysis_irdft);
av_rdft_end(s->rdft);
av_rdft_end(s->irdft);
av_fft_end(s->fft_ctx);
s->analysis_rdft = s->analysis_irdft = s->rdft = s->irdft = NULL;
s->fft_ctx = NULL;

av_freep(&s->analysis_buf);
av_freep(&s->dump_buf);
@@ -230,6 +235,70 @@ static void fast_convolute(FIREqualizerContext *s, const float *kernel_buf, floa
}
}

static void fast_convolute2(FIREqualizerContext *s, const float *kernel_buf, FFTComplex *conv_buf,
OverlapIndex *idx, float *data0, float *data1, int nsamples)
{
if (nsamples <= s->nsamples_max) {
FFTComplex *buf = conv_buf + idx->buf_idx * s->rdft_len;
FFTComplex *obuf = conv_buf + !idx->buf_idx * s->rdft_len + idx->overlap_idx;
int center = s->fir_len/2;
int k;
float tmp;

memset(buf, 0, center * sizeof(*buf));
for (k = 0; k < nsamples; k++) {
buf[center+k].re = data0[k];
buf[center+k].im = data1[k];
}
memset(buf + center + nsamples, 0, (s->rdft_len - nsamples - center) * sizeof(*buf));
av_fft_permute(s->fft_ctx, buf);
av_fft_calc(s->fft_ctx, buf);

/* swap re <-> im, do backward fft using forward fft_ctx */
/* normalize with 0.5f */
tmp = buf[0].re;
buf[0].re = 0.5f * kernel_buf[0] * buf[0].im;
buf[0].im = 0.5f * kernel_buf[0] * tmp;
for (k = 1; k < s->rdft_len/2; k++) {
int m = s->rdft_len - k;
tmp = buf[k].re;
buf[k].re = 0.5f * kernel_buf[k] * buf[k].im;
buf[k].im = 0.5f * kernel_buf[k] * tmp;
tmp = buf[m].re;
buf[m].re = 0.5f * kernel_buf[k] * buf[m].im;
buf[m].im = 0.5f * kernel_buf[k] * tmp;
}
tmp = buf[k].re;
buf[k].re = 0.5f * kernel_buf[k] * buf[k].im;
buf[k].im = 0.5f * kernel_buf[k] * tmp;

av_fft_permute(s->fft_ctx, buf);
av_fft_calc(s->fft_ctx, buf);

for (k = 0; k < s->rdft_len - idx->overlap_idx; k++) {
buf[k].re += obuf[k].re;
buf[k].im += obuf[k].im;
}

/* swapped re <-> im */
for (k = 0; k < nsamples; k++) {
data0[k] = buf[k].im;
data1[k] = buf[k].re;
}
idx->buf_idx = !idx->buf_idx;
idx->overlap_idx = nsamples;
} else {
while (nsamples > s->nsamples_max * 2) {
fast_convolute2(s, kernel_buf, conv_buf, idx, data0, data1, s->nsamples_max);
data0 += s->nsamples_max;
data1 += s->nsamples_max;
nsamples -= s->nsamples_max;
}
fast_convolute2(s, kernel_buf, conv_buf, idx, data0, data1, nsamples/2);
fast_convolute2(s, kernel_buf, conv_buf, idx, data0 + nsamples/2, data1 + nsamples/2, nsamples - nsamples/2);
}
}

static void dump_fir(AVFilterContext *ctx, FILE *fp, int ch)
{
FIREqualizerContext *s = ctx->priv;
@@ -598,6 +667,9 @@ static int config_input(AVFilterLink *inlink)
if (!(s->rdft = av_rdft_init(rdft_bits, DFT_R2C)) || !(s->irdft = av_rdft_init(rdft_bits, IDFT_C2R)))
return AVERROR(ENOMEM);

if (s->fft2 && !s->multi && inlink->channels > 1 && !(s->fft_ctx = av_fft_init(rdft_bits, 0)))
return AVERROR(ENOMEM);

for ( ; rdft_bits <= RDFT_BITS_MAX; rdft_bits++) {
s->analysis_rdft_len = 1 << rdft_bits;
if (inlink->sample_rate <= s->accuracy * s->analysis_rdft_len)
@@ -640,7 +712,13 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
FIREqualizerContext *s = ctx->priv;
int ch;

for (ch = 0; ch < inlink->channels; ch++) {
for (ch = 0; ch + 1 < inlink->channels && s->fft_ctx; ch += 2) {
fast_convolute2(s, s->kernel_buf, (FFTComplex *)(s->conv_buf + 2 * ch * s->rdft_len),
s->conv_idx + ch, (float *) frame->extended_data[ch],
(float *) frame->extended_data[ch+1], frame->nb_samples);
}

for ( ; ch < inlink->channels; ch++) {
fast_convolute(s, s->kernel_buf + (s->multi ? ch * s->rdft_len : 0),
s->conv_buf + 2 * ch * s->rdft_len, s->conv_idx + ch,
(float *) frame->extended_data[ch], frame->nb_samples);


+ 5
- 3
tests/filtergraphs/firequalizer View File

@@ -1,4 +1,5 @@
firequalizer =
fft2 = on:
gain = 'sin(0.001*f) - 1':
delay = 0.05,

@@ -10,14 +11,15 @@ firequalizer =
zero_phase = on:
wfunc = nuttall,

firequalizer =
fft2 = on:
gain_entry = 'entry(1000, 0); entry(5000, 0.1); entry(10000, 0.2)',

firequalizer =
gain = 'if (ch, -0.3 * sin(0.001*f), -0.8 * sin(0.001*f)) - 1':
delay = 0.05:
multi = on,

firequalizer =
gain_entry = 'entry(1000, 0); entry(5000, 0.1); entry(10000, 0.2)',

firequalizer =
gain_entry = 'entry(1000, 0.2); entry(5000, 0.1); entry(10000, 0)',



Write Preview
Loading…
Cancel
Save