falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
49626 Commits
32 Branches
313MB
Tree: 0ddca7d416
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0ddca7d416'
${ noResults }
FFmpeg/libavfilter/af_biquads.c

600 lines
24KB
Raw Blame History 

  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/opt.h"

  66. #include "libavutil/avassert.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.     band,

  77.     bandpass,

  78.     bandreject,

  79.     allpass,

  80.     highpass,

  81.     lowpass,

  82. };

  83. 

  84. enum WidthType {

  85.     NONE,

  86.     HZ,

  87.     OCTAVE,

  88.     QFACTOR,

  89.     SLOPE,

  90. };

  91. 

  92. typedef struct ChanCache {

  93.     double i1, i2;

  94.     double o1, o2;

  95. } ChanCache;

  96. 

  97. typedef struct {

  98.     const AVClass *class;

  99. 

  100.     enum FilterType filter_type;

  101.     enum WidthType width_type;

  102.     int poles;

  103.     int csg;

  104. 

  105.     double gain;

  106.     double frequency;

  107.     double width;

  108. 

  109.     double a0, a1, a2;

  110.     double b0, b1, b2;

  111. 

  112.     ChanCache *cache;

  113. 

  114.     void (*filter)(const void *ibuf, void *obuf, int len,

  115.                    double *i1, double *i2, double *o1, double *o2,

  116.                    double b0, double b1, double b2, double a1, double a2);

  117. } BiquadsContext;

  118. 

  119. static av_cold int init(AVFilterContext *ctx, const char *args)

  120. {

  121.     BiquadsContext *p = ctx->priv;

  122.     int ret;

  123. 

  124.     av_opt_set_defaults(p);

  125. 

  126.     if ((ret = av_set_options_string(p, args, "=", ":")) < 0)

  127.         return ret;

  128. 

  129.     if (p->filter_type != biquad) {

  130.         if (p->frequency <= 0 || p->width <= 0) {

  131.             av_log(ctx, AV_LOG_ERROR, "Invalid frequency %f and/or width %f <= 0\n",

  132.                    p->frequency, p->width);

  133.             return AVERROR(EINVAL);

  134.         }

  135.     }

  136. 

  137.     return 0;

  138. }

  139. 

  140. static int query_formats(AVFilterContext *ctx)

  141. {

  142.     AVFilterFormats *formats;

  143.     AVFilterChannelLayouts *layouts;

  144.     static const enum AVSampleFormat sample_fmts[] = {

  145.         AV_SAMPLE_FMT_S16P,

  146.         AV_SAMPLE_FMT_S32P,

  147.         AV_SAMPLE_FMT_FLTP,

  148.         AV_SAMPLE_FMT_DBLP,

  149.         AV_SAMPLE_FMT_NONE

  150.     };

  151. 

  152.     layouts = ff_all_channel_layouts();

  153.     if (!layouts)

  154.         return AVERROR(ENOMEM);

  155.     ff_set_common_channel_layouts(ctx, layouts);

  156. 

  157.     formats = ff_make_format_list(sample_fmts);

  158.     if (!formats)

  159.         return AVERROR(ENOMEM);

  160.     ff_set_common_formats(ctx, formats);

  161. 

  162.     formats = ff_all_samplerates();

  163.     if (!formats)

  164.         return AVERROR(ENOMEM);

  165.     ff_set_common_samplerates(ctx, formats);

  166. 

  167.     return 0;

  168. }

  169. 

  170. #define BIQUAD_FILTER(name, type, min, max)                                   \

  171. static void biquad_## name (const void *input, void *output, int len,         \

  172.                             double *in1, double *in2,                         \

  173.                             double *out1, double *out2,                       \

  174.                             double b0, double b1, double b2,                  \

  175.                             double a1, double a2)                             \

  176. {                                                                             \

  177.     const type *ibuf = input;                                                 \

  178.     type *obuf = output;                                                      \

  179.     double i1 = *in1;                                                         \

  180.     double i2 = *in2;                                                         \

  181.     double o1 = *out1;                                                        \

  182.     double o2 = *out2;                                                        \

  183.     int i;                                                                    \

  184.                                                                               \

  185.     for (i = 0; i < len; i++) {                                               \

  186.         double o0 = ibuf[i] * b0 + i1 * b1 + i2 * b2 - o1 * a1 - o2 * a2;     \

  187.         i2 = i1;                                                              \

  188.         i1 = ibuf[i];                                                         \

  189.         o2 = o1;                                                              \

  190.         o1 = o0;                                                              \

  191.         if (o0 < min) {                                                       \

  192.             av_log(NULL, AV_LOG_WARNING, "clipping\n");                       \

  193.             obuf[i] = min;                                                    \

  194.         } else if (o0 > max) {                                                \

  195.             av_log(NULL, AV_LOG_WARNING, "clipping\n");                       \

  196.             obuf[i] = max;                                                    \

  197.         } else {                                                              \

  198.             obuf[i] = o0;                                                     \

  199.         }                                                                     \

  200.     }                                                                         \

  201.     *in1  = i1;                                                               \

  202.     *in2  = i2;                                                               \

  203.     *out1 = o1;                                                               \

  204.     *out2 = o2;                                                               \

  205. }

  206. 

  207. BIQUAD_FILTER(s16, int16_t, INT16_MIN, INT16_MAX)

  208. BIQUAD_FILTER(s32, int32_t, INT32_MIN, INT32_MAX)

  209. BIQUAD_FILTER(flt, float,   -1., 1.)

  210. BIQUAD_FILTER(dbl, double,  -1., 1.)

  211. 

  212. static int config_output(AVFilterLink *outlink)

  213. {

  214.     AVFilterContext *ctx    = outlink->src;

  215.     BiquadsContext *p       = ctx->priv;

  216.     AVFilterLink *inlink    = ctx->inputs[0];

  217.     double A = exp(p->gain / 40 * log(10.));

  218.     double w0 = 2 * M_PI * p->frequency / inlink->sample_rate;

  219.     double alpha;

  220. 

  221.     if (w0 > M_PI) {

  222.         av_log(ctx, AV_LOG_ERROR,

  223.                "Invalid frequency %f. Frequency must be less than half the sample-rate %d.\n",

  224.                p->frequency, inlink->sample_rate);

  225.         return AVERROR(EINVAL);

  226.     }

  227. 

  228.     switch (p->width_type) {

  229.     case NONE:

  230.         alpha = 0.0;

  231.         break;

  232.     case HZ:

  233.         alpha = sin(w0) / (2 * p->frequency / p->width);

  234.         break;

  235.     case OCTAVE:

  236.         alpha = sin(w0) * sinh(log(2.) / 2 * p->width * w0 / sin(w0));

  237.         break;

  238.     case QFACTOR:

  239.         alpha = sin(w0) / (2 * p->width);

  240.         break;

  241.     case SLOPE:

  242.         alpha = sin(w0) / 2 * sqrt((A + 1 / A) * (1 / p->width - 1) + 2);

  243.         break;

  244.     default:

  245.         av_assert0(0);

  246.     }

  247. 

  248.     switch (p->filter_type) {

  249.     case biquad:

  250.         break;

  251.     case equalizer:

  252.         p->a0 =   1 + alpha / A;

  253.         p->a1 =  -2 * cos(w0);

  254.         p->a2 =   1 - alpha / A;

  255.         p->b0 =   1 + alpha * A;

  256.         p->b1 =  -2 * cos(w0);

  257.         p->b2 =   1 - alpha * A;

  258.         break;

  259.     case bass:

  260.         p->a0 =          (A + 1) + (A - 1) * cos(w0) + 2 * sqrt(A) * alpha;

  261.         p->a1 =    -2 * ((A - 1) + (A + 1) * cos(w0));

  262.         p->a2 =          (A + 1) + (A - 1) * cos(w0) - 2 * sqrt(A) * alpha;

  263.         p->b0 =     A * ((A + 1) - (A - 1) * cos(w0) + 2 * sqrt(A) * alpha);

  264.         p->b1 = 2 * A * ((A - 1) - (A + 1) * cos(w0));

  265.         p->b2 =     A * ((A + 1) - (A - 1) * cos(w0) - 2 * sqrt(A) * alpha);

  266.         break;

  267.     case treble:

  268.         p->a0 =          (A + 1) - (A - 1) * cos(w0) + 2 * sqrt(A) * alpha;

  269.         p->a1 =     2 * ((A - 1) - (A + 1) * cos(w0));

  270.         p->a2 =          (A + 1) - (A - 1) * cos(w0) - 2 * sqrt(A) * alpha;

  271.         p->b0 =     A * ((A + 1) + (A - 1) * cos(w0) + 2 * sqrt(A) * alpha);

  272.         p->b1 =-2 * A * ((A - 1) + (A + 1) * cos(w0));

  273.         p->b2 =     A * ((A + 1) + (A - 1) * cos(w0) - 2 * sqrt(A) * alpha);

  274.         break;

  275.     case bandpass:

  276.         if (p->csg) {

  277.             p->a0 =  1 + alpha;

  278.             p->a1 = -2 * cos(w0);

  279.             p->a2 =  1 - alpha;

  280.             p->b0 =  sin(w0) / 2;

  281.             p->b1 =  0;

  282.             p->b2 = -sin(w0) / 2;

  283.         } else {

  284.             p->a0 =  1 + alpha;

  285.             p->a1 = -2 * cos(w0);

  286.             p->a2 =  1 - alpha;

  287.             p->b0 =  alpha;

  288.             p->b1 =  0;

  289.             p->b2 = -alpha;

  290.         }

  291.         break;

  292.     case bandreject:

  293.         p->a0 =  1 + alpha;

  294.         p->a1 = -2 * cos(w0);

  295.         p->a2 =  1 - alpha;

  296.         p->b0 =  1;

  297.         p->b1 = -2 * cos(w0);

  298.         p->b2 =  1;

  299.         break;

  300.     case lowpass:

  301.         if (p->poles == 1) {

  302.             p->a0 = 1;

  303.             p->a1 = -exp(-w0);

  304.             p->a2 = 0;

  305.             p->b0 = 1 + p->a1;

  306.             p->b1 = 0;

  307.             p->b2 = 0;

  308.         } else {

  309.             p->a0 =  1 + alpha;

  310.             p->a1 = -2 * cos(w0);

  311.             p->a2 =  1 - alpha;

  312.             p->b0 = (1 - cos(w0)) / 2;

  313.             p->b1 =  1 - cos(w0);

  314.             p->b2 = (1 - cos(w0)) / 2;

  315.         }

  316.         break;

  317.     case highpass:

  318.         if (p->poles == 1) {

  319.             p->a0 = 1;

  320.             p->a1 = -exp(-w0);

  321.             p->a2 = 0;

  322.             p->b0 = (1 - p->a1) / 2;

  323.             p->b1 = -p->b0;

  324.             p->b2 = 0;

  325.         } else {

  326.             p->a0 =   1 + alpha;

  327.             p->a1 =  -2 * cos(w0);

  328.             p->a2 =   1 - alpha;

  329.             p->b0 =  (1 + cos(w0)) / 2;

  330.             p->b1 = -(1 + cos(w0));

  331.             p->b2 =  (1 + cos(w0)) / 2;

  332.         }

  333.         break;

  334.     case allpass:

  335.         p->a0 =  1 + alpha;

  336.         p->a1 = -2 * cos(w0);

  337.         p->a2 =  1 - alpha;

  338.         p->b0 =  1 - alpha;

  339.         p->b1 = -2 * cos(w0);

  340.         p->b2 =  1 + alpha;

  341.         break;

  342.     default:

  343.         av_assert0(0);

  344.     }

  345. 

  346.     p->a1 /= p->a0;

  347.     p->a2 /= p->a0;

  348.     p->b0 /= p->a0;

  349.     p->b1 /= p->a0;

  350.     p->b2 /= p->a0;

  351. 

  352.     p->cache = av_realloc_f(p->cache, sizeof(ChanCache), inlink->channels);

  353.     if (!p->cache)

  354.         return AVERROR(ENOMEM);

  355. 

  356.     switch (inlink->format) {

  357.     case AV_SAMPLE_FMT_S16P: p->filter = biquad_s16; break;

  358.     case AV_SAMPLE_FMT_S32P: p->filter = biquad_s32; break;

  359.     case AV_SAMPLE_FMT_FLTP: p->filter = biquad_flt; break;

  360.     case AV_SAMPLE_FMT_DBLP: p->filter = biquad_dbl; break;

  361.     default: av_assert0(0);

  362.     }

  363. 

  364.     return 0;

  365. }

  366. 

  367. static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *buf)

  368. {

  369.     BiquadsContext *p       = inlink->dst->priv;

  370.     AVFilterLink *outlink   = inlink->dst->outputs[0];

  371.     AVFilterBufferRef *out_buf;

  372.     int nb_samples = buf->audio->nb_samples;

  373.     int ch;

  374. 

  375.     if (buf->perms & AV_PERM_WRITE) {

  376.         out_buf = buf;

  377.     } else {

  378.         out_buf = ff_get_audio_buffer(inlink, AV_PERM_WRITE, nb_samples);

  379.         if (!out_buf)

  380.             return AVERROR(ENOMEM);

  381.         out_buf->pts = buf->pts;

  382.     }

  383. 

  384.     for (ch = 0; ch < buf->audio->channels; ch++)

  385.         p->filter(buf->extended_data[ch],

  386.                   out_buf->extended_data[ch], nb_samples,

  387.                   &p->cache[ch].i1, &p->cache[ch].i2,

  388.                   &p->cache[ch].o1, &p->cache[ch].o2,

  389.                   p->b0, p->b1, p->b2, p->a1, p->a2);

  390. 

  391.     if (buf != out_buf)

  392.         avfilter_unref_buffer(buf);

  393. 

  394.     return ff_filter_frame(outlink, out_buf);

  395. }

  396. 

  397. static av_cold void uninit(AVFilterContext *ctx)

  398. {

  399.     BiquadsContext *p = ctx->priv;

  400. 

  401.     av_freep(&p->cache);

  402.     av_opt_free(p);

  403. }

  404. 

  405. static const AVFilterPad inputs[] = {

  406.     {

  407.         .name         = "default",

  408.         .type         = AVMEDIA_TYPE_AUDIO,

  409.         .filter_frame = filter_frame,

  410.     },

  411.     { NULL }

  412. };

  413. 

  414. static const AVFilterPad outputs[] = {

  415.     {

  416.         .name         = "default",

  417.         .type         = AVMEDIA_TYPE_AUDIO,

  418.         .config_props = config_output,

  419.     },

  420.     { NULL }

  421. };

  422. 

  423. #define OFFSET(x) offsetof(BiquadsContext, x)

  424. #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM

  425. 

  426. #define DEFINE_BIQUAD_FILTER(name_, description_)                       \

  427. AVFILTER_DEFINE_CLASS(name_);                                           \

  428. static av_cold int name_##_init(AVFilterContext *ctx, const char *args) \

  429. {                                                                       \

  430.     BiquadsContext *p = ctx->priv;                                      \

  431.     p->class = &name_##_class;                                          \

  432.     p->filter_type = name_;                                             \

  433.     return init(ctx, args);                                             \

  434. }                                                                       \

  435.                                                          \

  436. AVFilter avfilter_af_##name_ = {                         \

  437.     .name          = #name_,                             \

  438.     .description   = NULL_IF_CONFIG_SMALL(description_), \

  439.     .priv_size     = sizeof(BiquadsContext),             \

  440.     .init          = name_##_init,                       \

  441.     .uninit        = uninit,                             \

  442.     .query_formats = query_formats,                      \

  443.     .inputs        = inputs,                             \

  444.     .outputs       = outputs,                            \

  445.     .priv_class    = &name_##_class,                     \

  446. }

  447. 

  448. #if CONFIG_EQUALIZER_FILTER

  449. static const AVOption equalizer_options[] = {

  450.     {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0, 999999, FLAGS},

  451.     {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0, 999999, FLAGS},

  452.     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HZ, SLOPE, FLAGS, "width_type"},

  453.     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HZ}, 0, 0, FLAGS, "width_type"},

  454.     {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},

  455.     {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},

  456.     {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},

  457.     {"width", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 999, FLAGS},

  458.     {"w",     "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 999, FLAGS},

  459.     {"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},

  460.     {"g",    "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},

  461.     {NULL},

  462. };

  463. 

  464. DEFINE_BIQUAD_FILTER(equalizer, "Apply two-pole peaking equalization (EQ) filter.");

  465. #endif  /* CONFIG_EQUALIZER_FILTER */

  466. #if CONFIG_BASS_FILTER

  467. static const AVOption bass_options[] = {

  468.     {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=100}, 0, 999999, FLAGS},

  469.     {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=100}, 0, 999999, FLAGS},

  470.     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HZ, SLOPE, FLAGS, "width_type"},

  471.     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HZ}, 0, 0, FLAGS, "width_type"},

  472.     {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},

  473.     {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},

  474.     {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},

  475.     {"width", "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},

  476.     {"w",     "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},

  477.     {"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},

  478.     {"g",    "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},

  479.     {NULL},

  480. };

  481. 

  482. DEFINE_BIQUAD_FILTER(bass, "Boost or cut lower frequencies.");

  483. #endif  /* CONFIG_BASS_FILTER */

  484. #if CONFIG_TREBLE_FILTER

  485. static const AVOption treble_options[] = {

  486.     {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},

  487.     {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},

  488.     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HZ, SLOPE, FLAGS, "width_type"},

  489.     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HZ}, 0, 0, FLAGS, "width_type"},

  490.     {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},

  491.     {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},

  492.     {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},

  493.     {"width", "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},

  494.     {"w",     "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},

  495.     {"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},

  496.     {"g",    "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},

  497.     {NULL},

  498. };

  499. 

  500. DEFINE_BIQUAD_FILTER(treble, "Boost or cut upper frequencies.");

  501. #endif  /* CONFIG_TREBLE_FILTER */

  502. #if CONFIG_BANDPASS_FILTER

  503. static const AVOption bandpass_options[] = {

  504.     {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},

  505.     {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},

  506.     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HZ, SLOPE, FLAGS, "width_type"},

  507.     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HZ}, 0, 0, FLAGS, "width_type"},

  508.     {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},

  509.     {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},

  510.     {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},

  511.     {"width", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 999, FLAGS},

  512.     {"w",     "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 999, FLAGS},

  513.     {"csg",   "use constant skirt gain", OFFSET(csg), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS},

  514.     {NULL},

  515. };

  516. 

  517. DEFINE_BIQUAD_FILTER(bandpass, "Apply a two-pole Butterworth band-pass filter.");

  518. #endif  /* CONFIG_BANDPASS_FILTER */

  519. #if CONFIG_BANDREJECT_FILTER

  520. static const AVOption bandreject_options[] = {

  521.     {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},

  522.     {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},

  523.     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HZ, SLOPE, FLAGS, "width_type"},

  524.     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HZ}, 0, 0, FLAGS, "width_type"},

  525.     {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},

  526.     {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},

  527.     {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},

  528.     {"width", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 999, FLAGS},

  529.     {"w",     "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 999, FLAGS},

  530.     {NULL},

  531. };

  532. 

  533. DEFINE_BIQUAD_FILTER(bandreject, "Apply a two-pole Butterworth band-reject filter.");

  534. #endif  /* CONFIG_BANDREJECT_FILTER */

  535. #if CONFIG_LOWPASS_FILTER

  536. static const AVOption lowpass_options[] = {

  537.     {"frequency", "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=500}, 0, 999999, FLAGS},

  538.     {"f",         "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=500}, 0, 999999, FLAGS},

  539.     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HZ, SLOPE, FLAGS, "width_type"},

  540.     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HZ}, 0, 0, FLAGS, "width_type"},

  541.     {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},

  542.     {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},

  543.     {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},

  544.     {"width", "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},

  545.     {"w",     "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},

  546.     {"poles", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},

  547.     {"p",     "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},

  548.     {NULL},

  549. };

  550. 

  551. DEFINE_BIQUAD_FILTER(lowpass, "Apply a low-pass filter with 3dB point frequency.");

  552. #endif  /* CONFIG_LOWPASS_FILTER */

  553. #if CONFIG_HIGHPASS_FILTER

  554. static const AVOption highpass_options[] = {

  555.     {"frequency", "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},

  556.     {"f",         "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},

  557.     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HZ, SLOPE, FLAGS, "width_type"},

  558.     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HZ}, 0, 0, FLAGS, "width_type"},

  559.     {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},

  560.     {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},

  561.     {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},

  562.     {"width", "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},

  563.     {"w",     "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},

  564.     {"poles", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},

  565.     {"p",     "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},

  566.     {NULL},

  567. };

  568. 

  569. DEFINE_BIQUAD_FILTER(highpass, "Apply a high-pass filter with 3dB point frequency.");

  570. #endif  /* CONFIG_HIGHPASS_FILTER */

  571. #if CONFIG_ALLPASS_FILTER

  572. static const AVOption allpass_options[] = {

  573.     {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},

  574.     {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},

  575.     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=HZ}, HZ, SLOPE, FLAGS, "width_type"},

  576.     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HZ}, 0, 0, FLAGS, "width_type"},

  577.     {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},

  578.     {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},

  579.     {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},

  580.     {"width", "set filter-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=707.1}, 0, 99999, FLAGS},

  581.     {"w",     "set filter-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=707.1}, 0, 99999, FLAGS},

  582.     {NULL},

  583. };

  584. 

  585. DEFINE_BIQUAD_FILTER(allpass, "Apply a two-pole all-pass filter.");

  586. #endif  /* CONFIG_ALLPASS_FILTER */

  587. #if CONFIG_BIQUAD_FILTER

  588. static const AVOption biquad_options[] = {

  589.     {"a0", NULL, OFFSET(a0), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT16_MAX, INT16_MAX, FLAGS},

  590.     {"a1", NULL, OFFSET(a1), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT16_MAX, INT16_MAX, FLAGS},

  591.     {"a2", NULL, OFFSET(a2), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT16_MAX, INT16_MAX, FLAGS},

  592.     {"b0", NULL, OFFSET(b0), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT16_MAX, INT16_MAX, FLAGS},

  593.     {"b1", NULL, OFFSET(b1), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT16_MAX, INT16_MAX, FLAGS},

  594.     {"b2", NULL, OFFSET(b2), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT16_MAX, INT16_MAX, FLAGS},

  595.     {NULL},

  596. };

  597. 

  598. DEFINE_BIQUAD_FILTER(biquad, "Apply a biquad IIR filter with the given coefficients.");

  599. #endif  /* CONFIG_BIQUAD_FILTER */