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  uint64_t channels;
114 
115  double a0, a1, a2;
116  double b0, b1, b2;
117 
118  ChanCache *cache;
119  int block_align;
120 
121  void (*filter)(struct BiquadsContext *s, const void *ibuf, void *obuf, int len,
122  double *i1, double *i2, double *o1, double *o2,
123  double b0, double b1, double b2, double a1, double a2, int *clippings,
124  int disabled);
125 } BiquadsContext;
126 
127 static av_cold int init(AVFilterContext *ctx)
128 {
129  BiquadsContext *s = ctx->priv;
130 
131  if (s->filter_type != biquad) {
132  if (s->frequency <= 0 || s->width <= 0) {
133  av_log(ctx, AV_LOG_ERROR, "Invalid frequency %f and/or width %f <= 0\n",
134  s->frequency, s->width);
135  return AVERROR(EINVAL);
136  }
137  }
138 
139  return 0;
140 }
141 
142 static int query_formats(AVFilterContext *ctx)
143 {
144  AVFilterFormats *formats;
145  AVFilterChannelLayouts *layouts;
146  static const enum AVSampleFormat sample_fmts[] = {
147  AV_SAMPLE_FMT_S16P,
148  AV_SAMPLE_FMT_S32P,
149  AV_SAMPLE_FMT_FLTP,
150  AV_SAMPLE_FMT_DBLP,
151  AV_SAMPLE_FMT_NONE
152  };
153  int ret;
154 
155  layouts = ff_all_channel_counts();
156  if (!layouts)
157  return AVERROR(ENOMEM);
158  ret = ff_set_common_channel_layouts(ctx, layouts);
159  if (ret < 0)
160  return ret;
161 
162  formats = ff_make_format_list(sample_fmts);
163  if (!formats)
164  return AVERROR(ENOMEM);
165  ret = ff_set_common_formats(ctx, formats);
166  if (ret < 0)
167  return ret;
168 
169  formats = ff_all_samplerates();
170  if (!formats)
171  return AVERROR(ENOMEM);
172  return ff_set_common_samplerates(ctx, formats);
173 }
174 
175 #define BIQUAD_FILTER(name, type, min, max, need_clipping) \
176 static void biquad_## name (BiquadsContext *s, \
177  const void *input, void *output, int len, \
178  double *in1, double *in2, \
179  double *out1, double *out2, \
180  double b0, double b1, double b2, \
181  double a1, double a2, int *clippings, \
182  int disabled) \
183 { \
184  const type *ibuf = input; \
185  type *obuf = output; \
186  double i1 = *in1; \
187  double i2 = *in2; \
188  double o1 = *out1; \
189  double o2 = *out2; \
190  int i; \
191  a1 = -a1; \
192  a2 = -a2; \
193  \
194  for (i = 0; i+1 < len; i++) { \
195  o2 = i2 * b2 + i1 * b1 + ibuf[i] * b0 + o2 * a2 + o1 * a1; \
196  i2 = ibuf[i]; \
197  if (disabled) { \
198  obuf[i] = i2; \
199  } else if (need_clipping && o2 < min) { \
200  (*clippings)++; \
201  obuf[i] = min; \
202  } else if (need_clipping && o2 > max) { \
203  (*clippings)++; \
204  obuf[i] = max; \
205  } else { \
206  obuf[i] = o2; \
207  } \
208  i++; \
209  o1 = i1 * b2 + i2 * b1 + ibuf[i] * b0 + o1 * a2 + o2 * a1; \
210  i1 = ibuf[i]; \
211  if (disabled) { \
212  obuf[i] = i1; \
213  } else if (need_clipping && o1 < min) { \
214  (*clippings)++; \
215  obuf[i] = min; \
216  } else if (need_clipping && o1 > max) { \
217  (*clippings)++; \
218  obuf[i] = max; \
219  } else { \
220  obuf[i] = o1; \
221  } \
222  } \
223  if (i < len) { \
224  double o0 = ibuf[i] * b0 + i1 * b1 + i2 * b2 + o1 * a1 + o2 * a2; \
225  i2 = i1; \
226  i1 = ibuf[i]; \
227  o2 = o1; \
228  o1 = o0; \
229  if (disabled) { \
230  obuf[i] = i1; \
231  } else if (need_clipping && o0 < min) { \
232  (*clippings)++; \
233  obuf[i] = min; \
234  } else if (need_clipping && o0 > max) { \
235  (*clippings)++; \
236  obuf[i] = max; \
237  } else { \
238  obuf[i] = o0; \
239  } \
240  } \
241  *in1 = i1; \
242  *in2 = i2; \
243  *out1 = o1; \
244  *out2 = o2; \
245 }
246 
247 BIQUAD_FILTER(s16, int16_t, INT16_MIN, INT16_MAX, 1)
248 BIQUAD_FILTER(s32, int32_t, INT32_MIN, INT32_MAX, 1)
249 BIQUAD_FILTER(flt, float, -1., 1., 0)
250 BIQUAD_FILTER(dbl, double, -1., 1., 0)
251 
252 static int config_filter(AVFilterLink *outlink, int reset)
253 {
254  AVFilterContext *ctx = outlink->src;
255  BiquadsContext *s = ctx->priv;
256  AVFilterLink *inlink = ctx->inputs[0];
257  double A = ff_exp10(s->gain / 40);
258  double w0 = 2 * M_PI * s->frequency / inlink->sample_rate;
259  double alpha, beta;
260 
261  if (w0 > M_PI) {
262  av_log(ctx, AV_LOG_ERROR,
263  "Invalid frequency %f. Frequency must be less than half the sample-rate %d.\n",
264  s->frequency, inlink->sample_rate);
265  return AVERROR(EINVAL);
266  }
267 
268  switch (s->width_type) {
269  case NONE:
270  alpha = 0.0;
271  break;
272  case HERTZ:
273  alpha = sin(w0) / (2 * s->frequency / s->width);
274  break;
275  case KHERTZ:
276  alpha = sin(w0) / (2 * s->frequency / (s->width * 1000));
277  break;
278  case OCTAVE:
279  alpha = sin(w0) * sinh(log(2.) / 2 * s->width * w0 / sin(w0));
280  break;
281  case QFACTOR:
282  alpha = sin(w0) / (2 * s->width);
283  break;
284  case SLOPE:
285  alpha = sin(w0) / 2 * sqrt((A + 1 / A) * (1 / s->width - 1) + 2);
286  break;
287  default:
288  av_assert0(0);
289  }
290 
291  beta = 2 * sqrt(A);
292 
293  switch (s->filter_type) {
294  case biquad:
295  break;
296  case equalizer:
297  s->a0 = 1 + alpha / A;
298  s->a1 = -2 * cos(w0);
299  s->a2 = 1 - alpha / A;
300  s->b0 = 1 + alpha * A;
301  s->b1 = -2 * cos(w0);
302  s->b2 = 1 - alpha * A;
303  break;
304  case bass:
305  beta = sqrt((A * A + 1) - (A - 1) * (A - 1));
306  case lowshelf:
307  s->a0 = (A + 1) + (A - 1) * cos(w0) + beta * alpha;
308  s->a1 = -2 * ((A - 1) + (A + 1) * cos(w0));
309  s->a2 = (A + 1) + (A - 1) * cos(w0) - beta * alpha;
310  s->b0 = A * ((A + 1) - (A - 1) * cos(w0) + beta * alpha);
311  s->b1 = 2 * A * ((A - 1) - (A + 1) * cos(w0));
312  s->b2 = A * ((A + 1) - (A - 1) * cos(w0) - beta * alpha);
313  break;
314  case treble:
315  beta = sqrt((A * A + 1) - (A - 1) * (A - 1));
316  case highshelf:
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 bandpass:
325  if (s->csg) {
326  s->a0 = 1 + alpha;
327  s->a1 = -2 * cos(w0);
328  s->a2 = 1 - alpha;
329  s->b0 = sin(w0) / 2;
330  s->b1 = 0;
331  s->b2 = -sin(w0) / 2;
332  } else {
333  s->a0 = 1 + alpha;
334  s->a1 = -2 * cos(w0);
335  s->a2 = 1 - alpha;
336  s->b0 = alpha;
337  s->b1 = 0;
338  s->b2 = -alpha;
339  }
340  break;
341  case bandreject:
342  s->a0 = 1 + alpha;
343  s->a1 = -2 * cos(w0);
344  s->a2 = 1 - alpha;
345  s->b0 = 1;
346  s->b1 = -2 * cos(w0);
347  s->b2 = 1;
348  break;
349  case lowpass:
350  if (s->poles == 1) {
351  s->a0 = 1;
352  s->a1 = -exp(-w0);
353  s->a2 = 0;
354  s->b0 = 1 + s->a1;
355  s->b1 = 0;
356  s->b2 = 0;
357  } else {
358  s->a0 = 1 + alpha;
359  s->a1 = -2 * cos(w0);
360  s->a2 = 1 - alpha;
361  s->b0 = (1 - cos(w0)) / 2;
362  s->b1 = 1 - cos(w0);
363  s->b2 = (1 - cos(w0)) / 2;
364  }
365  break;
366  case highpass:
367  if (s->poles == 1) {
368  s->a0 = 1;
369  s->a1 = -exp(-w0);
370  s->a2 = 0;
371  s->b0 = (1 - s->a1) / 2;
372  s->b1 = -s->b0;
373  s->b2 = 0;
374  } else {
375  s->a0 = 1 + alpha;
376  s->a1 = -2 * cos(w0);
377  s->a2 = 1 - alpha;
378  s->b0 = (1 + cos(w0)) / 2;
379  s->b1 = -(1 + cos(w0));
380  s->b2 = (1 + cos(w0)) / 2;
381  }
382  break;
383  case allpass:
384  s->a0 = 1 + alpha;
385  s->a1 = -2 * cos(w0);
386  s->a2 = 1 - alpha;
387  s->b0 = 1 - alpha;
388  s->b1 = -2 * cos(w0);
389  s->b2 = 1 + alpha;
390  break;
391  default:
392  av_assert0(0);
393  }
394 
395  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);
396 
397  s->a1 /= s->a0;
398  s->a2 /= s->a0;
399  s->b0 /= s->a0;
400  s->b1 /= s->a0;
401  s->b2 /= s->a0;
402  s->a0 /= s->a0;
403 
404  s->cache = av_realloc_f(s->cache, sizeof(ChanCache), inlink->channels);
405  if (!s->cache)
406  return AVERROR(ENOMEM);
407  if (reset)
408  memset(s->cache, 0, sizeof(ChanCache) * inlink->channels);
409 
410  switch (inlink->format) {
411  case AV_SAMPLE_FMT_S16P: s->filter = biquad_s16; break;
412  case AV_SAMPLE_FMT_S32P: s->filter = biquad_s32; break;
413  case AV_SAMPLE_FMT_FLTP: s->filter = biquad_flt; break;
414  case AV_SAMPLE_FMT_DBLP: s->filter = biquad_dbl; break;
415  default: av_assert0(0);
416  }
417 
418  s->block_align = av_get_bytes_per_sample(inlink->format);
419 
420  return 0;
421 }
422 
423 static int config_output(AVFilterLink *outlink)
424 {
425  return config_filter(outlink, 1);
426 }
427 
428 typedef struct ThreadData {
429  AVFrame *in, *out;
430 } ThreadData;
431 
432 static int filter_channel(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
433 {
434  AVFilterLink *inlink = ctx->inputs[0];
435  ThreadData *td = arg;
436  AVFrame *buf = td->in;
437  AVFrame *out_buf = td->out;
438  BiquadsContext *s = ctx->priv;
439  const int start = (buf->channels * jobnr) / nb_jobs;
440  const int end = (buf->channels * (jobnr+1)) / nb_jobs;
441  int ch;
442 
443  for (ch = start; ch < end; ch++) {
444  if (!((av_channel_layout_extract_channel(inlink->channel_layout, ch) & s->channels))) {
445  if (buf != out_buf)
446  memcpy(out_buf->extended_data[ch], buf->extended_data[ch],
447  buf->nb_samples * s->block_align);
448  continue;
449  }
450 
451  s->filter(s, buf->extended_data[ch], out_buf->extended_data[ch], buf->nb_samples,
452  &s->cache[ch].i1, &s->cache[ch].i2, &s->cache[ch].o1, &s->cache[ch].o2,
453  s->b0, s->b1, s->b2, s->a1, s->a2, &s->cache[ch].clippings, ctx->is_disabled);
454  }
455 
456  return 0;
457 }
458 
459 static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
460 {
461  AVFilterContext *ctx = inlink->dst;
462  BiquadsContext *s = ctx->priv;
463  AVFilterLink *outlink = ctx->outputs[0];
464  AVFrame *out_buf;
465  ThreadData td;
466  int ch;
467 
468  if (av_frame_is_writable(buf)) {
469  out_buf = buf;
470  } else {
471  out_buf = ff_get_audio_buffer(outlink, buf->nb_samples);
472  if (!out_buf) {
473  av_frame_free(&buf);
474  return AVERROR(ENOMEM);
475  }
476  av_frame_copy_props(out_buf, buf);
477  }
478 
479  td.in = buf;
480  td.out = out_buf;
481  ctx->internal->execute(ctx, filter_channel, &td, NULL, FFMIN(outlink->channels, ff_filter_get_nb_threads(ctx)));
482 
483  for (ch = 0; ch < outlink->channels; ch++) {
484  if (s->cache[ch].clippings > 0)
485  av_log(ctx, AV_LOG_WARNING, "Channel %d clipping %d times. Please reduce gain.\n",
486  ch, s->cache[ch].clippings);
487  s->cache[ch].clippings = 0;
488  }
489 
490  if (buf != out_buf)
491  av_frame_free(&buf);
492 
493  return ff_filter_frame(outlink, out_buf);
494 }
495 
496 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
497  char *res, int res_len, int flags)
498 {
499  BiquadsContext *s = ctx->priv;
500  AVFilterLink *outlink = ctx->outputs[0];
501 
502  if ((!strcmp(cmd, "frequency") || !strcmp(cmd, "f")) &&
503  (s->filter_type == equalizer ||
504  s->filter_type == lowshelf ||
505  s->filter_type == highshelf ||
506  s->filter_type == bass ||
507  s->filter_type == treble ||
508  s->filter_type == bandpass ||
509  s->filter_type == bandreject||
510  s->filter_type == lowpass ||
511  s->filter_type == highpass ||
512  s->filter_type == allpass)) {
513  double freq;
514 
515  if (sscanf(args, "%lf", &freq) != 1) {
516  av_log(ctx, AV_LOG_ERROR, "Invalid frequency value.\n");
517  return AVERROR(EINVAL);
518  }
519 
520  s->frequency = freq;
521  } else if ((!strcmp(cmd, "gain") || !strcmp(cmd, "g")) &&
522  (s->filter_type == equalizer ||
523  s->filter_type == lowshelf ||
524  s->filter_type == highshelf ||
525  s->filter_type == bass ||
526  s->filter_type == treble)) {
527  double gain;
528 
529  if (sscanf(args, "%lf", &gain) != 1) {
530  av_log(ctx, AV_LOG_ERROR, "Invalid gain value.\n");
531  return AVERROR(EINVAL);
532  }
533 
534  s->gain = gain;
535  } else if ((!strcmp(cmd, "width") || !strcmp(cmd, "w")) &&
536  (s->filter_type == equalizer ||
537  s->filter_type == lowshelf ||
538  s->filter_type == highshelf ||
539  s->filter_type == bass ||
540  s->filter_type == treble ||
541  s->filter_type == bandpass ||
542  s->filter_type == bandreject||
543  s->filter_type == lowpass ||
544  s->filter_type == highpass ||
545  s->filter_type == allpass)) {
546  double width;
547 
548  if (sscanf(args, "%lf", &width) != 1) {
549  av_log(ctx, AV_LOG_ERROR, "Invalid width value.\n");
550  return AVERROR(EINVAL);
551  }
552 
553  s->width = width;
554  } else if ((!strcmp(cmd, "width_type") || !strcmp(cmd, "t")) &&
555  (s->filter_type == equalizer ||
556  s->filter_type == lowshelf ||
557  s->filter_type == highshelf ||
558  s->filter_type == bass ||
559  s->filter_type == treble ||
560  s->filter_type == bandpass ||
561  s->filter_type == bandreject||
562  s->filter_type == lowpass ||
563  s->filter_type == highpass ||
564  s->filter_type == allpass)) {
565  char width_type;
566 
567  if (sscanf(args, "%c", &width_type) != 1) {
568  av_log(ctx, AV_LOG_ERROR, "Invalid width_type value.\n");
569  return AVERROR(EINVAL);
570  }
571 
572  switch (width_type) {
573  case 'h': width_type = HERTZ; break;
574  case 'q': width_type = QFACTOR; break;
575  case 'o': width_type = OCTAVE; break;
576  case 's': width_type = SLOPE; break;
577  case 'k': width_type = KHERTZ; break;
578  default:
579  av_log(ctx, AV_LOG_ERROR, "Invalid width_type value: %c\n", width_type);
580  return AVERROR(EINVAL);
581  }
582 
583  s->width_type = width_type;
584  } else if ((!strcmp(cmd, "a0") ||
585  !strcmp(cmd, "a1") ||
586  !strcmp(cmd, "a2") ||
587  !strcmp(cmd, "b0") ||
588  !strcmp(cmd, "b1") ||
589  !strcmp(cmd, "b2")) &&
590  s->filter_type == biquad) {
591  double value;
592 
593  if (sscanf(args, "%lf", &value) != 1) {
594  av_log(ctx, AV_LOG_ERROR, "Invalid biquad value.\n");
595  return AVERROR(EINVAL);
596  }
597 
598  if (!strcmp(cmd, "a0"))
599  s->a0 = value;
600  else if (!strcmp(cmd, "a1"))
601  s->a1 = value;
602  else if (!strcmp(cmd, "a2"))
603  s->a2 = value;
604  else if (!strcmp(cmd, "b0"))
605  s->b0 = value;
606  else if (!strcmp(cmd, "b1"))
607  s->b1 = value;
608  else if (!strcmp(cmd, "b2"))
609  s->b2 = value;
610  }
611 
612  return config_filter(outlink, 0);
613 }
614 
615 static av_cold void uninit(AVFilterContext *ctx)
616 {
617  BiquadsContext *s = ctx->priv;
618 
619  av_freep(&s->cache);
620 }
621 
622 static const AVFilterPad inputs[] = {
623  {
624  .name = "default",
625  .type = AVMEDIA_TYPE_AUDIO,
626  .filter_frame = filter_frame,
627  },
628  { NULL }
629 };
630 
631 static const AVFilterPad outputs[] = {
632  {
633  .name = "default",
634  .type = AVMEDIA_TYPE_AUDIO,
635  .config_props = config_output,
636  },
637  { NULL }
638 };
639 
640 #define OFFSET(x) offsetof(BiquadsContext, x)
641 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
642 
643 #define DEFINE_BIQUAD_FILTER(name_, description_) \
644 AVFILTER_DEFINE_CLASS(name_); \
645 static av_cold int name_##_init(AVFilterContext *ctx) \
646 { \
647  BiquadsContext *s = ctx->priv; \
648  s->class = &name_##_class; \
649  s->filter_type = name_; \
650  return init(ctx); \
651 } \
652  \
653 AVFilter ff_af_##name_ = { \
654  .name = #name_, \
655  .description = NULL_IF_CONFIG_SMALL(description_), \
656  .priv_size = sizeof(BiquadsContext), \
657  .init = name_##_init, \
658  .uninit = uninit, \
659  .query_formats = query_formats, \
660  .inputs = inputs, \
661  .outputs = outputs, \
662  .priv_class = &name_##_class, \
663  .process_command = process_command, \
664  .flags = AVFILTER_FLAG_SLICE_THREADS | AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL, \
665 }
666 
667 #if CONFIG_EQUALIZER_FILTER
668 static const AVOption equalizer_options[] = {
669  {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0, 999999, FLAGS},
670  {"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0, 999999, FLAGS},
671  {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
672  {"t", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
673  {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
674  {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
675  {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
676  {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
677  {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
678  {"width", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 99999, FLAGS},
679  {"w", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 99999, FLAGS},
680  {"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
681  {"g", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
682  {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
683  {"c", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
684  {NULL}
685 };
686 
687 DEFINE_BIQUAD_FILTER(equalizer, "Apply two-pole peaking equalization (EQ) filter.");
688 #endif /* CONFIG_EQUALIZER_FILTER */
689 #if CONFIG_BASS_FILTER
690 static const AVOption bass_options[] = {
691  {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=100}, 0, 999999, FLAGS},
692  {"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=100}, 0, 999999, FLAGS},
693  {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
694  {"t", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
695  {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
696  {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
697  {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
698  {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
699  {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
700  {"width", "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
701  {"w", "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
702  {"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
703  {"g", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
704  {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
705  {"c", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
706  {NULL}
707 };
708 
709 DEFINE_BIQUAD_FILTER(bass, "Boost or cut lower frequencies.");
710 #endif /* CONFIG_BASS_FILTER */
711 #if CONFIG_TREBLE_FILTER
712 static const AVOption treble_options[] = {
713  {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
714  {"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
715  {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
716  {"t", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
717  {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
718  {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
719  {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
720  {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
721  {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
722  {"width", "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
723  {"w", "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
724  {"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
725  {"g", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
726  {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
727  {"c", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
728  {NULL}
729 };
730 
731 DEFINE_BIQUAD_FILTER(treble, "Boost or cut upper frequencies.");
732 #endif /* CONFIG_TREBLE_FILTER */
733 #if CONFIG_BANDPASS_FILTER
734 static const AVOption bandpass_options[] = {
735  {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
736  {"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
737  {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
738  {"t", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
739  {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
740  {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
741  {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
742  {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
743  {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
744  {"width", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
745  {"w", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
746  {"csg", "use constant skirt gain", OFFSET(csg), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
747  {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
748  {"c", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
749  {NULL}
750 };
751 
752 DEFINE_BIQUAD_FILTER(bandpass, "Apply a two-pole Butterworth band-pass filter.");
753 #endif /* CONFIG_BANDPASS_FILTER */
754 #if CONFIG_BANDREJECT_FILTER
755 static const AVOption bandreject_options[] = {
756  {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
757  {"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
758  {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
759  {"t", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
760  {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
761  {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
762  {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
763  {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
764  {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
765  {"width", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
766  {"w", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
767  {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
768  {"c", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
769  {NULL}
770 };
771 
772 DEFINE_BIQUAD_FILTER(bandreject, "Apply a two-pole Butterworth band-reject filter.");
773 #endif /* CONFIG_BANDREJECT_FILTER */
774 #if CONFIG_LOWPASS_FILTER
775 static const AVOption lowpass_options[] = {
776  {"frequency", "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=500}, 0, 999999, FLAGS},
777  {"f", "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=500}, 0, 999999, FLAGS},
778  {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
779  {"t", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
780  {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
781  {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
782  {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
783  {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
784  {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
785  {"width", "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},
786  {"w", "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},
787  {"poles", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
788  {"p", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
789  {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
790  {"c", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
791  {NULL}
792 };
793 
794 DEFINE_BIQUAD_FILTER(lowpass, "Apply a low-pass filter with 3dB point frequency.");
795 #endif /* CONFIG_LOWPASS_FILTER */
796 #if CONFIG_HIGHPASS_FILTER
797 static const AVOption highpass_options[] = {
798  {"frequency", "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
799  {"f", "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
800  {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
801  {"t", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
802  {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
803  {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
804  {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
805  {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
806  {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
807  {"width", "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},
808  {"w", "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},
809  {"poles", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
810  {"p", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
811  {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
812  {"c", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
813  {NULL}
814 };
815 
816 DEFINE_BIQUAD_FILTER(highpass, "Apply a high-pass filter with 3dB point frequency.");
817 #endif /* CONFIG_HIGHPASS_FILTER */
818 #if CONFIG_ALLPASS_FILTER
819 static const AVOption allpass_options[] = {
820  {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
821  {"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
822  {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=HERTZ}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
823  {"t", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=HERTZ}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
824  {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
825  {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
826  {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
827  {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
828  {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
829  {"width", "set filter-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=707.1}, 0, 99999, FLAGS},
830  {"w", "set filter-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=707.1}, 0, 99999, FLAGS},
831  {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
832  {"c", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
833  {NULL}
834 };
835 
836 DEFINE_BIQUAD_FILTER(allpass, "Apply a two-pole all-pass filter.");
837 #endif /* CONFIG_ALLPASS_FILTER */
838 #if CONFIG_LOWSHELF_FILTER
839 static const AVOption lowshelf_options[] = {
840  {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=100}, 0, 999999, FLAGS},
841  {"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=100}, 0, 999999, FLAGS},
842  {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
843  {"t", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
844  {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
845  {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
846  {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
847  {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
848  {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
849  {"width", "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
850  {"w", "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
851  {"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
852  {"g", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
853  {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
854  {"c", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
855  {NULL}
856 };
857 
858 DEFINE_BIQUAD_FILTER(lowshelf, "Apply a low shelf filter.");
859 #endif /* CONFIG_LOWSHELF_FILTER */
860 #if CONFIG_HIGHSHELF_FILTER
861 static const AVOption highshelf_options[] = {
862  {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
863  {"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
864  {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
865  {"t", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
866  {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
867  {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
868  {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
869  {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
870  {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
871  {"width", "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
872  {"w", "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
873  {"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
874  {"g", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
875  {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
876  {"c", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
877  {NULL}
878 };
879 
880 DEFINE_BIQUAD_FILTER(highshelf, "Apply a high shelf filter.");
881 #endif /* CONFIG_HIGHSHELF_FILTER */
882 #if CONFIG_BIQUAD_FILTER
883 static const AVOption biquad_options[] = {
884  {"a0", NULL, OFFSET(a0), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT32_MIN, INT32_MAX, FLAGS},
885  {"a1", NULL, OFFSET(a1), AV_OPT_TYPE_DOUBLE, {.dbl=0}, INT32_MIN, INT32_MAX, FLAGS},
886  {"a2", NULL, OFFSET(a2), AV_OPT_TYPE_DOUBLE, {.dbl=0}, INT32_MIN, INT32_MAX, FLAGS},
887  {"b0", NULL, OFFSET(b0), AV_OPT_TYPE_DOUBLE, {.dbl=0}, INT32_MIN, INT32_MAX, FLAGS},
888  {"b1", NULL, OFFSET(b1), AV_OPT_TYPE_DOUBLE, {.dbl=0}, INT32_MIN, INT32_MAX, FLAGS},
889  {"b2", NULL, OFFSET(b2), AV_OPT_TYPE_DOUBLE, {.dbl=0}, INT32_MIN, INT32_MAX, FLAGS},
890  {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
891  {"c", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
892  {NULL}
893 };
894 
895 DEFINE_BIQUAD_FILTER(biquad, "Apply a biquad IIR filter with the given coefficients.");
896 #endif /* CONFIG_BIQUAD_FILTER */
AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
NULL
#define NULL
Definition: coverity.c:32
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:549
ThreadData::out
AVFrame * out
Definition: af_adeclick.c:488
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:268
av_realloc_f
#define av_realloc_f(p, o, n)
Definition: tableprint_vlc.h:33
AVOption
AVOption.
Definition: opt.h:246
BiquadsContext::cache
ChanCache * cache
Definition: af_biquads.c:118
bandpass
Definition: af_biquads.c:77
ret
ret
Definition: filter_design.txt:187
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
avfilter.h
Main libavfilter public API header.
AV_OPT_TYPE_INT
Definition: opt.h:223
ChanCache::i2
double i2
Definition: af_biquads.c:97
a0
#define a0
Definition: regdef.h:46
channels
channels
Definition: aptx.c:30
highshelf
Definition: af_biquads.c:83
ch
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(INT64_C(1)<< 63)))#define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};static void cpy1(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, len);}static void cpy2(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 2 *len);}static void cpy4(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 4 *len);}static void cpy8(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;}void swri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len){int ch;int off=0;const int os=(out->planar?1:out->ch_count)*out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){int planes=in->planar?in->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){int planes=out->planar?out->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){int planes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
AV_SAMPLE_FMT_DBLP
double, planar
Definition: samplefmt.h:70
a1
#define a1
Definition: regdef.h:47
QFACTOR
Definition: af_biquads.c:90
AVS_Value
Definition: avisynth_c.h:672
inputs
static const AVFilterPad inputs[]
Definition: af_biquads.c:622
AVFilterContext::is_disabled
int is_disabled
the enabled state from the last expression evaluation
Definition: avfilter.h:385
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
biquad
Definition: af_biquads.c:73
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:60
lowshelf
Definition: af_biquads.c:82
AVFilterContext::inputs
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:346
FilterType
FilterType
Definition: af_anequalizer.c:33
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AV_OPT_TYPE_CONST
Definition: opt.h:232
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1080
OFFSET
#define OFFSET(x)
Definition: af_biquads.c:640
av_cold
#define av_cold
Definition: attributes.h:82
opt.h
AVOptions.
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
value
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
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:121
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
A
#define A(x)
Definition: vp56_arith.h:28
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AV_OPT_TYPE_CHANNEL_LAYOUT
Definition: opt.h:239
outputs
static const AVFilterPad outputs[]
Definition: af_biquads.c:631
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:54
init
static av_cold int init(AVFilterContext *ctx)
Definition: af_biquads.c:127
ff_exp10
static av_always_inline double ff_exp10(double x)
Compute 10^x for floating point values.
Definition: ffmath.h:42
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
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:568
td
#define td
Definition: regdef.h:70
FLAGS
#define FLAGS
Definition: af_biquads.c:641
treble
Definition: af_biquads.c:76
filter
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
Definition: filter_design.txt:228
KHERTZ
Definition: af_biquads.c:92
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_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
AVFilterContext::priv
void * priv
private data for use by the filter
Definition: avfilter.h:353
arg
const char * arg
Definition: jacosubdec.c:66
AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
avassert.h
simple assert() macros that are a bit more flexible than ISO C assert().
BiquadsContext::channels
uint64_t channels
Definition: af_biquads.c:113
exp
int8_t exp
Definition: eval.c:72
ChanCache::o1
double o1
Definition: af_biquads.c:98
HERTZ
Definition: af_biquads.c:88
AVFrame::channels
int channels
number of audio channels, only used for audio.
Definition: frame.h:573
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:802
NONE
Definition: af_biquads.c:87
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
AV_SAMPLE_FMT_S32P
signed 32 bits, planar
Definition: samplefmt.h:68
width
#define width
void
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
int32_t
int32_t
Definition: audio_convert.c:194
ctx
AVFormatContext * ctx
Definition: movenc.c:48
a2
#define a2
Definition: regdef.h:48
AV_OPT_TYPE_BOOL
Definition: opt.h:240
s
#define s(width, name)
Definition: cbs_vp9.c:257
allpass
Definition: af_biquads.c:79
SLOPE
Definition: af_biquads.c:91
NB_WTYPE
Definition: af_biquads.c:93
highpass
Definition: af_biquads.c:80
AVFilterChannelLayouts
A list of supported channel layouts.
Definition: formats.h:85
AV_OPT_TYPE_DOUBLE
Definition: opt.h:225
BIQUAD_FILTER
#define BIQUAD_FILTER(name, type, min, max, need_clipping)
Definition: af_biquads.c:175
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
filter_channel
static int filter_channel(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: af_biquads.c:432
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:594
ThreadData
Used for passing data between threads.
Definition: af_adeclick.c:487
config_output
static int config_output(AVFilterLink *outlink)
Definition: af_biquads.c:423
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
buf
void * buf
Definition: avisynth_c.h:766
bass
Definition: af_biquads.c:75
in
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
Definition: audio_convert.c:194
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
DEFINE_BIQUAD_FILTER
#define DEFINE_BIQUAD_FILTER(name_, description_)
Definition: af_biquads.c:643
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: af_biquads.c:142
equalizer
Definition: af_biquads.c:74
ChanCache::o2
double o2
Definition: af_biquads.c:98
AVFilterContext::outputs
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
layouts
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:434
ff_all_samplerates
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:395
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVFilterContext::internal
AVFilterInternal * internal
An opaque struct for libavfilter internal use.
Definition: avfilter.h:378
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: af_biquads.c:615
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
ChanCache::clippings
int clippings
Definition: af_biquads.c:99
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:207
ffmath.h
internal math functions header
lowpass
Definition: af_biquads.c:81
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
AVFilterInternal::execute
avfilter_execute_func * execute
Definition: internal.h:155
config_filter
static int config_filter(AVFilterLink *outlink, int reset)
Definition: af_biquads.c:252
WidthType
WidthType
Definition: af_biquads.c:86
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
Definition: af_biquads.c:459
len
int len
Definition: vorbis_enc_data.h:452
ChanCache::i1
double i1
Definition: af_biquads.c:97
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
AVFilterContext
An instance of a filter.
Definition: avfilter.h:338
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:701
out
FILE * out
Definition: movenc.c:54
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:496
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
start
void INT64 start
Definition: avisynth_c.h:766
AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:67
BiquadsContext::frequency
double frequency
Definition: af_biquads.c:111
M_PI
#define M_PI
Definition: mathematics.h:52
bandreject
Definition: af_biquads.c:78
ThreadData::in
AVFrame * in
Definition: af_afftdn.c:1082
formats
formats
Definition: signature.h:48
internal.h
internal API functions
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
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:410
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:315
BiquadsContext::filter_type
enum FilterType filter_type
Definition: af_biquads.c:105
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:334
ff_set_common_samplerates
int ff_set_common_samplerates(AVFilterContext *ctx, AVFilterFormats *samplerates)
Definition: formats.c:556
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:654
OCTAVE
Definition: af_biquads.c:89
Generated on Mon Jun 24 2019 19:22:01 for FFmpeg by   doxygen 1.8.11