FFmpeg
Loading...
Searching...
No Matches
af_firequalizer.c
Go to the documentation of this file.
1/*
2 * Copyright (c) 2016 Muhammad Faiz <mfcc64@gmail.com>
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
22#include "libavutil/file_open.h"
23#include "libavutil/mem.h"
24#include "libavutil/opt.h"
25#include "libavutil/eval.h"
26#include "libavutil/avassert.h"
27#include "libavutil/tx.h"
28#include "avfilter.h"
29#include "filters.h"
30#include "audio.h"
31
32#define RDFT_BITS_MIN 4
33#define RDFT_BITS_MAX 16
34
48
56
57#define NB_GAIN_ENTRY_MAX 4096
58typedef struct GainEntry {
59 double freq;
60 double gain;
61} GainEntry;
62
63typedef struct OverlapIndex {
67
126
127#define OFFSET(x) offsetof(FIREqualizerContext, x)
128#define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
129#define TFLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
130
132 { "gain", "set gain curve", OFFSET(gain), AV_OPT_TYPE_STRING, { .str = "gain_interpolate(f)" }, 0, 0, TFLAGS },
133 { "gain_entry", "set gain entry", OFFSET(gain_entry), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, TFLAGS },
134 { "delay", "set delay", OFFSET(delay), AV_OPT_TYPE_DOUBLE, { .dbl = 0.01 }, 0.0, 1e10, FLAGS },
135 { "accuracy", "set accuracy", OFFSET(accuracy), AV_OPT_TYPE_DOUBLE, { .dbl = 5.0 }, 0.0, 1e10, FLAGS },
136 { "wfunc", "set window function", OFFSET(wfunc), AV_OPT_TYPE_INT, { .i64 = WFUNC_HANN }, 0, NB_WFUNC-1, FLAGS, .unit = "wfunc" },
137 { "rectangular", "rectangular window", 0, AV_OPT_TYPE_CONST, { .i64 = WFUNC_RECTANGULAR }, 0, 0, FLAGS, .unit = "wfunc" },
138 { "hann", "hann window", 0, AV_OPT_TYPE_CONST, { .i64 = WFUNC_HANN }, 0, 0, FLAGS, .unit = "wfunc" },
139 { "hamming", "hamming window", 0, AV_OPT_TYPE_CONST, { .i64 = WFUNC_HAMMING }, 0, 0, FLAGS, .unit = "wfunc" },
140 { "blackman", "blackman window", 0, AV_OPT_TYPE_CONST, { .i64 = WFUNC_BLACKMAN }, 0, 0, FLAGS, .unit = "wfunc" },
141 { "nuttall3", "3-term nuttall window", 0, AV_OPT_TYPE_CONST, { .i64 = WFUNC_NUTTALL3 }, 0, 0, FLAGS, .unit = "wfunc" },
142 { "mnuttall3", "minimum 3-term nuttall window", 0, AV_OPT_TYPE_CONST, { .i64 = WFUNC_MNUTTALL3 }, 0, 0, FLAGS, .unit = "wfunc" },
143 { "nuttall", "nuttall window", 0, AV_OPT_TYPE_CONST, { .i64 = WFUNC_NUTTALL }, 0, 0, FLAGS, .unit = "wfunc" },
144 { "bnuttall", "blackman-nuttall window", 0, AV_OPT_TYPE_CONST, { .i64 = WFUNC_BNUTTALL }, 0, 0, FLAGS, .unit = "wfunc" },
145 { "bharris", "blackman-harris window", 0, AV_OPT_TYPE_CONST, { .i64 = WFUNC_BHARRIS }, 0, 0, FLAGS, .unit = "wfunc" },
146 { "tukey", "tukey window", 0, AV_OPT_TYPE_CONST, { .i64 = WFUNC_TUKEY }, 0, 0, FLAGS, .unit = "wfunc" },
147 { "fixed", "set fixed frame samples", OFFSET(fixed), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
148 { "multi", "set multi channels mode", OFFSET(multi), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
149 { "zero_phase", "set zero phase mode", OFFSET(zero_phase), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
150 { "scale", "set gain scale", OFFSET(scale), AV_OPT_TYPE_INT, { .i64 = SCALE_LINLOG }, 0, NB_SCALE-1, FLAGS, .unit = "scale" },
151 { "linlin", "linear-freq linear-gain", 0, AV_OPT_TYPE_CONST, { .i64 = SCALE_LINLIN }, 0, 0, FLAGS, .unit = "scale" },
152 { "linlog", "linear-freq logarithmic-gain", 0, AV_OPT_TYPE_CONST, { .i64 = SCALE_LINLOG }, 0, 0, FLAGS, .unit = "scale" },
153 { "loglin", "logarithmic-freq linear-gain", 0, AV_OPT_TYPE_CONST, { .i64 = SCALE_LOGLIN }, 0, 0, FLAGS, .unit = "scale" },
154 { "loglog", "logarithmic-freq logarithmic-gain", 0, AV_OPT_TYPE_CONST, { .i64 = SCALE_LOGLOG }, 0, 0, FLAGS, .unit = "scale" },
155 { "dumpfile", "set dump file", OFFSET(dumpfile), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, FLAGS },
156 { "dumpscale", "set dump scale", OFFSET(dumpscale), AV_OPT_TYPE_INT, { .i64 = SCALE_LINLOG }, 0, NB_SCALE-1, FLAGS, .unit = "scale" },
157 { "fft2", "set 2-channels fft", OFFSET(fft2), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
158 { "min_phase", "set minimum phase mode", OFFSET(min_phase), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
159 { NULL }
160};
161
163
165{
166 av_tx_uninit(&s->analysis_rdft);
167 av_tx_uninit(&s->analysis_irdft);
168 av_tx_uninit(&s->rdft);
169 av_tx_uninit(&s->irdft);
170 av_tx_uninit(&s->fft_ctx);
171 av_tx_uninit(&s->cepstrum_rdft);
172 av_tx_uninit(&s->cepstrum_irdft);
173 s->analysis_rdft = s->analysis_irdft = s->rdft = s->irdft = NULL;
174 s->fft_ctx = NULL;
175 s->cepstrum_rdft = NULL;
176 s->cepstrum_irdft = NULL;
177
178 av_freep(&s->analysis_buf);
179 av_freep(&s->analysis_tbuf);
180 av_freep(&s->dump_buf);
181 av_freep(&s->kernel_tmp_buf);
182 av_freep(&s->kernel_tmp_tbuf);
183 av_freep(&s->kernel_buf);
184 av_freep(&s->tx_buf);
185 av_freep(&s->cepstrum_buf);
186 av_freep(&s->cepstrum_tbuf);
187 av_freep(&s->conv_buf);
188 av_freep(&s->conv_idx);
189}
190
192{
193 FIREqualizerContext *s = ctx->priv;
194
196 av_freep(&s->gain_cmd);
197 av_freep(&s->gain_entry_cmd);
198}
199
200static void fast_convolute(FIREqualizerContext *restrict s, const float *restrict kernel_buf, float *restrict conv_buf,
201 OverlapIndex *restrict idx, float *restrict data, int nsamples)
202{
203 if (nsamples <= s->nsamples_max) {
204 float *buf = conv_buf + idx->buf_idx * s->rdft_len;
205 float *obuf = conv_buf + !idx->buf_idx * s->rdft_len + idx->overlap_idx;
206 float *tbuf = s->tx_buf;
207 int center = s->fir_len/2;
208 int k;
209
210 memset(buf, 0, center * sizeof(*data));
211 memcpy(buf + center, data, nsamples * sizeof(*data));
212 memset(buf + center + nsamples, 0, (s->rdft_len - nsamples - center) * sizeof(*data));
213 s->rdft_fn(s->rdft, tbuf, buf, sizeof(float));
214
215 for (k = 0; k <= s->rdft_len/2; k++) {
216 tbuf[2*k] *= kernel_buf[k];
217 tbuf[2*k+1] *= kernel_buf[k];
218 }
219
220 s->irdft_fn(s->irdft, buf, tbuf, sizeof(AVComplexFloat));
221 for (k = 0; k < s->rdft_len - idx->overlap_idx; k++)
222 buf[k] += obuf[k];
223 memcpy(data, buf, nsamples * sizeof(*data));
224 idx->buf_idx = !idx->buf_idx;
225 idx->overlap_idx = nsamples;
226 } else {
227 while (nsamples > s->nsamples_max * 2) {
228 fast_convolute(s, kernel_buf, conv_buf, idx, data, s->nsamples_max);
229 data += s->nsamples_max;
230 nsamples -= s->nsamples_max;
231 }
232 fast_convolute(s, kernel_buf, conv_buf, idx, data, nsamples/2);
233 fast_convolute(s, kernel_buf, conv_buf, idx, data + nsamples/2, nsamples - nsamples/2);
234 }
235}
236
237static void fast_convolute_nonlinear(FIREqualizerContext *restrict s, const float *restrict kernel_buf,
238 float *restrict conv_buf, OverlapIndex *restrict idx,
239 float *restrict data, int nsamples)
240{
241 if (nsamples <= s->nsamples_max) {
242 float *buf = conv_buf + idx->buf_idx * s->rdft_len;
243 float *obuf = conv_buf + !idx->buf_idx * s->rdft_len + idx->overlap_idx;
244 float *tbuf = s->tx_buf;
245 int k;
246
247 memcpy(buf, data, nsamples * sizeof(*data));
248 memset(buf + nsamples, 0, (s->rdft_len - nsamples) * sizeof(*data));
249 s->rdft_fn(s->rdft, tbuf, buf, sizeof(float));
250
251 for (k = 0; k < s->rdft_len + 2; k += 2) {
252 float re, im;
253 re = tbuf[k] * kernel_buf[k] - tbuf[k+1] * kernel_buf[k+1];
254 im = tbuf[k] * kernel_buf[k+1] + tbuf[k+1] * kernel_buf[k];
255 tbuf[k] = re;
256 tbuf[k+1] = im;
257 }
258
259 s->irdft_fn(s->irdft, buf, tbuf, sizeof(AVComplexFloat));
260 for (k = 0; k < s->rdft_len - idx->overlap_idx; k++)
261 buf[k] += obuf[k];
262 memcpy(data, buf, nsamples * sizeof(*data));
263 idx->buf_idx = !idx->buf_idx;
264 idx->overlap_idx = nsamples;
265 } else {
266 while (nsamples > s->nsamples_max * 2) {
267 fast_convolute_nonlinear(s, kernel_buf, conv_buf, idx, data, s->nsamples_max);
268 data += s->nsamples_max;
269 nsamples -= s->nsamples_max;
270 }
271 fast_convolute_nonlinear(s, kernel_buf, conv_buf, idx, data, nsamples/2);
272 fast_convolute_nonlinear(s, kernel_buf, conv_buf, idx, data + nsamples/2, nsamples - nsamples/2);
273 }
274}
275
276static void fast_convolute2(FIREqualizerContext *restrict s, const float *restrict kernel_buf, AVComplexFloat *restrict conv_buf,
277 OverlapIndex *restrict idx, float *restrict data0, float *restrict data1, int nsamples)
278{
279 if (nsamples <= s->nsamples_max) {
280 AVComplexFloat *buf = conv_buf + idx->buf_idx * s->rdft_len;
281 AVComplexFloat *obuf = conv_buf + !idx->buf_idx * s->rdft_len + idx->overlap_idx;
282 AVComplexFloat *tbuf = (AVComplexFloat *)s->tx_buf;
283 int center = s->fir_len/2;
284 int k;
285 float tmp;
286
287 memset(buf, 0, center * sizeof(*buf));
288 for (k = 0; k < nsamples; k++) {
289 buf[center+k].re = data0[k];
290 buf[center+k].im = data1[k];
291 }
292 memset(buf + center + nsamples, 0, (s->rdft_len - nsamples - center) * sizeof(*buf));
293 s->fft_fn(s->fft_ctx, tbuf, buf, sizeof(AVComplexFloat));
294
295 /* swap re <-> im, do backward fft using forward fft_ctx */
296 /* normalize with 0.5f */
297 tmp = tbuf[0].re;
298 tbuf[0].re = 0.5f * kernel_buf[0] * tbuf[0].im;
299 tbuf[0].im = 0.5f * kernel_buf[0] * tmp;
300 for (k = 1; k < s->rdft_len/2; k++) {
301 int m = s->rdft_len - k;
302 tmp = tbuf[k].re;
303 tbuf[k].re = 0.5f * kernel_buf[k] * tbuf[k].im;
304 tbuf[k].im = 0.5f * kernel_buf[k] * tmp;
305 tmp = tbuf[m].re;
306 tbuf[m].re = 0.5f * kernel_buf[k] * tbuf[m].im;
307 tbuf[m].im = 0.5f * kernel_buf[k] * tmp;
308 }
309 tmp = tbuf[k].re;
310 tbuf[k].re = 0.5f * kernel_buf[k] * tbuf[k].im;
311 tbuf[k].im = 0.5f * kernel_buf[k] * tmp;
312
313 s->fft_fn(s->fft_ctx, buf, tbuf, sizeof(AVComplexFloat));
314
315 for (k = 0; k < s->rdft_len - idx->overlap_idx; k++) {
316 buf[k].re += obuf[k].re;
317 buf[k].im += obuf[k].im;
318 }
319
320 /* swapped re <-> im */
321 for (k = 0; k < nsamples; k++) {
322 data0[k] = buf[k].im;
323 data1[k] = buf[k].re;
324 }
325 idx->buf_idx = !idx->buf_idx;
326 idx->overlap_idx = nsamples;
327 } else {
328 while (nsamples > s->nsamples_max * 2) {
329 fast_convolute2(s, kernel_buf, conv_buf, idx, data0, data1, s->nsamples_max);
330 data0 += s->nsamples_max;
331 data1 += s->nsamples_max;
332 nsamples -= s->nsamples_max;
333 }
334 fast_convolute2(s, kernel_buf, conv_buf, idx, data0, data1, nsamples/2);
335 fast_convolute2(s, kernel_buf, conv_buf, idx, data0 + nsamples/2, data1 + nsamples/2, nsamples - nsamples/2);
336 }
337}
338
339static void dump_fir(AVFilterContext *ctx, FILE *fp, int ch)
340{
341 FIREqualizerContext *s = ctx->priv;
342 int rate = ctx->inputs[0]->sample_rate;
343 int xlog = s->dumpscale == SCALE_LOGLIN || s->dumpscale == SCALE_LOGLOG;
344 int ylog = s->dumpscale == SCALE_LINLOG || s->dumpscale == SCALE_LOGLOG;
345 int x;
346 int center = s->fir_len / 2;
347 double delay = s->zero_phase ? 0.0 : (double) center / rate;
348 double vx, ya, yb;
349
350 if (!s->min_phase) {
351 s->analysis_buf[0] *= s->rdft_len/2;
352 for (x = 1; x <= center; x++) {
353 s->analysis_buf[x] *= s->rdft_len/2;
354 s->analysis_buf[s->analysis_rdft_len - x] *= s->rdft_len/2;
355 }
356 } else {
357 for (x = 0; x < s->fir_len; x++)
358 s->analysis_buf[x] *= s->rdft_len/2;
359 }
360
361 if (ch)
362 fprintf(fp, "\n\n");
363
364 fprintf(fp, "# time[%d] (time amplitude)\n", ch);
365
366 if (!s->min_phase) {
367 for (x = center; x > 0; x--)
368 fprintf(fp, "%15.10f %15.10f\n", delay - (double) x / rate, (double) s->analysis_buf[s->analysis_rdft_len - x]);
369
370 for (x = 0; x <= center; x++)
371 fprintf(fp, "%15.10f %15.10f\n", delay + (double)x / rate , (double) s->analysis_buf[x]);
372 } else {
373 for (x = 0; x < s->fir_len; x++)
374 fprintf(fp, "%15.10f %15.10f\n", (double)x / rate, (double) s->analysis_buf[x]);
375 }
376
377 s->analysis_rdft_fn(s->analysis_rdft, s->analysis_tbuf, s->analysis_buf, sizeof(float));
378
379 fprintf(fp, "\n\n# freq[%d] (frequency desired_gain actual_gain)\n", ch);
380
381 for (x = 0; x <= s->analysis_rdft_len/2; x++) {
382 int i = 2 * x;
383 vx = (double)x * rate / s->analysis_rdft_len;
384 if (xlog)
385 vx = log2(0.05*vx);
386 ya = s->dump_buf[i];
387 yb = s->min_phase ? hypotf(s->analysis_tbuf[i], s->analysis_tbuf[i+1]) : s->analysis_tbuf[i];
388 if (s->min_phase)
389 yb = fabs(yb);
390 if (ylog) {
391 ya = 20.0 * log10(fabs(ya));
392 yb = 20.0 * log10(fabs(yb));
393 }
394 fprintf(fp, "%17.10f %17.10f %17.10f\n", vx, ya, yb);
395 }
396}
397
398static double entry_func(void *p, double freq, double gain)
399{
400 AVFilterContext *ctx = p;
401 FIREqualizerContext *s = ctx->priv;
402
403 if (s->nb_gain_entry >= NB_GAIN_ENTRY_MAX) {
404 av_log(ctx, AV_LOG_ERROR, "entry table overflow.\n");
405 s->gain_entry_err = AVERROR(EINVAL);
406 return 0;
407 }
408
409 if (isnan(freq)) {
410 av_log(ctx, AV_LOG_ERROR, "nan frequency (%g, %g).\n", freq, gain);
411 s->gain_entry_err = AVERROR(EINVAL);
412 return 0;
413 }
414
415 if (s->nb_gain_entry > 0 && freq <= s->gain_entry_tbl[s->nb_gain_entry - 1].freq) {
416 av_log(ctx, AV_LOG_ERROR, "unsorted frequency (%g, %g).\n", freq, gain);
417 s->gain_entry_err = AVERROR(EINVAL);
418 return 0;
419 }
420
421 s->gain_entry_tbl[s->nb_gain_entry].freq = freq;
422 s->gain_entry_tbl[s->nb_gain_entry].gain = gain;
423 s->nb_gain_entry++;
424 return 0;
425}
426
427static int gain_entry_compare(const void *key, const void *memb)
428{
429 const double *freq = key;
430 const GainEntry *entry = memb;
431
432 if (*freq < entry[0].freq)
433 return -1;
434 if (*freq > entry[1].freq)
435 return 1;
436 return 0;
437}
438
439static double gain_interpolate_func(void *p, double freq)
440{
441 AVFilterContext *ctx = p;
442 FIREqualizerContext *s = ctx->priv;
443 GainEntry *res;
444 double d0, d1, d;
445
446 if (isnan(freq))
447 return freq;
448
449 if (!s->nb_gain_entry)
450 return 0;
451
452 if (freq <= s->gain_entry_tbl[0].freq)
453 return s->gain_entry_tbl[0].gain;
454
455 if (freq >= s->gain_entry_tbl[s->nb_gain_entry-1].freq)
456 return s->gain_entry_tbl[s->nb_gain_entry-1].gain;
457
458 res = bsearch(&freq, &s->gain_entry_tbl, s->nb_gain_entry - 1, sizeof(*res), gain_entry_compare);
459 av_assert0(res);
460
461 d = res[1].freq - res[0].freq;
462 d0 = freq - res[0].freq;
463 d1 = res[1].freq - freq;
464
465 if (d0 && d1)
466 return (d0 * res[1].gain + d1 * res[0].gain) / d;
467
468 if (d0)
469 return res[1].gain;
470
471 return res[0].gain;
472}
473
474static double cubic_interpolate_func(void *p, double freq)
475{
476 AVFilterContext *ctx = p;
477 FIREqualizerContext *s = ctx->priv;
478 GainEntry *res;
479 double x, x2, x3;
480 double a, b, c, d;
481 double m0, m1, m2, msum, unit;
482
483 if (!s->nb_gain_entry)
484 return 0;
485
486 if (freq <= s->gain_entry_tbl[0].freq)
487 return s->gain_entry_tbl[0].gain;
488
489 if (freq >= s->gain_entry_tbl[s->nb_gain_entry-1].freq)
490 return s->gain_entry_tbl[s->nb_gain_entry-1].gain;
491
492 res = bsearch(&freq, &s->gain_entry_tbl, s->nb_gain_entry - 1, sizeof(*res), gain_entry_compare);
493 av_assert0(res);
494
495 unit = res[1].freq - res[0].freq;
496 m0 = res != s->gain_entry_tbl ?
497 unit * (res[0].gain - res[-1].gain) / (res[0].freq - res[-1].freq) : 0;
498 m1 = res[1].gain - res[0].gain;
499 m2 = res != s->gain_entry_tbl + s->nb_gain_entry - 2 ?
500 unit * (res[2].gain - res[1].gain) / (res[2].freq - res[1].freq) : 0;
501
502 msum = fabs(m0) + fabs(m1);
503 m0 = msum > 0 ? (fabs(m0) * m1 + fabs(m1) * m0) / msum : 0;
504 msum = fabs(m1) + fabs(m2);
505 m1 = msum > 0 ? (fabs(m1) * m2 + fabs(m2) * m1) / msum : 0;
506
507 d = res[0].gain;
508 c = m0;
509 b = 3 * res[1].gain - m1 - 2 * c - 3 * d;
510 a = res[1].gain - b - c - d;
511
512 x = (freq - res[0].freq) / unit;
513 x2 = x * x;
514 x3 = x2 * x;
515
516 return a * x3 + b * x2 + c * x + d;
517}
518
519static const char *const var_names[] = {
520 "f",
521 "sr",
522 "ch",
523 "chid",
524 "chs",
525 "chlayout",
526 NULL
527};
528
538
539static void generate_min_phase_kernel(FIREqualizerContext *s, float *rdft_buf)
540{
541 int k, cepstrum_len = s->cepstrum_len, rdft_len = s->rdft_len;
542 double norm = 2.0 / cepstrum_len;
543 double minval = 1e-7 / rdft_len;
544
545 av_assert0(cepstrum_len >= 2);
546
547 memset(s->cepstrum_buf, 0, cepstrum_len * sizeof(*s->cepstrum_buf));
548 memset(s->cepstrum_tbuf, 0, (cepstrum_len + 2) * sizeof(*s->cepstrum_tbuf));
549 memcpy(s->cepstrum_buf, rdft_buf, rdft_len/2 * sizeof(*rdft_buf));
550 memcpy(s->cepstrum_buf + cepstrum_len - rdft_len/2, rdft_buf + rdft_len/2, rdft_len/2 * sizeof(*rdft_buf));
551
552 s->cepstrum_rdft_fn(s->cepstrum_rdft, s->cepstrum_tbuf, s->cepstrum_buf, sizeof(float));
553
554 for (k = 0; k < cepstrum_len + 2; k += 2) {
555 s->cepstrum_tbuf[k] = log(FFMAX(s->cepstrum_tbuf[k], minval));
556 s->cepstrum_tbuf[k+1] = 0;
557 }
558
559 s->cepstrum_irdft_fn(s->cepstrum_irdft, s->cepstrum_buf, s->cepstrum_tbuf, sizeof(AVComplexFloat));
560
561 memset(s->cepstrum_buf + cepstrum_len/2 + 1, 0, (cepstrum_len/2 - 1) * sizeof(*s->cepstrum_buf));
562 for (k = 1; k <= cepstrum_len/2; k++)
563 s->cepstrum_buf[k] *= 2;
564
565 s->cepstrum_rdft_fn(s->cepstrum_rdft, s->cepstrum_tbuf, s->cepstrum_buf, sizeof(float));
566
567 for (k = 0; k < cepstrum_len + 2; k += 2) {
568 double mag = exp(s->cepstrum_tbuf[k] * norm) * norm;
569 double ph = s->cepstrum_tbuf[k+1] * norm;
570 s->cepstrum_tbuf[k] = mag * cos(ph);
571 s->cepstrum_tbuf[k+1] = mag * sin(ph);
572 }
573
574 s->cepstrum_irdft_fn(s->cepstrum_irdft, s->cepstrum_buf, s->cepstrum_tbuf, sizeof(AVComplexFloat));
575 memset(rdft_buf, 0, s->rdft_len * sizeof(*rdft_buf));
576 memcpy(rdft_buf, s->cepstrum_buf, s->fir_len * sizeof(*rdft_buf));
577
578 if (s->dumpfile) {
579 memset(s->analysis_buf, 0, (s->analysis_rdft_len + 2) * sizeof(*s->analysis_buf));
580 memcpy(s->analysis_buf, s->cepstrum_buf, s->fir_len * sizeof(*s->analysis_buf));
581 }
582}
583
584static int generate_kernel(AVFilterContext *ctx, const char *gain, const char *gain_entry)
585{
586 FIREqualizerContext *s = ctx->priv;
587 AVFilterLink *inlink = ctx->inputs[0];
588 const char *gain_entry_func_names[] = { "entry", NULL };
589 const char *gain_func_names[] = { "gain_interpolate", "cubic_interpolate", NULL };
590 double (*gain_entry_funcs[])(void *, double, double) = { entry_func, NULL };
591 double (*gain_funcs[])(void *, double) = { gain_interpolate_func, cubic_interpolate_func, NULL };
592 double vars[VAR_NB];
593 AVExpr *gain_expr;
594 int ret, k, center, ch;
595 int xlog = s->scale == SCALE_LOGLIN || s->scale == SCALE_LOGLOG;
596 int ylog = s->scale == SCALE_LINLOG || s->scale == SCALE_LOGLOG;
597 FILE *dump_fp = NULL;
598
599 s->nb_gain_entry = 0;
600 s->gain_entry_err = 0;
601 if (gain_entry) {
602 double result = 0.0;
603 ret = av_expr_parse_and_eval(&result, gain_entry, NULL, NULL, NULL, NULL,
604 gain_entry_func_names, gain_entry_funcs, ctx, 0, ctx);
605 if (ret < 0)
606 return ret;
607 if (s->gain_entry_err < 0)
608 return s->gain_entry_err;
609 }
610
611 av_log(ctx, AV_LOG_DEBUG, "nb_gain_entry = %d.\n", s->nb_gain_entry);
612
613 ret = av_expr_parse(&gain_expr, gain, var_names,
614 gain_func_names, gain_funcs, NULL, NULL, 0, ctx);
615 if (ret < 0)
616 return ret;
617
618 if (s->dumpfile && (!s->dump_buf || !s->analysis_rdft || !(dump_fp = avpriv_fopen_utf8(s->dumpfile, "w"))))
619 av_log(ctx, AV_LOG_WARNING, "dumping failed.\n");
620
623 inlink->ch_layout.u.mask : 0;
624 vars[VAR_SR] = inlink->sample_rate;
625 for (ch = 0; ch < inlink->ch_layout.nb_channels; ch++) {
626 float *rdft_buf = s->kernel_tmp_buf + ch * (s->rdft_len * 2);
627 float *rdft_tbuf = s->kernel_tmp_tbuf;
628 double result;
629 vars[VAR_CH] = ch;
631
632 for (k = 0; k <= s->analysis_rdft_len/2; k++) {
633 vars[VAR_F] = k * ((double)inlink->sample_rate /(double)s->analysis_rdft_len);
634 if (xlog)
635 vars[VAR_F] = log2(0.05 * vars[VAR_F]);
636 result = av_expr_eval(gain_expr, vars, ctx);
637 s->analysis_tbuf[2*k] = ylog ? pow(10.0, 0.05 * result) : s->min_phase ? fabs(result) : result;
638 s->analysis_tbuf[2*k+1] = 0.0;
639 }
640
641 if (s->dump_buf)
642 memcpy(s->dump_buf, s->analysis_tbuf, (s->analysis_rdft_len + 2) * sizeof(*s->analysis_tbuf));
643
644 s->analysis_irdft_fn(s->analysis_irdft, s->analysis_buf, s->analysis_tbuf, sizeof(AVComplexFloat));
645 center = s->fir_len / 2;
646
647 for (k = 0; k <= center; k++) {
648 double u = k * (M_PI/center);
649 double win;
650 switch (s->wfunc) {
652 win = 1.0;
653 break;
654 case WFUNC_HANN:
655 win = 0.5 + 0.5 * cos(u);
656 break;
657 case WFUNC_HAMMING:
658 win = 0.53836 + 0.46164 * cos(u);
659 break;
660 case WFUNC_BLACKMAN:
661 win = 0.42 + 0.5 * cos(u) + 0.08 * cos(2*u);
662 break;
663 case WFUNC_NUTTALL3:
664 win = 0.40897 + 0.5 * cos(u) + 0.09103 * cos(2*u);
665 break;
666 case WFUNC_MNUTTALL3:
667 win = 0.4243801 + 0.4973406 * cos(u) + 0.0782793 * cos(2*u);
668 break;
669 case WFUNC_NUTTALL:
670 win = 0.355768 + 0.487396 * cos(u) + 0.144232 * cos(2*u) + 0.012604 * cos(3*u);
671 break;
672 case WFUNC_BNUTTALL:
673 win = 0.3635819 + 0.4891775 * cos(u) + 0.1365995 * cos(2*u) + 0.0106411 * cos(3*u);
674 break;
675 case WFUNC_BHARRIS:
676 win = 0.35875 + 0.48829 * cos(u) + 0.14128 * cos(2*u) + 0.01168 * cos(3*u);
677 break;
678 case WFUNC_TUKEY:
679 win = (u <= 0.5 * M_PI) ? 1.0 : (0.5 + 0.5 * cos(2*u - M_PI));
680 break;
681 default:
682 av_assert0(0);
683 }
684 s->analysis_buf[k] *= (2.0/s->analysis_rdft_len) * (2.0/s->rdft_len) * win;
685 if (k)
686 s->analysis_buf[s->analysis_rdft_len - k] = s->analysis_buf[k];
687 }
688
689 memset(s->analysis_buf + center + 1, 0, (s->analysis_rdft_len - s->fir_len) * sizeof(*s->analysis_buf));
690 memcpy(rdft_tbuf, s->analysis_buf, s->rdft_len/2 * sizeof(*s->analysis_buf));
691 memcpy(rdft_tbuf + s->rdft_len/2, s->analysis_buf + s->analysis_rdft_len - s->rdft_len/2, s->rdft_len/2 * sizeof(*s->analysis_buf));
692 if (s->min_phase)
693 generate_min_phase_kernel(s, rdft_tbuf);
694 s->rdft_fn(s->rdft, rdft_buf, rdft_tbuf, sizeof(float));
695
696 for (k = 0; k < s->rdft_len + 2; k++) {
697 if (isnan(rdft_buf[k]) || isinf(rdft_buf[k])) {
698 av_log(ctx, AV_LOG_ERROR, "filter kernel contains nan or infinity.\n");
699 av_expr_free(gain_expr);
700 if (dump_fp)
701 fclose(dump_fp);
702 return AVERROR(EINVAL);
703 }
704 }
705
706 if (!s->min_phase) {
707 for (k = 0; k <= s->rdft_len/2; k++)
708 rdft_buf[k] = rdft_buf[2*k];
709 }
710
711 if (dump_fp)
712 dump_fir(ctx, dump_fp, ch);
713
714 if (!s->multi)
715 break;
716 }
717
718 memcpy(s->kernel_buf, s->kernel_tmp_buf, (s->multi ? inlink->ch_layout.nb_channels : 1) * (s->rdft_len * 2) * sizeof(*s->kernel_buf));
719 av_expr_free(gain_expr);
720 if (dump_fp)
721 fclose(dump_fp);
722 return 0;
723}
724
725#define SELECT_GAIN(s) (s->gain_cmd ? s->gain_cmd : s->gain)
726#define SELECT_GAIN_ENTRY(s) (s->gain_entry_cmd ? s->gain_entry_cmd : s->gain_entry)
727
728static int config_input(AVFilterLink *inlink)
729{
730 FilterLink *l = ff_filter_link(inlink);
731 AVFilterContext *ctx = inlink->dst;
732 FIREqualizerContext *s = ctx->priv;
733 const double delay_samples = inlink->sample_rate * s->delay;
734 float iscale, scale = 1.f;
735 int rdft_bits, ret;
736
738
739 s->next_pts = 0;
740 s->frame_nsamples_max = 0;
741
742 if (!isfinite(delay_samples) || delay_samples >= (INT_MAX + 1.0) / 2) {
743 av_log(ctx, AV_LOG_ERROR, "too large or non-finite delay, please decrease it.\n");
744 return AVERROR(EINVAL);
745 }
746 s->fir_len = FFMAX(2 * (int)delay_samples + 1, 3);
747 s->remaining = s->fir_len - 1;
748
749 for (rdft_bits = RDFT_BITS_MIN; rdft_bits <= RDFT_BITS_MAX; rdft_bits++) {
750 s->rdft_len = 1 << rdft_bits;
751 s->nsamples_max = s->rdft_len - s->fir_len + 1;
752 if ((int64_t)s->nsamples_max * 2 >= s->fir_len)
753 break;
754 }
755
756 if (rdft_bits > RDFT_BITS_MAX) {
757 av_log(ctx, AV_LOG_ERROR, "too large delay, please decrease it.\n");
758 return AVERROR(EINVAL);
759 }
760
761 iscale = 0.5f;
762 if (((ret = av_tx_init(&s->rdft, &s->rdft_fn, AV_TX_FLOAT_RDFT, 0, 1 << rdft_bits, &scale, 0)) < 0) ||
763 ((ret = av_tx_init(&s->irdft, &s->irdft_fn, AV_TX_FLOAT_RDFT, 1, 1 << rdft_bits, &iscale, 0)) < 0))
764 return ret;
765
766 scale = 1.f;
767 if (s->fft2 && !s->multi && inlink->ch_layout.nb_channels > 1 &&
768 ((ret = av_tx_init(&s->fft_ctx, &s->fft_fn, AV_TX_FLOAT_FFT, 0, 1 << rdft_bits, &scale, 0)) < 0))
769 return ret;
770
771 if (s->min_phase) {
772 int cepstrum_bits = rdft_bits + 2;
773 if (cepstrum_bits > RDFT_BITS_MAX) {
774 av_log(ctx, AV_LOG_ERROR, "too large delay, please decrease it.\n");
775 return AVERROR(EINVAL);
776 }
777
778 cepstrum_bits = FFMIN(RDFT_BITS_MAX, cepstrum_bits + 1);
779 scale = 1.f;
780 ret = av_tx_init(&s->cepstrum_rdft, &s->cepstrum_rdft_fn, AV_TX_FLOAT_RDFT, 0, 1 << cepstrum_bits, &scale, 0);
781 if (ret < 0)
782 return ret;
783
784 iscale = 0.5f;
785 ret = av_tx_init(&s->cepstrum_irdft, &s->cepstrum_irdft_fn, AV_TX_FLOAT_RDFT, 1, 1 << cepstrum_bits, &iscale, 0);
786 if (ret < 0)
787 return ret;
788
789 s->cepstrum_len = 1 << cepstrum_bits;
790 s->cepstrum_buf = av_malloc_array(s->cepstrum_len, sizeof(*s->cepstrum_buf));
791 if (!s->cepstrum_buf)
792 return AVERROR(ENOMEM);
793 s->cepstrum_tbuf = av_malloc_array(s->cepstrum_len + 2, sizeof(*s->cepstrum_tbuf));
794 if (!s->cepstrum_tbuf)
795 return AVERROR(ENOMEM);
796 }
797
798 for ( ; rdft_bits <= RDFT_BITS_MAX; rdft_bits++) {
799 s->analysis_rdft_len = 1 << rdft_bits;
800 if (inlink->sample_rate <= s->accuracy * s->analysis_rdft_len)
801 break;
802 }
803
804 if (rdft_bits > RDFT_BITS_MAX) {
805 av_log(ctx, AV_LOG_ERROR, "too small accuracy, please increase it.\n");
806 return AVERROR(EINVAL);
807 }
808
809 iscale = 0.5f;
810 if ((ret = av_tx_init(&s->analysis_irdft, &s->analysis_irdft_fn, AV_TX_FLOAT_RDFT, 1, 1 << rdft_bits, &iscale, 0)) < 0)
811 return ret;
812
813 if (s->dumpfile) {
814 scale = 1.f;
815 if ((ret = av_tx_init(&s->analysis_rdft, &s->analysis_rdft_fn, AV_TX_FLOAT_RDFT, 0, 1 << rdft_bits, &scale, 0)) < 0)
816 return ret;
817 s->dump_buf = av_malloc_array(s->analysis_rdft_len + 2, sizeof(*s->dump_buf));
818 if (!s->dump_buf)
819 return AVERROR(ENOMEM);
820 }
821
822 s->analysis_buf = av_malloc_array((s->analysis_rdft_len + 2), sizeof(*s->analysis_buf));
823 s->analysis_tbuf = av_malloc_array(s->analysis_rdft_len + 2, sizeof(*s->analysis_tbuf));
824 s->kernel_tmp_buf = av_malloc_array((s->rdft_len * 2) * (s->multi ? inlink->ch_layout.nb_channels : 1), sizeof(*s->kernel_tmp_buf));
825 s->kernel_tmp_tbuf = av_malloc_array(s->rdft_len, sizeof(*s->kernel_tmp_tbuf));
826 s->kernel_buf = av_malloc_array((s->rdft_len * 2) * (s->multi ? inlink->ch_layout.nb_channels : 1), sizeof(*s->kernel_buf));
827 s->tx_buf = av_malloc_array(2 * (s->rdft_len + 2), sizeof(*s->kernel_buf));
828 s->conv_buf = av_calloc(2 * s->rdft_len * inlink->ch_layout.nb_channels, sizeof(*s->conv_buf));
829 s->conv_idx = av_calloc(inlink->ch_layout.nb_channels, sizeof(*s->conv_idx));
830 if (!s->analysis_buf || !s->analysis_tbuf || !s->kernel_tmp_buf || !s->kernel_buf || !s->conv_buf || !s->conv_idx || !s->kernel_tmp_tbuf || !s->tx_buf)
831 return AVERROR(ENOMEM);
832
833 av_log(ctx, AV_LOG_DEBUG, "sample_rate = %d, channels = %d, analysis_rdft_len = %d, rdft_len = %d, fir_len = %d, nsamples_max = %d.\n",
834 inlink->sample_rate, inlink->ch_layout.nb_channels, s->analysis_rdft_len, s->rdft_len, s->fir_len, s->nsamples_max);
835
836 if (s->fixed)
837 l->min_samples = l->max_samples = s->nsamples_max;
838
840}
841
843{
844 AVFilterContext *ctx = inlink->dst;
845 FIREqualizerContext *s = ctx->priv;
846 int ch;
847
848 if (!s->min_phase) {
849 for (ch = 0; ch + 1 < inlink->ch_layout.nb_channels && s->fft_ctx; ch += 2) {
850 fast_convolute2(s, s->kernel_buf, (AVComplexFloat *)(s->conv_buf + 2 * ch * s->rdft_len),
851 s->conv_idx + ch, (float *) frame->extended_data[ch],
852 (float *) frame->extended_data[ch+1], frame->nb_samples);
853 }
854
855 for ( ; ch < inlink->ch_layout.nb_channels; ch++) {
856 fast_convolute(s, s->kernel_buf + (s->multi ? ch * (s->rdft_len * 2) : 0),
857 s->conv_buf + 2 * ch * s->rdft_len, s->conv_idx + ch,
858 (float *) frame->extended_data[ch], frame->nb_samples);
859 }
860 } else {
861 for (ch = 0; ch < inlink->ch_layout.nb_channels; ch++) {
862 fast_convolute_nonlinear(s, s->kernel_buf + (s->multi ? ch * (s->rdft_len * 2) : 0),
863 s->conv_buf + 2 * ch * s->rdft_len, s->conv_idx + ch,
864 (float *) frame->extended_data[ch], frame->nb_samples);
865 }
866 }
867
868 s->next_pts = AV_NOPTS_VALUE;
869 if (frame->pts != AV_NOPTS_VALUE) {
870 s->next_pts = frame->pts + av_rescale_q(frame->nb_samples, av_make_q(1, inlink->sample_rate), inlink->time_base);
871 if (s->zero_phase && !s->min_phase)
872 frame->pts -= av_rescale_q(s->fir_len/2, av_make_q(1, inlink->sample_rate), inlink->time_base);
873 }
874 s->frame_nsamples_max = FFMAX(s->frame_nsamples_max, frame->nb_samples);
875 return ff_filter_frame(ctx->outputs[0], frame);
876}
877
878static int request_frame(AVFilterLink *outlink)
879{
880 AVFilterContext *ctx = outlink->src;
881 FIREqualizerContext *s= ctx->priv;
882 int ret;
883
884 ret = ff_request_frame(ctx->inputs[0]);
885 if (ret == AVERROR_EOF && s->remaining > 0 && s->frame_nsamples_max > 0) {
886 AVFrame *frame = ff_get_audio_buffer(outlink, FFMIN(s->remaining, s->frame_nsamples_max));
887
888 if (!frame)
889 return AVERROR(ENOMEM);
890
891 av_samples_set_silence(frame->extended_data, 0, frame->nb_samples, outlink->ch_layout.nb_channels, frame->format);
892 frame->pts = s->next_pts;
893 s->remaining -= frame->nb_samples;
894 ret = filter_frame(ctx->inputs[0], frame);
895 }
896
897 return ret;
898}
899
900static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
901 char *res, int res_len, int flags)
902{
903 FIREqualizerContext *s = ctx->priv;
904 int ret = AVERROR(ENOSYS);
905
906 if (!strcmp(cmd, "gain")) {
907 char *gain_cmd;
908
909 if (SELECT_GAIN(s) && !strcmp(SELECT_GAIN(s), args)) {
910 av_log(ctx, AV_LOG_DEBUG, "equal gain, do not rebuild.\n");
911 return 0;
912 }
913
914 gain_cmd = av_strdup(args);
915 if (!gain_cmd)
916 return AVERROR(ENOMEM);
917
919 if (ret >= 0) {
920 av_freep(&s->gain_cmd);
921 s->gain_cmd = gain_cmd;
922 } else {
923 av_freep(&gain_cmd);
924 }
925 } else if (!strcmp(cmd, "gain_entry")) {
926 char *gain_entry_cmd;
927
928 if (SELECT_GAIN_ENTRY(s) && !strcmp(SELECT_GAIN_ENTRY(s), args)) {
929 av_log(ctx, AV_LOG_DEBUG, "equal gain_entry, do not rebuild.\n");
930 return 0;
931 }
932
933 gain_entry_cmd = av_strdup(args);
934 if (!gain_entry_cmd)
935 return AVERROR(ENOMEM);
936
937 ret = generate_kernel(ctx, SELECT_GAIN(s), gain_entry_cmd);
938 if (ret >= 0) {
939 av_freep(&s->gain_entry_cmd);
940 s->gain_entry_cmd = gain_entry_cmd;
941 } else {
942 av_freep(&gain_entry_cmd);
943 }
944 }
945
946 return ret;
947}
948
950 {
951 .name = "default",
953 .config_props = config_input,
954 .filter_frame = filter_frame,
955 .type = AVMEDIA_TYPE_AUDIO,
956 },
957};
958
960 {
961 .name = "default",
962 .request_frame = request_frame,
963 .type = AVMEDIA_TYPE_AUDIO,
964 },
965};
966
968 .p.name = "firequalizer",
969 .p.description = NULL_IF_CONFIG_SMALL("Finite Impulse Response Equalizer."),
970 .p.priv_class = &firequalizer_class,
971 .uninit = uninit,
972 .process_command = process_command,
973 .priv_size = sizeof(FIREqualizerContext),
977};
@ VAR_CH
Definition aeval.c:49
static int config_input(AVFilterLink *inlink)
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
@ VAR_F
Definition af_adrc.c:50
static int request_frame(AVFilterLink *outlink)
Definition af_aecho.c:272
#define TFLAGS
Definition af_afade.c:66
static void fast_convolute_nonlinear(FIREqualizerContext *restrict s, const float *restrict kernel_buf, float *restrict conv_buf, OverlapIndex *restrict idx, float *restrict data, int nsamples)
#define RDFT_BITS_MIN
static const AVOption firequalizer_options[]
static double cubic_interpolate_func(void *p, double freq)
static void generate_min_phase_kernel(FIREqualizerContext *s, float *rdft_buf)
#define SELECT_GAIN_ENTRY(s)
#define SELECT_GAIN(s)
static double entry_func(void *p, double freq, double gain)
static const AVFilterPad firequalizer_outputs[]
static int config_input(AVFilterLink *inlink)
static void fast_convolute(FIREqualizerContext *restrict s, const float *restrict kernel_buf, float *restrict conv_buf, OverlapIndex *restrict idx, float *restrict data, int nsamples)
static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
static int gain_entry_compare(const void *key, const void *memb)
static int request_frame(AVFilterLink *outlink)
static void common_uninit(FIREqualizerContext *s)
static void dump_fir(AVFilterContext *ctx, FILE *fp, int ch)
@ SCALE_LINLOG
@ SCALE_LINLIN
@ NB_SCALE
@ SCALE_LOGLIN
@ SCALE_LOGLOG
#define NB_GAIN_ENTRY_MAX
static int generate_kernel(AVFilterContext *ctx, const char *gain, const char *gain_entry)
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
static av_cold void uninit(AVFilterContext *ctx)
static void fast_convolute2(FIREqualizerContext *restrict s, const float *restrict kernel_buf, AVComplexFloat *restrict conv_buf, OverlapIndex *restrict idx, float *restrict data0, float *restrict data1, int nsamples)
const FFFilter ff_af_firequalizer
#define OFFSET(x)
VarOffset
@ VAR_CHID
@ VAR_NB
@ VAR_CHLAYOUT
@ VAR_CHS
#define RDFT_BITS_MAX
static double gain_interpolate_func(void *p, double freq)
WindowFunc
@ WFUNC_HANN
@ WFUNC_HAMMING
@ WFUNC_BNUTTALL
@ WFUNC_BHARRIS
@ WFUNC_NUTTALL3
@ WFUNC_MNUTTALL3
@ WFUNC_BLACKMAN
@ WFUNC_NUTTALL
@ WFUNC_RECTANGULAR
@ WFUNC_TUKEY
@ NB_WFUNC
static const AVFilterPad firequalizer_inputs[]
static float win(SuperEqualizerContext *s, float n, int N)
#define log2(x)
Definition math.h:26
#define entry
static AVFormatContext * ctx
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
Definition audio.c:74
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition avassert.h:42
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition avfilter.c:1079
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
Definition avfilter.c:492
Main libavfilter public API header.
static const uint8_t vars[2][12]
Definition camellia.c:183
#define flags(name, subs,...)
Definition cbs_h264.c:74
#define i(width, name, range_min, range_max)
Definition cbs_h264.c:63
static int FUNC ph(CodedBitstreamContext *ctx, RWContext *rw, H266RawPH *current)
#define s(width, name)
Definition cbs_vp9.c:198
Public libavutil channel layout APIs header.
#define FLAGS
Definition cmdutils.c:596
#define NULL
Definition coverity.c:32
long long int64_t
Definition coverity.c:34
static __device__ float fabs(float a)
static AVFrame * frame
static int filter_frame(DBEDecodeContext *s, AVFrame *frame)
Definition dolby_e.c:1067
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
Definition eval.c:368
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
Definition eval.c:824
int av_expr_parse_and_eval(double *d, const char *s, const char *const *const_names, const double *const_values, const char *const *func1_names, double(*const *funcs1)(void *, double), const char *const *func2_names, double(*const *funcs2)(void *, double, double), void *opaque, int log_offset, void *log_ctx)
Parse and evaluate an expression.
Definition eval.c:839
int av_expr_parse(AVExpr **expr, const char *s, const char *const *const_names, const char *const *func1_names, double(*const *funcs1)(void *, double), const char *const *func2_names, double(*const *funcs2)(void *, double, double), int log_offset, void *log_ctx)
Parse an expression.
Definition eval.c:735
int8_t exp
Definition eval.c:76
simple arithmetic expression evaluator
const char * key
int ret
Definition ffplay.c:391
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition opt.h:298
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition opt.h:258
@ AV_OPT_TYPE_DOUBLE
Underlying C type is double.
Definition opt.h:266
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition opt.h:326
@ AV_OPT_TYPE_STRING
Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...
Definition opt.h:275
enum AVChannel av_channel_layout_channel_from_index(const AVChannelLayout *channel_layout, unsigned int idx)
Get the channel with the given index in a channel layout.
@ AV_CHANNEL_ORDER_NATIVE
The native channel order, i.e.
#define AVERROR_EOF
End of file.
Definition error.h:57
#define AVERROR(e)
Definition error.h:45
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition log.h:231
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition log.h:216
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition log.h:210
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition rational.h:71
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
@ AVMEDIA_TYPE_AUDIO
Definition avutil.h:201
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition samplefmt.h:66
int av_samples_set_silence(uint8_t *const *audio_data, int offset, int nb_samples, int nb_channels, enum AVSampleFormat sample_fmt)
Fill an audio buffer with silence.
Definition samplefmt.c:247
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition avutil.h:247
int a
static av_always_inline void scale(vec_s32 res[4], vec_s16 res_packed[2], const int shift)
#define b
Definition input.c:43
static av_cold void uninit(AVBitStreamFilterContext *ctx)
#define fixed(width, name, value)
Definition cbs_apv.c:75
#define u(width, name, range_min, range_max)
Definition cbs_apv.c:68
#define FILTER_INPUTS(array)
Definition filters.h:279
#define FILTER_OUTPUTS(array)
Definition filters.h:280
#define AVFILTERPAD_FLAG_NEEDS_WRITABLE
The filter expects writable frames from its input link, duplicating data buffers if needed.
Definition filters.h:59
static FilterLink * ff_filter_link(AVFilterLink *link)
Definition filters.h:199
#define FILTER_SINGLE_SAMPLEFMT(sample_fmt_)
Definition filters.h:272
#define AVFILTER_DEFINE_CLASS(fname)
Definition filters.h:493
#define av_cold
Definition attributes.h:117
FILE * avpriv_fopen_utf8(const char *path, const char *mode)
Open a file using a UTF-8 filename.
Definition file_open.c:160
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition internal.h:97
#define FFMIN(a, b)
Definition macros.h:49
#define FFMAX(a, b)
Definition macros.h:47
#define M_PI
Definition mathematics.h:67
void * av_calloc(size_t nmemb, size_t size)
Definition mem.c:370
Memory handling functions.
const char data[16]
Definition mxf.c:149
static const char *const var_names[]
Definition noise.c:30
#define av_strdup(s)
Definition ops_static.c:55
AVOptions.
@ VAR_SR
Definition setts.c:77
enum AVChannelOrder order
Channel order used in this layout.
uint64_t mask
This member must be used for AV_CHANNEL_ORDER_NATIVE, and may be used for AV_CHANNEL_ORDER_AMBISONIC ...
union AVChannelLayout::@162063043056170047076125117143030261346263330336 u
Details about which channels are present in this layout.
int nb_channels
Number of channels in this layout.
Describe the class of an AVClass context structure.
Definition log.h:76
float im
Definition tx.h:28
float re
Definition tx.h:28
Definition eval.c:171
An instance of a filter.
Definition avfilter.h:279
A filter pad used for either input or output.
Definition filters.h:40
This structure describes decoded (raw) audio or video data.
Definition frame.h:479
AVOption.
Definition opt.h:428
AVTXContext * cepstrum_rdft
AVTXContext * analysis_irdft
AVTXContext * fft_ctx
OverlapIndex * conv_idx
GainEntry gain_entry_tbl[NB_GAIN_ENTRY_MAX]
AVTXContext * analysis_rdft
AVTXContext * cepstrum_irdft
#define av_malloc_array(a, b)
#define av_freep(p)
#define av_log(a,...)
static uint8_t tmp[40]
Definition aes_ctr.c:52
FILE * fp
Definition swscale.c:145
av_cold void av_tx_uninit(AVTXContext **ctx)
Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.
Definition tx.c:295
av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)
Initialize a transform context with the given configuration (i)MDCTs with an odd length are currently...
Definition tx.c:903
@ AV_TX_FLOAT_FFT
Standard complex to complex FFT with sample data type of AVComplexFloat, AVComplexDouble or AVComplex...
Definition tx.h:47
@ AV_TX_FLOAT_RDFT
Real to complex and complex to real DFTs.
Definition tx.h:90
void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)
Function pointer to a function to perform the transform.
Definition tx.h:151
static double c[64]