FFmpeg
avf_showfreqs.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015 Paul B Mahol
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include <float.h>
22 #include <math.h>
23 
24 #include "libavcodec/avfft.h"
25 #include "libavutil/audio_fifo.h"
26 #include "libavutil/avassert.h"
27 #include "libavutil/avstring.h"
28 #include "libavutil/channel_layout.h"
29 #include "libavutil/intreadwrite.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/parseutils.h"
32 #include "audio.h"
33 #include "filters.h"
34 #include "video.h"
35 #include "avfilter.h"
36 #include "internal.h"
37 #include "window_func.h"
38 
39 enum DisplayMode { LINE, BAR, DOT, NB_MODES };
40 enum ChannelMode { COMBINED, SEPARATE, NB_CMODES };
41 enum FrequencyScale { FS_LINEAR, FS_LOG, FS_RLOG, NB_FSCALES };
42 enum AmplitudeScale { AS_LINEAR, AS_SQRT, AS_CBRT, AS_LOG, NB_ASCALES };
43 
44 typedef struct ShowFreqsContext {
45  const AVClass *class;
46  int w, h;
47  int mode;
48  int cmode;
49  int fft_size;
50  int fft_bits;
51  int ascale, fscale;
52  int avg;
53  int win_func;
54  FFTContext *fft;
55  FFTComplex **fft_data;
56  float **avg_data;
57  float *window_func_lut;
58  float overlap;
59  float minamp;
60  int hop_size;
61  int nb_channels;
62  int nb_freq;
63  int win_size;
64  float scale;
65  char *colors;
66  AVAudioFifo *fifo;
67  int64_t pts;
68 } ShowFreqsContext;
69 
70 #define OFFSET(x) offsetof(ShowFreqsContext, x)
71 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
72 
73 static const AVOption showfreqs_options[] = {
74  { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "1024x512"}, 0, 0, FLAGS },
75  { "s", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "1024x512"}, 0, 0, FLAGS },
76  { "mode", "set display mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=BAR}, 0, NB_MODES-1, FLAGS, "mode" },
77  { "line", "show lines", 0, AV_OPT_TYPE_CONST, {.i64=LINE}, 0, 0, FLAGS, "mode" },
78  { "bar", "show bars", 0, AV_OPT_TYPE_CONST, {.i64=BAR}, 0, 0, FLAGS, "mode" },
79  { "dot", "show dots", 0, AV_OPT_TYPE_CONST, {.i64=DOT}, 0, 0, FLAGS, "mode" },
80  { "ascale", "set amplitude scale", OFFSET(ascale), AV_OPT_TYPE_INT, {.i64=AS_LOG}, 0, NB_ASCALES-1, FLAGS, "ascale" },
81  { "lin", "linear", 0, AV_OPT_TYPE_CONST, {.i64=AS_LINEAR}, 0, 0, FLAGS, "ascale" },
82  { "sqrt", "square root", 0, AV_OPT_TYPE_CONST, {.i64=AS_SQRT}, 0, 0, FLAGS, "ascale" },
83  { "cbrt", "cubic root", 0, AV_OPT_TYPE_CONST, {.i64=AS_CBRT}, 0, 0, FLAGS, "ascale" },
84  { "log", "logarithmic", 0, AV_OPT_TYPE_CONST, {.i64=AS_LOG}, 0, 0, FLAGS, "ascale" },
85  { "fscale", "set frequency scale", OFFSET(fscale), AV_OPT_TYPE_INT, {.i64=FS_LINEAR}, 0, NB_FSCALES-1, FLAGS, "fscale" },
86  { "lin", "linear", 0, AV_OPT_TYPE_CONST, {.i64=FS_LINEAR}, 0, 0, FLAGS, "fscale" },
87  { "log", "logarithmic", 0, AV_OPT_TYPE_CONST, {.i64=FS_LOG}, 0, 0, FLAGS, "fscale" },
88  { "rlog", "reverse logarithmic", 0, AV_OPT_TYPE_CONST, {.i64=FS_RLOG}, 0, 0, FLAGS, "fscale" },
89  { "win_size", "set window size", OFFSET(fft_size), AV_OPT_TYPE_INT, {.i64=2048}, 16, 65536, FLAGS },
90  { "win_func", "set window function", OFFSET(win_func), AV_OPT_TYPE_INT, {.i64=WFUNC_HANNING}, 0, NB_WFUNC-1, FLAGS, "win_func" },
91  { "rect", "Rectangular", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_RECT}, 0, 0, FLAGS, "win_func" },
92  { "bartlett", "Bartlett", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BARTLETT}, 0, 0, FLAGS, "win_func" },
93  { "hanning", "Hanning", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_HANNING}, 0, 0, FLAGS, "win_func" },
94  { "hamming", "Hamming", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_HAMMING}, 0, 0, FLAGS, "win_func" },
95  { "blackman", "Blackman", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BLACKMAN}, 0, 0, FLAGS, "win_func" },
96  { "welch", "Welch", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_WELCH}, 0, 0, FLAGS, "win_func" },
97  { "flattop", "Flat-top", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_FLATTOP}, 0, 0, FLAGS, "win_func" },
98  { "bharris", "Blackman-Harris", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BHARRIS}, 0, 0, FLAGS, "win_func" },
99  { "bnuttall", "Blackman-Nuttall", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BNUTTALL}, 0, 0, FLAGS, "win_func" },
100  { "bhann", "Bartlett-Hann", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BHANN}, 0, 0, FLAGS, "win_func" },
101  { "sine", "Sine", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_SINE}, 0, 0, FLAGS, "win_func" },
102  { "nuttall", "Nuttall", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_NUTTALL}, 0, 0, FLAGS, "win_func" },
103  { "lanczos", "Lanczos", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_LANCZOS}, 0, 0, FLAGS, "win_func" },
104  { "gauss", "Gauss", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_GAUSS}, 0, 0, FLAGS, "win_func" },
105  { "tukey", "Tukey", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_TUKEY}, 0, 0, FLAGS, "win_func" },
106  { "dolph", "Dolph-Chebyshev", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_DOLPH}, 0, 0, FLAGS, "win_func" },
107  { "cauchy", "Cauchy", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_CAUCHY}, 0, 0, FLAGS, "win_func" },
108  { "parzen", "Parzen", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_PARZEN}, 0, 0, FLAGS, "win_func" },
109  { "poisson", "Poisson", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_POISSON}, 0, 0, FLAGS, "win_func" },
110  { "bohman", "Bohman", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BOHMAN} , 0, 0, FLAGS, "win_func" },
111  { "overlap", "set window overlap", OFFSET(overlap), AV_OPT_TYPE_FLOAT, {.dbl=1.}, 0., 1., FLAGS },
112  { "averaging", "set time averaging", OFFSET(avg), AV_OPT_TYPE_INT, {.i64=1}, 0, INT32_MAX, FLAGS },
113  { "colors", "set channels colors", OFFSET(colors), AV_OPT_TYPE_STRING, {.str = "red|green|blue|yellow|orange|lime|pink|magenta|brown" }, 0, 0, FLAGS },
114  { "cmode", "set channel mode", OFFSET(cmode), AV_OPT_TYPE_INT, {.i64=COMBINED}, 0, NB_CMODES-1, FLAGS, "cmode" },
115  { "combined", "show all channels in same window", 0, AV_OPT_TYPE_CONST, {.i64=COMBINED}, 0, 0, FLAGS, "cmode" },
116  { "separate", "show each channel in own window", 0, AV_OPT_TYPE_CONST, {.i64=SEPARATE}, 0, 0, FLAGS, "cmode" },
117  { "minamp", "set minimum amplitude", OFFSET(minamp), AV_OPT_TYPE_FLOAT, {.dbl=1e-6}, FLT_MIN, 1e-6, FLAGS },
118  { NULL }
119 };
120 
121 AVFILTER_DEFINE_CLASS(showfreqs);
122 
123 static int query_formats(AVFilterContext *ctx)
124 {
125  AVFilterFormats *formats = NULL;
126  AVFilterChannelLayouts *layouts = NULL;
127  AVFilterLink *inlink = ctx->inputs[0];
128  AVFilterLink *outlink = ctx->outputs[0];
129  static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE };
130  static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGBA, AV_PIX_FMT_NONE };
131  int ret;
132 
133  /* set input audio formats */
134  formats = ff_make_format_list(sample_fmts);
135  if ((ret = ff_formats_ref(formats, &inlink->out_formats)) < 0)
136  return ret;
137 
138  layouts = ff_all_channel_layouts();
139  if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0)
140  return ret;
141 
142  formats = ff_all_samplerates();
143  if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0)
144  return ret;
145 
146  /* set output video format */
147  formats = ff_make_format_list(pix_fmts);
148  if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0)
149  return ret;
150 
151  return 0;
152 }
153 
154 static av_cold int init(AVFilterContext *ctx)
155 {
156  ShowFreqsContext *s = ctx->priv;
157 
158  s->pts = AV_NOPTS_VALUE;
159 
160  return 0;
161 }
162 
163 static int config_output(AVFilterLink *outlink)
164 {
165  AVFilterContext *ctx = outlink->src;
166  AVFilterLink *inlink = ctx->inputs[0];
167  ShowFreqsContext *s = ctx->priv;
168  float overlap;
169  int i;
170 
171  s->fft_bits = av_log2(s->fft_size);
172  s->nb_freq = 1 << (s->fft_bits - 1);
173  s->win_size = s->nb_freq << 1;
174  av_audio_fifo_free(s->fifo);
175  av_fft_end(s->fft);
176  s->fft = av_fft_init(s->fft_bits, 0);
177  if (!s->fft) {
178  av_log(ctx, AV_LOG_ERROR, "Unable to create FFT context. "
179  "The window size might be too high.\n");
180  return AVERROR(ENOMEM);
181  }
182 
183  /* FFT buffers: x2 for each (display) channel buffer.
184  * Note: we use free and malloc instead of a realloc-like function to
185  * make sure the buffer is aligned in memory for the FFT functions. */
186  for (i = 0; i < s->nb_channels; i++) {
187  av_freep(&s->fft_data[i]);
188  av_freep(&s->avg_data[i]);
189  }
190  av_freep(&s->fft_data);
191  av_freep(&s->avg_data);
192  s->nb_channels = inlink->channels;
193 
194  s->fft_data = av_calloc(s->nb_channels, sizeof(*s->fft_data));
195  if (!s->fft_data)
196  return AVERROR(ENOMEM);
197  s->avg_data = av_calloc(s->nb_channels, sizeof(*s->avg_data));
198  if (!s->avg_data)
199  return AVERROR(ENOMEM);
200  for (i = 0; i < s->nb_channels; i++) {
201  s->fft_data[i] = av_calloc(s->win_size, sizeof(**s->fft_data));
202  s->avg_data[i] = av_calloc(s->nb_freq, sizeof(**s->avg_data));
203  if (!s->fft_data[i] || !s->avg_data[i])
204  return AVERROR(ENOMEM);
205  }
206 
207  /* pre-calc windowing function */
208  s->window_func_lut = av_realloc_f(s->window_func_lut, s->win_size,
209  sizeof(*s->window_func_lut));
210  if (!s->window_func_lut)
211  return AVERROR(ENOMEM);
212  generate_window_func(s->window_func_lut, s->win_size, s->win_func, &overlap);
213  if (s->overlap == 1.)
214  s->overlap = overlap;
215  s->hop_size = (1. - s->overlap) * s->win_size;
216  if (s->hop_size < 1) {
217  av_log(ctx, AV_LOG_ERROR, "overlap %f too big\n", s->overlap);
218  return AVERROR(EINVAL);
219  }
220 
221  for (s->scale = 0, i = 0; i < s->win_size; i++) {
222  s->scale += s->window_func_lut[i] * s->window_func_lut[i];
223  }
224 
225  outlink->frame_rate = av_make_q(inlink->sample_rate, s->win_size * (1.-s->overlap));
226  outlink->sample_aspect_ratio = (AVRational){1,1};
227  outlink->w = s->w;
228  outlink->h = s->h;
229 
230  s->fifo = av_audio_fifo_alloc(inlink->format, inlink->channels, s->win_size);
231  if (!s->fifo)
232  return AVERROR(ENOMEM);
233  return 0;
234 }
235 
236 static inline void draw_dot(AVFrame *out, int x, int y, uint8_t fg[4])
237 {
238 
239  uint32_t color = AV_RL32(out->data[0] + y * out->linesize[0] + x * 4);
240 
241  if ((color & 0xffffff) != 0)
242  AV_WL32(out->data[0] + y * out->linesize[0] + x * 4, AV_RL32(fg) | color);
243  else
244  AV_WL32(out->data[0] + y * out->linesize[0] + x * 4, AV_RL32(fg));
245 }
246 
247 static int get_sx(ShowFreqsContext *s, int f)
248 {
249  switch (s->fscale) {
250  case FS_LINEAR:
251  return (s->w/(float)s->nb_freq)*f;
252  case FS_LOG:
253  return s->w-pow(s->w, (s->nb_freq-f-1)/(s->nb_freq-1.));
254  case FS_RLOG:
255  return pow(s->w, f/(s->nb_freq-1.));
256  }
257 
258  return 0;
259 }
260 
261 static float get_bsize(ShowFreqsContext *s, int f)
262 {
263  switch (s->fscale) {
264  case FS_LINEAR:
265  return s->w/(float)s->nb_freq;
266  case FS_LOG:
267  return pow(s->w, (s->nb_freq-f-1)/(s->nb_freq-1.))-
268  pow(s->w, (s->nb_freq-f-2)/(s->nb_freq-1.));
269  case FS_RLOG:
270  return pow(s->w, (f+1)/(s->nb_freq-1.))-
271  pow(s->w, f /(s->nb_freq-1.));
272  }
273 
274  return 1.;
275 }
276 
277 static inline void plot_freq(ShowFreqsContext *s, int ch,
278  double a, int f, uint8_t fg[4], int *prev_y,
279  AVFrame *out, AVFilterLink *outlink)
280 {
281  const int w = s->w;
282  const float min = s->minamp;
283  const float avg = s->avg_data[ch][f];
284  const float bsize = get_bsize(s, f);
285  const int sx = get_sx(s, f);
286  int end = outlink->h;
287  int x, y, i;
288 
289  switch(s->ascale) {
290  case AS_SQRT:
291  a = 1.0 - sqrt(a);
292  break;
293  case AS_CBRT:
294  a = 1.0 - cbrt(a);
295  break;
296  case AS_LOG:
297  a = log(av_clipd(a, min, 1)) / log(min);
298  break;
299  case AS_LINEAR:
300  a = 1.0 - a;
301  break;
302  }
303 
304  switch (s->cmode) {
305  case COMBINED:
306  y = a * outlink->h - 1;
307  break;
308  case SEPARATE:
309  end = (outlink->h / s->nb_channels) * (ch + 1);
310  y = (outlink->h / s->nb_channels) * ch + a * (outlink->h / s->nb_channels) - 1;
311  break;
312  default:
313  av_assert0(0);
314  }
315  if (y < 0)
316  return;
317 
318  switch (s->avg) {
319  case 0:
320  y = s->avg_data[ch][f] = !outlink->frame_count_in ? y : FFMIN(avg, y);
321  break;
322  case 1:
323  break;
324  default:
325  s->avg_data[ch][f] = avg + y * (y - avg) / (FFMIN(outlink->frame_count_in + 1, s->avg) * y);
326  y = s->avg_data[ch][f];
327  break;
328  }
329 
330  switch(s->mode) {
331  case LINE:
332  if (*prev_y == -1) {
333  *prev_y = y;
334  }
335  if (y <= *prev_y) {
336  for (x = sx + 1; x < sx + bsize && x < w; x++)
337  draw_dot(out, x, y, fg);
338  for (i = y; i <= *prev_y; i++)
339  draw_dot(out, sx, i, fg);
340  } else {
341  for (i = *prev_y; i <= y; i++)
342  draw_dot(out, sx, i, fg);
343  for (x = sx + 1; x < sx + bsize && x < w; x++)
344  draw_dot(out, x, i - 1, fg);
345  }
346  *prev_y = y;
347  break;
348  case BAR:
349  for (x = sx; x < sx + bsize && x < w; x++)
350  for (i = y; i < end; i++)
351  draw_dot(out, x, i, fg);
352  break;
353  case DOT:
354  for (x = sx; x < sx + bsize && x < w; x++)
355  draw_dot(out, x, y, fg);
356  break;
357  }
358 }
359 
360 static int plot_freqs(AVFilterLink *inlink, AVFrame *in)
361 {
362  AVFilterContext *ctx = inlink->dst;
363  AVFilterLink *outlink = ctx->outputs[0];
364  ShowFreqsContext *s = ctx->priv;
365  const int win_size = s->win_size;
366  char *colors, *color, *saveptr = NULL;
367  AVFrame *out;
368  int ch, n;
369 
370  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
371  if (!out)
372  return AVERROR(ENOMEM);
373 
374  for (n = 0; n < outlink->h; n++)
375  memset(out->data[0] + out->linesize[0] * n, 0, outlink->w * 4);
376 
377  /* fill FFT input with the number of samples available */
378  for (ch = 0; ch < s->nb_channels; ch++) {
379  const float *p = (float *)in->extended_data[ch];
380 
381  for (n = 0; n < in->nb_samples; n++) {
382  s->fft_data[ch][n].re = p[n] * s->window_func_lut[n];
383  s->fft_data[ch][n].im = 0;
384  }
385  for (; n < win_size; n++) {
386  s->fft_data[ch][n].re = 0;
387  s->fft_data[ch][n].im = 0;
388  }
389  }
390 
391  /* run FFT on each samples set */
392  for (ch = 0; ch < s->nb_channels; ch++) {
393  av_fft_permute(s->fft, s->fft_data[ch]);
394  av_fft_calc(s->fft, s->fft_data[ch]);
395  }
396 
397 #define RE(x, ch) s->fft_data[ch][x].re
398 #define IM(x, ch) s->fft_data[ch][x].im
399 #define M(a, b) (sqrt((a) * (a) + (b) * (b)))
400 
401  colors = av_strdup(s->colors);
402  if (!colors) {
403  av_frame_free(&out);
404  return AVERROR(ENOMEM);
405  }
406 
407  for (ch = 0; ch < s->nb_channels; ch++) {
408  uint8_t fg[4] = { 0xff, 0xff, 0xff, 0xff };
409  int prev_y = -1, f;
410  double a;
411 
412  color = av_strtok(ch == 0 ? colors : NULL, " |", &saveptr);
413  if (color)
414  av_parse_color(fg, color, -1, ctx);
415 
416  a = av_clipd(M(RE(0, ch), 0) / s->scale, 0, 1);
417  plot_freq(s, ch, a, 0, fg, &prev_y, out, outlink);
418 
419  for (f = 1; f < s->nb_freq; f++) {
420  a = av_clipd(M(RE(f, ch), IM(f, ch)) / s->scale, 0, 1);
421 
422  plot_freq(s, ch, a, f, fg, &prev_y, out, outlink);
423  }
424  }
425 
426  av_free(colors);
427  out->pts = in->pts;
428  out->sample_aspect_ratio = (AVRational){1,1};
429  return ff_filter_frame(outlink, out);
430 }
431 
432 static int filter_frame(AVFilterLink *inlink)
433 {
434  AVFilterContext *ctx = inlink->dst;
435  ShowFreqsContext *s = ctx->priv;
436  AVFrame *fin = NULL;
437  int ret = 0;
438 
439  fin = ff_get_audio_buffer(inlink, s->win_size);
440  if (!fin) {
441  ret = AVERROR(ENOMEM);
442  goto fail;
443  }
444 
445  fin->pts = s->pts;
446  s->pts += s->hop_size;
447  ret = av_audio_fifo_peek(s->fifo, (void **)fin->extended_data, s->win_size);
448  if (ret < 0)
449  goto fail;
450 
451  ret = plot_freqs(inlink, fin);
452  av_frame_free(&fin);
453  av_audio_fifo_drain(s->fifo, s->hop_size);
454 
455 fail:
456  av_frame_free(&fin);
457  return ret;
458 }
459 
460 static int activate(AVFilterContext *ctx)
461 {
462  AVFilterLink *inlink = ctx->inputs[0];
463  AVFilterLink *outlink = ctx->outputs[0];
464  ShowFreqsContext *s = ctx->priv;
465  AVFrame *in = NULL;
466  int ret = 0;
467 
468  FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink);
469 
470  if (av_audio_fifo_size(s->fifo) < s->win_size)
471  ret = ff_inlink_consume_samples(inlink, s->win_size, s->win_size, &in);
472  if (ret < 0)
473  return ret;
474  if (ret > 0) {
475  av_audio_fifo_write(s->fifo, (void **)in->extended_data, in->nb_samples);
476  if (s->pts == AV_NOPTS_VALUE)
477  s->pts = in->pts;
478  av_frame_free(&in);
479  }
480 
481  if (av_audio_fifo_size(s->fifo) >= s->win_size) {
482  ret = filter_frame(inlink);
483  if (ret <= 0)
484  return ret;
485  }
486 
487  FF_FILTER_FORWARD_STATUS(inlink, outlink);
488  FF_FILTER_FORWARD_WANTED(outlink, inlink);
489 
490  return FFERROR_NOT_READY;
491 }
492 
493 static av_cold void uninit(AVFilterContext *ctx)
494 {
495  ShowFreqsContext *s = ctx->priv;
496  int i;
497 
498  av_fft_end(s->fft);
499  for (i = 0; i < s->nb_channels; i++) {
500  if (s->fft_data)
501  av_freep(&s->fft_data[i]);
502  if (s->avg_data)
503  av_freep(&s->avg_data[i]);
504  }
505  av_freep(&s->fft_data);
506  av_freep(&s->avg_data);
507  av_freep(&s->window_func_lut);
508  av_audio_fifo_free(s->fifo);
509 }
510 
511 static const AVFilterPad showfreqs_inputs[] = {
512  {
513  .name = "default",
514  .type = AVMEDIA_TYPE_AUDIO,
515  },
516  { NULL }
517 };
518 
519 static const AVFilterPad showfreqs_outputs[] = {
520  {
521  .name = "default",
522  .type = AVMEDIA_TYPE_VIDEO,
523  .config_props = config_output,
524  },
525  { NULL }
526 };
527 
528 AVFilter ff_avf_showfreqs = {
529  .name = "showfreqs",
530  .description = NULL_IF_CONFIG_SMALL("Convert input audio to a frequencies video output."),
531  .init = init,
532  .uninit = uninit,
533  .query_formats = query_formats,
534  .priv_size = sizeof(ShowFreqsContext),
535  .activate = activate,
536  .inputs = showfreqs_inputs,
537  .outputs = showfreqs_outputs,
538  .priv_class = &showfreqs_class,
539 };
av_audio_fifo_free
void av_audio_fifo_free(AVAudioFifo *af)
Free an AVAudioFifo.
Definition: audio_fifo.c:45
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
av_fft_end
av_cold void av_fft_end(FFTContext *s)
Definition: avfft.c:48
ff_get_audio_buffer
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
Definition: audio.c:86
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
AVFilterChannelLayouts
A list of supported channel layouts.
Definition: formats.h:85
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
ShowFreqsContext::fscale
int fscale
Definition: avf_showfreqs.c:51
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
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
out
FILE * out
Definition: movenc.c:54
M
#define M(a, b)
ShowFreqsContext::win_func
int win_func
Definition: avf_showfreqs.c:53
color
Definition: vf_paletteuse.c:582
ff_avf_showfreqs
AVFilter ff_avf_showfreqs
Definition: avf_showfreqs.c:528
FrequencyScale
FrequencyScale
Definition: avf_showfreqs.c:41
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
ShowFreqsContext::scale
float scale
Definition: avf_showfreqs.c:64
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
FFERROR_NOT_READY
return FFERROR_NOT_READY
Definition: filter_design.txt:204
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
NB_CMODES
@ NB_CMODES
Definition: avf_showfreqs.c:40
LINE
@ LINE
Definition: avf_showfreqs.c:39
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
RE
#define RE(x, ch)
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
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
w
uint8_t w
Definition: llviddspenc.c:38
draw_dot
static void draw_dot(AVFrame *out, int x, int y, uint8_t fg[4])
Definition: avf_showfreqs.c:236
showfreqs_inputs
static const AVFilterPad showfreqs_inputs[]
Definition: avf_showfreqs.c:511
AVOption
AVOption.
Definition: opt.h:246
av_fft_permute
void av_fft_permute(FFTContext *s, FFTComplex *z)
Do the permutation needed BEFORE calling ff_fft_calc().
Definition: avfft.c:38
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: avf_showfreqs.c:123
NB_ASCALES
@ NB_ASCALES
Definition: avf_showfreqs.c:42
float.h
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:148
video.h
ShowFreqsContext::w
int w
Definition: avf_showfreqs.c:46
ShowFreqsContext::fft
FFTContext * fft
Definition: avf_showfreqs.c:54
FF_FILTER_FORWARD_STATUS_BACK
#define FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink)
Forward the status on an output link to an input link.
Definition: filters.h:199
WFUNC_FLATTOP
@ WFUNC_FLATTOP
Definition: window_func.h:29
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
WFUNC_BLACKMAN
@ WFUNC_BLACKMAN
Definition: af_firequalizer.c:36
WFUNC_PARZEN
@ WFUNC_PARZEN
Definition: window_func.h:32
OFFSET
#define OFFSET(x)
Definition: avf_showfreqs.c:70
AVAudioFifo
Context for an Audio FIFO Buffer.
Definition: audio_fifo.c:34
ShowFreqsContext::h
int h
Definition: avf_showfreqs.c:46
av_audio_fifo_drain
int av_audio_fifo_drain(AVAudioFifo *af, int nb_samples)
Drain data from an AVAudioFifo.
Definition: audio_fifo.c:201
fail
#define fail()
Definition: checkasm.h:123
ShowFreqsContext::fft_data
FFTComplex ** fft_data
Definition: avf_showfreqs.c:55
FS_LOG
@ FS_LOG
Definition: avf_showfreqs.c:41
WFUNC_BHANN
@ WFUNC_BHANN
Definition: window_func.h:31
ChannelMode
ChannelMode
Definition: avf_showfreqs.c:40
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:54
cbrt
#define cbrt
Definition: tablegen.h:35
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
WFUNC_DOLPH
@ WFUNC_DOLPH
Definition: window_func.h:32
av_cold
#define av_cold
Definition: attributes.h:90
AmplitudeScale
AmplitudeScale
Definition: avf_ahistogram.c:32
BAR
@ BAR
Definition: avf_showfreqs.c:39
WFUNC_NUTTALL
@ WFUNC_NUTTALL
Definition: af_firequalizer.c:39
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
ShowFreqsContext::nb_channels
int nb_channels
Definition: avf_showfreqs.c:61
config_output
static int config_output(AVFilterLink *outlink)
Definition: avf_showfreqs.c:163
av_audio_fifo_write
int av_audio_fifo_write(AVAudioFifo *af, void **data, int nb_samples)
Write data to an AVAudioFifo.
Definition: audio_fifo.c:112
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
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
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
WFUNC_LANCZOS
@ WFUNC_LANCZOS
Definition: window_func.h:31
outputs
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
filters.h
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
WFUNC_RECT
@ WFUNC_RECT
Definition: window_func.h:28
ShowFreqsContext::colors
char * colors
Definition: avf_showfreqs.c:65
ctx
AVFormatContext * ctx
Definition: movenc.c:48
WFUNC_BHARRIS
@ WFUNC_BHARRIS
Definition: af_firequalizer.c:41
filter_frame
static int filter_frame(AVFilterLink *inlink)
Definition: avf_showfreqs.c:432
FS_LINEAR
@ FS_LINEAR
Definition: avf_showfreqs.c:41
f
#define f(width, name)
Definition: cbs_vp9.c:255
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:93
ShowFreqsContext::fft_size
int fft_size
Definition: avf_showfreqs.c:49
if
if(ret)
Definition: filter_design.txt:179
SEPARATE
@ SEPARATE
Definition: avf_showfreqs.c:40
ShowFreqsContext::nb_freq
int nb_freq
Definition: avf_showfreqs.c:62
av_realloc_f
#define av_realloc_f(p, o, n)
Definition: tableprint_vlc.h:33
FLAGS
#define FLAGS
Definition: avf_showfreqs.c:71
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
ff_inlink_consume_samples
int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max, AVFrame **rframe)
Take samples from the link's FIFO and update the link's stats.
Definition: avfilter.c:1495
NULL
#define NULL
Definition: coverity.c:32
ShowFreqsContext::cmode
int cmode
Definition: avf_showfreqs.c:48
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
av_audio_fifo_alloc
AVAudioFifo * av_audio_fifo_alloc(enum AVSampleFormat sample_fmt, int channels, int nb_samples)
Allocate an AVAudioFifo.
Definition: audio_fifo.c:59
WFUNC_HAMMING
@ WFUNC_HAMMING
Definition: af_firequalizer.c:35
AV_OPT_TYPE_IMAGE_SIZE
@ AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive integers
Definition: opt.h:233
init
static av_cold int init(AVFilterContext *ctx)
Definition: avf_showfreqs.c:154
parseutils.h
ShowFreqsContext::minamp
float minamp
Definition: avf_showfreqs.c:59
generate_window_func
static void generate_window_func(float *lut, int N, int win_func, float *overlap)
Definition: window_func.h:36
avfft.h
WFUNC_HANNING
@ WFUNC_HANNING
Definition: window_func.h:28
WFUNC_BARTLETT
@ WFUNC_BARTLETT
Definition: window_func.h:29
inputs
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
Definition: filter_design.txt:243
WFUNC_BOHMAN
@ WFUNC_BOHMAN
Definition: window_func.h:33
ShowFreqsContext::ascale
int ascale
Definition: avf_showfreqs.c:51
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
ShowFreqsContext::avg_data
float ** avg_data
Definition: avf_showfreqs.c:56
ShowFreqsContext::hop_size
int hop_size
Definition: avf_showfreqs.c:60
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
activate
static int activate(AVFilterContext *ctx)
Definition: avf_showfreqs.c:460
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
color
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
Definition: log.c:92
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
ShowFreqsContext::mode
int mode
Definition: avf_showfreqs.c:47
WFUNC_TUKEY
@ WFUNC_TUKEY
Definition: af_firequalizer.c:42
avg
#define avg(a, b, c, d)
Definition: colorspacedsp_template.c:28
plot_freqs
static int plot_freqs(AVFilterLink *inlink, AVFrame *in)
Definition: avf_showfreqs.c:360
IM
#define IM(x, ch)
ShowFreqsContext
Definition: avf_showfreqs.c:44
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
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
FF_FILTER_FORWARD_WANTED
FF_FILTER_FORWARD_WANTED(outlink, inlink)
ff_all_channel_layouts
AVFilterChannelLayouts * ff_all_channel_layouts(void)
Construct an empty AVFilterChannelLayouts/AVFilterFormats struct – representing any channel layout (w...
Definition: formats.c:445
av_audio_fifo_size
int av_audio_fifo_size(AVAudioFifo *af)
Get the current number of samples in the AVAudioFifo available for reading.
Definition: audio_fifo.c:228
internal.h
ShowFreqsContext::fft_bits
int fft_bits
Definition: avf_showfreqs.c:50
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:226
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
FFTContext
Definition: fft.h:88
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AS_LINEAR
@ AS_LINEAR
Definition: avf_showfreqs.c:42
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:347
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
FS_RLOG
@ FS_RLOG
Definition: avf_showfreqs.c:41
get_sx
static int get_sx(ShowFreqsContext *s, int f)
Definition: avf_showfreqs.c:247
uint8_t
uint8_t
Definition: audio_convert.c:194
audio_fifo.h
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:60
AVFilter
Filter definition.
Definition: avfilter.h:144
NB_MODES
@ NB_MODES
Definition: avf_showfreqs.c:39
ret
ret
Definition: filter_design.txt:187
plot_freq
static void plot_freq(ShowFreqsContext *s, int ch, double a, int f, uint8_t fg[4], int *prev_y, AVFrame *out, AVFilterLink *outlink)
Definition: avf_showfreqs.c:277
showfreqs_outputs
static const AVFilterPad showfreqs_outputs[]
Definition: avf_showfreqs.c:519
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:88
av_fft_init
FFTContext * av_fft_init(int nbits, int inverse)
Set up a complex FFT.
Definition: avfft.c:28
ShowFreqsContext::window_func_lut
float * window_func_lut
Definition: avf_showfreqs.c:57
window_func.h
NB_FSCALES
@ NB_FSCALES
Definition: avf_showfreqs.c:41
ShowFreqsContext::pts
int64_t pts
Definition: avf_showfreqs.c:67
showfreqs_options
static const AVOption showfreqs_options[]
Definition: avf_showfreqs.c:73
NB_WFUNC
@ NB_WFUNC
Definition: af_firequalizer.c:43
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
channel_layout.h
WFUNC_SINE
@ WFUNC_SINE
Definition: window_func.h:30
WFUNC_CAUCHY
@ WFUNC_CAUCHY
Definition: window_func.h:32
mode
mode
Definition: ebur128.h:83
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:223
avfilter.h
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: avf_showfreqs.c:493
AVFilterContext
An instance of a filter.
Definition: avfilter.h:338
ShowFreqsContext::win_size
int win_size
Definition: avf_showfreqs.c:63
DisplayMode
DisplayMode
Definition: avf_ahistogram.c:34
ShowFreqsContext::avg
int avg
Definition: avf_showfreqs.c:52
get_bsize
static float get_bsize(ShowFreqsContext *s, int f)
Definition: avf_showfreqs.c:261
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
WFUNC_GAUSS
@ WFUNC_GAUSS
Definition: window_func.h:31
WFUNC_BNUTTALL
@ WFUNC_BNUTTALL
Definition: af_firequalizer.c:40
audio.h
WFUNC_POISSON
@ WFUNC_POISSON
Definition: window_func.h:32
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
FF_FILTER_FORWARD_STATUS
FF_FILTER_FORWARD_STATUS(inlink, outlink)
AS_CBRT
@ AS_CBRT
Definition: avf_showfreqs.c:42
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
COMBINED
@ COMBINED
Definition: avf_showfreqs.c:40
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
ShowFreqsContext::fifo
AVAudioFifo * fifo
Definition: avf_showfreqs.c:66
DOT
@ DOT
Definition: avf_showfreqs.c:39
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:227
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(showfreqs)
av_audio_fifo_peek
int av_audio_fifo_peek(AVAudioFifo *af, void **data, int nb_samples)
Peek data from an AVAudioFifo.
Definition: audio_fifo.c:138
AS_LOG
@ AS_LOG
Definition: avf_showfreqs.c:42
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:232
av_fft_calc
void av_fft_calc(FFTContext *s, FFTComplex *z)
Do a complex FFT with the parameters defined in av_fft_init().
Definition: avfft.c:43
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
WFUNC_WELCH
@ WFUNC_WELCH
Definition: window_func.h:29
ShowFreqsContext::overlap
float overlap
Definition: avf_showfreqs.c:58
AS_SQRT
@ AS_SQRT
Definition: avf_showfreqs.c:42
FFTComplex
Definition: avfft.h:37
min
float min
Definition: vorbis_enc_data.h:456
Generated on Wed Aug 24 2022 21:31:46 for FFmpeg by   doxygen 1.8.17