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