FFmpeg
af_biquads.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2013 Paul B Mahol
3  * Copyright (c) 2006-2008 Rob Sykes <robs@users.sourceforge.net>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /*
23  * 2-pole filters designed by Robert Bristow-Johnson <rbj@audioimagination.com>
24  * see http://www.musicdsp.org/files/Audio-EQ-Cookbook.txt
25  *
26  * 1-pole filters based on code (c) 2000 Chris Bagwell <cbagwell@sprynet.com>
27  * Algorithms: Recursive single pole low/high pass filter
28  * Reference: The Scientist and Engineer's Guide to Digital Signal Processing
29  *
30  * low-pass: output[N] = input[N] * A + output[N-1] * B
31  * X = exp(-2.0 * pi * Fc)
32  * A = 1 - X
33  * B = X
34  * Fc = cutoff freq / sample rate
35  *
36  * Mimics an RC low-pass filter:
37  *
38  * ---/\/\/\/\----------->
39  * |
40  * --- C
41  * ---
42  * |
43  * |
44  * V
45  *
46  * high-pass: output[N] = A0 * input[N] + A1 * input[N-1] + B1 * output[N-1]
47  * X = exp(-2.0 * pi * Fc)
48  * A0 = (1 + X) / 2
49  * A1 = -(1 + X) / 2
50  * B1 = X
51  * Fc = cutoff freq / sample rate
52  *
53  * Mimics an RC high-pass filter:
54  *
55  * || C
56  * ----||--------->
57  * || |
58  * <
59  * > R
60  * <
61  * |
62  * V
63  */
64 
65 #include "libavutil/avassert.h"
66 #include "libavutil/ffmath.h"
67 #include "libavutil/opt.h"
68 #include "audio.h"
69 #include "avfilter.h"
70 #include "internal.h"
71 
72 enum FilterType {
73  biquad,
74  equalizer,
75  bass,
76  treble,
77  bandpass,
78  bandreject,
79  allpass,
80  highpass,
81  lowpass,
82  lowshelf,
83  highshelf,
84 };
85 
86 enum WidthType {
87  NONE,
88  HERTZ,
89  OCTAVE,
90  QFACTOR,
91  SLOPE,
92  KHERTZ,
93  NB_WTYPE,
94 };
95 
96 typedef struct ChanCache {
97  double i1, i2;
98  double o1, o2;
99  int clippings;
100 } ChanCache;
101 
102 typedef struct BiquadsContext {
103  const AVClass *class;
104 
105  enum FilterType filter_type;
106  int width_type;
107  int poles;
108  int csg;
109 
110  double gain;
111  double frequency;
112  double width;
113  double mix;
114  uint64_t channels;
115  int normalize;
116  int order;
117 
118  double a0, a1, a2;
119  double b0, b1, b2;
120 
121  ChanCache *cache;
122  int block_align;
123 
124  void (*filter)(struct BiquadsContext *s, const void *ibuf, void *obuf, int len,
125  double *i1, double *i2, double *o1, double *o2,
126  double b0, double b1, double b2, double a1, double a2, int *clippings,
127  int disabled);
128 } BiquadsContext;
129 
130 static av_cold int init(AVFilterContext *ctx)
131 {
132  BiquadsContext *s = ctx->priv;
133 
134  if (s->filter_type != biquad) {
135  if (s->frequency <= 0 || s->width <= 0) {
136  av_log(ctx, AV_LOG_ERROR, "Invalid frequency %f and/or width %f <= 0\n",
137  s->frequency, s->width);
138  return AVERROR(EINVAL);
139  }
140  }
141 
142  return 0;
143 }
144 
145 static int query_formats(AVFilterContext *ctx)
146 {
147  AVFilterFormats *formats;
148  AVFilterChannelLayouts *layouts;
149  static const enum AVSampleFormat sample_fmts[] = {
150  AV_SAMPLE_FMT_S16P,
151  AV_SAMPLE_FMT_S32P,
152  AV_SAMPLE_FMT_FLTP,
153  AV_SAMPLE_FMT_DBLP,
154  AV_SAMPLE_FMT_NONE
155  };
156  int ret;
157 
158  layouts = ff_all_channel_counts();
159  if (!layouts)
160  return AVERROR(ENOMEM);
161  ret = ff_set_common_channel_layouts(ctx, layouts);
162  if (ret < 0)
163  return ret;
164 
165  formats = ff_make_format_list(sample_fmts);
166  if (!formats)
167  return AVERROR(ENOMEM);
168  ret = ff_set_common_formats(ctx, formats);
169  if (ret < 0)
170  return ret;
171 
172  formats = ff_all_samplerates();
173  if (!formats)
174  return AVERROR(ENOMEM);
175  return ff_set_common_samplerates(ctx, formats);
176 }
177 
178 #define BIQUAD_FILTER(name, type, min, max, need_clipping) \
179 static void biquad_## name (BiquadsContext *s, \
180  const void *input, void *output, int len, \
181  double *in1, double *in2, \
182  double *out1, double *out2, \
183  double b0, double b1, double b2, \
184  double a1, double a2, int *clippings, \
185  int disabled) \
186 { \
187  const type *ibuf = input; \
188  type *obuf = output; \
189  double i1 = *in1; \
190  double i2 = *in2; \
191  double o1 = *out1; \
192  double o2 = *out2; \
193  double wet = s->mix; \
194  double dry = 1. - wet; \
195  double out; \
196  int i; \
197  a1 = -a1; \
198  a2 = -a2; \
199  \
200  for (i = 0; i+1 < len; i++) { \
201  o2 = i2 * b2 + i1 * b1 + ibuf[i] * b0 + o2 * a2 + o1 * a1; \
202  i2 = ibuf[i]; \
203  out = o2 * wet + i2 * dry; \
204  if (disabled) { \
205  obuf[i] = i2; \
206  } else if (need_clipping && out < min) { \
207  (*clippings)++; \
208  obuf[i] = min; \
209  } else if (need_clipping && out > max) { \
210  (*clippings)++; \
211  obuf[i] = max; \
212  } else { \
213  obuf[i] = out; \
214  } \
215  i++; \
216  o1 = i1 * b2 + i2 * b1 + ibuf[i] * b0 + o1 * a2 + o2 * a1; \
217  i1 = ibuf[i]; \
218  out = o1 * wet + i1 * dry; \
219  if (disabled) { \
220  obuf[i] = i1; \
221  } else if (need_clipping && out < min) { \
222  (*clippings)++; \
223  obuf[i] = min; \
224  } else if (need_clipping && out > max) { \
225  (*clippings)++; \
226  obuf[i] = max; \
227  } else { \
228  obuf[i] = out; \
229  } \
230  } \
231  if (i < len) { \
232  double o0 = ibuf[i] * b0 + i1 * b1 + i2 * b2 + o1 * a1 + o2 * a2; \
233  i2 = i1; \
234  i1 = ibuf[i]; \
235  o2 = o1; \
236  o1 = o0; \
237  out = o0 * wet + i1 * dry; \
238  if (disabled) { \
239  obuf[i] = i1; \
240  } else if (need_clipping && out < min) { \
241  (*clippings)++; \
242  obuf[i] = min; \
243  } else if (need_clipping && out > max) { \
244  (*clippings)++; \
245  obuf[i] = max; \
246  } else { \
247  obuf[i] = out; \
248  } \
249  } \
250  *in1 = i1; \
251  *in2 = i2; \
252  *out1 = o1; \
253  *out2 = o2; \
254 }
255 
256 BIQUAD_FILTER(s16, int16_t, INT16_MIN, INT16_MAX, 1)
257 BIQUAD_FILTER(s32, int32_t, INT32_MIN, INT32_MAX, 1)
258 BIQUAD_FILTER(flt, float, -1., 1., 0)
259 BIQUAD_FILTER(dbl, double, -1., 1., 0)
260 
261 static int config_filter(AVFilterLink *outlink, int reset)
262 {
263  AVFilterContext *ctx = outlink->src;
264  BiquadsContext *s = ctx->priv;
265  AVFilterLink *inlink = ctx->inputs[0];
266  double A = ff_exp10(s->gain / 40);
267  double w0 = 2 * M_PI * s->frequency / inlink->sample_rate;
268  double K = tan(w0 / 2.);
269  double alpha, beta;
270 
271  if (w0 > M_PI) {
272  av_log(ctx, AV_LOG_ERROR,
273  "Invalid frequency %f. Frequency must be less than half the sample-rate %d.\n",
274  s->frequency, inlink->sample_rate);
275  return AVERROR(EINVAL);
276  }
277 
278  switch (s->width_type) {
279  case NONE:
280  alpha = 0.0;
281  break;
282  case HERTZ:
283  alpha = sin(w0) / (2 * s->frequency / s->width);
284  break;
285  case KHERTZ:
286  alpha = sin(w0) / (2 * s->frequency / (s->width * 1000));
287  break;
288  case OCTAVE:
289  alpha = sin(w0) * sinh(log(2.) / 2 * s->width * w0 / sin(w0));
290  break;
291  case QFACTOR:
292  alpha = sin(w0) / (2 * s->width);
293  break;
294  case SLOPE:
295  alpha = sin(w0) / 2 * sqrt((A + 1 / A) * (1 / s->width - 1) + 2);
296  break;
297  default:
298  av_assert0(0);
299  }
300 
301  beta = 2 * sqrt(A);
302 
303  switch (s->filter_type) {
304  case biquad:
305  break;
306  case equalizer:
307  s->a0 = 1 + alpha / A;
308  s->a1 = -2 * cos(w0);
309  s->a2 = 1 - alpha / A;
310  s->b0 = 1 + alpha * A;
311  s->b1 = -2 * cos(w0);
312  s->b2 = 1 - alpha * A;
313  break;
314  case bass:
315  beta = sqrt((A * A + 1) - (A - 1) * (A - 1));
316  case lowshelf:
317  s->a0 = (A + 1) + (A - 1) * cos(w0) + beta * alpha;
318  s->a1 = -2 * ((A - 1) + (A + 1) * cos(w0));
319  s->a2 = (A + 1) + (A - 1) * cos(w0) - beta * alpha;
320  s->b0 = A * ((A + 1) - (A - 1) * cos(w0) + beta * alpha);
321  s->b1 = 2 * A * ((A - 1) - (A + 1) * cos(w0));
322  s->b2 = A * ((A + 1) - (A - 1) * cos(w0) - beta * alpha);
323  break;
324  case treble:
325  beta = sqrt((A * A + 1) - (A - 1) * (A - 1));
326  case highshelf:
327  s->a0 = (A + 1) - (A - 1) * cos(w0) + beta * alpha;
328  s->a1 = 2 * ((A - 1) - (A + 1) * cos(w0));
329  s->a2 = (A + 1) - (A - 1) * cos(w0) - beta * alpha;
330  s->b0 = A * ((A + 1) + (A - 1) * cos(w0) + beta * alpha);
331  s->b1 =-2 * A * ((A - 1) + (A + 1) * cos(w0));
332  s->b2 = A * ((A + 1) + (A - 1) * cos(w0) - beta * alpha);
333  break;
334  case bandpass:
335  if (s->csg) {
336  s->a0 = 1 + alpha;
337  s->a1 = -2 * cos(w0);
338  s->a2 = 1 - alpha;
339  s->b0 = sin(w0) / 2;
340  s->b1 = 0;
341  s->b2 = -sin(w0) / 2;
342  } else {
343  s->a0 = 1 + alpha;
344  s->a1 = -2 * cos(w0);
345  s->a2 = 1 - alpha;
346  s->b0 = alpha;
347  s->b1 = 0;
348  s->b2 = -alpha;
349  }
350  break;
351  case bandreject:
352  s->a0 = 1 + alpha;
353  s->a1 = -2 * cos(w0);
354  s->a2 = 1 - alpha;
355  s->b0 = 1;
356  s->b1 = -2 * cos(w0);
357  s->b2 = 1;
358  break;
359  case lowpass:
360  if (s->poles == 1) {
361  s->a0 = 1;
362  s->a1 = -exp(-w0);
363  s->a2 = 0;
364  s->b0 = 1 + s->a1;
365  s->b1 = 0;
366  s->b2 = 0;
367  } else {
368  s->a0 = 1 + alpha;
369  s->a1 = -2 * cos(w0);
370  s->a2 = 1 - alpha;
371  s->b0 = (1 - cos(w0)) / 2;
372  s->b1 = 1 - cos(w0);
373  s->b2 = (1 - cos(w0)) / 2;
374  }
375  break;
376  case highpass:
377  if (s->poles == 1) {
378  s->a0 = 1;
379  s->a1 = -exp(-w0);
380  s->a2 = 0;
381  s->b0 = (1 - s->a1) / 2;
382  s->b1 = -s->b0;
383  s->b2 = 0;
384  } else {
385  s->a0 = 1 + alpha;
386  s->a1 = -2 * cos(w0);
387  s->a2 = 1 - alpha;
388  s->b0 = (1 + cos(w0)) / 2;
389  s->b1 = -(1 + cos(w0));
390  s->b2 = (1 + cos(w0)) / 2;
391  }
392  break;
393  case allpass:
394  switch (s->order) {
395  case 1:
396  s->a0 = 1.;
397  s->a1 = -(1. - K) / (1. + K);
398  s->a2 = 0.;
399  s->b0 = s->a1;
400  s->b1 = s->a0;
401  s->b2 = 0.;
402  break;
403  case 2:
404  s->a0 = 1 + alpha;
405  s->a1 = -2 * cos(w0);
406  s->a2 = 1 - alpha;
407  s->b0 = 1 - alpha;
408  s->b1 = -2 * cos(w0);
409  s->b2 = 1 + alpha;
410  break;
411  }
412  break;
413  default:
414  av_assert0(0);
415  }
416 
417  av_log(ctx, AV_LOG_VERBOSE, "a=%f %f %f:b=%f %f %f\n", s->a0, s->a1, s->a2, s->b0, s->b1, s->b2);
418 
419  s->a1 /= s->a0;
420  s->a2 /= s->a0;
421  s->b0 /= s->a0;
422  s->b1 /= s->a0;
423  s->b2 /= s->a0;
424  s->a0 /= s->a0;
425 
426  if (s->normalize && fabs(s->b0 + s->b1 + s->b2) > 1e-6) {
427  double factor = (s->a0 + s->a1 + s->a2) / (s->b0 + s->b1 + s->b2);
428 
429  s->b0 *= factor;
430  s->b1 *= factor;
431  s->b2 *= factor;
432  }
433 
434  s->cache = av_realloc_f(s->cache, sizeof(ChanCache), inlink->channels);
435  if (!s->cache)
436  return AVERROR(ENOMEM);
437  if (reset)
438  memset(s->cache, 0, sizeof(ChanCache) * inlink->channels);
439 
440  switch (inlink->format) {
441  case AV_SAMPLE_FMT_S16P: s->filter = biquad_s16; break;
442  case AV_SAMPLE_FMT_S32P: s->filter = biquad_s32; break;
443  case AV_SAMPLE_FMT_FLTP: s->filter = biquad_flt; break;
444  case AV_SAMPLE_FMT_DBLP: s->filter = biquad_dbl; break;
445  default: av_assert0(0);
446  }
447 
448  s->block_align = av_get_bytes_per_sample(inlink->format);
449 
450  return 0;
451 }
452 
453 static int config_output(AVFilterLink *outlink)
454 {
455  return config_filter(outlink, 1);
456 }
457 
458 typedef struct ThreadData {
459  AVFrame *in, *out;
460 } ThreadData;
461 
462 static int filter_channel(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
463 {
464  AVFilterLink *inlink = ctx->inputs[0];
465  ThreadData *td = arg;
466  AVFrame *buf = td->in;
467  AVFrame *out_buf = td->out;
468  BiquadsContext *s = ctx->priv;
469  const int start = (buf->channels * jobnr) / nb_jobs;
470  const int end = (buf->channels * (jobnr+1)) / nb_jobs;
471  int ch;
472 
473  for (ch = start; ch < end; ch++) {
474  if (!((av_channel_layout_extract_channel(inlink->channel_layout, ch) & s->channels))) {
475  if (buf != out_buf)
476  memcpy(out_buf->extended_data[ch], buf->extended_data[ch],
477  buf->nb_samples * s->block_align);
478  continue;
479  }
480 
481  s->filter(s, buf->extended_data[ch], out_buf->extended_data[ch], buf->nb_samples,
482  &s->cache[ch].i1, &s->cache[ch].i2, &s->cache[ch].o1, &s->cache[ch].o2,
483  s->b0, s->b1, s->b2, s->a1, s->a2, &s->cache[ch].clippings, ctx->is_disabled);
484  }
485 
486  return 0;
487 }
488 
489 static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
490 {
491  AVFilterContext *ctx = inlink->dst;
492  BiquadsContext *s = ctx->priv;
493  AVFilterLink *outlink = ctx->outputs[0];
494  AVFrame *out_buf;
495  ThreadData td;
496  int ch;
497 
498  if (av_frame_is_writable(buf)) {
499  out_buf = buf;
500  } else {
501  out_buf = ff_get_audio_buffer(outlink, buf->nb_samples);
502  if (!out_buf) {
503  av_frame_free(&buf);
504  return AVERROR(ENOMEM);
505  }
506  av_frame_copy_props(out_buf, buf);
507  }
508 
509  td.in = buf;
510  td.out = out_buf;
511  ctx->internal->execute(ctx, filter_channel, &td, NULL, FFMIN(outlink->channels, ff_filter_get_nb_threads(ctx)));
512 
513  for (ch = 0; ch < outlink->channels; ch++) {
514  if (s->cache[ch].clippings > 0)
515  av_log(ctx, AV_LOG_WARNING, "Channel %d clipping %d times. Please reduce gain.\n",
516  ch, s->cache[ch].clippings);
517  s->cache[ch].clippings = 0;
518  }
519 
520  if (buf != out_buf)
521  av_frame_free(&buf);
522 
523  return ff_filter_frame(outlink, out_buf);
524 }
525 
526 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
527  char *res, int res_len, int flags)
528 {
529  AVFilterLink *outlink = ctx->outputs[0];
530  int ret;
531 
532  ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
533  if (ret < 0)
534  return ret;
535 
536  return config_filter(outlink, 0);
537 }
538 
539 static av_cold void uninit(AVFilterContext *ctx)
540 {
541  BiquadsContext *s = ctx->priv;
542 
543  av_freep(&s->cache);
544 }
545 
546 static const AVFilterPad inputs[] = {
547  {
548  .name = "default",
549  .type = AVMEDIA_TYPE_AUDIO,
550  .filter_frame = filter_frame,
551  },
552  { NULL }
553 };
554 
555 static const AVFilterPad outputs[] = {
556  {
557  .name = "default",
558  .type = AVMEDIA_TYPE_AUDIO,
559  .config_props = config_output,
560  },
561  { NULL }
562 };
563 
564 #define OFFSET(x) offsetof(BiquadsContext, x)
565 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
566 #define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
567 
568 #define DEFINE_BIQUAD_FILTER(name_, description_) \
569 AVFILTER_DEFINE_CLASS(name_); \
570 static av_cold int name_##_init(AVFilterContext *ctx) \
571 { \
572  BiquadsContext *s = ctx->priv; \
573  s->class = &name_##_class; \
574  s->filter_type = name_; \
575  return init(ctx); \
576 } \
577  \
578 AVFilter ff_af_##name_ = { \
579  .name = #name_, \
580  .description = NULL_IF_CONFIG_SMALL(description_), \
581  .priv_size = sizeof(BiquadsContext), \
582  .init = name_##_init, \
583  .uninit = uninit, \
584  .query_formats = query_formats, \
585  .inputs = inputs, \
586  .outputs = outputs, \
587  .priv_class = &name_##_class, \
588  .process_command = process_command, \
589  .flags = AVFILTER_FLAG_SLICE_THREADS | AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL, \
590 }
591 
592 #if CONFIG_EQUALIZER_FILTER
593 static const AVOption equalizer_options[] = {
594  {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0, 999999, FLAGS},
595  {"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0, 999999, FLAGS},
596  {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
597  {"t", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
598  {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
599  {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
600  {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
601  {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
602  {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
603  {"width", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 99999, FLAGS},
604  {"w", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 99999, FLAGS},
605  {"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
606  {"g", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
607  {"mix", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},
608  {"m", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},
609  {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
610  {"c", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
611  {"normalize", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
612  {"n", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
613  {NULL}
614 };
615 
616 DEFINE_BIQUAD_FILTER(equalizer, "Apply two-pole peaking equalization (EQ) filter.");
617 #endif /* CONFIG_EQUALIZER_FILTER */
618 #if CONFIG_BASS_FILTER
619 static const AVOption bass_options[] = {
620  {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=100}, 0, 999999, FLAGS},
621  {"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=100}, 0, 999999, FLAGS},
622  {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
623  {"t", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
624  {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
625  {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
626  {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
627  {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
628  {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
629  {"width", "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
630  {"w", "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
631  {"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
632  {"g", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
633  {"mix", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},
634  {"m", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},
635  {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
636  {"c", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
637  {"normalize", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
638  {"n", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
639  {NULL}
640 };
641 
642 DEFINE_BIQUAD_FILTER(bass, "Boost or cut lower frequencies.");
643 #endif /* CONFIG_BASS_FILTER */
644 #if CONFIG_TREBLE_FILTER
645 static const AVOption treble_options[] = {
646  {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
647  {"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
648  {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
649  {"t", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
650  {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
651  {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
652  {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
653  {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
654  {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
655  {"width", "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
656  {"w", "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
657  {"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
658  {"g", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
659  {"mix", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},
660  {"m", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},
661  {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
662  {"c", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
663  {"normalize", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
664  {"n", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
665  {NULL}
666 };
667 
668 DEFINE_BIQUAD_FILTER(treble, "Boost or cut upper frequencies.");
669 #endif /* CONFIG_TREBLE_FILTER */
670 #if CONFIG_BANDPASS_FILTER
671 static const AVOption bandpass_options[] = {
672  {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
673  {"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
674  {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
675  {"t", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
676  {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
677  {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
678  {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
679  {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
680  {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
681  {"width", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
682  {"w", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
683  {"csg", "use constant skirt gain", OFFSET(csg), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
684  {"mix", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},
685  {"m", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},
686  {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
687  {"c", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
688  {"normalize", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
689  {"n", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
690  {NULL}
691 };
692 
693 DEFINE_BIQUAD_FILTER(bandpass, "Apply a two-pole Butterworth band-pass filter.");
694 #endif /* CONFIG_BANDPASS_FILTER */
695 #if CONFIG_BANDREJECT_FILTER
696 static const AVOption bandreject_options[] = {
697  {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
698  {"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
699  {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
700  {"t", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
701  {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
702  {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
703  {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
704  {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
705  {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
706  {"width", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
707  {"w", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
708  {"mix", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},
709  {"m", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},
710  {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
711  {"c", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
712  {"normalize", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
713  {"n", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
714  {NULL}
715 };
716 
717 DEFINE_BIQUAD_FILTER(bandreject, "Apply a two-pole Butterworth band-reject filter.");
718 #endif /* CONFIG_BANDREJECT_FILTER */
719 #if CONFIG_LOWPASS_FILTER
720 static const AVOption lowpass_options[] = {
721  {"frequency", "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=500}, 0, 999999, FLAGS},
722  {"f", "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=500}, 0, 999999, FLAGS},
723  {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
724  {"t", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
725  {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
726  {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
727  {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
728  {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
729  {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
730  {"width", "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},
731  {"w", "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},
732  {"poles", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, AF},
733  {"p", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, AF},
734  {"mix", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},
735  {"m", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},
736  {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
737  {"c", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
738  {"normalize", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
739  {"n", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
740  {NULL}
741 };
742 
743 DEFINE_BIQUAD_FILTER(lowpass, "Apply a low-pass filter with 3dB point frequency.");
744 #endif /* CONFIG_LOWPASS_FILTER */
745 #if CONFIG_HIGHPASS_FILTER
746 static const AVOption highpass_options[] = {
747  {"frequency", "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
748  {"f", "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
749  {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
750  {"t", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
751  {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
752  {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
753  {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
754  {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
755  {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
756  {"width", "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},
757  {"w", "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},
758  {"poles", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, AF},
759  {"p", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, AF},
760  {"mix", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},
761  {"m", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},
762  {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
763  {"c", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
764  {"normalize", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
765  {"n", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
766  {NULL}
767 };
768 
769 DEFINE_BIQUAD_FILTER(highpass, "Apply a high-pass filter with 3dB point frequency.");
770 #endif /* CONFIG_HIGHPASS_FILTER */
771 #if CONFIG_ALLPASS_FILTER
772 static const AVOption allpass_options[] = {
773  {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
774  {"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
775  {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=HERTZ}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
776  {"t", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=HERTZ}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
777  {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
778  {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
779  {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
780  {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
781  {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
782  {"width", "set filter-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=707.1}, 0, 99999, FLAGS},
783  {"w", "set filter-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=707.1}, 0, 99999, FLAGS},
784  {"mix", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},
785  {"m", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},
786  {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
787  {"c", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
788  {"normalize", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
789  {"n", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
790  {"order", "set filter order", OFFSET(order), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
791  {"o", "set filter order", OFFSET(order), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
792  {NULL}
793 };
794 
795 DEFINE_BIQUAD_FILTER(allpass, "Apply a two-pole all-pass filter.");
796 #endif /* CONFIG_ALLPASS_FILTER */
797 #if CONFIG_LOWSHELF_FILTER
798 static const AVOption lowshelf_options[] = {
799  {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=100}, 0, 999999, FLAGS},
800  {"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=100}, 0, 999999, FLAGS},
801  {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
802  {"t", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
803  {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
804  {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
805  {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
806  {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
807  {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
808  {"width", "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
809  {"w", "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
810  {"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
811  {"g", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
812  {"mix", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},
813  {"m", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},
814  {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
815  {"c", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
816  {"normalize", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
817  {"n", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
818  {NULL}
819 };
820 
821 DEFINE_BIQUAD_FILTER(lowshelf, "Apply a low shelf filter.");
822 #endif /* CONFIG_LOWSHELF_FILTER */
823 #if CONFIG_HIGHSHELF_FILTER
824 static const AVOption highshelf_options[] = {
825  {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
826  {"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
827  {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
828  {"t", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
829  {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
830  {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
831  {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
832  {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
833  {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
834  {"width", "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
835  {"w", "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
836  {"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
837  {"g", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
838  {"mix", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},
839  {"m", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},
840  {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
841  {"c", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
842  {"normalize", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
843  {"n", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
844  {NULL}
845 };
846 
847 DEFINE_BIQUAD_FILTER(highshelf, "Apply a high shelf filter.");
848 #endif /* CONFIG_HIGHSHELF_FILTER */
849 #if CONFIG_BIQUAD_FILTER
850 static const AVOption biquad_options[] = {
851  {"a0", NULL, OFFSET(a0), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT32_MIN, INT32_MAX, FLAGS},
852  {"a1", NULL, OFFSET(a1), AV_OPT_TYPE_DOUBLE, {.dbl=0}, INT32_MIN, INT32_MAX, FLAGS},
853  {"a2", NULL, OFFSET(a2), AV_OPT_TYPE_DOUBLE, {.dbl=0}, INT32_MIN, INT32_MAX, FLAGS},
854  {"b0", NULL, OFFSET(b0), AV_OPT_TYPE_DOUBLE, {.dbl=0}, INT32_MIN, INT32_MAX, FLAGS},
855  {"b1", NULL, OFFSET(b1), AV_OPT_TYPE_DOUBLE, {.dbl=0}, INT32_MIN, INT32_MAX, FLAGS},
856  {"b2", NULL, OFFSET(b2), AV_OPT_TYPE_DOUBLE, {.dbl=0}, INT32_MIN, INT32_MAX, FLAGS},
857  {"mix", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},
858  {"m", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},
859  {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
860  {"c", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
861  {"normalize", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
862  {"n", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
863  {NULL}
864 };
865 
866 DEFINE_BIQUAD_FILTER(biquad, "Apply a biquad IIR filter with the given coefficients.");
867 #endif /* CONFIG_BIQUAD_FILTER */
formats
formats
Definition: signature.h:48
ff_get_audio_buffer
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
Definition: audio.c:86
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
AVFilterChannelLayouts
A list of supported channel layouts.
Definition: formats.h:85
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
td
#define td
Definition: regdef.h:70
ff_exp10
static av_always_inline double ff_exp10(double x)
Compute 10^x for floating point values.
Definition: ffmath.h:42
mix
static int mix(int c0, int c1)
Definition: 4xm.c:714
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
BiquadsContext::b0
double b0
Definition: af_biquads.c:119
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:300
BiquadsContext::normalize
int normalize
Definition: af_biquads.c:115
BiquadsContext
Definition: af_biquads.c:102
BiquadsContext::block_align
int block_align
Definition: af_biquads.c:122
BiquadsContext::width_type
int width_type
Definition: af_biquads.c:106
ff_set_common_channel_layouts
int ff_set_common_channel_layouts(AVFilterContext *ctx, AVFilterChannelLayouts *layouts)
A helper for query_formats() which sets all links to the same list of channel layouts/sample rates.
Definition: formats.c:586
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1075
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:716
layouts
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:434
BiquadsContext::a0
double a0
Definition: af_biquads.c:118
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
SLOPE
@ SLOPE
Definition: af_biquads.c:91
FilterType
FilterType
Definition: af_anequalizer.c:33
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
ff_all_channel_counts
AVFilterChannelLayouts * ff_all_channel_counts(void)
Construct an AVFilterChannelLayouts coding for any channel layout, with known or unknown disposition.
Definition: formats.c:454
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
AVOption
AVOption.
Definition: opt.h:246
BiquadsContext::csg
int csg
Definition: af_biquads.c:108
AV_SAMPLE_FMT_S32P
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
Definition: samplefmt.h:68
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
bandreject
@ bandreject
Definition: af_biquads.c:78
ThreadData::out
AVFrame * out
Definition: af_adeclick.c:494
AVFormatContext::internal
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1788
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
A
#define A(x)
Definition: vp56_arith.h:28
ChanCache::i2
double i2
Definition: af_biquads.c:97
b1
static double b1(void *priv, double x, double y)
Definition: vf_xfade.c:1332
outputs
static const AVFilterPad outputs[]
Definition: af_biquads.c:555
BiquadsContext::filter
void(* filter)(struct BiquadsContext *s, const void *ibuf, void *obuf, int len, double *i1, double *i2, double *o1, double *o2, double b0, double b1, double b2, double a1, double a2, int *clippings, int disabled)
Definition: af_biquads.c:124
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:54
BiquadsContext::channels
uint64_t channels
Definition: af_biquads.c:114
a1
#define a1
Definition: regdef.h:47
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_cold
#define av_cold
Definition: attributes.h:90
ff_set_common_formats
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:605
width
#define width
s
#define s(width, name)
Definition: cbs_vp9.c:257
AVFrame::channels
int channels
number of audio channels, only used for audio.
Definition: frame.h:606
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Definition: opt.h:225
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
highpass
@ highpass
Definition: af_biquads.c:80
NB_WTYPE
@ NB_WTYPE
Definition: af_biquads.c:93
BiquadsContext::a1
double a1
Definition: af_biquads.c:118
ctx
AVFormatContext * ctx
Definition: movenc.c:48
channels
channels
Definition: aptx.h:33
BiquadsContext::width
double width
Definition: af_biquads.c:112
BiquadsContext::poles
int poles
Definition: af_biquads.c:107
int32_t
int32_t
Definition: audio_convert.c:194
arg
const char * arg
Definition: jacosubdec.c:66
av_realloc_f
#define av_realloc_f(p, o, n)
Definition: tableprint_vlc.h:33
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
NULL
#define NULL
Definition: coverity.c:32
biquad
@ biquad
Definition: af_biquads.c:73
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:659
BiquadsContext::cache
ChanCache * cache
Definition: af_biquads.c:121
allpass
@ allpass
Definition: af_biquads.c:79
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
Definition: af_biquads.c:489
exp
int8_t exp
Definition: eval.c:72
process_command
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: af_biquads.c:526
BiquadsContext::order
int order
Definition: af_biquads.c:116
init
static av_cold int init(AVFilterContext *ctx)
Definition: af_biquads.c:130
KHERTZ
@ KHERTZ
Definition: af_biquads.c:92
ChanCache::i1
double i1
Definition: af_biquads.c:97
lowpass
@ lowpass
Definition: af_biquads.c:81
AF
#define AF
Definition: af_biquads.c:566
filter_channel
static int filter_channel(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: af_biquads.c:462
BiquadsContext::b1
double b1
Definition: af_biquads.c:119
NONE
@ NONE
Definition: af_biquads.c:87
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
highshelf
@ highshelf
Definition: af_biquads.c:83
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:595
ChanCache::o2
double o2
Definition: af_biquads.c:98
bass
@ bass
Definition: af_biquads.c:75
AV_OPT_TYPE_CHANNEL_LAYOUT
@ AV_OPT_TYPE_CHANNEL_LAYOUT
Definition: opt.h:239
ff_filter_process_command
int ff_filter_process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Generic processing of user supplied commands that are set in the same way as the filter options.
Definition: avfilter.c:869
config_output
static int config_output(AVFilterLink *outlink)
Definition: af_biquads.c:453
b2
static double b2(void *priv, double x, double y)
Definition: vf_xfade.c:1333
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
a0
#define a0
Definition: regdef.h:46
M_PI
#define M_PI
Definition: mathematics.h:52
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:67
internal.h
inputs
static const AVFilterPad inputs[]
Definition: af_biquads.c:546
BiquadsContext::mix
double mix
Definition: af_biquads.c:113
QFACTOR
@ QFACTOR
Definition: af_biquads.c:90
normalize
Definition: normalize.py:1
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:366
av_get_bytes_per_sample
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
av_channel_layout_extract_channel
uint64_t av_channel_layout_extract_channel(uint64_t channel_layout, int index)
Get the channel with the given index in channel_layout.
Definition: channel_layout.c:265
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:347
a2
#define a2
Definition: regdef.h:48
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:784
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
ThreadData
Used for passing data between threads.
Definition: dsddec.c:67
config_filter
static int config_filter(AVFilterLink *outlink, int reset)
Definition: af_biquads.c:261
len
int len
Definition: vorbis_enc_data.h:452
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:60
treble
@ treble
Definition: af_biquads.c:76
OFFSET
#define OFFSET(x)
Definition: af_biquads.c:564
ret
ret
Definition: filter_design.txt:187
WidthType
WidthType
Definition: af_biquads.c:86
BIQUAD_FILTER
#define BIQUAD_FILTER(name, type, min, max, need_clipping)
Definition: af_biquads.c:178
ChanCache
Definition: af_biquads.c:96
DEFINE_BIQUAD_FILTER
#define DEFINE_BIQUAD_FILTER(name_, description_)
Definition: af_biquads.c:568
ff_all_samplerates
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:439
BiquadsContext::filter_type
enum FilterType filter_type
Definition: af_biquads.c:105
HERTZ
@ HERTZ
Definition: af_biquads.c:88
BiquadsContext::gain
double gain
Definition: af_biquads.c:110
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:223
avfilter.h
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: af_biquads.c:145
AV_SAMPLE_FMT_DBLP
@ AV_SAMPLE_FMT_DBLP
double, planar
Definition: samplefmt.h:70
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: af_biquads.c:539
ffmath.h
ChanCache::o1
double o1
Definition: af_biquads.c:98
AVFilterContext
An instance of a filter.
Definition: avfilter.h:338
factor
static const int factor[16]
Definition: vf_pp7.c:75
FLAGS
#define FLAGS
Definition: af_biquads.c:565
BiquadsContext::b2
double b2
Definition: af_biquads.c:119
audio.h
ThreadData::in
AVFrame * in
Definition: af_afftdn.c:1083
lowshelf
@ lowshelf
Definition: af_biquads.c:82
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:240
equalizer
@ equalizer
Definition: af_biquads.c:74
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
ChanCache::clippings
int clippings
Definition: af_biquads.c:99
OCTAVE
@ OCTAVE
Definition: af_biquads.c:89
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:565
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
ff_set_common_samplerates
int ff_set_common_samplerates(AVFilterContext *ctx, AVFilterFormats *samplerates)
Definition: formats.c:593
b0
static double b0(void *priv, double x, double y)
Definition: vf_xfade.c:1331
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:232
BiquadsContext::frequency
double frequency
Definition: af_biquads.c:111
BiquadsContext::a2
double a2
Definition: af_biquads.c:118
bandpass
@ bandpass
Definition: af_biquads.c:77
Generated on Wed Aug 24 2022 21:31:44 for FFmpeg by   doxygen 1.8.17