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

1075 lines
56KB
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. enum TransformType {

  97.     DI,

  98.     DII,

  99.     TDII,

  100.     NB_TTYPE,

  101. };

  102. 

  103. typedef struct ChanCache {

  104.     double i1, i2;

  105.     double o1, o2;

  106.     int clippings;

  107. } ChanCache;

  108. 

  109. typedef struct BiquadsContext {

  110.     const AVClass *class;

  111. 

  112.     enum FilterType filter_type;

  113.     int width_type;

  114.     int poles;

  115.     int csg;

  116.     int transform_type;

  117. 

  118.     double gain;

  119.     double frequency;

  120.     double width;

  121.     double mix;

  122.     uint64_t channels;

  123.     int normalize;

  124.     int order;

  125. 

  126.     double a0, a1, a2;

  127.     double b0, b1, b2;

  128. 

  129.     ChanCache *cache;

  130.     int block_align;

  131. 

  132.     void (*filter)(struct BiquadsContext *s, const void *ibuf, void *obuf, int len,

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

  134.                    double b0, double b1, double b2, double a1, double a2, int *clippings,

  135.                    int disabled);

  136. } BiquadsContext;

  137. 

  138. static av_cold int init(AVFilterContext *ctx)

  139. {

  140.     BiquadsContext *s = ctx->priv;

  141. 

  142.     if (s->filter_type != biquad) {

  143.         if (s->frequency <= 0 || s->width <= 0) {

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

  145.                    s->frequency, s->width);

  146.             return AVERROR(EINVAL);

  147.         }

  148.     }

  149. 

  150.     return 0;

  151. }

  152. 

  153. static int query_formats(AVFilterContext *ctx)

  154. {

  155.     AVFilterFormats *formats;

  156.     AVFilterChannelLayouts *layouts;

  157.     static const enum AVSampleFormat sample_fmts[] = {

  158.         AV_SAMPLE_FMT_S16P,

  159.         AV_SAMPLE_FMT_S32P,

  160.         AV_SAMPLE_FMT_FLTP,

  161.         AV_SAMPLE_FMT_DBLP,

  162.         AV_SAMPLE_FMT_NONE

  163.     };

  164.     int ret;

  165. 

  166.     layouts = ff_all_channel_counts();

  167.     if (!layouts)

  168.         return AVERROR(ENOMEM);

  169.     ret = ff_set_common_channel_layouts(ctx, layouts);

  170.     if (ret < 0)

  171.         return ret;

  172. 

  173.     formats = ff_make_format_list(sample_fmts);

  174.     if (!formats)

  175.         return AVERROR(ENOMEM);

  176.     ret = ff_set_common_formats(ctx, formats);

  177.     if (ret < 0)

  178.         return ret;

  179. 

  180.     formats = ff_all_samplerates();

  181.     if (!formats)

  182.         return AVERROR(ENOMEM);

  183.     return ff_set_common_samplerates(ctx, formats);

  184. }

  185. 

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

  187. static void biquad_## name (BiquadsContext *s,                                \

  188.                             const void *input, void *output, int len,         \

  189.                             double *in1, double *in2,                         \

  190.                             double *out1, double *out2,                       \

  191.                             double b0, double b1, double b2,                  \

  192.                             double a1, double a2, int *clippings,             \

  193.                             int disabled)                                     \

  194. {                                                                             \

  195.     const type *ibuf = input;                                                 \

  196.     type *obuf = output;                                                      \

  197.     double i1 = *in1;                                                         \

  198.     double i2 = *in2;                                                         \

  199.     double o1 = *out1;                                                        \

  200.     double o2 = *out2;                                                        \

  201.     double wet = s->mix;                                                      \

  202.     double dry = 1. - wet;                                                    \

  203.     double out;                                                               \

  204.     int i;                                                                    \

  205.     a1 = -a1;                                                                 \

  206.     a2 = -a2;                                                                 \

  207.                                                                               \

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

  209.         o2 = i2 * b2 + i1 * b1 + ibuf[i] * b0 + o2 * a2 + o1 * a1;            \

  210.         i2 = ibuf[i];                                                         \

  211.         out = o2 * wet + i2 * dry;                                            \

  212.         if (disabled) {                                                       \

  213.             obuf[i] = i2;                                                     \

  214.         } else if (need_clipping && out < min) {                              \

  215.             (*clippings)++;                                                   \

  216.             obuf[i] = min;                                                    \

  217.         } else if (need_clipping && out > max) {                              \

  218.             (*clippings)++;                                                   \

  219.             obuf[i] = max;                                                    \

  220.         } else {                                                              \

  221.             obuf[i] = out;                                                    \

  222.         }                                                                     \

  223.         i++;                                                                  \

  224.         o1 = i1 * b2 + i2 * b1 + ibuf[i] * b0 + o1 * a2 + o2 * a1;            \

  225.         i1 = ibuf[i];                                                         \

  226.         out = o1 * wet + i1 * dry;                                            \

  227.         if (disabled) {                                                       \

  228.             obuf[i] = i1;                                                     \

  229.         } else if (need_clipping && out < min) {                              \

  230.             (*clippings)++;                                                   \

  231.             obuf[i] = min;                                                    \

  232.         } else if (need_clipping && out > max) {                              \

  233.             (*clippings)++;                                                   \

  234.             obuf[i] = max;                                                    \

  235.         } else {                                                              \

  236.             obuf[i] = out;                                                    \

  237.         }                                                                     \

  238.     }                                                                         \

  239.     if (i < len) {                                                            \

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

  241.         i2 = i1;                                                              \

  242.         i1 = ibuf[i];                                                         \

  243.         o2 = o1;                                                              \

  244.         o1 = o0;                                                              \

  245.         out = o0 * wet + i1 * dry;                                            \

  246.         if (disabled) {                                                       \

  247.             obuf[i] = i1;                                                     \

  248.         } else if (need_clipping && out < min) {                              \

  249.             (*clippings)++;                                                   \

  250.             obuf[i] = min;                                                    \

  251.         } else if (need_clipping && out > max) {                              \

  252.             (*clippings)++;                                                   \

  253.             obuf[i] = max;                                                    \

  254.         } else {                                                              \

  255.             obuf[i] = out;                                                    \

  256.         }                                                                     \

  257.     }                                                                         \

  258.     *in1  = i1;                                                               \

  259.     *in2  = i2;                                                               \

  260.     *out1 = o1;                                                               \

  261.     *out2 = o2;                                                               \

  262. }

  263. 

  264. BIQUAD_FILTER(s16, int16_t, INT16_MIN, INT16_MAX, 1)

  265. BIQUAD_FILTER(s32, int32_t, INT32_MIN, INT32_MAX, 1)

  266. BIQUAD_FILTER(flt, float,   -1., 1., 0)

  267. BIQUAD_FILTER(dbl, double,  -1., 1., 0)

  268. 

  269. #define BIQUAD_DII_FILTER(name, type, min, max, need_clipping)                \

  270. static void biquad_dii_## name (BiquadsContext *s,                            \

  271.                             const void *input, void *output, int len,         \

  272.                             double *z1, double *z2,                           \

  273.                             double *unused1, double *unused2,                 \

  274.                             double b0, double b1, double b2,                  \

  275.                             double a1, double a2, int *clippings,             \

  276.                             int disabled)                                     \

  277. {                                                                             \

  278.     const type *ibuf = input;                                                 \

  279.     type *obuf = output;                                                      \

  280.     double w1 = *z1;                                                          \

  281.     double w2 = *z2;                                                          \

  282.     double wet = s->mix;                                                      \

  283.     double dry = 1. - wet;                                                    \

  284.     double in, out, w0;                                                       \

  285.                                                                               \

  286.     a1 = -a1;                                                                 \

  287.     a2 = -a2;                                                                 \

  288.                                                                               \

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

  290.         in = ibuf[i];                                                         \

  291.         w0 = in + a1 * w1 + a2 * w2;                                          \

  292.         out = b0 * w0 + b1 * w1 + b2 * w2;                                    \

  293.         w2 = w1;                                                              \

  294.         w1 = w0;                                                              \

  295.         out = out * wet + in * dry;                                           \

  296.         if (disabled) {                                                       \

  297.             obuf[i] = in;                                                     \

  298.         } else if (need_clipping && out < min) {                              \

  299.             (*clippings)++;                                                   \

  300.             obuf[i] = min;                                                    \

  301.         } else if (need_clipping && out > max) {                              \

  302.             (*clippings)++;                                                   \

  303.             obuf[i] = max;                                                    \

  304.         } else {                                                              \

  305.             obuf[i] = out;                                                    \

  306.         }                                                                     \

  307.     }                                                                         \

  308.     *z1 = w1;                                                                 \

  309.     *z2 = w2;                                                                 \

  310. }

  311. 

  312. BIQUAD_DII_FILTER(s16, int16_t, INT16_MIN, INT16_MAX, 1)

  313. BIQUAD_DII_FILTER(s32, int32_t, INT32_MIN, INT32_MAX, 1)

  314. BIQUAD_DII_FILTER(flt, float,   -1., 1., 0)

  315. BIQUAD_DII_FILTER(dbl, double,  -1., 1., 0)

  316. 

  317. #define BIQUAD_TDII_FILTER(name, type, min, max, need_clipping)               \

  318. static void biquad_tdii_## name (BiquadsContext *s,                           \

  319.                             const void *input, void *output, int len,         \

  320.                             double *z1, double *z2,                           \

  321.                             double *unused1, double *unused2,                 \

  322.                             double b0, double b1, double b2,                  \

  323.                             double a1, double a2, int *clippings,             \

  324.                             int disabled)                                     \

  325. {                                                                             \

  326.     const type *ibuf = input;                                                 \

  327.     type *obuf = output;                                                      \

  328.     double w1 = *z1;                                                          \

  329.     double w2 = *z2;                                                          \

  330.     double wet = s->mix;                                                      \

  331.     double dry = 1. - wet;                                                    \

  332.     double in, out;                                                           \

  333.                                                                               \

  334.     a1 = -a1;                                                                 \

  335.     a2 = -a2;                                                                 \

  336.                                                                               \

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

  338.         in = ibuf[i];                                                         \

  339.         out = b0 * in + w1;                                                   \

  340.         w1 = b1 * in + w2 + a1 * out;                                         \

  341.         w2 = b2 * in + a2 * out;                                              \

  342.         out = out * wet + in * dry;                                           \

  343.         if (disabled) {                                                       \

  344.             obuf[i] = in;                                                     \

  345.         } else if (need_clipping && out < min) {                              \

  346.             (*clippings)++;                                                   \

  347.             obuf[i] = min;                                                    \

  348.         } else if (need_clipping && out > max) {                              \

  349.             (*clippings)++;                                                   \

  350.             obuf[i] = max;                                                    \

  351.         } else {                                                              \

  352.             obuf[i] = out;                                                    \

  353.         }                                                                     \

  354.     }                                                                         \

  355.     *z1 = w1;                                                                 \

  356.     *z2 = w2;                                                                 \

  357. }

  358. 

  359. BIQUAD_TDII_FILTER(s16, int16_t, INT16_MIN, INT16_MAX, 1)

  360. BIQUAD_TDII_FILTER(s32, int32_t, INT32_MIN, INT32_MAX, 1)

  361. BIQUAD_TDII_FILTER(flt, float,   -1., 1., 0)

  362. BIQUAD_TDII_FILTER(dbl, double,  -1., 1., 0)

  363. 

  364. static int config_filter(AVFilterLink *outlink, int reset)

  365. {

  366.     AVFilterContext *ctx    = outlink->src;

  367.     BiquadsContext *s       = ctx->priv;

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

  369.     double A = ff_exp10(s->gain / 40);

  370.     double w0 = 2 * M_PI * s->frequency / inlink->sample_rate;

  371.     double K = tan(w0 / 2.);

  372.     double alpha, beta;

  373. 

  374.     if (w0 > M_PI) {

  375.         av_log(ctx, AV_LOG_ERROR,

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

  377.                s->frequency, inlink->sample_rate);

  378.         return AVERROR(EINVAL);

  379.     }

  380. 

  381.     switch (s->width_type) {

  382.     case NONE:

  383.         alpha = 0.0;

  384.         break;

  385.     case HERTZ:

  386.         alpha = sin(w0) / (2 * s->frequency / s->width);

  387.         break;

  388.     case KHERTZ:

  389.         alpha = sin(w0) / (2 * s->frequency / (s->width * 1000));

  390.         break;

  391.     case OCTAVE:

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

  393.         break;

  394.     case QFACTOR:

  395.         alpha = sin(w0) / (2 * s->width);

  396.         break;

  397.     case SLOPE:

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

  399.         break;

  400.     default:

  401.         av_assert0(0);

  402.     }

  403. 

  404.     beta = 2 * sqrt(A);

  405. 

  406.     switch (s->filter_type) {

  407.     case biquad:

  408.         break;

  409.     case equalizer:

  410.         s->a0 =   1 + alpha / A;

  411.         s->a1 =  -2 * cos(w0);

  412.         s->a2 =   1 - alpha / A;

  413.         s->b0 =   1 + alpha * A;

  414.         s->b1 =  -2 * cos(w0);

  415.         s->b2 =   1 - alpha * A;

  416.         break;

  417.     case bass:

  418.         beta = sqrt((A * A + 1) - (A - 1) * (A - 1));

  419.     case lowshelf:

  420.         s->a0 =          (A + 1) + (A - 1) * cos(w0) + beta * alpha;

  421.         s->a1 =    -2 * ((A - 1) + (A + 1) * cos(w0));

  422.         s->a2 =          (A + 1) + (A - 1) * cos(w0) - beta * alpha;

  423.         s->b0 =     A * ((A + 1) - (A - 1) * cos(w0) + beta * alpha);

  424.         s->b1 = 2 * A * ((A - 1) - (A + 1) * cos(w0));

  425.         s->b2 =     A * ((A + 1) - (A - 1) * cos(w0) - beta * alpha);

  426.         break;

  427.     case treble:

  428.         beta = sqrt((A * A + 1) - (A - 1) * (A - 1));

  429.     case highshelf:

  430.         s->a0 =          (A + 1) - (A - 1) * cos(w0) + beta * alpha;

  431.         s->a1 =     2 * ((A - 1) - (A + 1) * cos(w0));

  432.         s->a2 =          (A + 1) - (A - 1) * cos(w0) - beta * alpha;

  433.         s->b0 =     A * ((A + 1) + (A - 1) * cos(w0) + beta * alpha);

  434.         s->b1 =-2 * A * ((A - 1) + (A + 1) * cos(w0));

  435.         s->b2 =     A * ((A + 1) + (A - 1) * cos(w0) - beta * alpha);

  436.         break;

  437.     case bandpass:

  438.         if (s->csg) {

  439.             s->a0 =  1 + alpha;

  440.             s->a1 = -2 * cos(w0);

  441.             s->a2 =  1 - alpha;

  442.             s->b0 =  sin(w0) / 2;

  443.             s->b1 =  0;

  444.             s->b2 = -sin(w0) / 2;

  445.         } else {

  446.             s->a0 =  1 + alpha;

  447.             s->a1 = -2 * cos(w0);

  448.             s->a2 =  1 - alpha;

  449.             s->b0 =  alpha;

  450.             s->b1 =  0;

  451.             s->b2 = -alpha;

  452.         }

  453.         break;

  454.     case bandreject:

  455.         s->a0 =  1 + alpha;

  456.         s->a1 = -2 * cos(w0);

  457.         s->a2 =  1 - alpha;

  458.         s->b0 =  1;

  459.         s->b1 = -2 * cos(w0);

  460.         s->b2 =  1;

  461.         break;

  462.     case lowpass:

  463.         if (s->poles == 1) {

  464.             s->a0 = 1;

  465.             s->a1 = -exp(-w0);

  466.             s->a2 = 0;

  467.             s->b0 = 1 + s->a1;

  468.             s->b1 = 0;

  469.             s->b2 = 0;

  470.         } else {

  471.             s->a0 =  1 + alpha;

  472.             s->a1 = -2 * cos(w0);

  473.             s->a2 =  1 - alpha;

  474.             s->b0 = (1 - cos(w0)) / 2;

  475.             s->b1 =  1 - cos(w0);

  476.             s->b2 = (1 - cos(w0)) / 2;

  477.         }

  478.         break;

  479.     case highpass:

  480.         if (s->poles == 1) {

  481.             s->a0 = 1;

  482.             s->a1 = -exp(-w0);

  483.             s->a2 = 0;

  484.             s->b0 = (1 - s->a1) / 2;

  485.             s->b1 = -s->b0;

  486.             s->b2 = 0;

  487.         } else {

  488.             s->a0 =   1 + alpha;

  489.             s->a1 =  -2 * cos(w0);

  490.             s->a2 =   1 - alpha;

  491.             s->b0 =  (1 + cos(w0)) / 2;

  492.             s->b1 = -(1 + cos(w0));

  493.             s->b2 =  (1 + cos(w0)) / 2;

  494.         }

  495.         break;

  496.     case allpass:

  497.         switch (s->order) {

  498.         case 1:

  499.             s->a0 = 1.;

  500.             s->a1 = -(1. - K) / (1. + K);

  501.             s->a2 = 0.;

  502.             s->b0 = s->a1;

  503.             s->b1 = s->a0;

  504.             s->b2 = 0.;

  505.             break;

  506.         case 2:

  507.             s->a0 =  1 + alpha;

  508.             s->a1 = -2 * cos(w0);

  509.             s->a2 =  1 - alpha;

  510.             s->b0 =  1 - alpha;

  511.             s->b1 = -2 * cos(w0);

  512.             s->b2 =  1 + alpha;

  513.         break;

  514.         }

  515.         break;

  516.     default:

  517.         av_assert0(0);

  518.     }

  519. 

  520.     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);

  521. 

  522.     s->a1 /= s->a0;

  523.     s->a2 /= s->a0;

  524.     s->b0 /= s->a0;

  525.     s->b1 /= s->a0;

  526.     s->b2 /= s->a0;

  527.     s->a0 /= s->a0;

  528. 

  529.     if (s->normalize && fabs(s->b0 + s->b1 + s->b2) > 1e-6) {

  530.         double factor = (s->a0 + s->a1 + s->a2) / (s->b0 + s->b1 + s->b2);

  531. 

  532.         s->b0 *= factor;

  533.         s->b1 *= factor;

  534.         s->b2 *= factor;

  535.     }

  536. 

  537.     s->cache = av_realloc_f(s->cache, sizeof(ChanCache), inlink->channels);

  538.     if (!s->cache)

  539.         return AVERROR(ENOMEM);

  540.     if (reset)

  541.         memset(s->cache, 0, sizeof(ChanCache) * inlink->channels);

  542. 

  543. 

  544.     switch (s->transform_type) {

  545.     case DI:

  546.         switch (inlink->format) {

  547.         case AV_SAMPLE_FMT_S16P:

  548.             s->filter = biquad_s16;

  549.             break;

  550.         case AV_SAMPLE_FMT_S32P:

  551.             s->filter = biquad_s32;

  552.             break;

  553.         case AV_SAMPLE_FMT_FLTP:

  554.             s->filter = biquad_flt;

  555.             break;

  556.         case AV_SAMPLE_FMT_DBLP:

  557.             s->filter = biquad_dbl;

  558.             break;

  559.         default: av_assert0(0);

  560.         }

  561.         break;

  562.     case DII:

  563.         switch (inlink->format) {

  564.         case AV_SAMPLE_FMT_S16P:

  565.             s->filter = biquad_dii_s16;

  566.             break;

  567.         case AV_SAMPLE_FMT_S32P:

  568.             s->filter = biquad_dii_s32;

  569.             break;

  570.         case AV_SAMPLE_FMT_FLTP:

  571.             s->filter = biquad_dii_flt;

  572.             break;

  573.         case AV_SAMPLE_FMT_DBLP:

  574.             s->filter = biquad_dii_dbl;

  575.             break;

  576.         default: av_assert0(0);

  577.         }

  578.         break;

  579.     case TDII:

  580.         switch (inlink->format) {

  581.         case AV_SAMPLE_FMT_S16P:

  582.             s->filter = biquad_tdii_s16;

  583.             break;

  584.         case AV_SAMPLE_FMT_S32P:

  585.             s->filter = biquad_tdii_s32;

  586.             break;

  587.         case AV_SAMPLE_FMT_FLTP:

  588.             s->filter = biquad_tdii_flt;

  589.             break;

  590.         case AV_SAMPLE_FMT_DBLP:

  591.             s->filter = biquad_tdii_dbl;

  592.             break;

  593.         default: av_assert0(0);

  594.         }

  595.         break;

  596.     default:

  597.         av_assert0(0);

  598.      }

  599. 

  600.      s->block_align = av_get_bytes_per_sample(inlink->format);

  601. 

  602.     return 0;

  603. }

  604. 

  605. static int config_output(AVFilterLink *outlink)

  606. {

  607.     return config_filter(outlink, 1);

  608. }

  609. 

  610. typedef struct ThreadData {

  611.     AVFrame *in, *out;

  612. } ThreadData;

  613. 

  614. static int filter_channel(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)

  615. {

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

  617.     ThreadData *td = arg;

  618.     AVFrame *buf = td->in;

  619.     AVFrame *out_buf = td->out;

  620.     BiquadsContext *s = ctx->priv;

  621.     const int start = (buf->channels * jobnr) / nb_jobs;

  622.     const int end = (buf->channels * (jobnr+1)) / nb_jobs;

  623.     int ch;

  624. 

  625.     for (ch = start; ch < end; ch++) {

  626.         if (!((av_channel_layout_extract_channel(inlink->channel_layout, ch) & s->channels))) {

  627.             if (buf != out_buf)

  628.                 memcpy(out_buf->extended_data[ch], buf->extended_data[ch],

  629.                        buf->nb_samples * s->block_align);

  630.             continue;

  631.         }

  632. 

  633.         s->filter(s, buf->extended_data[ch], out_buf->extended_data[ch], buf->nb_samples,

  634.                   &s->cache[ch].i1, &s->cache[ch].i2, &s->cache[ch].o1, &s->cache[ch].o2,

  635.                   s->b0, s->b1, s->b2, s->a1, s->a2, &s->cache[ch].clippings, ctx->is_disabled);

  636.     }

  637. 

  638.     return 0;

  639. }

  640. 

  641. static int filter_frame(AVFilterLink *inlink, AVFrame *buf)

  642. {

  643.     AVFilterContext  *ctx = inlink->dst;

  644.     BiquadsContext *s     = ctx->priv;

  645.     AVFilterLink *outlink = ctx->outputs[0];

  646.     AVFrame *out_buf;

  647.     ThreadData td;

  648.     int ch;

  649. 

  650.     if (av_frame_is_writable(buf)) {

  651.         out_buf = buf;

  652.     } else {

  653.         out_buf = ff_get_audio_buffer(outlink, buf->nb_samples);

  654.         if (!out_buf) {

  655.             av_frame_free(&buf);

  656.             return AVERROR(ENOMEM);

  657.         }

  658.         av_frame_copy_props(out_buf, buf);

  659.     }

  660. 

  661.     td.in = buf;

  662.     td.out = out_buf;

  663.     ctx->internal->execute(ctx, filter_channel, &td, NULL, FFMIN(outlink->channels, ff_filter_get_nb_threads(ctx)));

  664. 

  665.     for (ch = 0; ch < outlink->channels; ch++) {

  666.         if (s->cache[ch].clippings > 0)

  667.             av_log(ctx, AV_LOG_WARNING, "Channel %d clipping %d times. Please reduce gain.\n",

  668.                    ch, s->cache[ch].clippings);

  669.         s->cache[ch].clippings = 0;

  670.     }

  671. 

  672.     if (buf != out_buf)

  673.         av_frame_free(&buf);

  674. 

  675.     return ff_filter_frame(outlink, out_buf);

  676. }

  677. 

  678. static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,

  679.                            char *res, int res_len, int flags)

  680. {

  681.     AVFilterLink *outlink = ctx->outputs[0];

  682.     int ret;

  683. 

  684.     ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);

  685.     if (ret < 0)

  686.         return ret;

  687. 

  688.     return config_filter(outlink, 0);

  689. }

  690. 

  691. static av_cold void uninit(AVFilterContext *ctx)

  692. {

  693.     BiquadsContext *s = ctx->priv;

  694. 

  695.     av_freep(&s->cache);

  696. }

  697. 

  698. static const AVFilterPad inputs[] = {

  699.     {

  700.         .name         = "default",

  701.         .type         = AVMEDIA_TYPE_AUDIO,

  702.         .filter_frame = filter_frame,

  703.     },

  704.     { NULL }

  705. };

  706. 

  707. static const AVFilterPad outputs[] = {

  708.     {

  709.         .name         = "default",

  710.         .type         = AVMEDIA_TYPE_AUDIO,

  711.         .config_props = config_output,

  712.     },

  713.     { NULL }

  714. };

  715. 

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

  717. #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM

  718. #define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM

  719. 

  720. #define DEFINE_BIQUAD_FILTER(name_, description_)                       \

  721. AVFILTER_DEFINE_CLASS(name_);                                           \

  722. static av_cold int name_##_init(AVFilterContext *ctx) \

  723. {                                                                       \

  724.     BiquadsContext *s = ctx->priv;                                      \

  725.     s->class = &name_##_class;                                          \

  726.     s->filter_type = name_;                                             \

  727.     return init(ctx);                                             \

  728. }                                                                       \

  729.                                                          \

  730. AVFilter ff_af_##name_ = {                         \

  731.     .name          = #name_,                             \

  732.     .description   = NULL_IF_CONFIG_SMALL(description_), \

  733.     .priv_size     = sizeof(BiquadsContext),             \

  734.     .init          = name_##_init,                       \

  735.     .uninit        = uninit,                             \

  736.     .query_formats = query_formats,                      \

  737.     .inputs        = inputs,                             \

  738.     .outputs       = outputs,                            \

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

  740.     .process_command = process_command,                  \

  741.     .flags         = AVFILTER_FLAG_SLICE_THREADS | AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL, \

  742. }

  743. 

  744. #if CONFIG_EQUALIZER_FILTER

  745. static const AVOption equalizer_options[] = {

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

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

  748.     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},

  749.     {"t",          "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},

  750.     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},

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

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

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

  754.     {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},

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

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

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

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

  759.     {"mix", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},

  760.     {"m",   "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},

  761.     {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},

  762.     {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},

  763.     {"normalize", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},

  764.     {"n",         "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},

  765.     {"transform", "set transform type", OFFSET(transform_type), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},

  766.     {"a",         "set transform type", OFFSET(transform_type), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},

  767.     {"di",   "direct form I",  0, AV_OPT_TYPE_CONST, {.i64=DI}, 0, 0, AF, "transform_type"},

  768.     {"dii",  "direct form II", 0, AV_OPT_TYPE_CONST, {.i64=DII}, 0, 0, AF, "transform_type"},

  769.     {"tdii", "transposed direct form II", 0, AV_OPT_TYPE_CONST, {.i64=TDII}, 0, 0, AF, "transform_type"},

  770.     {NULL}

  771. };

  772. 

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

  774. #endif  /* CONFIG_EQUALIZER_FILTER */

  775. #if CONFIG_BASS_FILTER

  776. static const AVOption bass_options[] = {

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

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

  779.     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},

  780.     {"t",          "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},

  781.     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},

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

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

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

  785.     {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},

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

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

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

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

  790.     {"mix", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},

  791.     {"m",   "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},

  792.     {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},

  793.     {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},

  794.     {"normalize", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},

  795.     {"n",         "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},

  796.     {"transform", "set transform type", OFFSET(transform_type), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},

  797.     {"a",         "set transform type", OFFSET(transform_type), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},

  798.     {"di",   "direct form I",  0, AV_OPT_TYPE_CONST, {.i64=DI}, 0, 0, AF, "transform_type"},

  799.     {"dii",  "direct form II", 0, AV_OPT_TYPE_CONST, {.i64=DII}, 0, 0, AF, "transform_type"},

  800.     {"tdii", "transposed direct form II", 0, AV_OPT_TYPE_CONST, {.i64=TDII}, 0, 0, AF, "transform_type"},

  801.     {NULL}

  802. };

  803. 

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

  805. #endif  /* CONFIG_BASS_FILTER */

  806. #if CONFIG_TREBLE_FILTER

  807. static const AVOption treble_options[] = {

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

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

  810.     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},

  811.     {"t",          "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},

  812.     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},

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

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

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

  816.     {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},

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

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

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

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

  821.     {"mix", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},

  822.     {"m",   "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},

  823.     {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},

  824.     {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},

  825.     {"normalize", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},

  826.     {"n",         "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},

  827.     {"transform", "set transform type", OFFSET(transform_type), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},

  828.     {"a",         "set transform type", OFFSET(transform_type), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},

  829.     {"di",   "direct form I",  0, AV_OPT_TYPE_CONST, {.i64=DI}, 0, 0, AF, "transform_type"},

  830.     {"dii",  "direct form II", 0, AV_OPT_TYPE_CONST, {.i64=DII}, 0, 0, AF, "transform_type"},

  831.     {"tdii", "transposed direct form II", 0, AV_OPT_TYPE_CONST, {.i64=TDII}, 0, 0, AF, "transform_type"},

  832.     {NULL}

  833. };

  834. 

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

  836. #endif  /* CONFIG_TREBLE_FILTER */

  837. #if CONFIG_BANDPASS_FILTER

  838. static const AVOption bandpass_options[] = {

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

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

  841.     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},

  842.     {"t",          "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},

  843.     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},

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

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

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

  847.     {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},

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

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

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

  851.     {"mix", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},

  852.     {"m",   "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},

  853.     {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},

  854.     {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},

  855.     {"normalize", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},

  856.     {"n",         "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},

  857.     {"transform", "set transform type", OFFSET(transform_type), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},

  858.     {"a",         "set transform type", OFFSET(transform_type), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},

  859.     {"di",   "direct form I",  0, AV_OPT_TYPE_CONST, {.i64=DI}, 0, 0, AF, "transform_type"},

  860.     {"dii",  "direct form II", 0, AV_OPT_TYPE_CONST, {.i64=DII}, 0, 0, AF, "transform_type"},

  861.     {"tdii", "transposed direct form II", 0, AV_OPT_TYPE_CONST, {.i64=TDII}, 0, 0, AF, "transform_type"},

  862.     {NULL}

  863. };

  864. 

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

  866. #endif  /* CONFIG_BANDPASS_FILTER */

  867. #if CONFIG_BANDREJECT_FILTER

  868. static const AVOption bandreject_options[] = {

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

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

  871.     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},

  872.     {"t",          "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},

  873.     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},

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

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

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

  877.     {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},

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

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

  880.     {"mix", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},

  881.     {"m",   "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},

  882.     {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},

  883.     {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},

  884.     {"normalize", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},

  885.     {"n",         "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},

  886.     {"transform", "set transform type", OFFSET(transform_type), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},

  887.     {"a",         "set transform type", OFFSET(transform_type), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},

  888.     {"di",   "direct form I",  0, AV_OPT_TYPE_CONST, {.i64=DI}, 0, 0, AF, "transform_type"},

  889.     {"dii",  "direct form II", 0, AV_OPT_TYPE_CONST, {.i64=DII}, 0, 0, AF, "transform_type"},

  890.     {"tdii", "transposed direct form II", 0, AV_OPT_TYPE_CONST, {.i64=TDII}, 0, 0, AF, "transform_type"},

  891.     {NULL}

  892. };

  893. 

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

  895. #endif  /* CONFIG_BANDREJECT_FILTER */

  896. #if CONFIG_LOWPASS_FILTER

  897. static const AVOption lowpass_options[] = {

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

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

  900.     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},

  901.     {"t",          "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},

  902.     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},

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

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

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

  906.     {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},

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

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

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

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

  911.     {"mix", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},

  912.     {"m",   "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},

  913.     {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},

  914.     {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},

  915.     {"normalize", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},

  916.     {"n",         "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},

  917.     {"transform", "set transform type", OFFSET(transform_type), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},

  918.     {"a",         "set transform type", OFFSET(transform_type), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},

  919.     {"di",   "direct form I",  0, AV_OPT_TYPE_CONST, {.i64=DI}, 0, 0, AF, "transform_type"},

  920.     {"dii",  "direct form II", 0, AV_OPT_TYPE_CONST, {.i64=DII}, 0, 0, AF, "transform_type"},

  921.     {"tdii", "transposed direct form II", 0, AV_OPT_TYPE_CONST, {.i64=TDII}, 0, 0, AF, "transform_type"},

  922.     {NULL}

  923. };

  924. 

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

  926. #endif  /* CONFIG_LOWPASS_FILTER */

  927. #if CONFIG_HIGHPASS_FILTER

  928. static const AVOption highpass_options[] = {

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

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

  931.     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},

  932.     {"t",          "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},

  933.     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},

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

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

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

  937.     {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},

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

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

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

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

  942.     {"mix", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},

  943.     {"m",   "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},

  944.     {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},

  945.     {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},

  946.     {"normalize", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},

  947.     {"n",         "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},

  948.     {"transform", "set transform type", OFFSET(transform_type), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},

  949.     {"a",         "set transform type", OFFSET(transform_type), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},

  950.     {"di",   "direct form I",  0, AV_OPT_TYPE_CONST, {.i64=DI}, 0, 0, AF, "transform_type"},

  951.     {"dii",  "direct form II", 0, AV_OPT_TYPE_CONST, {.i64=DII}, 0, 0, AF, "transform_type"},

  952.     {"tdii", "transposed direct form II", 0, AV_OPT_TYPE_CONST, {.i64=TDII}, 0, 0, AF, "transform_type"},

  953.     {NULL}

  954. };

  955. 

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

  957. #endif  /* CONFIG_HIGHPASS_FILTER */

  958. #if CONFIG_ALLPASS_FILTER

  959. static const AVOption allpass_options[] = {

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

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

  962.     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=HERTZ}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},

  963.     {"t",          "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=HERTZ}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},

  964.     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},

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

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

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

  968.     {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},

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

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

  971.     {"mix", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},

  972.     {"m",   "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},

  973.     {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},

  974.     {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},

  975.     {"normalize", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},

  976.     {"n",         "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},

  977.     {"order", "set filter order", OFFSET(order), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},

  978.     {"o",     "set filter order", OFFSET(order), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},

  979.     {"transform", "set transform type", OFFSET(transform_type), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},

  980.     {"a",         "set transform type", OFFSET(transform_type), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},

  981.     {"di",   "direct form I",  0, AV_OPT_TYPE_CONST, {.i64=DI}, 0, 0, AF, "transform_type"},

  982.     {"dii",  "direct form II", 0, AV_OPT_TYPE_CONST, {.i64=DII}, 0, 0, AF, "transform_type"},

  983.     {"tdii", "transposed direct form II", 0, AV_OPT_TYPE_CONST, {.i64=TDII}, 0, 0, AF, "transform_type"},

  984.     {NULL}

  985. };

  986. 

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

  988. #endif  /* CONFIG_ALLPASS_FILTER */

  989. #if CONFIG_LOWSHELF_FILTER

  990. static const AVOption lowshelf_options[] = {

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

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

  993.     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},

  994.     {"t",          "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},

  995.     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},

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

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

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

  999.     {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},

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

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

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

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

  1004.     {"mix", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},

  1005.     {"m",   "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},

  1006.     {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},

  1007.     {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},

  1008.     {"normalize", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},

  1009.     {"n",         "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},

  1010.     {"transform", "set transform type", OFFSET(transform_type), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},

  1011.     {"a",         "set transform type", OFFSET(transform_type), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},

  1012.     {"di",   "direct form I",  0, AV_OPT_TYPE_CONST, {.i64=DI}, 0, 0, AF, "transform_type"},

  1013.     {"dii",  "direct form II", 0, AV_OPT_TYPE_CONST, {.i64=DII}, 0, 0, AF, "transform_type"},

  1014.     {"tdii", "transposed direct form II", 0, AV_OPT_TYPE_CONST, {.i64=TDII}, 0, 0, AF, "transform_type"},

  1015.     {NULL}

  1016. };

  1017. 

  1018. DEFINE_BIQUAD_FILTER(lowshelf, "Apply a low shelf filter.");

  1019. #endif  /* CONFIG_LOWSHELF_FILTER */

  1020. #if CONFIG_HIGHSHELF_FILTER

  1021. static const AVOption highshelf_options[] = {

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

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

  1024.     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},

  1025.     {"t",          "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, NB_WTYPE-1, FLAGS, "width_type"},

  1026.     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},

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

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

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

  1030.     {"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, "width_type"},

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

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

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

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

  1035.     {"mix", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},

  1036.     {"m",   "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},

  1037.     {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},

  1038.     {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},

  1039.     {"normalize", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},

  1040.     {"n",         "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},

  1041.     {"transform", "set transform type", OFFSET(transform_type), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},

  1042.     {"a",         "set transform type", OFFSET(transform_type), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},

  1043.     {"di",   "direct form I",  0, AV_OPT_TYPE_CONST, {.i64=DI}, 0, 0, AF, "transform_type"},

  1044.     {"dii",  "direct form II", 0, AV_OPT_TYPE_CONST, {.i64=DII}, 0, 0, AF, "transform_type"},

  1045.     {"tdii", "transposed direct form II", 0, AV_OPT_TYPE_CONST, {.i64=TDII}, 0, 0, AF, "transform_type"},

  1046.     {NULL}

  1047. };

  1048. 

  1049. DEFINE_BIQUAD_FILTER(highshelf, "Apply a high shelf filter.");

  1050. #endif  /* CONFIG_HIGHSHELF_FILTER */

  1051. #if CONFIG_BIQUAD_FILTER

  1052. static const AVOption biquad_options[] = {

  1053.     {"a0", NULL, OFFSET(a0), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT32_MIN, INT32_MAX, FLAGS},

  1054.     {"a1", NULL, OFFSET(a1), AV_OPT_TYPE_DOUBLE, {.dbl=0}, INT32_MIN, INT32_MAX, FLAGS},

  1055.     {"a2", NULL, OFFSET(a2), AV_OPT_TYPE_DOUBLE, {.dbl=0}, INT32_MIN, INT32_MAX, FLAGS},

  1056.     {"b0", NULL, OFFSET(b0), AV_OPT_TYPE_DOUBLE, {.dbl=0}, INT32_MIN, INT32_MAX, FLAGS},

  1057.     {"b1", NULL, OFFSET(b1), AV_OPT_TYPE_DOUBLE, {.dbl=0}, INT32_MIN, INT32_MAX, FLAGS},

  1058.     {"b2", NULL, OFFSET(b2), AV_OPT_TYPE_DOUBLE, {.dbl=0}, INT32_MIN, INT32_MAX, FLAGS},

  1059.     {"mix", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},

  1060.     {"m",   "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},

  1061.     {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},

  1062.     {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},

  1063.     {"normalize", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},

  1064.     {"n",         "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},

  1065.     {"transform", "set transform type", OFFSET(transform_type), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},

  1066.     {"a",         "set transform type", OFFSET(transform_type), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},

  1067.     {"di",   "direct form I",  0, AV_OPT_TYPE_CONST, {.i64=DI}, 0, 0, AF, "transform_type"},

  1068.     {"dii",  "direct form II", 0, AV_OPT_TYPE_CONST, {.i64=DII}, 0, 0, AF, "transform_type"},

  1069.     {"tdii", "transposed direct form II", 0, AV_OPT_TYPE_CONST, {.i64=TDII}, 0, 0, AF, "transform_type"},

  1070.     {NULL}

  1071. };

  1072. 

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

  1074. #endif  /* CONFIG_BIQUAD_FILTER */