avfilter: rename variables in geq
[ffmpeg.git] / libavfilter / af_biquads.c
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/opt.h"
67 #include "audio.h"
68 #include "avfilter.h"
69 #include "internal.h"
70
71 enum FilterType {
72     biquad,
73     equalizer,
74     bass,
75     treble,
76     bandpass,
77     bandreject,
78     allpass,
79     highpass,
80     lowpass,
81 };
82
83 enum WidthType {
84     NONE,
85     HERTZ,
86     OCTAVE,
87     QFACTOR,
88     SLOPE,
89     KHERTZ,
90     NB_WTYPE,
91 };
92
93 typedef struct ChanCache {
94     double i1, i2;
95     double o1, o2;
96 } ChanCache;
97
98 typedef struct BiquadsContext {
99     const AVClass *class;
100
101     enum FilterType filter_type;
102     int width_type;
103     int poles;
104     int csg;
105
106     double gain;
107     double frequency;
108     double width;
109     uint64_t channels;
110
111     double a0, a1, a2;
112     double b0, b1, b2;
113
114     ChanCache *cache;
115     int clippings;
116     int block_align;
117
118     void (*filter)(struct BiquadsContext *s, const void *ibuf, void *obuf, int len,
119                    double *i1, double *i2, double *o1, double *o2,
120                    double b0, double b1, double b2, double a1, double a2);
121 } BiquadsContext;
122
123 static av_cold int init(AVFilterContext *ctx)
124 {
125     BiquadsContext *s = ctx->priv;
126
127     if (s->filter_type != biquad) {
128         if (s->frequency <= 0 || s->width <= 0) {
129             av_log(ctx, AV_LOG_ERROR, "Invalid frequency %f and/or width %f <= 0\n",
130                    s->frequency, s->width);
131             return AVERROR(EINVAL);
132         }
133     }
134
135     return 0;
136 }
137
138 static int query_formats(AVFilterContext *ctx)
139 {
140     AVFilterFormats *formats;
141     AVFilterChannelLayouts *layouts;
142     static const enum AVSampleFormat sample_fmts[] = {
143         AV_SAMPLE_FMT_S16P,
144         AV_SAMPLE_FMT_S32P,
145         AV_SAMPLE_FMT_FLTP,
146         AV_SAMPLE_FMT_DBLP,
147         AV_SAMPLE_FMT_NONE
148     };
149     int ret;
150
151     layouts = ff_all_channel_counts();
152     if (!layouts)
153         return AVERROR(ENOMEM);
154     ret = ff_set_common_channel_layouts(ctx, layouts);
155     if (ret < 0)
156         return ret;
157
158     formats = ff_make_format_list(sample_fmts);
159     if (!formats)
160         return AVERROR(ENOMEM);
161     ret = ff_set_common_formats(ctx, formats);
162     if (ret < 0)
163         return ret;
164
165     formats = ff_all_samplerates();
166     if (!formats)
167         return AVERROR(ENOMEM);
168     return ff_set_common_samplerates(ctx, formats);
169 }
170
171 #define BIQUAD_FILTER(name, type, min, max, need_clipping)                    \
172 static void biquad_## name (BiquadsContext *s,                                \
173                             const void *input, void *output, int len,         \
174                             double *in1, double *in2,                         \
175                             double *out1, double *out2,                       \
176                             double b0, double b1, double b2,                  \
177                             double a1, double a2)                             \
178 {                                                                             \
179     const type *ibuf = input;                                                 \
180     type *obuf = output;                                                      \
181     double i1 = *in1;                                                         \
182     double i2 = *in2;                                                         \
183     double o1 = *out1;                                                        \
184     double o2 = *out2;                                                        \
185     int i;                                                                    \
186     a1 = -a1;                                                                 \
187     a2 = -a2;                                                                 \
188                                                                               \
189     for (i = 0; i+1 < len; i++) {                                             \
190         o2 = i2 * b2 + i1 * b1 + ibuf[i] * b0 + o2 * a2 + o1 * a1;            \
191         i2 = ibuf[i];                                                         \
192         if (need_clipping && o2 < min) {                                      \
193             s->clippings++;                                                   \
194             obuf[i] = min;                                                    \
195         } else if (need_clipping && o2 > max) {                               \
196             s->clippings++;                                                   \
197             obuf[i] = max;                                                    \
198         } else {                                                              \
199             obuf[i] = o2;                                                     \
200         }                                                                     \
201         i++;                                                                  \
202         o1 = i1 * b2 + i2 * b1 + ibuf[i] * b0 + o1 * a2 + o2 * a1;            \
203         i1 = ibuf[i];                                                         \
204         if (need_clipping && o1 < min) {                                      \
205             s->clippings++;                                                   \
206             obuf[i] = min;                                                    \
207         } else if (need_clipping && o1 > max) {                               \
208             s->clippings++;                                                   \
209             obuf[i] = max;                                                    \
210         } else {                                                              \
211             obuf[i] = o1;                                                     \
212         }                                                                     \
213     }                                                                         \
214     if (i < len) {                                                            \
215         double o0 = ibuf[i] * b0 + i1 * b1 + i2 * b2 + o1 * a1 + o2 * a2;     \
216         i2 = i1;                                                              \
217         i1 = ibuf[i];                                                         \
218         o2 = o1;                                                              \
219         o1 = o0;                                                              \
220         if (need_clipping && o0 < min) {                                      \
221             s->clippings++;                                                   \
222             obuf[i] = min;                                                    \
223         } else if (need_clipping && o0 > max) {                               \
224             s->clippings++;                                                   \
225             obuf[i] = max;                                                    \
226         } else {                                                              \
227             obuf[i] = o0;                                                     \
228         }                                                                     \
229     }                                                                         \
230     *in1  = i1;                                                               \
231     *in2  = i2;                                                               \
232     *out1 = o1;                                                               \
233     *out2 = o2;                                                               \
234 }
235
236 BIQUAD_FILTER(s16, int16_t, INT16_MIN, INT16_MAX, 1)
237 BIQUAD_FILTER(s32, int32_t, INT32_MIN, INT32_MAX, 1)
238 BIQUAD_FILTER(flt, float,   -1., 1., 0)
239 BIQUAD_FILTER(dbl, double,  -1., 1., 0)
240
241 static int config_filter(AVFilterLink *outlink, int reset)
242 {
243     AVFilterContext *ctx    = outlink->src;
244     BiquadsContext *s       = ctx->priv;
245     AVFilterLink *inlink    = ctx->inputs[0];
246     double A = exp(s->gain / 40 * log(10.));
247     double w0 = 2 * M_PI * s->frequency / inlink->sample_rate;
248     double alpha;
249
250     if (w0 > M_PI) {
251         av_log(ctx, AV_LOG_ERROR,
252                "Invalid frequency %f. Frequency must be less than half the sample-rate %d.\n",
253                s->frequency, inlink->sample_rate);
254         return AVERROR(EINVAL);
255     }
256
257     switch (s->width_type) {
258     case NONE:
259         alpha = 0.0;
260         break;
261     case HERTZ:
262         alpha = sin(w0) / (2 * s->frequency / s->width);
263         break;
264     case KHERTZ:
265         alpha = sin(w0) / (2 * s->frequency / (s->width * 1000));
266         break;
267     case OCTAVE:
268         alpha = sin(w0) * sinh(log(2.) / 2 * s->width * w0 / sin(w0));
269         break;
270     case QFACTOR:
271         alpha = sin(w0) / (2 * s->width);
272         break;
273     case SLOPE:
274         alpha = sin(w0) / 2 * sqrt((A + 1 / A) * (1 / s->width - 1) + 2);
275         break;
276     default:
277         av_assert0(0);
278     }
279
280     switch (s->filter_type) {
281     case biquad:
282         break;
283     case equalizer:
284         s->a0 =   1 + alpha / A;
285         s->a1 =  -2 * cos(w0);
286         s->a2 =   1 - alpha / A;
287         s->b0 =   1 + alpha * A;
288         s->b1 =  -2 * cos(w0);
289         s->b2 =   1 - alpha * A;
290         break;
291     case bass:
292         s->a0 =          (A + 1) + (A - 1) * cos(w0) + 2 * sqrt(A) * alpha;
293         s->a1 =    -2 * ((A - 1) + (A + 1) * cos(w0));
294         s->a2 =          (A + 1) + (A - 1) * cos(w0) - 2 * sqrt(A) * alpha;
295         s->b0 =     A * ((A + 1) - (A - 1) * cos(w0) + 2 * sqrt(A) * alpha);
296         s->b1 = 2 * A * ((A - 1) - (A + 1) * cos(w0));
297         s->b2 =     A * ((A + 1) - (A - 1) * cos(w0) - 2 * sqrt(A) * alpha);
298         break;
299     case treble:
300         s->a0 =          (A + 1) - (A - 1) * cos(w0) + 2 * sqrt(A) * alpha;
301         s->a1 =     2 * ((A - 1) - (A + 1) * cos(w0));
302         s->a2 =          (A + 1) - (A - 1) * cos(w0) - 2 * sqrt(A) * alpha;
303         s->b0 =     A * ((A + 1) + (A - 1) * cos(w0) + 2 * sqrt(A) * alpha);
304         s->b1 =-2 * A * ((A - 1) + (A + 1) * cos(w0));
305         s->b2 =     A * ((A + 1) + (A - 1) * cos(w0) - 2 * sqrt(A) * alpha);
306         break;
307     case bandpass:
308         if (s->csg) {
309             s->a0 =  1 + alpha;
310             s->a1 = -2 * cos(w0);
311             s->a2 =  1 - alpha;
312             s->b0 =  sin(w0) / 2;
313             s->b1 =  0;
314             s->b2 = -sin(w0) / 2;
315         } else {
316             s->a0 =  1 + alpha;
317             s->a1 = -2 * cos(w0);
318             s->a2 =  1 - alpha;
319             s->b0 =  alpha;
320             s->b1 =  0;
321             s->b2 = -alpha;
322         }
323         break;
324     case bandreject:
325         s->a0 =  1 + alpha;
326         s->a1 = -2 * cos(w0);
327         s->a2 =  1 - alpha;
328         s->b0 =  1;
329         s->b1 = -2 * cos(w0);
330         s->b2 =  1;
331         break;
332     case lowpass:
333         if (s->poles == 1) {
334             s->a0 = 1;
335             s->a1 = -exp(-w0);
336             s->a2 = 0;
337             s->b0 = 1 + s->a1;
338             s->b1 = 0;
339             s->b2 = 0;
340         } else {
341             s->a0 =  1 + alpha;
342             s->a1 = -2 * cos(w0);
343             s->a2 =  1 - alpha;
344             s->b0 = (1 - cos(w0)) / 2;
345             s->b1 =  1 - cos(w0);
346             s->b2 = (1 - cos(w0)) / 2;
347         }
348         break;
349     case highpass:
350         if (s->poles == 1) {
351             s->a0 = 1;
352             s->a1 = -exp(-w0);
353             s->a2 = 0;
354             s->b0 = (1 - s->a1) / 2;
355             s->b1 = -s->b0;
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 allpass:
367         s->a0 =  1 + alpha;
368         s->a1 = -2 * cos(w0);
369         s->a2 =  1 - alpha;
370         s->b0 =  1 - alpha;
371         s->b1 = -2 * cos(w0);
372         s->b2 =  1 + alpha;
373         break;
374     default:
375         av_assert0(0);
376     }
377
378     s->a1 /= s->a0;
379     s->a2 /= s->a0;
380     s->b0 /= s->a0;
381     s->b1 /= s->a0;
382     s->b2 /= s->a0;
383
384     s->cache = av_realloc_f(s->cache, sizeof(ChanCache), inlink->channels);
385     if (!s->cache)
386         return AVERROR(ENOMEM);
387     if (reset)
388         memset(s->cache, 0, sizeof(ChanCache) * inlink->channels);
389
390     switch (inlink->format) {
391     case AV_SAMPLE_FMT_S16P: s->filter = biquad_s16; break;
392     case AV_SAMPLE_FMT_S32P: s->filter = biquad_s32; break;
393     case AV_SAMPLE_FMT_FLTP: s->filter = biquad_flt; break;
394     case AV_SAMPLE_FMT_DBLP: s->filter = biquad_dbl; break;
395     default: av_assert0(0);
396     }
397
398     s->block_align = av_get_bytes_per_sample(inlink->format);
399
400     return 0;
401 }
402
403 static int config_output(AVFilterLink *outlink)
404 {
405     return config_filter(outlink, 1);
406 }
407
408 static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
409 {
410     AVFilterContext  *ctx = inlink->dst;
411     BiquadsContext *s     = ctx->priv;
412     AVFilterLink *outlink = ctx->outputs[0];
413     AVFrame *out_buf;
414     int nb_samples = buf->nb_samples;
415     int ch;
416
417     if (av_frame_is_writable(buf)) {
418         out_buf = buf;
419     } else {
420         out_buf = ff_get_audio_buffer(outlink, nb_samples);
421         if (!out_buf) {
422             av_frame_free(&buf);
423             return AVERROR(ENOMEM);
424         }
425         av_frame_copy_props(out_buf, buf);
426     }
427
428     for (ch = 0; ch < buf->channels; ch++) {
429         if (!((av_channel_layout_extract_channel(inlink->channel_layout, ch) & s->channels))) {
430             if (buf != out_buf)
431                 memcpy(out_buf->extended_data[ch], buf->extended_data[ch], nb_samples * s->block_align);
432             continue;
433         }
434         s->filter(s, buf->extended_data[ch],
435                   out_buf->extended_data[ch], nb_samples,
436                   &s->cache[ch].i1, &s->cache[ch].i2,
437                   &s->cache[ch].o1, &s->cache[ch].o2,
438                   s->b0, s->b1, s->b2, s->a1, s->a2);
439     }
440
441     if (s->clippings > 0)
442         av_log(ctx, AV_LOG_WARNING, "clipping %d times. Please reduce gain.\n", s->clippings);
443     s->clippings = 0;
444
445     if (buf != out_buf)
446         av_frame_free(&buf);
447
448     return ff_filter_frame(outlink, out_buf);
449 }
450
451 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
452                            char *res, int res_len, int flags)
453 {
454     BiquadsContext *s = ctx->priv;
455     AVFilterLink *outlink = ctx->outputs[0];
456
457     if ((!strcmp(cmd, "frequency") || !strcmp(cmd, "f")) &&
458         (s->filter_type == equalizer ||
459          s->filter_type == bass      ||
460          s->filter_type == treble    ||
461          s->filter_type == bandpass  ||
462          s->filter_type == bandreject||
463          s->filter_type == lowpass   ||
464          s->filter_type == highpass  ||
465          s->filter_type == allpass)) {
466         double freq;
467
468         if (sscanf(args, "%lf", &freq) != 1) {
469             av_log(ctx, AV_LOG_ERROR, "Invalid frequency value.\n");
470             return AVERROR(EINVAL);
471         }
472
473         s->frequency = freq;
474     } else if ((!strcmp(cmd, "gain") || !strcmp(cmd, "g")) &&
475         (s->filter_type == equalizer ||
476          s->filter_type == bass      ||
477          s->filter_type == treble)) {
478         double gain;
479
480         if (sscanf(args, "%lf", &gain) != 1) {
481             av_log(ctx, AV_LOG_ERROR, "Invalid gain value.\n");
482             return AVERROR(EINVAL);
483         }
484
485         s->gain = gain;
486     } else if ((!strcmp(cmd, "width") || !strcmp(cmd, "w")) &&
487         (s->filter_type == equalizer ||
488          s->filter_type == bass      ||
489          s->filter_type == treble    ||
490          s->filter_type == bandpass  ||
491          s->filter_type == bandreject||
492          s->filter_type == lowpass   ||
493          s->filter_type == highpass  ||
494          s->filter_type == allpass)) {
495         double width;
496
497         if (sscanf(args, "%lf", &width) != 1) {
498             av_log(ctx, AV_LOG_ERROR, "Invalid width value.\n");
499             return AVERROR(EINVAL);
500         }
501
502         s->width = width;
503     } else if ((!strcmp(cmd, "width_type") || !strcmp(cmd, "t")) &&
504         (s->filter_type == equalizer ||
505          s->filter_type == bass      ||
506          s->filter_type == treble    ||
507          s->filter_type == bandpass  ||
508          s->filter_type == bandreject||
509          s->filter_type == lowpass   ||
510          s->filter_type == highpass  ||
511          s->filter_type == allpass)) {
512         char width_type;
513
514         if (sscanf(args, "%c", &width_type) != 1) {
515             av_log(ctx, AV_LOG_ERROR, "Invalid width_type value.\n");
516             return AVERROR(EINVAL);
517         }
518
519         switch (width_type) {
520         case 'h': width_type = HERTZ;   break;
521         case 'q': width_type = QFACTOR; break;
522         case 'o': width_type = OCTAVE;  break;
523         case 's': width_type = SLOPE;   break;
524         case 'k': width_type = KHERTZ;  break;
525         default:
526             av_log(ctx, AV_LOG_ERROR, "Invalid width_type value: %c\n", width_type);
527             return AVERROR(EINVAL);
528         }
529
530         s->width_type = width_type;
531     } else if ((!strcmp(cmd, "a0") ||
532                 !strcmp(cmd, "a1") ||
533                 !strcmp(cmd, "a2") ||
534                 !strcmp(cmd, "b0") ||
535                 !strcmp(cmd, "b1") ||
536                 !strcmp(cmd, "b2")) &&
537                s->filter_type == biquad) {
538         double value;
539
540         if (sscanf(args, "%lf", &value) != 1) {
541             av_log(ctx, AV_LOG_ERROR, "Invalid biquad value.\n");
542             return AVERROR(EINVAL);
543         }
544
545         if (!strcmp(cmd, "a0"))
546             s->a0 = value;
547         else if (!strcmp(cmd, "a1"))
548             s->a1 = value;
549         else if (!strcmp(cmd, "a2"))
550             s->a2 = value;
551         else if (!strcmp(cmd, "b0"))
552             s->b0 = value;
553         else if (!strcmp(cmd, "b1"))
554             s->b1 = value;
555         else if (!strcmp(cmd, "b2"))
556             s->b2 = value;
557     }
558
559     return config_filter(outlink, 0);
560 }
561
562 static av_cold void uninit(AVFilterContext *ctx)
563 {
564     BiquadsContext *s = ctx->priv;
565
566     av_freep(&s->cache);
567 }
568
569 static const AVFilterPad inputs[] = {
570     {
571         .name         = "default",
572         .type         = AVMEDIA_TYPE_AUDIO,
573         .filter_frame = filter_frame,
574     },
575     { NULL }
576 };
577
578 static const AVFilterPad outputs[] = {
579     {
580         .name         = "default",
581         .type         = AVMEDIA_TYPE_AUDIO,
582         .config_props = config_output,
583     },
584     { NULL }
585 };
586
587 #define OFFSET(x) offsetof(BiquadsContext, x)
588 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
589
590 #define DEFINE_BIQUAD_FILTER(name_, description_)                       \
591 AVFILTER_DEFINE_CLASS(name_);                                           \
592 static av_cold int name_##_init(AVFilterContext *ctx) \
593 {                                                                       \
594     BiquadsContext *s = ctx->priv;                                      \
595     s->class = &name_##_class;                                          \
596     s->filter_type = name_;                                             \
597     return init(ctx);                                             \
598 }                                                                       \
599                                                          \
600 AVFilter ff_af_##name_ = {                         \
601     .name          = #name_,                             \
602     .description   = NULL_IF_CONFIG_SMALL(description_), \
603     .priv_size     = sizeof(BiquadsContext),             \
604     .init          = name_##_init,                       \
605     .uninit        = uninit,                             \
606     .query_formats = query_formats,                      \
607     .inputs        = inputs,                             \
608     .outputs       = outputs,                            \
609     .priv_class    = &name_##_class,                     \
610     .process_command = process_command,                  \
611 }
612
613 #if CONFIG_EQUALIZER_FILTER
614 static const AVOption equalizer_options[] = {
615     {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0, 999999, FLAGS},
616     {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0, 999999, FLAGS},
617     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
618     {"t",          "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
619     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
620     {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
621     {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
622     {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
623     {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
624     {"width", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 99999, FLAGS},
625     {"w",     "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 99999, FLAGS},
626     {"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
627     {"g",    "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
628     {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
629     {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
630     {NULL}
631 };
632
633 DEFINE_BIQUAD_FILTER(equalizer, "Apply two-pole peaking equalization (EQ) filter.");
634 #endif  /* CONFIG_EQUALIZER_FILTER */
635 #if CONFIG_BASS_FILTER
636 static const AVOption bass_options[] = {
637     {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=100}, 0, 999999, FLAGS},
638     {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=100}, 0, 999999, FLAGS},
639     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
640     {"t",          "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
641     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
642     {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
643     {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
644     {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
645     {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
646     {"width", "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
647     {"w",     "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
648     {"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
649     {"g",    "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
650     {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
651     {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
652     {NULL}
653 };
654
655 DEFINE_BIQUAD_FILTER(bass, "Boost or cut lower frequencies.");
656 #endif  /* CONFIG_BASS_FILTER */
657 #if CONFIG_TREBLE_FILTER
658 static const AVOption treble_options[] = {
659     {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
660     {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
661     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
662     {"t",          "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
663     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
664     {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
665     {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
666     {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
667     {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
668     {"width", "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
669     {"w",     "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
670     {"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
671     {"g",    "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
672     {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
673     {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
674     {NULL}
675 };
676
677 DEFINE_BIQUAD_FILTER(treble, "Boost or cut upper frequencies.");
678 #endif  /* CONFIG_TREBLE_FILTER */
679 #if CONFIG_BANDPASS_FILTER
680 static const AVOption bandpass_options[] = {
681     {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
682     {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
683     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
684     {"t",          "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
685     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
686     {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
687     {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
688     {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
689     {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
690     {"width", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
691     {"w",     "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
692     {"csg",   "use constant skirt gain", OFFSET(csg), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
693     {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
694     {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
695     {NULL}
696 };
697
698 DEFINE_BIQUAD_FILTER(bandpass, "Apply a two-pole Butterworth band-pass filter.");
699 #endif  /* CONFIG_BANDPASS_FILTER */
700 #if CONFIG_BANDREJECT_FILTER
701 static const AVOption bandreject_options[] = {
702     {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
703     {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
704     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
705     {"t",          "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
706     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
707     {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
708     {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
709     {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
710     {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
711     {"width", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
712     {"w",     "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
713     {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
714     {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
715     {NULL}
716 };
717
718 DEFINE_BIQUAD_FILTER(bandreject, "Apply a two-pole Butterworth band-reject filter.");
719 #endif  /* CONFIG_BANDREJECT_FILTER */
720 #if CONFIG_LOWPASS_FILTER
721 static const AVOption lowpass_options[] = {
722     {"frequency", "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=500}, 0, 999999, FLAGS},
723     {"f",         "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=500}, 0, 999999, FLAGS},
724     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
725     {"t",          "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
726     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
727     {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
728     {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
729     {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
730     {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
731     {"width", "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},
732     {"w",     "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},
733     {"poles", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
734     {"p",     "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
735     {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
736     {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
737     {NULL}
738 };
739
740 DEFINE_BIQUAD_FILTER(lowpass, "Apply a low-pass filter with 3dB point frequency.");
741 #endif  /* CONFIG_LOWPASS_FILTER */
742 #if CONFIG_HIGHPASS_FILTER
743 static const AVOption highpass_options[] = {
744     {"frequency", "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
745     {"f",         "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
746     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
747     {"t",          "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
748     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
749     {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
750     {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
751     {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
752     {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
753     {"width", "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},
754     {"w",     "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},
755     {"poles", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
756     {"p",     "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
757     {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
758     {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
759     {NULL}
760 };
761
762 DEFINE_BIQUAD_FILTER(highpass, "Apply a high-pass filter with 3dB point frequency.");
763 #endif  /* CONFIG_HIGHPASS_FILTER */
764 #if CONFIG_ALLPASS_FILTER
765 static const AVOption allpass_options[] = {
766     {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
767     {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
768     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=HERTZ}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
769     {"t",          "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=HERTZ}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},
770     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
771     {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
772     {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
773     {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
774     {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},
775     {"width", "set filter-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=707.1}, 0, 99999, FLAGS},
776     {"w",     "set filter-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=707.1}, 0, 99999, FLAGS},
777     {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
778     {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
779     {NULL}
780 };
781
782 DEFINE_BIQUAD_FILTER(allpass, "Apply a two-pole all-pass filter.");
783 #endif  /* CONFIG_ALLPASS_FILTER */
784 #if CONFIG_BIQUAD_FILTER
785 static const AVOption biquad_options[] = {
786     {"a0", NULL, OFFSET(a0), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT32_MIN, INT32_MAX, FLAGS},
787     {"a1", NULL, OFFSET(a1), AV_OPT_TYPE_DOUBLE, {.dbl=0}, INT32_MIN, INT32_MAX, FLAGS},
788     {"a2", NULL, OFFSET(a2), AV_OPT_TYPE_DOUBLE, {.dbl=0}, INT32_MIN, INT32_MAX, FLAGS},
789     {"b0", NULL, OFFSET(b0), AV_OPT_TYPE_DOUBLE, {.dbl=0}, INT32_MIN, INT32_MAX, FLAGS},
790     {"b1", NULL, OFFSET(b1), AV_OPT_TYPE_DOUBLE, {.dbl=0}, INT32_MIN, INT32_MAX, FLAGS},
791     {"b2", NULL, OFFSET(b2), AV_OPT_TYPE_DOUBLE, {.dbl=0}, INT32_MIN, INT32_MAX, FLAGS},
792     {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
793     {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
794     {NULL}
795 };
796
797 DEFINE_BIQUAD_FILTER(biquad, "Apply a biquad IIR filter with the given coefficients.");
798 #endif  /* CONFIG_BIQUAD_FILTER */