FFmpeg coverage

Directory:	../../../ffmpeg/
File:	src/libavfilter/af_adynamicequalizer.c
Date:	2024-04-17 23:49:55

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

Function (Line)	Call count	Block coverage
config_input (line 147)	not called	0.0%
filter_frame (line 180)	not called	0.0%
get_coef (line 131)	not called	0.0%
query_formats (line 112)	not called	0.0%
uninit (line 210)	not called	0.0%