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.
98774 Commits
32 Branches
1.9GB
Tree: a4d28ea030
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a4d28ea030'
${ noResults }
FFmpeg/libavfilter/af_biquads.c

868 lines
42KB
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/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 */