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.
94240 Commits
32 Branches
303MB
Tree: dc481105a1
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'dc481105a1'
${ noResults }
FFmpeg/libavfilter/af_aiir.c

1104 lines
37KB
Raw Blame History 

  1. /*

  2.  * Copyright (c) 2018 Paul B Mahol

  3.  *

  4.  * This file is part of FFmpeg.

  5.  *

  6.  * FFmpeg is free software; you can redistribute it and/or

  7.  * modify it under the terms of the GNU Lesser General Public

  8.  * License as published by the Free Software Foundation; either

  9.  * version 2.1 of the License, or (at your option) any later version.

  10.  *

  11.  * FFmpeg is distributed in the hope that it will be useful,

  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  14.  * Lesser General Public License for more details.

  15.  *

  16.  * You should have received a copy of the GNU Lesser General Public

  17.  * License along with FFmpeg; if not, write to the Free Software

  18.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  19.  */

  20. 

  21. #include <float.h>

  22. 

  23. #include "libavutil/avassert.h"

  24. #include "libavutil/avstring.h"

  25. #include "libavutil/intreadwrite.h"

  26. #include "libavutil/opt.h"

  27. #include "libavutil/xga_font_data.h"

  28. #include "audio.h"

  29. #include "avfilter.h"

  30. #include "internal.h"

  31. 

  32. typedef struct ThreadData {

  33.     AVFrame *in, *out;

  34. } ThreadData;

  35. 

  36. typedef struct Pair {

  37.     int a, b;

  38. } Pair;

  39. 

  40. typedef struct BiquadContext {

  41.     double a0, a1, a2;

  42.     double b0, b1, b2;

  43.     double i1, i2;

  44.     double o1, o2;

  45. } BiquadContext;

  46. 

  47. typedef struct IIRChannel {

  48.     int nb_ab[2];

  49.     double *ab[2];

  50.     double g;

  51.     double *cache[2];

  52.     BiquadContext *biquads;

  53.     int clippings;

  54. } IIRChannel;

  55. 

  56. typedef struct AudioIIRContext {

  57.     const AVClass *class;

  58.     char *a_str, *b_str, *g_str;

  59.     double dry_gain, wet_gain;

  60.     double mix;

  61.     int format;

  62.     int process;

  63.     int precision;

  64.     int response;

  65.     int w, h;

  66.     int ir_channel;

  67.     AVRational rate;

  68. 

  69.     AVFrame *video;

  70. 

  71.     IIRChannel *iir;

  72.     int channels;

  73.     enum AVSampleFormat sample_format;

  74. 

  75.     int (*iir_channel)(AVFilterContext *ctx, void *arg, int ch, int nb_jobs);

  76. } AudioIIRContext;

  77. 

  78. static int query_formats(AVFilterContext *ctx)

  79. {

  80.     AudioIIRContext *s = ctx->priv;

  81.     AVFilterFormats *formats;

  82.     AVFilterChannelLayouts *layouts;

  83.     enum AVSampleFormat sample_fmts[] = {

  84.         AV_SAMPLE_FMT_DBLP,

  85.         AV_SAMPLE_FMT_NONE

  86.     };

  87.     static const enum AVPixelFormat pix_fmts[] = {

  88.         AV_PIX_FMT_RGB0,

  89.         AV_PIX_FMT_NONE

  90.     };

  91.     int ret;

  92. 

  93.     if (s->response) {

  94.         AVFilterLink *videolink = ctx->outputs[1];

  95. 

  96.         formats = ff_make_format_list(pix_fmts);

  97.         if ((ret = ff_formats_ref(formats, &videolink->in_formats)) < 0)

  98.             return ret;

  99.     }

  100. 

  101.     layouts = ff_all_channel_counts();

  102.     if (!layouts)

  103.         return AVERROR(ENOMEM);

  104.     ret = ff_set_common_channel_layouts(ctx, layouts);

  105.     if (ret < 0)

  106.         return ret;

  107. 

  108.     sample_fmts[0] = s->sample_format;

  109.     formats = ff_make_format_list(sample_fmts);

  110.     if (!formats)

  111.         return AVERROR(ENOMEM);

  112.     ret = ff_set_common_formats(ctx, formats);

  113.     if (ret < 0)

  114.         return ret;

  115. 

  116.     formats = ff_all_samplerates();

  117.     if (!formats)

  118.         return AVERROR(ENOMEM);

  119.     return ff_set_common_samplerates(ctx, formats);

  120. }

  121. 

  122. #define IIR_CH(name, type, min, max, need_clipping)                     \

  123. static int iir_ch_## name(AVFilterContext *ctx, void *arg, int ch, int nb_jobs)  \

  124. {                                                                       \

  125.     AudioIIRContext *s = ctx->priv;                                     \

  126.     const double ig = s->dry_gain;                                      \

  127.     const double og = s->wet_gain;                                      \

  128.     const double mix = s->mix;                                          \

  129.     ThreadData *td = arg;                                               \

  130.     AVFrame *in = td->in, *out = td->out;                               \

  131.     const type *src = (const type *)in->extended_data[ch];              \

  132.     double *ic = (double *)s->iir[ch].cache[0];                         \

  133.     double *oc = (double *)s->iir[ch].cache[1];                         \

  134.     const int nb_a = s->iir[ch].nb_ab[0];                               \

  135.     const int nb_b = s->iir[ch].nb_ab[1];                               \

  136.     const double *a = s->iir[ch].ab[0];                                 \

  137.     const double *b = s->iir[ch].ab[1];                                 \

  138.     int *clippings = &s->iir[ch].clippings;                             \

  139.     type *dst = (type *)out->extended_data[ch];                         \

  140.     int n;                                                              \

  141.                                                                         \

  142.     for (n = 0; n < in->nb_samples; n++) {                              \

  143.         double sample = 0.;                                             \

  144.         int x;                                                          \

  145.                                                                         \

  146.         memmove(&ic[1], &ic[0], (nb_b - 1) * sizeof(*ic));              \

  147.         memmove(&oc[1], &oc[0], (nb_a - 1) * sizeof(*oc));              \

  148.         ic[0] = src[n] * ig;                                            \

  149.         for (x = 0; x < nb_b; x++)                                      \

  150.             sample += b[x] * ic[x];                                     \

  151.                                                                         \

  152.         for (x = 1; x < nb_a; x++)                                      \

  153.             sample -= a[x] * oc[x];                                     \

  154.                                                                         \

  155.         oc[0] = sample;                                                 \

  156.         sample *= og;                                                   \

  157.         sample = sample * mix + ic[0] * (1. - mix);                     \

  158.         if (need_clipping && sample < min) {                            \

  159.             (*clippings)++;                                             \

  160.             dst[n] = min;                                               \

  161.         } else if (need_clipping && sample > max) {                     \

  162.             (*clippings)++;                                             \

  163.             dst[n] = max;                                               \

  164.         } else {                                                        \

  165.             dst[n] = sample;                                            \

  166.         }                                                               \

  167.     }                                                                   \

  168.                                                                         \

  169.     return 0;                                                           \

  170. }

  171. 

  172. IIR_CH(s16p, int16_t, INT16_MIN, INT16_MAX, 1)

  173. IIR_CH(s32p, int32_t, INT32_MIN, INT32_MAX, 1)

  174. IIR_CH(fltp, float,         -1.,        1., 0)

  175. IIR_CH(dblp, double,        -1.,        1., 0)

  176. 

  177. #define SERIAL_IIR_CH(name, type, min, max, need_clipping)                  \

  178. static int iir_ch_serial_## name(AVFilterContext *ctx, void *arg, int ch, int nb_jobs)  \

  179. {                                                                       \

  180.     AudioIIRContext *s = ctx->priv;                                     \

  181.     const double ig = s->dry_gain;                                      \

  182.     const double og = s->wet_gain;                                      \

  183.     const double mix = s->mix;                                          \

  184.     ThreadData *td = arg;                                               \

  185.     AVFrame *in = td->in, *out = td->out;                               \

  186.     const type *src = (const type *)in->extended_data[ch];              \

  187.     type *dst = (type *)out->extended_data[ch];                         \

  188.     IIRChannel *iir = &s->iir[ch];                                      \

  189.     int *clippings = &iir->clippings;                                   \

  190.     int nb_biquads = (FFMAX(iir->nb_ab[0], iir->nb_ab[1]) + 1) / 2;     \

  191.     int n, i;                                                           \

  192.                                                                         \

  193.     for (i = 0; i < nb_biquads; i++) {                                  \

  194.         const double a1 = -iir->biquads[i].a1;                          \

  195.         const double a2 = -iir->biquads[i].a2;                          \

  196.         const double b0 = iir->biquads[i].b0;                           \

  197.         const double b1 = iir->biquads[i].b1;                           \

  198.         const double b2 = iir->biquads[i].b2;                           \

  199.         double i1 = iir->biquads[i].i1;                                 \

  200.         double i2 = iir->biquads[i].i2;                                 \

  201.         double o1 = iir->biquads[i].o1;                                 \

  202.         double o2 = iir->biquads[i].o2;                                 \

  203.                                                                         \

  204.         for (n = 0; n < in->nb_samples; n++) {                          \

  205.             double sample = ig * (i ? dst[n] : src[n]);                 \

  206.             double o0 = sample * b0 + i1 * b1 + i2 * b2 + o1 * a1 + o2 * a2; \

  207.                                                                         \

  208.             i2 = i1;                                                    \

  209.             i1 = src[n];                                                \

  210.             o2 = o1;                                                    \

  211.             o1 = o0;                                                    \

  212.             o0 *= og;                                                   \

  213.                                                                         \

  214.             o0 = o0 * mix + (1. - mix) * sample;                        \

  215.             if (need_clipping && o0 < min) {                            \

  216.                 (*clippings)++;                                         \

  217.                 dst[n] = min;                                           \

  218.             } else if (need_clipping && o0 > max) {                     \

  219.                 (*clippings)++;                                         \

  220.                 dst[n] = max;                                           \

  221.             } else {                                                    \

  222.                 dst[n] = o0;                                            \

  223.             }                                                           \

  224.         }                                                               \

  225.         iir->biquads[i].i1 = i1;                                        \

  226.         iir->biquads[i].i2 = i2;                                        \

  227.         iir->biquads[i].o1 = o1;                                        \

  228.         iir->biquads[i].o2 = o2;                                        \

  229.     }                                                                   \

  230.                                                                         \

  231.     return 0;                                                           \

  232. }

  233. 

  234. SERIAL_IIR_CH(s16p, int16_t, INT16_MIN, INT16_MAX, 1)

  235. SERIAL_IIR_CH(s32p, int32_t, INT32_MIN, INT32_MAX, 1)

  236. SERIAL_IIR_CH(fltp, float,         -1.,        1., 0)

  237. SERIAL_IIR_CH(dblp, double,        -1.,        1., 0)

  238. 

  239. static void count_coefficients(char *item_str, int *nb_items)

  240. {

  241.     char *p;

  242. 

  243.     if (!item_str)

  244.         return;

  245. 

  246.     *nb_items = 1;

  247.     for (p = item_str; *p && *p != '|'; p++) {

  248.         if (*p == ' ')

  249.             (*nb_items)++;

  250.     }

  251. }

  252. 

  253. static int read_gains(AVFilterContext *ctx, char *item_str, int nb_items)

  254. {

  255.     AudioIIRContext *s = ctx->priv;

  256.     char *p, *arg, *old_str, *prev_arg = NULL, *saveptr = NULL;

  257.     int i;

  258. 

  259.     p = old_str = av_strdup(item_str);

  260.     if (!p)

  261.         return AVERROR(ENOMEM);

  262.     for (i = 0; i < nb_items; i++) {

  263.         if (!(arg = av_strtok(p, "|", &saveptr)))

  264.             arg = prev_arg;

  265. 

  266.         if (!arg) {

  267.             av_freep(&old_str);

  268.             return AVERROR(EINVAL);

  269.         }

  270. 

  271.         p = NULL;

  272.         if (sscanf(arg, "%lf", &s->iir[i].g) != 1) {

  273.             av_log(ctx, AV_LOG_ERROR, "Invalid gains supplied: %s\n", arg);

  274.             av_freep(&old_str);

  275.             return AVERROR(EINVAL);

  276.         }

  277. 

  278.         prev_arg = arg;

  279.     }

  280. 

  281.     av_freep(&old_str);

  282. 

  283.     return 0;

  284. }

  285. 

  286. static int read_tf_coefficients(AVFilterContext *ctx, char *item_str, int nb_items, double *dst)

  287. {

  288.     char *p, *arg, *old_str, *saveptr = NULL;

  289.     int i;

  290. 

  291.     p = old_str = av_strdup(item_str);

  292.     if (!p)

  293.         return AVERROR(ENOMEM);

  294.     for (i = 0; i < nb_items; i++) {

  295.         if (!(arg = av_strtok(p, " ", &saveptr)))

  296.             break;

  297. 

  298.         p = NULL;

  299.         if (sscanf(arg, "%lf", &dst[i]) != 1) {

  300.             av_log(ctx, AV_LOG_ERROR, "Invalid coefficients supplied: %s\n", arg);

  301.             av_freep(&old_str);

  302.             return AVERROR(EINVAL);

  303.         }

  304.     }

  305. 

  306.     av_freep(&old_str);

  307. 

  308.     return 0;

  309. }

  310. 

  311. static int read_zp_coefficients(AVFilterContext *ctx, char *item_str, int nb_items, double *dst, const char *format)

  312. {

  313.     char *p, *arg, *old_str, *saveptr = NULL;

  314.     int i;

  315. 

  316.     p = old_str = av_strdup(item_str);

  317.     if (!p)

  318.         return AVERROR(ENOMEM);

  319.     for (i = 0; i < nb_items; i++) {

  320.         if (!(arg = av_strtok(p, " ", &saveptr)))

  321.             break;

  322. 

  323.         p = NULL;

  324.         if (sscanf(arg, format, &dst[i*2], &dst[i*2+1]) != 2) {

  325.             av_log(ctx, AV_LOG_ERROR, "Invalid coefficients supplied: %s\n", arg);

  326.             av_freep(&old_str);

  327.             return AVERROR(EINVAL);

  328.         }

  329.     }

  330. 

  331.     av_freep(&old_str);

  332. 

  333.     return 0;

  334. }

  335. 

  336. static const char *format[] = { "%lf", "%lf %lfi", "%lf %lfr", "%lf %lfd" };

  337. 

  338. static int read_channels(AVFilterContext *ctx, int channels, uint8_t *item_str, int ab)

  339. {

  340.     AudioIIRContext *s = ctx->priv;

  341.     char *p, *arg, *old_str, *prev_arg = NULL, *saveptr = NULL;

  342.     int i, ret;

  343. 

  344.     p = old_str = av_strdup(item_str);

  345.     if (!p)

  346.         return AVERROR(ENOMEM);

  347.     for (i = 0; i < channels; i++) {

  348.         IIRChannel *iir = &s->iir[i];

  349. 

  350.         if (!(arg = av_strtok(p, "|", &saveptr)))

  351.             arg = prev_arg;

  352. 

  353.         if (!arg) {

  354.             av_freep(&old_str);

  355.             return AVERROR(EINVAL);

  356.         }

  357. 

  358.         count_coefficients(arg, &iir->nb_ab[ab]);

  359. 

  360.         p = NULL;

  361.         iir->cache[ab] = av_calloc(iir->nb_ab[ab] + 1, sizeof(double));

  362.         iir->ab[ab] = av_calloc(iir->nb_ab[ab] * (!!s->format + 1), sizeof(double));

  363.         if (!iir->ab[ab] || !iir->cache[ab]) {

  364.             av_freep(&old_str);

  365.             return AVERROR(ENOMEM);

  366.         }

  367. 

  368.         if (s->format) {

  369.             ret = read_zp_coefficients(ctx, arg, iir->nb_ab[ab], iir->ab[ab], format[s->format]);

  370.         } else {

  371.             ret = read_tf_coefficients(ctx, arg, iir->nb_ab[ab], iir->ab[ab]);

  372.         }

  373.         if (ret < 0) {

  374.             av_freep(&old_str);

  375.             return ret;

  376.         }

  377.         prev_arg = arg;

  378.     }

  379. 

  380.     av_freep(&old_str);

  381. 

  382.     return 0;

  383. }

  384. 

  385. static void multiply(double wre, double wim, int npz, double *coeffs)

  386. {

  387.     double nwre = -wre, nwim = -wim;

  388.     double cre, cim;

  389.     int i;

  390. 

  391.     for (i = npz; i >= 1; i--) {

  392.         cre = coeffs[2 * i + 0];

  393.         cim = coeffs[2 * i + 1];

  394. 

  395.         coeffs[2 * i + 0] = (nwre * cre - nwim * cim) + coeffs[2 * (i - 1) + 0];

  396.         coeffs[2 * i + 1] = (nwre * cim + nwim * cre) + coeffs[2 * (i - 1) + 1];

  397.     }

  398. 

  399.     cre = coeffs[0];

  400.     cim = coeffs[1];

  401.     coeffs[0] = nwre * cre - nwim * cim;

  402.     coeffs[1] = nwre * cim + nwim * cre;

  403. }

  404. 

  405. static int expand(AVFilterContext *ctx, double *pz, int nb, double *coeffs)

  406. {

  407.     int i;

  408. 

  409.     coeffs[0] = 1.0;

  410.     coeffs[1] = 0.0;

  411. 

  412.     for (i = 0; i < nb; i++) {

  413.         coeffs[2 * (i + 1)    ] = 0.0;

  414.         coeffs[2 * (i + 1) + 1] = 0.0;

  415.     }

  416. 

  417.     for (i = 0; i < nb; i++)

  418.         multiply(pz[2 * i], pz[2 * i + 1], nb, coeffs);

  419. 

  420.     for (i = 0; i < nb + 1; i++) {

  421.         if (fabs(coeffs[2 * i + 1]) > FLT_EPSILON) {

  422.             av_log(ctx, AV_LOG_ERROR, "coeff: %f of z^%d is not real; poles/zeros are not complex conjugates.\n",

  423.                    coeffs[2 * i + 1], i);

  424.             return AVERROR(EINVAL);

  425.         }

  426.     }

  427. 

  428.     return 0;

  429. }

  430. 

  431. static int convert_zp2tf(AVFilterContext *ctx, int channels)

  432. {

  433.     AudioIIRContext *s = ctx->priv;

  434.     int ch, i, j, ret = 0;

  435. 

  436.     for (ch = 0; ch < channels; ch++) {

  437.         IIRChannel *iir = &s->iir[ch];

  438.         double *topc, *botc;

  439. 

  440.         topc = av_calloc((iir->nb_ab[0] + 1) * 2, sizeof(*topc));

  441.         botc = av_calloc((iir->nb_ab[1] + 1) * 2, sizeof(*botc));

  442.         if (!topc || !botc) {

  443.             ret = AVERROR(ENOMEM);

  444.             goto fail;

  445.         }

  446. 

  447.         ret = expand(ctx, iir->ab[0], iir->nb_ab[0], botc);

  448.         if (ret < 0) {

  449.             goto fail;

  450.         }

  451. 

  452.         ret = expand(ctx, iir->ab[1], iir->nb_ab[1], topc);

  453.         if (ret < 0) {

  454.             goto fail;

  455.         }

  456. 

  457.         for (j = 0, i = iir->nb_ab[1]; i >= 0; j++, i--) {

  458.             iir->ab[1][j] = topc[2 * i];

  459.         }

  460.         iir->nb_ab[1]++;

  461. 

  462.         for (j = 0, i = iir->nb_ab[0]; i >= 0; j++, i--) {

  463.             iir->ab[0][j] = botc[2 * i];

  464.         }

  465.         iir->nb_ab[0]++;

  466. 

  467. fail:

  468.         av_free(topc);

  469.         av_free(botc);

  470.         if (ret < 0)

  471.             break;

  472.     }

  473. 

  474.     return ret;

  475. }

  476. 

  477. static int decompose_zp2biquads(AVFilterContext *ctx, int channels)

  478. {

  479.     AudioIIRContext *s = ctx->priv;

  480.     int ch, ret;

  481. 

  482.     for (ch = 0; ch < channels; ch++) {

  483.         IIRChannel *iir = &s->iir[ch];

  484.         int nb_biquads = (FFMAX(iir->nb_ab[0], iir->nb_ab[1]) + 1) / 2;

  485.         int current_biquad = 0;

  486. 

  487.         iir->biquads = av_calloc(nb_biquads, sizeof(BiquadContext));

  488.         if (!iir->biquads)

  489.             return AVERROR(ENOMEM);

  490. 

  491.         while (nb_biquads--) {

  492.             Pair outmost_pole = { -1, -1 };

  493.             Pair nearest_zero = { -1, -1 };

  494.             double zeros[4] = { 0 };

  495.             double poles[4] = { 0 };

  496.             double b[6] = { 0 };

  497.             double a[6] = { 0 };

  498.             double min_distance = DBL_MAX;

  499.             double max_mag = 0;

  500.             int i;

  501. 

  502.             for (i = 0; i < iir->nb_ab[0]; i++) {

  503.                 double mag;

  504. 

  505.                 if (isnan(iir->ab[0][2 * i]) || isnan(iir->ab[0][2 * i + 1]))

  506.                     continue;

  507.                 mag = hypot(iir->ab[0][2 * i], iir->ab[0][2 * i + 1]);

  508. 

  509.                 if (mag > max_mag) {

  510.                     max_mag = mag;

  511.                     outmost_pole.a = i;

  512.                 }

  513.             }

  514. 

  515.             for (i = 0; i < iir->nb_ab[1]; i++) {

  516.                 if (isnan(iir->ab[0][2 * i]) || isnan(iir->ab[0][2 * i + 1]))

  517.                     continue;

  518. 

  519.                 if (iir->ab[0][2 * i    ] ==  iir->ab[0][2 * outmost_pole.a    ] &&

  520.                     iir->ab[0][2 * i + 1] == -iir->ab[0][2 * outmost_pole.a + 1]) {

  521.                     outmost_pole.b = i;

  522.                     break;

  523.                 }

  524.             }

  525. 

  526.             av_log(ctx, AV_LOG_VERBOSE, "outmost_pole is %d.%d\n", outmost_pole.a, outmost_pole.b);

  527. 

  528.             if (outmost_pole.a < 0 || outmost_pole.b < 0)

  529.                 return AVERROR(EINVAL);

  530. 

  531.             for (i = 0; i < iir->nb_ab[1]; i++) {

  532.                 double distance;

  533. 

  534.                 if (isnan(iir->ab[1][2 * i]) || isnan(iir->ab[1][2 * i + 1]))

  535.                     continue;

  536.                 distance = hypot(iir->ab[0][2 * outmost_pole.a    ] - iir->ab[1][2 * i    ],

  537.                                  iir->ab[0][2 * outmost_pole.a + 1] - iir->ab[1][2 * i + 1]);

  538. 

  539.                 if (distance < min_distance) {

  540.                     min_distance = distance;

  541.                     nearest_zero.a = i;

  542.                 }

  543.             }

  544. 

  545.             for (i = 0; i < iir->nb_ab[1]; i++) {

  546.                 if (isnan(iir->ab[1][2 * i]) || isnan(iir->ab[1][2 * i + 1]))

  547.                     continue;

  548. 

  549.                 if (iir->ab[1][2 * i    ] ==  iir->ab[1][2 * nearest_zero.a    ] &&

  550.                     iir->ab[1][2 * i + 1] == -iir->ab[1][2 * nearest_zero.a + 1]) {

  551.                     nearest_zero.b = i;

  552.                     break;

  553.                 }

  554.             }

  555. 

  556.             av_log(ctx, AV_LOG_VERBOSE, "nearest_zero is %d.%d\n", nearest_zero.a, nearest_zero.b);

  557. 

  558.             if (nearest_zero.a < 0 || nearest_zero.b < 0)

  559.                 return AVERROR(EINVAL);

  560. 

  561.             poles[0] = iir->ab[0][2 * outmost_pole.a    ];

  562.             poles[1] = iir->ab[0][2 * outmost_pole.a + 1];

  563. 

  564.             zeros[0] = iir->ab[1][2 * nearest_zero.a    ];

  565.             zeros[1] = iir->ab[1][2 * nearest_zero.a + 1];

  566. 

  567.             if (nearest_zero.a == nearest_zero.b && outmost_pole.a == outmost_pole.b) {

  568.                 zeros[2] = 0;

  569.                 zeros[3] = 0;

  570. 

  571.                 poles[2] = 0;

  572.                 poles[3] = 0;

  573.             } else {

  574.                 poles[2] = iir->ab[0][2 * outmost_pole.b    ];

  575.                 poles[3] = iir->ab[0][2 * outmost_pole.b + 1];

  576. 

  577.                 zeros[2] = iir->ab[1][2 * nearest_zero.b    ];

  578.                 zeros[3] = iir->ab[1][2 * nearest_zero.b + 1];

  579.             }

  580. 

  581.             ret = expand(ctx, zeros, 2, b);

  582.             if (ret < 0)

  583.                 return ret;

  584. 

  585.             ret = expand(ctx, poles, 2, a);

  586.             if (ret < 0)

  587.                 return ret;

  588. 

  589.             iir->ab[0][2 * outmost_pole.a] = iir->ab[0][2 * outmost_pole.a + 1] = NAN;

  590.             iir->ab[0][2 * outmost_pole.b] = iir->ab[0][2 * outmost_pole.b + 1] = NAN;

  591.             iir->ab[1][2 * nearest_zero.a] = iir->ab[1][2 * nearest_zero.a + 1] = NAN;

  592.             iir->ab[1][2 * nearest_zero.b] = iir->ab[1][2 * nearest_zero.b + 1] = NAN;

  593. 

  594.             iir->biquads[current_biquad].a0 = 1.0;

  595.             iir->biquads[current_biquad].a1 = a[2] / a[4];

  596.             iir->biquads[current_biquad].a2 = a[0] / a[4];

  597.             iir->biquads[current_biquad].b0 = b[4] / a[4] * (current_biquad ? 1.0 : iir->g);

  598.             iir->biquads[current_biquad].b1 = b[2] / a[4] * (current_biquad ? 1.0 : iir->g);

  599.             iir->biquads[current_biquad].b2 = b[0] / a[4] * (current_biquad ? 1.0 : iir->g);

  600. 

  601.             av_log(ctx, AV_LOG_VERBOSE, "a=%f %f %f:b=%f %f %f\n",

  602.                    iir->biquads[current_biquad].a0,

  603.                    iir->biquads[current_biquad].a1,

  604.                    iir->biquads[current_biquad].a2,

  605.                    iir->biquads[current_biquad].b0,

  606.                    iir->biquads[current_biquad].b1,

  607.                    iir->biquads[current_biquad].b2);

  608. 

  609.             current_biquad++;

  610.         }

  611.     }

  612. 

  613.     return 0;

  614. }

  615. 

  616. static void convert_pr2zp(AVFilterContext *ctx, int channels)

  617. {

  618.     AudioIIRContext *s = ctx->priv;

  619.     int ch;

  620. 

  621.     for (ch = 0; ch < channels; ch++) {

  622.         IIRChannel *iir = &s->iir[ch];

  623.         int n;

  624. 

  625.         for (n = 0; n < iir->nb_ab[0]; n++) {

  626.             double r = iir->ab[0][2*n];

  627.             double angle = iir->ab[0][2*n+1];

  628. 

  629.             iir->ab[0][2*n]   = r * cos(angle);

  630.             iir->ab[0][2*n+1] = r * sin(angle);

  631.         }

  632. 

  633.         for (n = 0; n < iir->nb_ab[1]; n++) {

  634.             double r = iir->ab[1][2*n];

  635.             double angle = iir->ab[1][2*n+1];

  636. 

  637.             iir->ab[1][2*n]   = r * cos(angle);

  638.             iir->ab[1][2*n+1] = r * sin(angle);

  639.         }

  640.     }

  641. }

  642. 

  643. static void convert_pd2zp(AVFilterContext *ctx, int channels)

  644. {

  645.     AudioIIRContext *s = ctx->priv;

  646.     int ch;

  647. 

  648.     for (ch = 0; ch < channels; ch++) {

  649.         IIRChannel *iir = &s->iir[ch];

  650.         int n;

  651. 

  652.         for (n = 0; n < iir->nb_ab[0]; n++) {

  653.             double r = iir->ab[0][2*n];

  654.             double angle = M_PI*iir->ab[0][2*n+1]/180.;

  655. 

  656.             iir->ab[0][2*n]   = r * cos(angle);

  657.             iir->ab[0][2*n+1] = r * sin(angle);

  658.         }

  659. 

  660.         for (n = 0; n < iir->nb_ab[1]; n++) {

  661.             double r = iir->ab[1][2*n];

  662.             double angle = M_PI*iir->ab[1][2*n+1]/180.;

  663. 

  664.             iir->ab[1][2*n]   = r * cos(angle);

  665.             iir->ab[1][2*n+1] = r * sin(angle);

  666.         }

  667.     }

  668. }

  669. 

  670. static void drawtext(AVFrame *pic, int x, int y, const char *txt, uint32_t color)

  671. {

  672.     const uint8_t *font;

  673.     int font_height;

  674.     int i;

  675. 

  676.     font = avpriv_cga_font, font_height = 8;

  677. 

  678.     for (i = 0; txt[i]; i++) {

  679.         int char_y, mask;

  680. 

  681.         uint8_t *p = pic->data[0] + y * pic->linesize[0] + (x + i * 8) * 4;

  682.         for (char_y = 0; char_y < font_height; char_y++) {

  683.             for (mask = 0x80; mask; mask >>= 1) {

  684.                 if (font[txt[i] * font_height + char_y] & mask)

  685.                     AV_WL32(p, color);

  686.                 p += 4;

  687.             }

  688.             p += pic->linesize[0] - 8 * 4;

  689.         }

  690.     }

  691. }

  692. 

  693. static void draw_line(AVFrame *out, int x0, int y0, int x1, int y1, uint32_t color)

  694. {

  695.     int dx = FFABS(x1-x0);

  696.     int dy = FFABS(y1-y0), sy = y0 < y1 ? 1 : -1;

  697.     int err = (dx>dy ? dx : -dy) / 2, e2;

  698. 

  699.     for (;;) {

  700.         AV_WL32(out->data[0] + y0 * out->linesize[0] + x0 * 4, color);

  701. 

  702.         if (x0 == x1 && y0 == y1)

  703.             break;

  704. 

  705.         e2 = err;

  706. 

  707.         if (e2 >-dx) {

  708.             err -= dy;

  709.             x0--;

  710.         }

  711. 

  712.         if (e2 < dy) {

  713.             err += dx;

  714.             y0 += sy;

  715.         }

  716.     }

  717. }

  718. 

  719. static void draw_response(AVFilterContext *ctx, AVFrame *out)

  720. {

  721.     AudioIIRContext *s = ctx->priv;

  722.     float *mag, *phase, min = FLT_MAX, max = FLT_MIN;

  723.     int prev_ymag = -1, prev_yphase = -1;

  724.     char text[32];

  725.     int ch, i, x;

  726. 

  727.     memset(out->data[0], 0, s->h * out->linesize[0]);

  728. 

  729.     phase = av_malloc_array(s->w, sizeof(*phase));

  730.     mag = av_malloc_array(s->w, sizeof(*mag));

  731.     if (!mag || !phase)

  732.         goto end;

  733. 

  734.     ch = av_clip(s->ir_channel, 0, s->channels - 1);

  735.     for (i = 0; i < s->w; i++) {

  736.         const double *b = s->iir[ch].ab[0];

  737.         const double *a = s->iir[ch].ab[1];

  738.         double w = i * M_PI / (s->w - 1);

  739.         double realz, realp;

  740.         double imagz, imagp;

  741.         double real, imag, div;

  742. 

  743.         if (s->format == 0) {

  744.             realz = 0., realp = 0.;

  745.             imagz = 0., imagp = 0.;

  746.             for (x = 0; x < s->iir[ch].nb_ab[1]; x++) {

  747.                 realz += cos(-x * w) * a[x];

  748.                 imagz += sin(-x * w) * a[x];

  749.             }

  750. 

  751.             for (x = 0; x < s->iir[ch].nb_ab[0]; x++) {

  752.                 realp += cos(-x * w) * b[x];

  753.                 imagp += sin(-x * w) * b[x];

  754.             }

  755. 

  756.             div = realp * realp + imagp * imagp;

  757.             real = (realz * realp + imagz * imagp) / div;

  758.             imag = (imagz * realp - imagp * realz) / div;

  759.         } else {

  760.             real = 1;

  761.             imag = 0;

  762.             for (x = 0; x < s->iir[ch].nb_ab[1]; x++) {

  763.                 double ore, oim, re, im;

  764. 

  765.                 re = cos(w) - a[2 * x];

  766.                 im = sin(w) - a[2 * x + 1];

  767. 

  768.                 ore = real;

  769.                 oim = imag;

  770. 

  771.                 real = ore * re - oim * im;

  772.                 imag = ore * im + oim * re;

  773.             }

  774. 

  775.             for (x = 0; x < s->iir[ch].nb_ab[0]; x++) {

  776.                 double ore, oim, re, im;

  777. 

  778.                 re = cos(w) - b[2 * x];

  779.                 im = sin(w) - b[2 * x + 1];

  780. 

  781.                 ore = real;

  782.                 oim = imag;

  783.                 div = re * re + im * im;

  784. 

  785.                 real = (ore * re + oim * im) / div;

  786.                 imag = (oim * re - ore * im) / div;

  787.             }

  788.         }

  789. 

  790.         mag[i] = s->iir[ch].g * hypot(real, imag);

  791.         phase[i] = atan2(imag, real);

  792.         min = fminf(min, mag[i]);

  793.         max = fmaxf(max, mag[i]);

  794.     }

  795. 

  796.     for (i = 0; i < s->w; i++) {

  797.         int ymag = mag[i] / max * (s->h - 1);

  798.         int yphase = (0.5 * (1. + phase[i] / M_PI)) * (s->h - 1);

  799. 

  800.         ymag = s->h - 1 - av_clip(ymag, 0, s->h - 1);

  801.         yphase = s->h - 1 - av_clip(yphase, 0, s->h - 1);

  802. 

  803.         if (prev_ymag < 0)

  804.             prev_ymag = ymag;

  805.         if (prev_yphase < 0)

  806.             prev_yphase = yphase;

  807. 

  808.         draw_line(out, i,   ymag, FFMAX(i - 1, 0),   prev_ymag, 0xFFFF00FF);

  809.         draw_line(out, i, yphase, FFMAX(i - 1, 0), prev_yphase, 0xFF00FF00);

  810. 

  811.         prev_ymag   = ymag;

  812.         prev_yphase = yphase;

  813.     }

  814. 

  815.     if (s->w > 400 && s->h > 100) {

  816.         drawtext(out, 2, 2, "Max Magnitude:", 0xDDDDDDDD);

  817.         snprintf(text, sizeof(text), "%.2f", max);

  818.         drawtext(out, 15 * 8 + 2, 2, text, 0xDDDDDDDD);

  819. 

  820.         drawtext(out, 2, 12, "Min Magnitude:", 0xDDDDDDDD);

  821.         snprintf(text, sizeof(text), "%.2f", min);

  822.         drawtext(out, 15 * 8 + 2, 12, text, 0xDDDDDDDD);

  823.     }

  824. 

  825. end:

  826.     av_free(phase);

  827.     av_free(mag);

  828. }

  829. 

  830. static int config_output(AVFilterLink *outlink)

  831. {

  832.     AVFilterContext *ctx = outlink->src;

  833.     AudioIIRContext *s = ctx->priv;

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

  835.     int ch, ret, i;

  836. 

  837.     s->channels = inlink->channels;

  838.     s->iir = av_calloc(s->channels, sizeof(*s->iir));

  839.     if (!s->iir)

  840.         return AVERROR(ENOMEM);

  841. 

  842.     ret = read_gains(ctx, s->g_str, inlink->channels);

  843.     if (ret < 0)

  844.         return ret;

  845. 

  846.     ret = read_channels(ctx, inlink->channels, s->a_str, 0);

  847.     if (ret < 0)

  848.         return ret;

  849. 

  850.     ret = read_channels(ctx, inlink->channels, s->b_str, 1);

  851.     if (ret < 0)

  852.         return ret;

  853. 

  854.     if (s->format == 2) {

  855.         convert_pr2zp(ctx, inlink->channels);

  856.     } else if (s->format == 3) {

  857.         convert_pd2zp(ctx, inlink->channels);

  858.     }

  859. 

  860.     av_frame_free(&s->video);

  861.     if (s->response) {

  862.         s->video = ff_get_video_buffer(ctx->outputs[1], s->w, s->h);

  863.         if (!s->video)

  864.             return AVERROR(ENOMEM);

  865. 

  866.         draw_response(ctx, s->video);

  867.     }

  868. 

  869.     if (s->format == 0)

  870.         av_log(ctx, AV_LOG_WARNING, "tf coefficients format is not recommended for too high number of zeros/poles.\n");

  871. 

  872.     if (s->format > 0 && s->process == 0) {

  873.         av_log(ctx, AV_LOG_WARNING, "Direct processsing is not recommended for zp coefficients format.\n");

  874. 

  875.         ret = convert_zp2tf(ctx, inlink->channels);

  876.         if (ret < 0)

  877.             return ret;

  878.     } else if (s->format == 0 && s->process == 1) {

  879.         av_log(ctx, AV_LOG_ERROR, "Serial cascading is not implemented for transfer function.\n");

  880.         return AVERROR_PATCHWELCOME;

  881.     } else if (s->format > 0 && s->process == 1) {

  882.         if (inlink->format == AV_SAMPLE_FMT_S16P)

  883.             av_log(ctx, AV_LOG_WARNING, "Serial cascading is not recommended for i16 precision.\n");

  884. 

  885.         ret = decompose_zp2biquads(ctx, inlink->channels);

  886.         if (ret < 0)

  887.             return ret;

  888.     }

  889. 

  890.     for (ch = 0; s->format == 0 && ch < inlink->channels; ch++) {

  891.         IIRChannel *iir = &s->iir[ch];

  892. 

  893.         for (i = 1; i < iir->nb_ab[0]; i++) {

  894.             iir->ab[0][i] /= iir->ab[0][0];

  895.         }

  896. 

  897.         for (i = 0; i < iir->nb_ab[1]; i++) {

  898.             iir->ab[1][i] *= iir->g / iir->ab[0][0];

  899.         }

  900.     }

  901. 

  902.     switch (inlink->format) {

  903.     case AV_SAMPLE_FMT_DBLP: s->iir_channel = s->process == 1 ? iir_ch_serial_dblp : iir_ch_dblp; break;

  904.     case AV_SAMPLE_FMT_FLTP: s->iir_channel = s->process == 1 ? iir_ch_serial_fltp : iir_ch_fltp; break;

  905.     case AV_SAMPLE_FMT_S32P: s->iir_channel = s->process == 1 ? iir_ch_serial_s32p : iir_ch_s32p; break;

  906.     case AV_SAMPLE_FMT_S16P: s->iir_channel = s->process == 1 ? iir_ch_serial_s16p : iir_ch_s16p; break;

  907.     }

  908. 

  909.     return 0;

  910. }

  911. 

  912. static int filter_frame(AVFilterLink *inlink, AVFrame *in)

  913. {

  914.     AVFilterContext *ctx = inlink->dst;

  915.     AudioIIRContext *s = ctx->priv;

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

  917.     ThreadData td;

  918.     AVFrame *out;

  919.     int ch, ret;

  920. 

  921.     if (av_frame_is_writable(in)) {

  922.         out = in;

  923.     } else {

  924.         out = ff_get_audio_buffer(outlink, in->nb_samples);

  925.         if (!out) {

  926.             av_frame_free(&in);

  927.             return AVERROR(ENOMEM);

  928.         }

  929.         av_frame_copy_props(out, in);

  930.     }

  931. 

  932.     td.in  = in;

  933.     td.out = out;

  934.     ctx->internal->execute(ctx, s->iir_channel, &td, NULL, outlink->channels);

  935. 

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

  937.         if (s->iir[ch].clippings > 0)

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

  939.                    ch, s->iir[ch].clippings);

  940.         s->iir[ch].clippings = 0;

  941.     }

  942. 

  943.     if (in != out)

  944.         av_frame_free(&in);

  945. 

  946.     if (s->response) {

  947.         AVFilterLink *outlink = ctx->outputs[1];

  948.         int64_t old_pts = s->video->pts;

  949.         int64_t new_pts = av_rescale_q(out->pts, ctx->inputs[0]->time_base, outlink->time_base);

  950. 

  951.         if (new_pts > old_pts) {

  952.             s->video->pts = new_pts;

  953.             ret = ff_filter_frame(outlink, av_frame_clone(s->video));

  954.             if (ret < 0)

  955.                 return ret;

  956.         }

  957.     }

  958. 

  959.     return ff_filter_frame(outlink, out);

  960. }

  961. 

  962. static int config_video(AVFilterLink *outlink)

  963. {

  964.     AVFilterContext *ctx = outlink->src;

  965.     AudioIIRContext *s = ctx->priv;

  966. 

  967.     outlink->sample_aspect_ratio = (AVRational){1,1};

  968.     outlink->w = s->w;

  969.     outlink->h = s->h;

  970.     outlink->frame_rate = s->rate;

  971.     outlink->time_base = av_inv_q(outlink->frame_rate);

  972. 

  973.     return 0;

  974. }

  975. 

  976. static av_cold int init(AVFilterContext *ctx)

  977. {

  978.     AudioIIRContext *s = ctx->priv;

  979.     AVFilterPad pad, vpad;

  980.     int ret;

  981. 

  982.     if (!s->a_str || !s->b_str || !s->g_str) {

  983.         av_log(ctx, AV_LOG_ERROR, "Valid coefficients are mandatory.\n");

  984.         return AVERROR(EINVAL);

  985.     }

  986. 

  987.     switch (s->precision) {

  988.     case 0: s->sample_format = AV_SAMPLE_FMT_DBLP; break;

  989.     case 1: s->sample_format = AV_SAMPLE_FMT_FLTP; break;

  990.     case 2: s->sample_format = AV_SAMPLE_FMT_S32P; break;

  991.     case 3: s->sample_format = AV_SAMPLE_FMT_S16P; break;

  992.     default: return AVERROR_BUG;

  993.     }

  994. 

  995.     pad = (AVFilterPad){

  996.         .name         = av_strdup("default"),

  997.         .type         = AVMEDIA_TYPE_AUDIO,

  998.         .config_props = config_output,

  999.     };

  1000. 

  1001.     if (!pad.name)

  1002.         return AVERROR(ENOMEM);

  1003. 

  1004.     if (s->response) {

  1005.         vpad = (AVFilterPad){

  1006.             .name         = av_strdup("filter_response"),

  1007.             .type         = AVMEDIA_TYPE_VIDEO,

  1008.             .config_props = config_video,

  1009.         };

  1010.         if (!vpad.name)

  1011.             return AVERROR(ENOMEM);

  1012.     }

  1013. 

  1014.     ret = ff_insert_outpad(ctx, 0, &pad);

  1015.     if (ret < 0)

  1016.         return ret;

  1017. 

  1018.     if (s->response) {

  1019.         ret = ff_insert_outpad(ctx, 1, &vpad);

  1020.         if (ret < 0)

  1021.             return ret;

  1022.     }

  1023. 

  1024.     return 0;

  1025. }

  1026. 

  1027. static av_cold void uninit(AVFilterContext *ctx)

  1028. {

  1029.     AudioIIRContext *s = ctx->priv;

  1030.     int ch;

  1031. 

  1032.     if (s->iir) {

  1033.         for (ch = 0; ch < s->channels; ch++) {

  1034.             IIRChannel *iir = &s->iir[ch];

  1035.             av_freep(&iir->ab[0]);

  1036.             av_freep(&iir->ab[1]);

  1037.             av_freep(&iir->cache[0]);

  1038.             av_freep(&iir->cache[1]);

  1039.             av_freep(&iir->biquads);

  1040.         }

  1041.     }

  1042.     av_freep(&s->iir);

  1043. 

  1044.     av_freep(&ctx->output_pads[0].name);

  1045.     if (s->response)

  1046.         av_freep(&ctx->output_pads[1].name);

  1047.     av_frame_free(&s->video);

  1048. }

  1049. 

  1050. static const AVFilterPad inputs[] = {

  1051.     {

  1052.         .name         = "default",

  1053.         .type         = AVMEDIA_TYPE_AUDIO,

  1054.         .filter_frame = filter_frame,

  1055.     },

  1056.     { NULL }

  1057. };

  1058. 

  1059. #define OFFSET(x) offsetof(AudioIIRContext, x)

  1060. #define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM

  1061. #define VF AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM

  1062. 

  1063. static const AVOption aiir_options[] = {

  1064.     { "z", "set B/numerator/zeros coefficients",   OFFSET(b_str),    AV_OPT_TYPE_STRING, {.str="1+0i 1-0i"}, 0, 0, AF },

  1065.     { "p", "set A/denominator/poles coefficients", OFFSET(a_str),    AV_OPT_TYPE_STRING, {.str="1+0i 1-0i"}, 0, 0, AF },

  1066.     { "k", "set channels gains",                   OFFSET(g_str),    AV_OPT_TYPE_STRING, {.str="1|1"}, 0, 0, AF },

  1067.     { "dry", "set dry gain",                       OFFSET(dry_gain), AV_OPT_TYPE_DOUBLE, {.dbl=1},     0, 1, AF },

  1068.     { "wet", "set wet gain",                       OFFSET(wet_gain), AV_OPT_TYPE_DOUBLE, {.dbl=1},     0, 1, AF },

  1069.     { "f", "set coefficients format",              OFFSET(format),   AV_OPT_TYPE_INT,    {.i64=1},     0, 3, AF, "format" },

  1070.     { "tf", "transfer function",                   0,                AV_OPT_TYPE_CONST,  {.i64=0},     0, 0, AF, "format" },

  1071.     { "zp", "Z-plane zeros/poles",                 0,                AV_OPT_TYPE_CONST,  {.i64=1},     0, 0, AF, "format" },

  1072.     { "pr", "Z-plane zeros/poles (polar radians)", 0,                AV_OPT_TYPE_CONST,  {.i64=2},     0, 0, AF, "format" },

  1073.     { "pd", "Z-plane zeros/poles (polar degrees)", 0,                AV_OPT_TYPE_CONST,  {.i64=3},     0, 0, AF, "format" },

  1074.     { "r", "set kind of processing",               OFFSET(process),  AV_OPT_TYPE_INT,    {.i64=1},     0, 1, AF, "process" },

  1075.     { "d", "direct",                               0,                AV_OPT_TYPE_CONST,  {.i64=0},     0, 0, AF, "process" },

  1076.     { "s", "serial cascading",                     0,                AV_OPT_TYPE_CONST,  {.i64=1},     0, 0, AF, "process" },

  1077.     { "e", "set precision",                        OFFSET(precision),AV_OPT_TYPE_INT,    {.i64=0},     0, 3, AF, "precision" },

  1078.     { "dbl", "double-precision floating-point",    0,                AV_OPT_TYPE_CONST,  {.i64=0},     0, 0, AF, "precision" },

  1079.     { "flt", "single-precision floating-point",    0,                AV_OPT_TYPE_CONST,  {.i64=1},     0, 0, AF, "precision" },

  1080.     { "i32", "32-bit integers",                    0,                AV_OPT_TYPE_CONST,  {.i64=2},     0, 0, AF, "precision" },

  1081.     { "i16", "16-bit integers",                    0,                AV_OPT_TYPE_CONST,  {.i64=3},     0, 0, AF, "precision" },

  1082.     { "mix", "set mix",                            OFFSET(mix),      AV_OPT_TYPE_DOUBLE, {.dbl=1},     0, 1, AF },

  1083.     { "response", "show IR frequency response",    OFFSET(response), AV_OPT_TYPE_BOOL,   {.i64=0},     0, 1, VF },

  1084.     { "channel", "set IR channel to display frequency response", OFFSET(ir_channel), AV_OPT_TYPE_INT, {.i64=0}, 0, 1024, VF },

  1085.     { "size",   "set video size",                  OFFSET(w),        AV_OPT_TYPE_IMAGE_SIZE, {.str = "hd720"}, 0, 0, VF },

  1086.     { "rate",   "set video rate",                  OFFSET(rate),     AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT32_MAX, VF },

  1087.     { NULL },

  1088. };

  1089. 

  1090. AVFILTER_DEFINE_CLASS(aiir);

  1091. 

  1092. AVFilter ff_af_aiir = {

  1093.     .name          = "aiir",

  1094.     .description   = NULL_IF_CONFIG_SMALL("Apply Infinite Impulse Response filter with supplied coefficients."),

  1095.     .priv_size     = sizeof(AudioIIRContext),

  1096.     .priv_class    = &aiir_class,

  1097.     .init          = init,

  1098.     .uninit        = uninit,

  1099.     .query_formats = query_formats,

  1100.     .inputs        = inputs,

  1101.     .flags         = AVFILTER_FLAG_DYNAMIC_OUTPUTS |

  1102.                      AVFILTER_FLAG_SLICE_THREADS,

  1103. };