FFmpeg
af_anequalizer.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2001-2010 Krzysztof Foltman, Markus Schmidt, Thor Harald Johansen and others
3  * Copyright (c) 2015 Paul B Mahol
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavutil/intreadwrite.h"
23 #include "libavutil/avstring.h"
24 #include "libavutil/ffmath.h"
25 #include "libavutil/opt.h"
26 #include "libavutil/parseutils.h"
27 #include "avfilter.h"
28 #include "internal.h"
29 #include "audio.h"
30 
31 #define FILTER_ORDER 4
32 
33 enum FilterType {
34  BUTTERWORTH,
35  CHEBYSHEV1,
36  CHEBYSHEV2,
37  NB_TYPES
38 };
39 
40 typedef struct FoSection {
41  double a0, a1, a2, a3, a4;
42  double b0, b1, b2, b3, b4;
43 
44  double num[4];
45  double denum[4];
46 } FoSection;
47 
48 typedef struct EqualizatorFilter {
49  int ignore;
50  int channel;
51  int type;
52 
53  double freq;
54  double gain;
55  double width;
56 
57  FoSection section[2];
58 } EqualizatorFilter;
59 
60 typedef struct AudioNEqualizerContext {
61  const AVClass *class;
62  char *args;
63  char *colors;
64  int draw_curves;
65  int w, h;
66 
67  double mag;
68  int fscale;
69  int nb_filters;
70  int nb_allocated;
71  EqualizatorFilter *filters;
72  AVFrame *video;
73 } AudioNEqualizerContext;
74 
75 #define OFFSET(x) offsetof(AudioNEqualizerContext, x)
76 #define A AV_OPT_FLAG_AUDIO_PARAM
77 #define V AV_OPT_FLAG_VIDEO_PARAM
78 #define F AV_OPT_FLAG_FILTERING_PARAM
79 
80 static const AVOption anequalizer_options[] = {
81  { "params", NULL, OFFSET(args), AV_OPT_TYPE_STRING, {.str=""}, 0, 0, A|F },
82  { "curves", "draw frequency response curves", OFFSET(draw_curves), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, V|F },
83  { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "hd720"}, 0, 0, V|F },
84  { "mgain", "set max gain", OFFSET(mag), AV_OPT_TYPE_DOUBLE, {.dbl=60}, -900, 900, V|F },
85  { "fscale", "set frequency scale", OFFSET(fscale), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, V|F, "fscale" },
86  { "lin", "linear", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, V|F, "fscale" },
87  { "log", "logarithmic", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, V|F, "fscale" },
88  { "colors", "set channels curves colors", OFFSET(colors), AV_OPT_TYPE_STRING, {.str = "red|green|blue|yellow|orange|lime|pink|magenta|brown" }, 0, 0, V|F },
89  { NULL }
90 };
91 
92 AVFILTER_DEFINE_CLASS(anequalizer);
93 
94 static void draw_curves(AVFilterContext *ctx, AVFilterLink *inlink, AVFrame *out)
95 {
96  AudioNEqualizerContext *s = ctx->priv;
97  char *colors, *color, *saveptr = NULL;
98  int ch, i, n;
99 
100  colors = av_strdup(s->colors);
101  if (!colors)
102  return;
103 
104  memset(out->data[0], 0, s->h * out->linesize[0]);
105 
106  for (ch = 0; ch < inlink->channels; ch++) {
107  uint8_t fg[4] = { 0xff, 0xff, 0xff, 0xff };
108  int prev_v = -1;
109  double f;
110 
111  color = av_strtok(ch == 0 ? colors : NULL, " |", &saveptr);
112  if (color)
113  av_parse_color(fg, color, -1, ctx);
114 
115  for (f = 0; f < s->w; f++) {
116  double zr, zi, zr2, zi2;
117  double Hr, Hi;
118  double Hmag = 1;
119  double w;
120  int v, y, x;
121 
122  w = M_PI * (s->fscale ? pow(s->w - 1, f / s->w) : f) / (s->w - 1);
123  zr = cos(w);
124  zr2 = zr * zr;
125  zi = -sin(w);
126  zi2 = zi * zi;
127 
128  for (n = 0; n < s->nb_filters; n++) {
129  if (s->filters[n].channel != ch ||
130  s->filters[n].ignore)
131  continue;
132 
133  for (i = 0; i < FILTER_ORDER / 2; i++) {
134  FoSection *S = &s->filters[n].section[i];
135 
136  /* H *= (((((S->b4 * z + S->b3) * z + S->b2) * z + S->b1) * z + S->b0) /
137  ((((S->a4 * z + S->a3) * z + S->a2) * z + S->a1) * z + S->a0)); */
138 
139  Hr = S->b4*(1-8*zr2*zi2) + S->b2*(zr2-zi2) + zr*(S->b1+S->b3*(zr2-3*zi2))+ S->b0;
140  Hi = zi*(S->b3*(3*zr2-zi2) + S->b1 + 2*zr*(2*S->b4*(zr2-zi2) + S->b2));
141  Hmag *= hypot(Hr, Hi);
142  Hr = S->a4*(1-8*zr2*zi2) + S->a2*(zr2-zi2) + zr*(S->a1+S->a3*(zr2-3*zi2))+ S->a0;
143  Hi = zi*(S->a3*(3*zr2-zi2) + S->a1 + 2*zr*(2*S->a4*(zr2-zi2) + S->a2));
144  Hmag /= hypot(Hr, Hi);
145  }
146  }
147 
148  v = av_clip((1. + -20 * log10(Hmag) / s->mag) * s->h / 2, 0, s->h - 1);
149  x = lrint(f);
150  if (prev_v == -1)
151  prev_v = v;
152  if (v <= prev_v) {
153  for (y = v; y <= prev_v; y++)
154  AV_WL32(out->data[0] + y * out->linesize[0] + x * 4, AV_RL32(fg));
155  } else {
156  for (y = prev_v; y <= v; y++)
157  AV_WL32(out->data[0] + y * out->linesize[0] + x * 4, AV_RL32(fg));
158  }
159 
160  prev_v = v;
161  }
162  }
163 
164  av_free(colors);
165 }
166 
167 static int config_video(AVFilterLink *outlink)
168 {
169  AVFilterContext *ctx = outlink->src;
170  AudioNEqualizerContext *s = ctx->priv;
171  AVFilterLink *inlink = ctx->inputs[0];
172  AVFrame *out;
173 
174  outlink->w = s->w;
175  outlink->h = s->h;
176 
177  av_frame_free(&s->video);
178  s->video = out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
179  if (!out)
180  return AVERROR(ENOMEM);
181  outlink->sample_aspect_ratio = (AVRational){1,1};
182 
183  draw_curves(ctx, inlink, out);
184 
185  return 0;
186 }
187 
188 static av_cold int init(AVFilterContext *ctx)
189 {
190  AudioNEqualizerContext *s = ctx->priv;
191  AVFilterPad pad, vpad;
192  int ret;
193 
194  pad = (AVFilterPad){
195  .name = av_strdup("out0"),
196  .type = AVMEDIA_TYPE_AUDIO,
197  };
198 
199  if (!pad.name)
200  return AVERROR(ENOMEM);
201 
202  ret = ff_insert_outpad(ctx, 0, &pad);
203  if (ret < 0) {
204  av_freep(&pad.name);
205  return ret;
206  }
207 
208  if (s->draw_curves) {
209  vpad = (AVFilterPad){
210  .name = av_strdup("out1"),
211  .type = AVMEDIA_TYPE_VIDEO,
212  .config_props = config_video,
213  };
214  if (!vpad.name) {
215  return AVERROR(ENOMEM);
216  }
217  ret = ff_insert_outpad(ctx, 1, &vpad);
218  if (ret < 0) {
219  av_freep(&vpad.name);
220  return ret;
221  }
222  }
223 
224  return 0;
225 }
226 
227 static int query_formats(AVFilterContext *ctx)
228 {
229  AVFilterLink *inlink = ctx->inputs[0];
230  AVFilterLink *outlink = ctx->outputs[0];
231  AudioNEqualizerContext *s = ctx->priv;
232  AVFilterFormats *formats;
233  AVFilterChannelLayouts *layouts;
234  static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGBA, AV_PIX_FMT_NONE };
235  static const enum AVSampleFormat sample_fmts[] = {
236  AV_SAMPLE_FMT_DBLP,
237  AV_SAMPLE_FMT_NONE
238  };
239  int ret;
240 
241  if (s->draw_curves) {
242  AVFilterLink *videolink = ctx->outputs[1];
243  formats = ff_make_format_list(pix_fmts);
244  if ((ret = ff_formats_ref(formats, &videolink->in_formats)) < 0)
245  return ret;
246  }
247 
248  formats = ff_make_format_list(sample_fmts);
249  if ((ret = ff_formats_ref(formats, &inlink->out_formats)) < 0 ||
250  (ret = ff_formats_ref(formats, &outlink->in_formats)) < 0)
251  return ret;
252 
253  layouts = ff_all_channel_counts();
254  if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0 ||
255  (ret = ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts)) < 0)
256  return ret;
257 
258  formats = ff_all_samplerates();
259  if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0 ||
260  (ret = ff_formats_ref(formats, &outlink->in_samplerates)) < 0)
261  return ret;
262 
263  return 0;
264 }
265 
266 static av_cold void uninit(AVFilterContext *ctx)
267 {
268  AudioNEqualizerContext *s = ctx->priv;
269 
270  for (int i = 0; i < ctx->nb_outputs; i++)
271  av_freep(&ctx->output_pads[i].name);
272  av_frame_free(&s->video);
273  av_freep(&s->filters);
274  s->nb_filters = 0;
275  s->nb_allocated = 0;
276 }
277 
278 static void butterworth_fo_section(FoSection *S, double beta,
279  double si, double g, double g0,
280  double D, double c0)
281 {
282  if (c0 == 1 || c0 == -1) {
283  S->b0 = (g*g*beta*beta + 2*g*g0*si*beta + g0*g0)/D;
284  S->b1 = 2*c0*(g*g*beta*beta - g0*g0)/D;
285  S->b2 = (g*g*beta*beta - 2*g0*g*beta*si + g0*g0)/D;
286  S->b3 = 0;
287  S->b4 = 0;
288 
289  S->a0 = 1;
290  S->a1 = 2*c0*(beta*beta - 1)/D;
291  S->a2 = (beta*beta - 2*beta*si + 1)/D;
292  S->a3 = 0;
293  S->a4 = 0;
294  } else {
295  S->b0 = (g*g*beta*beta + 2*g*g0*si*beta + g0*g0)/D;
296  S->b1 = -4*c0*(g0*g0 + g*g0*si*beta)/D;
297  S->b2 = 2*(g0*g0*(1 + 2*c0*c0) - g*g*beta*beta)/D;
298  S->b3 = -4*c0*(g0*g0 - g*g0*si*beta)/D;
299  S->b4 = (g*g*beta*beta - 2*g*g0*si*beta + g0*g0)/D;
300 
301  S->a0 = 1;
302  S->a1 = -4*c0*(1 + si*beta)/D;
303  S->a2 = 2*(1 + 2*c0*c0 - beta*beta)/D;
304  S->a3 = -4*c0*(1 - si*beta)/D;
305  S->a4 = (beta*beta - 2*si*beta + 1)/D;
306  }
307 }
308 
309 static void butterworth_bp_filter(EqualizatorFilter *f,
310  int N, double w0, double wb,
311  double G, double Gb, double G0)
312 {
313  double g, c0, g0, beta;
314  double epsilon;
315  int r = N % 2;
316  int L = (N - r) / 2;
317  int i;
318 
319  if (G == 0 && G0 == 0) {
320  f->section[0].a0 = 1;
321  f->section[0].b0 = 1;
322  f->section[1].a0 = 1;
323  f->section[1].b0 = 1;
324  return;
325  }
326 
327  G = ff_exp10(G/20);
328  Gb = ff_exp10(Gb/20);
329  G0 = ff_exp10(G0/20);
330 
331  epsilon = sqrt((G * G - Gb * Gb) / (Gb * Gb - G0 * G0));
332  g = pow(G, 1.0 / N);
333  g0 = pow(G0, 1.0 / N);
334  beta = pow(epsilon, -1.0 / N) * tan(wb/2);
335  c0 = cos(w0);
336 
337  for (i = 1; i <= L; i++) {
338  double ui = (2.0 * i - 1) / N;
339  double si = sin(M_PI * ui / 2.0);
340  double Di = beta * beta + 2 * si * beta + 1;
341 
342  butterworth_fo_section(&f->section[i - 1], beta, si, g, g0, Di, c0);
343  }
344 }
345 
346 static void chebyshev1_fo_section(FoSection *S, double a,
347  double c, double tetta_b,
348  double g0, double si, double b,
349  double D, double c0)
350 {
351  if (c0 == 1 || c0 == -1) {
352  S->b0 = (tetta_b*tetta_b*(b*b+g0*g0*c*c) + 2*g0*b*si*tetta_b*tetta_b + g0*g0)/D;
353  S->b1 = 2*c0*(tetta_b*tetta_b*(b*b+g0*g0*c*c) - g0*g0)/D;
354  S->b2 = (tetta_b*tetta_b*(b*b+g0*g0*c*c) - 2*g0*b*si*tetta_b + g0*g0)/D;
355  S->b3 = 0;
356  S->b4 = 0;
357 
358  S->a0 = 1;
359  S->a1 = 2*c0*(tetta_b*tetta_b*(a*a+c*c) - 1)/D;
360  S->a2 = (tetta_b*tetta_b*(a*a+c*c) - 2*a*si*tetta_b + 1)/D;
361  S->a3 = 0;
362  S->a4 = 0;
363  } else {
364  S->b0 = ((b*b + g0*g0*c*c)*tetta_b*tetta_b + 2*g0*b*si*tetta_b + g0*g0)/D;
365  S->b1 = -4*c0*(g0*g0 + g0*b*si*tetta_b)/D;
366  S->b2 = 2*(g0*g0*(1 + 2*c0*c0) - (b*b + g0*g0*c*c)*tetta_b*tetta_b)/D;
367  S->b3 = -4*c0*(g0*g0 - g0*b*si*tetta_b)/D;
368  S->b4 = ((b*b + g0*g0*c*c)*tetta_b*tetta_b - 2*g0*b*si*tetta_b + g0*g0)/D;
369 
370  S->a0 = 1;
371  S->a1 = -4*c0*(1 + a*si*tetta_b)/D;
372  S->a2 = 2*(1 + 2*c0*c0 - (a*a + c*c)*tetta_b*tetta_b)/D;
373  S->a3 = -4*c0*(1 - a*si*tetta_b)/D;
374  S->a4 = ((a*a + c*c)*tetta_b*tetta_b - 2*a*si*tetta_b + 1)/D;
375  }
376 }
377 
378 static void chebyshev1_bp_filter(EqualizatorFilter *f,
379  int N, double w0, double wb,
380  double G, double Gb, double G0)
381 {
382  double a, b, c0, g0, alfa, beta, tetta_b;
383  double epsilon;
384  int r = N % 2;
385  int L = (N - r) / 2;
386  int i;
387 
388  if (G == 0 && G0 == 0) {
389  f->section[0].a0 = 1;
390  f->section[0].b0 = 1;
391  f->section[1].a0 = 1;
392  f->section[1].b0 = 1;
393  return;
394  }
395 
396  G = ff_exp10(G/20);
397  Gb = ff_exp10(Gb/20);
398  G0 = ff_exp10(G0/20);
399 
400  epsilon = sqrt((G*G - Gb*Gb) / (Gb*Gb - G0*G0));
401  g0 = pow(G0,1.0/N);
402  alfa = pow(1.0/epsilon + sqrt(1 + 1/(epsilon*epsilon)), 1.0/N);
403  beta = pow(G/epsilon + Gb * sqrt(1 + 1/(epsilon*epsilon)), 1.0/N);
404  a = 0.5 * (alfa - 1.0/alfa);
405  b = 0.5 * (beta - g0*g0*(1/beta));
406  tetta_b = tan(wb/2);
407  c0 = cos(w0);
408 
409  for (i = 1; i <= L; i++) {
410  double ui = (2.0*i-1.0)/N;
411  double ci = cos(M_PI*ui/2.0);
412  double si = sin(M_PI*ui/2.0);
413  double Di = (a*a + ci*ci)*tetta_b*tetta_b + 2.0*a*si*tetta_b + 1;
414 
415  chebyshev1_fo_section(&f->section[i - 1], a, ci, tetta_b, g0, si, b, Di, c0);
416  }
417 }
418 
419 static void chebyshev2_fo_section(FoSection *S, double a,
420  double c, double tetta_b,
421  double g, double si, double b,
422  double D, double c0)
423 {
424  if (c0 == 1 || c0 == -1) {
425  S->b0 = (g*g*tetta_b*tetta_b + 2*tetta_b*g*b*si + b*b + g*g*c*c)/D;
426  S->b1 = 2*c0*(g*g*tetta_b*tetta_b - b*b - g*g*c*c)/D;
427  S->b2 = (g*g*tetta_b*tetta_b - 2*tetta_b*g*b*si + b*b + g*g*c*c)/D;
428  S->b3 = 0;
429  S->b4 = 0;
430 
431  S->a0 = 1;
432  S->a1 = 2*c0*(tetta_b*tetta_b - a*a - c*c)/D;
433  S->a2 = (tetta_b*tetta_b - 2*tetta_b*a*si + a*a + c*c)/D;
434  S->a3 = 0;
435  S->a4 = 0;
436  } else {
437  S->b0 = (g*g*tetta_b*tetta_b + 2*g*b*si*tetta_b + b*b + g*g*c*c)/D;
438  S->b1 = -4*c0*(b*b + g*g*c*c + g*b*si*tetta_b)/D;
439  S->b2 = 2*((b*b + g*g*c*c)*(1 + 2*c0*c0) - g*g*tetta_b*tetta_b)/D;
440  S->b3 = -4*c0*(b*b + g*g*c*c - g*b*si*tetta_b)/D;
441  S->b4 = (g*g*tetta_b*tetta_b - 2*g*b*si*tetta_b + b*b + g*g*c*c)/D;
442 
443  S->a0 = 1;
444  S->a1 = -4*c0*(a*a + c*c + a*si*tetta_b)/D;
445  S->a2 = 2*((a*a + c*c)*(1 + 2*c0*c0) - tetta_b*tetta_b)/D;
446  S->a3 = -4*c0*(a*a + c*c - a*si*tetta_b)/D;
447  S->a4 = (tetta_b*tetta_b - 2*a*si*tetta_b + a*a + c*c)/D;
448  }
449 }
450 
451 static void chebyshev2_bp_filter(EqualizatorFilter *f,
452  int N, double w0, double wb,
453  double G, double Gb, double G0)
454 {
455  double a, b, c0, tetta_b;
456  double epsilon, g, eu, ew;
457  int r = N % 2;
458  int L = (N - r) / 2;
459  int i;
460 
461  if (G == 0 && G0 == 0) {
462  f->section[0].a0 = 1;
463  f->section[0].b0 = 1;
464  f->section[1].a0 = 1;
465  f->section[1].b0 = 1;
466  return;
467  }
468 
469  G = ff_exp10(G/20);
470  Gb = ff_exp10(Gb/20);
471  G0 = ff_exp10(G0/20);
472 
473  epsilon = sqrt((G*G - Gb*Gb) / (Gb*Gb - G0*G0));
474  g = pow(G, 1.0 / N);
475  eu = pow(epsilon + sqrt(1 + epsilon*epsilon), 1.0/N);
476  ew = pow(G0*epsilon + Gb*sqrt(1 + epsilon*epsilon), 1.0/N);
477  a = (eu - 1.0/eu)/2.0;
478  b = (ew - g*g/ew)/2.0;
479  tetta_b = tan(wb/2);
480  c0 = cos(w0);
481 
482  for (i = 1; i <= L; i++) {
483  double ui = (2.0 * i - 1.0)/N;
484  double ci = cos(M_PI * ui / 2.0);
485  double si = sin(M_PI * ui / 2.0);
486  double Di = tetta_b*tetta_b + 2*a*si*tetta_b + a*a + ci*ci;
487 
488  chebyshev2_fo_section(&f->section[i - 1], a, ci, tetta_b, g, si, b, Di, c0);
489  }
490 }
491 
492 static double butterworth_compute_bw_gain_db(double gain)
493 {
494  double bw_gain = 0;
495 
496  if (gain <= -6)
497  bw_gain = gain + 3;
498  else if(gain > -6 && gain < 6)
499  bw_gain = gain * 0.5;
500  else if(gain >= 6)
501  bw_gain = gain - 3;
502 
503  return bw_gain;
504 }
505 
506 static double chebyshev1_compute_bw_gain_db(double gain)
507 {
508  double bw_gain = 0;
509 
510  if (gain <= -6)
511  bw_gain = gain + 1;
512  else if(gain > -6 && gain < 6)
513  bw_gain = gain * 0.9;
514  else if(gain >= 6)
515  bw_gain = gain - 1;
516 
517  return bw_gain;
518 }
519 
520 static double chebyshev2_compute_bw_gain_db(double gain)
521 {
522  double bw_gain = 0;
523 
524  if (gain <= -6)
525  bw_gain = -3;
526  else if(gain > -6 && gain < 6)
527  bw_gain = gain * 0.3;
528  else if(gain >= 6)
529  bw_gain = 3;
530 
531  return bw_gain;
532 }
533 
534 static inline double hz_2_rad(double x, double fs)
535 {
536  return 2 * M_PI * x / fs;
537 }
538 
539 static void equalizer(EqualizatorFilter *f, double sample_rate)
540 {
541  double w0 = hz_2_rad(f->freq, sample_rate);
542  double wb = hz_2_rad(f->width, sample_rate);
543  double bw_gain;
544 
545  switch (f->type) {
546  case BUTTERWORTH:
547  bw_gain = butterworth_compute_bw_gain_db(f->gain);
548  butterworth_bp_filter(f, FILTER_ORDER, w0, wb, f->gain, bw_gain, 0);
549  break;
550  case CHEBYSHEV1:
551  bw_gain = chebyshev1_compute_bw_gain_db(f->gain);
552  chebyshev1_bp_filter(f, FILTER_ORDER, w0, wb, f->gain, bw_gain, 0);
553  break;
554  case CHEBYSHEV2:
555  bw_gain = chebyshev2_compute_bw_gain_db(f->gain);
556  chebyshev2_bp_filter(f, FILTER_ORDER, w0, wb, f->gain, bw_gain, 0);
557  break;
558  }
559 
560 }
561 
562 static int add_filter(AudioNEqualizerContext *s, AVFilterLink *inlink)
563 {
564  equalizer(&s->filters[s->nb_filters], inlink->sample_rate);
565  if (s->nb_filters >= s->nb_allocated - 1) {
566  EqualizatorFilter *filters;
567 
568  filters = av_calloc(s->nb_allocated, 2 * sizeof(*s->filters));
569  if (!filters)
570  return AVERROR(ENOMEM);
571  memcpy(filters, s->filters, sizeof(*s->filters) * s->nb_allocated);
572  av_free(s->filters);
573  s->filters = filters;
574  s->nb_allocated *= 2;
575  }
576  s->nb_filters++;
577 
578  return 0;
579 }
580 
581 static int config_input(AVFilterLink *inlink)
582 {
583  AVFilterContext *ctx = inlink->dst;
584  AudioNEqualizerContext *s = ctx->priv;
585  char *args = av_strdup(s->args);
586  char *saveptr = NULL;
587  int ret = 0;
588 
589  if (!args)
590  return AVERROR(ENOMEM);
591 
592  s->nb_allocated = 32 * inlink->channels;
593  s->filters = av_calloc(inlink->channels, 32 * sizeof(*s->filters));
594  if (!s->filters) {
595  s->nb_allocated = 0;
596  av_free(args);
597  return AVERROR(ENOMEM);
598  }
599 
600  while (1) {
601  char *arg = av_strtok(s->nb_filters == 0 ? args : NULL, "|", &saveptr);
602 
603  if (!arg)
604  break;
605 
606  s->filters[s->nb_filters].type = 0;
607  if (sscanf(arg, "c%d f=%lf w=%lf g=%lf t=%d", &s->filters[s->nb_filters].channel,
608  &s->filters[s->nb_filters].freq,
609  &s->filters[s->nb_filters].width,
610  &s->filters[s->nb_filters].gain,
611  &s->filters[s->nb_filters].type) != 5 &&
612  sscanf(arg, "c%d f=%lf w=%lf g=%lf", &s->filters[s->nb_filters].channel,
613  &s->filters[s->nb_filters].freq,
614  &s->filters[s->nb_filters].width,
615  &s->filters[s->nb_filters].gain) != 4 ) {
616  av_free(args);
617  return AVERROR(EINVAL);
618  }
619 
620  if (s->filters[s->nb_filters].freq < 0 ||
621  s->filters[s->nb_filters].freq > inlink->sample_rate / 2.0)
622  s->filters[s->nb_filters].ignore = 1;
623 
624  if (s->filters[s->nb_filters].channel < 0 ||
625  s->filters[s->nb_filters].channel >= inlink->channels)
626  s->filters[s->nb_filters].ignore = 1;
627 
628  s->filters[s->nb_filters].type = av_clip(s->filters[s->nb_filters].type, 0, NB_TYPES - 1);
629  ret = add_filter(s, inlink);
630  if (ret < 0)
631  break;
632  }
633 
634  av_free(args);
635 
636  return ret;
637 }
638 
639 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
640  char *res, int res_len, int flags)
641 {
642  AudioNEqualizerContext *s = ctx->priv;
643  AVFilterLink *inlink = ctx->inputs[0];
644  int ret = AVERROR(ENOSYS);
645 
646  if (!strcmp(cmd, "change")) {
647  double freq, width, gain;
648  int filter;
649 
650  if (sscanf(args, "%d|f=%lf|w=%lf|g=%lf", &filter, &freq, &width, &gain) != 4)
651  return AVERROR(EINVAL);
652 
653  if (filter < 0 || filter >= s->nb_filters)
654  return AVERROR(EINVAL);
655 
656  if (freq < 0 || freq > inlink->sample_rate / 2.0)
657  return AVERROR(EINVAL);
658 
659  s->filters[filter].freq = freq;
660  s->filters[filter].width = width;
661  s->filters[filter].gain = gain;
662  equalizer(&s->filters[filter], inlink->sample_rate);
663  if (s->draw_curves)
664  draw_curves(ctx, inlink, s->video);
665 
666  ret = 0;
667  }
668 
669  return ret;
670 }
671 
672 static inline double section_process(FoSection *S, double in)
673 {
674  double out;
675 
676  out = S->b0 * in;
677  out+= S->b1 * S->num[0] - S->denum[0] * S->a1;
678  out+= S->b2 * S->num[1] - S->denum[1] * S->a2;
679  out+= S->b3 * S->num[2] - S->denum[2] * S->a3;
680  out+= S->b4 * S->num[3] - S->denum[3] * S->a4;
681 
682  S->num[3] = S->num[2];
683  S->num[2] = S->num[1];
684  S->num[1] = S->num[0];
685  S->num[0] = in;
686 
687  S->denum[3] = S->denum[2];
688  S->denum[2] = S->denum[1];
689  S->denum[1] = S->denum[0];
690  S->denum[0] = out;
691 
692  return out;
693 }
694 
695 static double process_sample(FoSection *s1, double in)
696 {
697  double p0 = in, p1;
698  int i;
699 
700  for (i = 0; i < FILTER_ORDER / 2; i++) {
701  p1 = section_process(&s1[i], p0);
702  p0 = p1;
703  }
704 
705  return p1;
706 }
707 
708 static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
709 {
710  AVFilterContext *ctx = inlink->dst;
711  AudioNEqualizerContext *s = ctx->priv;
712  AVFilterLink *outlink = ctx->outputs[0];
713  double *bptr;
714  int i, n;
715 
716  for (i = 0; i < s->nb_filters; i++) {
717  EqualizatorFilter *f = &s->filters[i];
718 
719  if (f->gain == 0. || f->ignore)
720  continue;
721 
722  bptr = (double *)buf->extended_data[f->channel];
723  for (n = 0; n < buf->nb_samples; n++) {
724  double sample = bptr[n];
725 
726  sample = process_sample(f->section, sample);
727  bptr[n] = sample;
728  }
729  }
730 
731  if (s->draw_curves) {
732  AVFrame *clone;
733 
734  const int64_t pts = buf->pts +
735  av_rescale_q(buf->nb_samples, (AVRational){ 1, inlink->sample_rate },
736  outlink->time_base);
737  int ret;
738 
739  s->video->pts = pts;
740  clone = av_frame_clone(s->video);
741  if (!clone)
742  return AVERROR(ENOMEM);
743  ret = ff_filter_frame(ctx->outputs[1], clone);
744  if (ret < 0)
745  return ret;
746  }
747 
748  return ff_filter_frame(outlink, buf);
749 }
750 
751 static const AVFilterPad inputs[] = {
752  {
753  .name = "default",
754  .type = AVMEDIA_TYPE_AUDIO,
755  .config_props = config_input,
756  .filter_frame = filter_frame,
757  .needs_writable = 1,
758  },
759  { NULL }
760 };
761 
762 AVFilter ff_af_anequalizer = {
763  .name = "anequalizer",
764  .description = NULL_IF_CONFIG_SMALL("Apply high-order audio parametric multi band equalizer."),
765  .priv_size = sizeof(AudioNEqualizerContext),
766  .priv_class = &anequalizer_class,
767  .init = init,
768  .uninit = uninit,
769  .query_formats = query_formats,
770  .inputs = inputs,
771  .outputs = NULL,
772  .flags = AVFILTER_FLAG_DYNAMIC_OUTPUTS,
773  .process_command = process_command,
774 };
config_video
static int config_video(AVFilterLink *outlink)
Definition: af_anequalizer.c:167
formats
formats
Definition: signature.h:48
ff_get_video_buffer
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:99
AVFilterChannelLayouts
A list of supported channel layouts.
Definition: formats.h:85
AudioNEqualizerContext::args
char * args
Definition: af_anequalizer.c:62
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
ff_exp10
static av_always_inline double ff_exp10(double x)
Compute 10^x for floating point values.
Definition: ffmath.h:42
r
const char * r
Definition: vf_curves.c:114
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:300
butterworth_fo_section
static void butterworth_fo_section(FoSection *S, double beta, double si, double g, double g0, double D, double c0)
Definition: af_anequalizer.c:278
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
out
FILE * out
Definition: movenc.c:54
F
#define F
Definition: af_anequalizer.c:78
color
Definition: vf_paletteuse.c:582
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1075
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:716
ff_channel_layouts_ref
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:479
layouts
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:434
av_parse_color
int av_parse_color(uint8_t *rgba_color, const char *color_string, int slen, void *log_ctx)
Put the RGBA values that correspond to color_string in rgba_color.
Definition: parseutils.c:354
filters
static const struct PPFilter filters[]
Definition: postprocess.c:134
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
FilterType
FilterType
Definition: af_anequalizer.c:33
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
ff_all_channel_counts
AVFilterChannelLayouts * ff_all_channel_counts(void)
Construct an AVFilterChannelLayouts coding for any channel layout, with known or unknown disposition.
Definition: formats.c:454
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:393
EqualizatorFilter
Definition: af_anequalizer.c:48
w
uint8_t w
Definition: llviddspenc.c:38
AVOption
AVOption.
Definition: opt.h:246
b
#define b
Definition: input.c:41
CHEBYSHEV2
@ CHEBYSHEV2
Definition: af_anequalizer.c:36
EqualizatorFilter::width
double width
Definition: af_anequalizer.c:55
chebyshev1_bp_filter
static void chebyshev1_bp_filter(EqualizatorFilter *f, int N, double w0, double wb, double G, double Gb, double G0)
Definition: af_anequalizer.c:378
EqualizatorFilter::gain
double gain
Definition: af_anequalizer.c:54
filter
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
Definition: filter_design.txt:228
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:148
chebyshev2_bp_filter
static void chebyshev2_bp_filter(EqualizatorFilter *f, int N, double w0, double wb, double G, double Gb, double G0)
Definition: af_anequalizer.c:451
sample_rate
sample_rate
Definition: ffmpeg_filter.c:192
anequalizer_options
static const AVOption anequalizer_options[]
Definition: af_anequalizer.c:80
AudioNEqualizerContext::mag
double mag
Definition: af_anequalizer.c:67
D
D(D(float, sse)
Definition: rematrix_init.c:28
AudioNEqualizerContext::nb_filters
int nb_filters
Definition: af_anequalizer.c:69
FILTER_ORDER
#define FILTER_ORDER
Definition: af_anequalizer.c:31
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
S
#define S(s, c, i)
Definition: flacdsp_template.c:46
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
Definition: af_anequalizer.c:708
FoSection::b1
double b1
Definition: af_anequalizer.c:42
AudioNEqualizerContext::h
int h
Definition: af_anequalizer.c:65
AudioNEqualizerContext::fscale
int fscale
Definition: af_anequalizer.c:68
CHEBYSHEV1
@ CHEBYSHEV1
Definition: af_anequalizer.c:35
config_input
static int config_input(AVFilterLink *inlink)
Definition: af_anequalizer.c:581
pts
static int64_t pts
Definition: transcode_aac.c:647
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(anequalizer)
BUTTERWORTH
@ BUTTERWORTH
Definition: af_anequalizer.c:34
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:54
FoSection::denum
double denum[4]
Definition: af_anequalizer.c:45
lrint
#define lrint
Definition: tablegen.h:53
FoSection::a2
double a2
Definition: af_anequalizer.c:41
av_cold
#define av_cold
Definition: attributes.h:90
equalizer
static void equalizer(EqualizatorFilter *f, double sample_rate)
Definition: af_anequalizer.c:539
chebyshev2_fo_section
static void chebyshev2_fo_section(FoSection *S, double a, double c, double tetta_b, double g, double si, double b, double D, double c0)
Definition: af_anequalizer.c:419
FoSection::num
double num[4]
Definition: af_anequalizer.c:44
width
#define width
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
FoSection::a0
double a0
Definition: af_anequalizer.c:41
g
const char * g
Definition: vf_curves.c:115
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Definition: opt.h:225
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
s1
#define s1
Definition: regdef.h:38
ff_formats_ref
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:484
av_strtok
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok().
Definition: avstring.c:184
chebyshev1_fo_section
static void chebyshev1_fo_section(FoSection *S, double a, double c, double tetta_b, double g0, double si, double b, double D, double c0)
Definition: af_anequalizer.c:346
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: af_anequalizer.c:227
outputs
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
ctx
AVFormatContext * ctx
Definition: movenc.c:48
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:541
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
A
#define A
Definition: af_anequalizer.c:76
f
#define f(width, name)
Definition: cbs_vp9.c:255
hz_2_rad
static double hz_2_rad(double x, double fs)
Definition: af_anequalizer.c:534
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:93
arg
const char * arg
Definition: jacosubdec.c:66
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: af_anequalizer.c:266
AudioNEqualizerContext
Definition: af_anequalizer.c:60
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
NULL
#define NULL
Definition: coverity.c:32
fs
#define fs(width, name, subs,...)
Definition: cbs_vp9.c:259
inputs
static const AVFilterPad inputs[]
Definition: af_anequalizer.c:751
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AV_OPT_TYPE_IMAGE_SIZE
@ AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive integers
Definition: opt.h:233
FoSection::b3
double b3
Definition: af_anequalizer.c:42
parseutils.h
process_command
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: af_anequalizer.c:639
AudioNEqualizerContext::video
AVFrame * video
Definition: af_anequalizer.c:72
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
AVFILTER_FLAG_DYNAMIC_OUTPUTS
#define AVFILTER_FLAG_DYNAMIC_OUTPUTS
The number of the filter outputs is not determined just by AVFilter.outputs.
Definition: avfilter.h:111
draw_curves
static void draw_curves(AVFilterContext *ctx, AVFilterLink *inlink, AVFrame *out)
Definition: af_anequalizer.c:94
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:188
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
sample
#define sample
Definition: flacdsp_template.c:44
hypot
static av_const double hypot(double x, double y)
Definition: libm.h:366
color
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
Definition: log.c:92
section
Definition: ffprobe.c:140
FoSection::b4
double b4
Definition: af_anequalizer.c:42
ff_af_anequalizer
AVFilter ff_af_anequalizer
Definition: af_anequalizer.c:762
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
FoSection
Definition: af_anequalizer.c:40
N
#define N
Definition: af_mcompand.c:54
add_filter
static int add_filter(AudioNEqualizerContext *s, AVFilterLink *inlink)
Definition: af_anequalizer.c:562
M_PI
#define M_PI
Definition: mathematics.h:52
internal.h
EqualizatorFilter::channel
int channel
Definition: af_anequalizer.c:50
in
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
Definition: audio_convert.c:326
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:366
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
FoSection::b2
double b2
Definition: af_anequalizer.c:42
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:347
FoSection::b0
double b0
Definition: af_anequalizer.c:42
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
section_process
static double section_process(FoSection *S, double in)
Definition: af_anequalizer.c:672
NB_TYPES
@ NB_TYPES
Definition: af_anequalizer.c:37
uint8_t
uint8_t
Definition: audio_convert.c:194
chebyshev1_compute_bw_gain_db
static double chebyshev1_compute_bw_gain_db(double gain)
Definition: af_anequalizer.c:506
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:60
chebyshev2_compute_bw_gain_db
static double chebyshev2_compute_bw_gain_db(double gain)
Definition: af_anequalizer.c:520
V
#define V
Definition: af_anequalizer.c:77
OFFSET
#define OFFSET(x)
Definition: af_anequalizer.c:75
AVFilter
Filter definition.
Definition: avfilter.h:144
FoSection::a3
double a3
Definition: af_anequalizer.c:41
G
#define G
Definition: huffyuvdsp.h:33
ret
ret
Definition: filter_design.txt:187
FoSection::a1
double a1
Definition: af_anequalizer.c:41
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:88
L
#define L(x)
Definition: vp56_arith.h:36
ff_all_samplerates
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:439
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:245
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
ff_insert_outpad
static int ff_insert_outpad(AVFilterContext *f, unsigned index, AVFilterPad *p)
Insert a new output pad for the filter.
Definition: internal.h:274
butterworth_bp_filter
static void butterworth_bp_filter(EqualizatorFilter *f, int N, double w0, double wb, double G, double Gb, double G0)
Definition: af_anequalizer.c:309
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:223
avfilter.h
EqualizatorFilter::type
int type
Definition: af_anequalizer.c:51
AV_SAMPLE_FMT_DBLP
@ AV_SAMPLE_FMT_DBLP
double, planar
Definition: samplefmt.h:70
EqualizatorFilter::freq
double freq
Definition: af_anequalizer.c:53
ffmath.h
AVFilterContext
An instance of a filter.
Definition: avfilter.h:338
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
audio.h
AudioNEqualizerContext::w
int w
Definition: af_anequalizer.c:65
process_sample
static double process_sample(FoSection *s1, double in)
Definition: af_anequalizer.c:695
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:240
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AudioNEqualizerContext::filters
EqualizatorFilter * filters
Definition: af_anequalizer.c:71
AudioNEqualizerContext::nb_allocated
int nb_allocated
Definition: af_anequalizer.c:70
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:565
AudioNEqualizerContext::colors
char * colors
Definition: af_anequalizer.c:63
EqualizatorFilter::ignore
int ignore
Definition: af_anequalizer.c:49
AudioNEqualizerContext::draw_curves
int draw_curves
Definition: af_anequalizer.c:64
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:227
init
static av_cold int init(AVFilterContext *ctx)
Definition: af_anequalizer.c:188
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:232
FoSection::a4
double a4
Definition: af_anequalizer.c:41
ui
#define ui(width, name)
Definition: cbs_mpeg2.c:43
butterworth_compute_bw_gain_db
static double butterworth_compute_bw_gain_db(double gain)
Definition: af_anequalizer.c:492
Generated on Wed Aug 24 2022 21:31:44 for FFmpeg by   doxygen 1.8.17