FFmpeg coverage

Directory:	../../../ffmpeg/
File:	src/libavfilter/af_adynamicequalizer.c
Date:	2024-11-20 23:03:26

	Total	Coverage
Lines:	59	0.0%
Functions:	5	0.0%
Branches:	23	0.0%

  
      Line
      Branch
      Exec
      Source
    
      /*
    
       * This file is part of FFmpeg.
    
       *
    
       * FFmpeg is free software; you can redistribute it and/or
    
       * modify it under the terms of the GNU Lesser General Public
    
       * License as published by the Free Software Foundation; either
    
       * version 2.1 of the License, or (at your option) any later version.
    
       *
    
       * FFmpeg is distributed in the hope that it will be useful,
    
       * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
       * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    
       * Lesser General Public License for more details.
    
       *
    
       * You should have received a copy of the GNU Lesser General Public
    
       * License along with FFmpeg; if not, write to the Free Software
    
       * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
    
       */
    
      #include <float.h>
    
      #include "libavutil/ffmath.h"
    
      #include "libavutil/mem.h"
    
      #include "libavutil/opt.h"
    
      #include "avfilter.h"
    
      #include "audio.h"
    
      #include "filters.h"
    
      #include "formats.h"
    
      enum DetectionModes {
    
          DET_UNSET = 0,
    
          DET_DISABLED,
    
          DET_OFF,
    
          DET_ON,
    
          DET_ADAPTIVE,
    
          NB_DMODES,
    
      };
    
      enum FilterModes {
    
          LISTEN = -1,
    
          CUT_BELOW,
    
          CUT_ABOVE,
    
          BOOST_BELOW,
    
          BOOST_ABOVE,
    
          NB_FMODES,
    
      };
    
      typedef struct ChannelContext {
    
          double fa_double[3], fm_double[3];
    
          double dstate_double[2];
    
          double fstate_double[2];
    
          double tstate_double[2];
    
          double lin_gain_double;
    
          double detect_double;
    
          double threshold_log_double;
    
          double new_threshold_log_double;
    
          double log_sum_double;
    
          double sum_double;
    
          float fa_float[3], fm_float[3];
    
          float dstate_float[2];
    
          float fstate_float[2];
    
          float tstate_float[2];
    
          float lin_gain_float;
    
          float detect_float;
    
          float threshold_log_float;
    
          float new_threshold_log_float;
    
          float log_sum_float;
    
          float sum_float;
    
          void *dqueue;
    
          void *queue;
    
          int position;
    
          int size;
    
          int front;
    
          int back;
    
          int detection;
    
          int init;
    
      } ChannelContext;
    
      typedef struct AudioDynamicEqualizerContext {
    
          const AVClass *class;
    
          double threshold;
    
          double threshold_log;
    
          double dfrequency;
    
          double dqfactor;
    
          double tfrequency;
    
          double tqfactor;
    
          double ratio;
    
          double range;
    
          double makeup;
    
          double dattack;
    
          double drelease;
    
          double dattack_coef;
    
          double drelease_coef;
    
          double gattack_coef;
    
          double grelease_coef;
    
          int mode;
    
          int detection;
    
          int tftype;
    
          int dftype;
    
          int precision;
    
          int format;
    
          int nb_channels;
    
          int (*filter_prepare)(AVFilterContext *ctx);
    
          int (*filter_channels)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
    
          double da_double[3], dm_double[3];
    
          float da_float[3], dm_float[3];
    
          ChannelContext *cc;
    
      } AudioDynamicEqualizerContext;
    
      ✗
      static int query_formats(const AVFilterContext *ctx,
    
                               AVFilterFormatsConfig **cfg_in,
    
                               AVFilterFormatsConfig **cfg_out)
    
      {
    
      ✗
          const AudioDynamicEqualizerContext *s = ctx->priv;
    
          static const enum AVSampleFormat sample_fmts[3][3] = {
    
              { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_DBLP, AV_SAMPLE_FMT_NONE },
    
              { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE },
    
              { AV_SAMPLE_FMT_DBLP, AV_SAMPLE_FMT_NONE },
    
          };
    
          int ret;
    
      ✗
          if ((ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out,
    
      ✗
                                                      sample_fmts[s->precision])) < 0)
    
      ✗
              return ret;
    
      ✗
          return 0;
    
      }
    
      ✗
      static double get_coef(double x, double sr)
    
      {
    
      ✗
          return 1.0 - exp(-1.0 / (0.001 * x * sr));
    
      }
    
      typedef struct ThreadData {
    
          AVFrame *in, *out;
    
      } ThreadData;
    
      #define DEPTH 32
    
      #include "adynamicequalizer_template.c"
    
      #undef DEPTH
    
      #define DEPTH 64
    
      #include "adynamicequalizer_template.c"
    
      ✗
      static int config_input(AVFilterLink *inlink)
    
      {
    
      ✗
          AVFilterContext *ctx = inlink->dst;
    
      ✗
          AudioDynamicEqualizerContext *s = ctx->priv;
    
      ✗
          s->format = inlink->format;
    
      ✗
          s->cc = av_calloc(inlink->ch_layout.nb_channels, sizeof(*s->cc));
    
      ✗
          if (!s->cc)
    
      ✗
              return AVERROR(ENOMEM);
    
      ✗
          s->nb_channels = inlink->ch_layout.nb_channels;
    
      ✗
          switch (s->format) {
    
      ✗
          case AV_SAMPLE_FMT_DBLP:
    
      ✗
              s->filter_prepare  = filter_prepare_double;
    
      ✗
              s->filter_channels = filter_channels_double;
    
      ✗
              break;
    
      ✗
          case AV_SAMPLE_FMT_FLTP:
    
      ✗
              s->filter_prepare  = filter_prepare_float;
    
      ✗
              s->filter_channels = filter_channels_float;
    
      ✗
              break;
    
          }
    
      ✗
          for (int ch = 0; ch < s->nb_channels; ch++) {
    
      ✗
              ChannelContext *cc = &s->cc[ch];
    
      ✗
              cc->queue = av_calloc(inlink->sample_rate, sizeof(double));
    
      ✗
              cc->dqueue = av_calloc(inlink->sample_rate, sizeof(double));
    
      ✗
              if (!cc->queue || !cc->dqueue)
    
      ✗
                  return AVERROR(ENOMEM);
    
          }
    
      ✗
          return 0;
    
      }
    
      ✗
      static int filter_frame(AVFilterLink *inlink, AVFrame *in)
    
      {
    
      ✗
          AVFilterContext *ctx = inlink->dst;
    
      ✗
          AVFilterLink *outlink = ctx->outputs[0];
    
      ✗
          AudioDynamicEqualizerContext *s = ctx->priv;
    
          ThreadData td;
    
          AVFrame *out;
    
      ✗
          if (av_frame_is_writable(in)) {
    
      ✗
              out = in;
    
          } else {
    
      ✗
              out = ff_get_audio_buffer(outlink, in->nb_samples);
    
      ✗
              if (!out) {
    
      ✗
                  av_frame_free(&in);
    
      ✗
                  return AVERROR(ENOMEM);
    
              }
    
      ✗
              av_frame_copy_props(out, in);
    
          }
    
      ✗
          td.in = in;
    
      ✗
          td.out = out;
    
      ✗
          s->filter_prepare(ctx);
    
      ✗
          ff_filter_execute(ctx, s->filter_channels, &td, NULL,
    
      ✗
                           FFMIN(outlink->ch_layout.nb_channels, ff_filter_get_nb_threads(ctx)));
    
      ✗
          if (out != in)
    
      ✗
              av_frame_free(&in);
    
      ✗
          return ff_filter_frame(outlink, out);
    
      }
    
      ✗
      static av_cold void uninit(AVFilterContext *ctx)
    
      {
    
      ✗
          AudioDynamicEqualizerContext *s = ctx->priv;
    
      ✗
          for (int ch = 0; ch < s->nb_channels; ch++) {
    
      ✗
              ChannelContext *cc = &s->cc[ch];
    
      ✗
              av_freep(&cc->queue);
    
      ✗
              av_freep(&cc->dqueue);
    
          }
    
      ✗
          av_freep(&s->cc);
    
      ✗
      }
    
      #define OFFSET(x) offsetof(AudioDynamicEqualizerContext, x)
    
      #define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
    
      #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
    
      static const AVOption adynamicequalizer_options[] = {
    
          { "threshold",  "set detection threshold", OFFSET(threshold),  AV_OPT_TYPE_DOUBLE, {.dbl=0},        0, 100,     FLAGS },
    
          { "dfrequency", "set detection frequency", OFFSET(dfrequency), AV_OPT_TYPE_DOUBLE, {.dbl=1000},     2, 1000000, FLAGS },
    
          { "dqfactor",   "set detection Q factor",  OFFSET(dqfactor),   AV_OPT_TYPE_DOUBLE, {.dbl=1},    0.001, 1000,    FLAGS },
    
          { "tfrequency", "set target frequency",    OFFSET(tfrequency), AV_OPT_TYPE_DOUBLE, {.dbl=1000},     2, 1000000, FLAGS },
    
          { "tqfactor",   "set target Q factor",     OFFSET(tqfactor),   AV_OPT_TYPE_DOUBLE, {.dbl=1},    0.001, 1000,    FLAGS },
    
          { "attack", "set detection attack duration", OFFSET(dattack),  AV_OPT_TYPE_DOUBLE, {.dbl=20},    0.01, 2000,    FLAGS },
    
          { "release","set detection release duration",OFFSET(drelease), AV_OPT_TYPE_DOUBLE, {.dbl=200},   0.01, 2000,    FLAGS },
    
          { "ratio",      "set ratio factor",        OFFSET(ratio),      AV_OPT_TYPE_DOUBLE, {.dbl=1},        0, 30,      FLAGS },
    
          { "makeup",     "set makeup gain",         OFFSET(makeup),     AV_OPT_TYPE_DOUBLE, {.dbl=0},        0, 1000,    FLAGS },
    
          { "range",      "set max gain",            OFFSET(range),      AV_OPT_TYPE_DOUBLE, {.dbl=50},       1, 2000,    FLAGS },
    
          { "mode",       "set mode",                OFFSET(mode),       AV_OPT_TYPE_INT,    {.i64=0},  LISTEN,NB_FMODES-1,FLAGS, .unit = "mode" },
    
          {   "listen",   0,                         0,                  AV_OPT_TYPE_CONST,  {.i64=LISTEN},   0, 0,       FLAGS, .unit = "mode" },
    
          {   "cutbelow", 0,                         0,                  AV_OPT_TYPE_CONST,  {.i64=CUT_BELOW},0, 0,       FLAGS, .unit = "mode" },
    
          {   "cutabove", 0,                         0,                  AV_OPT_TYPE_CONST,  {.i64=CUT_ABOVE},0, 0,       FLAGS, .unit = "mode" },
    
          { "boostbelow", 0,                         0,                  AV_OPT_TYPE_CONST,  {.i64=BOOST_BELOW},0, 0,     FLAGS, .unit = "mode" },
    
          { "boostabove", 0,                         0,                  AV_OPT_TYPE_CONST,  {.i64=BOOST_ABOVE},0, 0,     FLAGS, .unit = "mode" },
    
          { "dftype",     "set detection filter type",OFFSET(dftype),    AV_OPT_TYPE_INT,    {.i64=0},        0, 3,       FLAGS, .unit = "dftype" },
    
          {   "bandpass", 0,                         0,                  AV_OPT_TYPE_CONST,  {.i64=0},        0, 0,       FLAGS, .unit = "dftype" },
    
          {   "lowpass",  0,                         0,                  AV_OPT_TYPE_CONST,  {.i64=1},        0, 0,       FLAGS, .unit = "dftype" },
    
          {   "highpass", 0,                         0,                  AV_OPT_TYPE_CONST,  {.i64=2},        0, 0,       FLAGS, .unit = "dftype" },
    
          {   "peak",     0,                         0,                  AV_OPT_TYPE_CONST,  {.i64=3},        0, 0,       FLAGS, .unit = "dftype" },
    
          { "tftype",     "set target filter type",  OFFSET(tftype),     AV_OPT_TYPE_INT,    {.i64=0},        0, 2,       FLAGS, .unit = "tftype" },
    
          {   "bell",     0,                         0,                  AV_OPT_TYPE_CONST,  {.i64=0},        0, 0,       FLAGS, .unit = "tftype" },
    
          {   "lowshelf", 0,                         0,                  AV_OPT_TYPE_CONST,  {.i64=1},        0, 0,       FLAGS, .unit = "tftype" },
    
          {   "highshelf",0,                         0,                  AV_OPT_TYPE_CONST,  {.i64=2},        0, 0,       FLAGS, .unit = "tftype" },
    
          { "auto",       "set auto threshold",      OFFSET(detection),  AV_OPT_TYPE_INT,    {.i64=DET_OFF},DET_DISABLED,NB_DMODES-1,FLAGS, .unit = "auto" },
    
          {   "disabled", 0,                         0,                  AV_OPT_TYPE_CONST,  {.i64=DET_DISABLED}, 0, 0,   FLAGS, .unit = "auto" },
    
          {   "off",      0,                         0,                  AV_OPT_TYPE_CONST,  {.i64=DET_OFF},      0, 0,   FLAGS, .unit = "auto" },
    
          {   "on",       0,                         0,                  AV_OPT_TYPE_CONST,  {.i64=DET_ON},       0, 0,   FLAGS, .unit = "auto" },
    
          {   "adaptive", 0,                         0,                  AV_OPT_TYPE_CONST,  {.i64=DET_ADAPTIVE}, 0, 0,   FLAGS, .unit = "auto" },
    
          { "precision", "set processing precision", OFFSET(precision),  AV_OPT_TYPE_INT,    {.i64=0},        0, 2,       AF, .unit = "precision" },
    
          {   "auto",  "set auto processing precision",                  0, AV_OPT_TYPE_CONST, {.i64=0},      0, 0,       AF, .unit = "precision" },
    
          {   "float", "set single-floating point processing precision", 0, AV_OPT_TYPE_CONST, {.i64=1},      0, 0,       AF, .unit = "precision" },
    
          {   "double","set double-floating point processing precision", 0, AV_OPT_TYPE_CONST, {.i64=2},      0, 0,       AF, .unit = "precision" },
    
          { NULL }
    
      };
    
      AVFILTER_DEFINE_CLASS(adynamicequalizer);
    
      static const AVFilterPad inputs[] = {
    
          {
    
              .name         = "default",
    
              .type         = AVMEDIA_TYPE_AUDIO,
    
              .filter_frame = filter_frame,
    
              .config_props = config_input,
    
          },
    
      };
    
      const AVFilter ff_af_adynamicequalizer = {
    
          .name            = "adynamicequalizer",
    
          .description     = NULL_IF_CONFIG_SMALL("Apply Dynamic Equalization of input audio."),
    
          .priv_size       = sizeof(AudioDynamicEqualizerContext),
    
          .priv_class      = &adynamicequalizer_class,
    
          .uninit          = uninit,
    
          FILTER_INPUTS(inputs),
    
          FILTER_OUTPUTS(ff_audio_default_filterpad),
    
          FILTER_QUERY_FUNC2(query_formats),
    
          .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
    
                             AVFILTER_FLAG_SLICE_THREADS,
    
          .process_command = ff_filter_process_command,
    
      };

Line	Exec	Source
1		/*
2		* This file is part of FFmpeg.
3		*
4		* FFmpeg is free software; you can redistribute it and/or
5		* modify it under the terms of the GNU Lesser General Public
6		* License as published by the Free Software Foundation; either
7		* version 2.1 of the License, or (at your option) any later version.
8		*
9		* FFmpeg is distributed in the hope that it will be useful,
10		* but WITHOUT ANY WARRANTY; without even the implied warranty of
11		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12		* Lesser General Public License for more details.
13		*
14		* You should have received a copy of the GNU Lesser General Public
15		* License along with FFmpeg; if not, write to the Free Software
16		* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17		*/
18
19		#include <float.h>
20
21		#include "libavutil/ffmath.h"
22		#include "libavutil/mem.h"
23		#include "libavutil/opt.h"
24		#include "avfilter.h"
25		#include "audio.h"
26		#include "filters.h"
27		#include "formats.h"
28
29		enum DetectionModes {
30		DET_UNSET = 0,
31		DET_DISABLED,
32		DET_OFF,
33		DET_ON,
34		DET_ADAPTIVE,
35		NB_DMODES,
36		};
37
38		enum FilterModes {
39		LISTEN = -1,
40		CUT_BELOW,
41		CUT_ABOVE,
42		BOOST_BELOW,
43		BOOST_ABOVE,
44		NB_FMODES,
45		};
46
47		typedef struct ChannelContext {
48		double fa_double[3], fm_double[3];
49		double dstate_double[2];
50		double fstate_double[2];
51		double tstate_double[2];
52		double lin_gain_double;
53		double detect_double;
54		double threshold_log_double;
55		double new_threshold_log_double;
56		double log_sum_double;
57		double sum_double;
58		float fa_float[3], fm_float[3];
59		float dstate_float[2];
60		float fstate_float[2];
61		float tstate_float[2];
62		float lin_gain_float;
63		float detect_float;
64		float threshold_log_float;
65		float new_threshold_log_float;
66		float log_sum_float;
67		float sum_float;
68		void *dqueue;
69		void *queue;
70		int position;
71		int size;
72		int front;
73		int back;
74		int detection;
75		int init;
76		} ChannelContext;
77
78		typedef struct AudioDynamicEqualizerContext {
79		const AVClass *class;
80
81		double threshold;
82		double threshold_log;
83		double dfrequency;
84		double dqfactor;
85		double tfrequency;
86		double tqfactor;
87		double ratio;
88		double range;
89		double makeup;
90		double dattack;
91		double drelease;
92		double dattack_coef;
93		double drelease_coef;
94		double gattack_coef;
95		double grelease_coef;
96		int mode;
97		int detection;
98		int tftype;
99		int dftype;
100		int precision;
101		int format;
102		int nb_channels;
103
104		int (filter_prepare)(AVFilterContext ctx);
105		int (filter_channels)(AVFilterContext ctx, void *arg, int jobnr, int nb_jobs);
106
107		double da_double[3], dm_double[3];
108		float da_float[3], dm_float[3];
109
110		ChannelContext *cc;
111		} AudioDynamicEqualizerContext;
112
113	✗	static int query_formats(const AVFilterContext *ctx,
114		AVFilterFormatsConfig **cfg_in,
115		AVFilterFormatsConfig **cfg_out)
116		{
117	✗	const AudioDynamicEqualizerContext *s = ctx->priv;
118		static const enum AVSampleFormat sample_fmts[3][3] = {
119		{ AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_DBLP, AV_SAMPLE_FMT_NONE },
120		{ AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE },
121		{ AV_SAMPLE_FMT_DBLP, AV_SAMPLE_FMT_NONE },
122		};
123		int ret;
124
125	✗	if ((ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out,
126	✗	sample_fmts[s->precision])) < 0)
127	✗	return ret;
128
129	✗	return 0;
130		}
131
132	✗	static double get_coef(double x, double sr)
133		{
134	✗	return 1.0 - exp(-1.0 / (0.001 * x * sr));
135		}
136
137		typedef struct ThreadData {
138		AVFrame in, out;
139		} ThreadData;
140
141		#define DEPTH 32
142		#include "adynamicequalizer_template.c"
143
144		#undef DEPTH
145		#define DEPTH 64
146		#include "adynamicequalizer_template.c"
147
148	✗	static int config_input(AVFilterLink *inlink)
149		{
150	✗	AVFilterContext *ctx = inlink->dst;
151	✗	AudioDynamicEqualizerContext *s = ctx->priv;
152
153	✗	s->format = inlink->format;
154	✗	s->cc = av_calloc(inlink->ch_layout.nb_channels, sizeof(*s->cc));
155	✗	if (!s->cc)
156	✗	return AVERROR(ENOMEM);
157	✗	s->nb_channels = inlink->ch_layout.nb_channels;
158
159	✗	switch (s->format) {
160	✗	case AV_SAMPLE_FMT_DBLP:
161	✗	s->filter_prepare = filter_prepare_double;
162	✗	s->filter_channels = filter_channels_double;
163	✗	break;
164	✗	case AV_SAMPLE_FMT_FLTP:
165	✗	s->filter_prepare = filter_prepare_float;
166	✗	s->filter_channels = filter_channels_float;
167	✗	break;
168		}
169
170	✗	for (int ch = 0; ch < s->nb_channels; ch++) {
171	✗	ChannelContext *cc = &s->cc[ch];
172	✗	cc->queue = av_calloc(inlink->sample_rate, sizeof(double));
173	✗	cc->dqueue = av_calloc(inlink->sample_rate, sizeof(double));
174	✗	if (!cc->queue \|\| !cc->dqueue)
175	✗	return AVERROR(ENOMEM);
176		}
177
178	✗	return 0;
179		}
180
181	✗	static int filter_frame(AVFilterLink inlink, AVFrame in)
182		{
183	✗	AVFilterContext *ctx = inlink->dst;
184	✗	AVFilterLink *outlink = ctx->outputs[0];
185	✗	AudioDynamicEqualizerContext *s = ctx->priv;
186		ThreadData td;
187		AVFrame *out;
188
189	✗	if (av_frame_is_writable(in)) {
190	✗	out = in;
191		} else {
192	✗	out = ff_get_audio_buffer(outlink, in->nb_samples);
193	✗	if (!out) {
194	✗	av_frame_free(&in);
195	✗	return AVERROR(ENOMEM);
196		}
197	✗	av_frame_copy_props(out, in);
198		}
199
200	✗	td.in = in;
201	✗	td.out = out;
202	✗	s->filter_prepare(ctx);
203	✗	ff_filter_execute(ctx, s->filter_channels, &td, NULL,
204	✗	FFMIN(outlink->ch_layout.nb_channels, ff_filter_get_nb_threads(ctx)));
205
206	✗	if (out != in)
207	✗	av_frame_free(&in);
208	✗	return ff_filter_frame(outlink, out);
209		}
210
211	✗	static av_cold void uninit(AVFilterContext *ctx)
212		{
213	✗	AudioDynamicEqualizerContext *s = ctx->priv;
214
215	✗	for (int ch = 0; ch < s->nb_channels; ch++) {
216	✗	ChannelContext *cc = &s->cc[ch];
217	✗	av_freep(&cc->queue);
218	✗	av_freep(&cc->dqueue);
219		}
220	✗	av_freep(&s->cc);
221	✗	}
222
223		#define OFFSET(x) offsetof(AudioDynamicEqualizerContext, x)
224		#define AF AV_OPT_FLAG_AUDIO_PARAM\|AV_OPT_FLAG_FILTERING_PARAM
225		#define FLAGS AV_OPT_FLAG_AUDIO_PARAM\|AV_OPT_FLAG_FILTERING_PARAM\|AV_OPT_FLAG_RUNTIME_PARAM
226
227		static const AVOption adynamicequalizer_options[] = {
228		{ "threshold", "set detection threshold", OFFSET(threshold), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0, 100, FLAGS },
229		{ "dfrequency", "set detection frequency", OFFSET(dfrequency), AV_OPT_TYPE_DOUBLE, {.dbl=1000}, 2, 1000000, FLAGS },
230		{ "dqfactor", "set detection Q factor", OFFSET(dqfactor), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0.001, 1000, FLAGS },
231		{ "tfrequency", "set target frequency", OFFSET(tfrequency), AV_OPT_TYPE_DOUBLE, {.dbl=1000}, 2, 1000000, FLAGS },
232		{ "tqfactor", "set target Q factor", OFFSET(tqfactor), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0.001, 1000, FLAGS },
233		{ "attack", "set detection attack duration", OFFSET(dattack), AV_OPT_TYPE_DOUBLE, {.dbl=20}, 0.01, 2000, FLAGS },
234		{ "release","set detection release duration",OFFSET(drelease), AV_OPT_TYPE_DOUBLE, {.dbl=200}, 0.01, 2000, FLAGS },
235		{ "ratio", "set ratio factor", OFFSET(ratio), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 30, FLAGS },
236		{ "makeup", "set makeup gain", OFFSET(makeup), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0, 1000, FLAGS },
237		{ "range", "set max gain", OFFSET(range), AV_OPT_TYPE_DOUBLE, {.dbl=50}, 1, 2000, FLAGS },
238		{ "mode", "set mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=0}, LISTEN,NB_FMODES-1,FLAGS, .unit = "mode" },
239		{ "listen", 0, 0, AV_OPT_TYPE_CONST, {.i64=LISTEN}, 0, 0, FLAGS, .unit = "mode" },
240		{ "cutbelow", 0, 0, AV_OPT_TYPE_CONST, {.i64=CUT_BELOW},0, 0, FLAGS, .unit = "mode" },
241		{ "cutabove", 0, 0, AV_OPT_TYPE_CONST, {.i64=CUT_ABOVE},0, 0, FLAGS, .unit = "mode" },
242		{ "boostbelow", 0, 0, AV_OPT_TYPE_CONST, {.i64=BOOST_BELOW},0, 0, FLAGS, .unit = "mode" },
243		{ "boostabove", 0, 0, AV_OPT_TYPE_CONST, {.i64=BOOST_ABOVE},0, 0, FLAGS, .unit = "mode" },
244		{ "dftype", "set detection filter type",OFFSET(dftype), AV_OPT_TYPE_INT, {.i64=0}, 0, 3, FLAGS, .unit = "dftype" },
245		{ "bandpass", 0, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, .unit = "dftype" },
246		{ "lowpass", 0, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, .unit = "dftype" },
247		{ "highpass", 0, 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, FLAGS, .unit = "dftype" },
248		{ "peak", 0, 0, AV_OPT_TYPE_CONST, {.i64=3}, 0, 0, FLAGS, .unit = "dftype" },
249		{ "tftype", "set target filter type", OFFSET(tftype), AV_OPT_TYPE_INT, {.i64=0}, 0, 2, FLAGS, .unit = "tftype" },
250		{ "bell", 0, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, .unit = "tftype" },
251		{ "lowshelf", 0, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, .unit = "tftype" },
252		{ "highshelf",0, 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, FLAGS, .unit = "tftype" },
253		{ "auto", "set auto threshold", OFFSET(detection), AV_OPT_TYPE_INT, {.i64=DET_OFF},DET_DISABLED,NB_DMODES-1,FLAGS, .unit = "auto" },
254		{ "disabled", 0, 0, AV_OPT_TYPE_CONST, {.i64=DET_DISABLED}, 0, 0, FLAGS, .unit = "auto" },
255		{ "off", 0, 0, AV_OPT_TYPE_CONST, {.i64=DET_OFF}, 0, 0, FLAGS, .unit = "auto" },
256		{ "on", 0, 0, AV_OPT_TYPE_CONST, {.i64=DET_ON}, 0, 0, FLAGS, .unit = "auto" },
257		{ "adaptive", 0, 0, AV_OPT_TYPE_CONST, {.i64=DET_ADAPTIVE}, 0, 0, FLAGS, .unit = "auto" },
258		{ "precision", "set processing precision", OFFSET(precision), AV_OPT_TYPE_INT, {.i64=0}, 0, 2, AF, .unit = "precision" },
259		{ "auto", "set auto processing precision", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, .unit = "precision" },
260		{ "float", "set single-floating point processing precision", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF, .unit = "precision" },
261		{ "double","set double-floating point processing precision", 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, AF, .unit = "precision" },
262		{ NULL }
263		};
264
265		AVFILTER_DEFINE_CLASS(adynamicequalizer);
266
267		static const AVFilterPad inputs[] = {
268		{
269		.name = "default",
270		.type = AVMEDIA_TYPE_AUDIO,
271		.filter_frame = filter_frame,
272		.config_props = config_input,
273		},
274		};
275
276		const AVFilter ff_af_adynamicequalizer = {
277		.name = "adynamicequalizer",
278		.description = NULL_IF_CONFIG_SMALL("Apply Dynamic Equalization of input audio."),
279		.priv_size = sizeof(AudioDynamicEqualizerContext),
280		.priv_class = &adynamicequalizer_class,
281		.uninit = uninit,
282		FILTER_INPUTS(inputs),
283		FILTER_OUTPUTS(ff_audio_default_filterpad),
284		FILTER_QUERY_FUNC2(query_formats),
285		.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL \|
286		AVFILTER_FLAG_SLICE_THREADS,
287		.process_command = ff_filter_process_command,
288		};
289

Function (Line)	Call count	Block coverage
config_input (line 148)	not called	0.0%
filter_frame (line 181)	not called	0.0%
get_coef (line 132)	not called	0.0%
query_formats (line 113)	not called	0.0%
uninit (line 211)	not called	0.0%