FFmpeg
af_astats.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2009 Rob Sykes <robs@users.sourceforge.net>
3  * Copyright (c) 2013 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 <float.h>
23 #include <math.h>
24 
25 #include "libavutil/opt.h"
26 #include "audio.h"
27 #include "avfilter.h"
28 #include "internal.h"
29 
30 #define HISTOGRAM_SIZE 8192
31 #define HISTOGRAM_MAX (HISTOGRAM_SIZE-1)
32 
33 #define MEASURE_ALL UINT_MAX
34 #define MEASURE_NONE 0
35 
36 #define MEASURE_DC_OFFSET (1 << 0)
37 #define MEASURE_MIN_LEVEL (1 << 1)
38 #define MEASURE_MAX_LEVEL (1 << 2)
39 #define MEASURE_MIN_DIFFERENCE (1 << 3)
40 #define MEASURE_MAX_DIFFERENCE (1 << 4)
41 #define MEASURE_MEAN_DIFFERENCE (1 << 5)
42 #define MEASURE_RMS_DIFFERENCE (1 << 6)
43 #define MEASURE_PEAK_LEVEL (1 << 7)
44 #define MEASURE_RMS_LEVEL (1 << 8)
45 #define MEASURE_RMS_PEAK (1 << 9)
46 #define MEASURE_RMS_TROUGH (1 << 10)
47 #define MEASURE_CREST_FACTOR (1 << 11)
48 #define MEASURE_FLAT_FACTOR (1 << 12)
49 #define MEASURE_PEAK_COUNT (1 << 13)
50 #define MEASURE_BIT_DEPTH (1 << 14)
51 #define MEASURE_DYNAMIC_RANGE (1 << 15)
52 #define MEASURE_ZERO_CROSSINGS (1 << 16)
53 #define MEASURE_ZERO_CROSSINGS_RATE (1 << 17)
54 #define MEASURE_NUMBER_OF_SAMPLES (1 << 18)
55 #define MEASURE_NUMBER_OF_NANS (1 << 19)
56 #define MEASURE_NUMBER_OF_INFS (1 << 20)
57 #define MEASURE_NUMBER_OF_DENORMALS (1 << 21)
58 #define MEASURE_NOISE_FLOOR (1 << 22)
59 #define MEASURE_NOISE_FLOOR_COUNT (1 << 23)
60 #define MEASURE_ENTROPY (1 << 24)
61 #define MEASURE_ABS_PEAK_COUNT (1 << 25)
62 
63 #define MEASURE_MINMAXPEAK (MEASURE_MIN_LEVEL | MEASURE_MAX_LEVEL | MEASURE_PEAK_LEVEL)
64 
65 typedef struct ChannelStats {
66  double last;
67  double last_non_zero;
68  double min_non_zero;
69  double sigma_x, sigma_x2;
70  double avg_sigma_x2, min_sigma_x2, max_sigma_x2;
71  double min, max;
72  double nmin, nmax;
73  double min_run, max_run;
74  double min_runs, max_runs;
75  double min_diff, max_diff;
76  double diff1_sum;
77  double diff1_sum_x2;
78  double abs_peak;
79  uint64_t mask, imask;
80  uint64_t min_count, max_count;
81  uint64_t abs_peak_count;
82  uint64_t noise_floor_count;
83  uint64_t zero_runs;
84  uint64_t nb_samples;
85  uint64_t nb_nans;
86  uint64_t nb_infs;
87  uint64_t nb_denormals;
88  double *win_samples;
89  double *sorted_samples;
90  uint64_t ehistogram[HISTOGRAM_SIZE];
91  int sorted_front;
92  int sorted_back;
93  int win_pos;
94  int max_index;
95  double noise_floor;
96  double entropy;
97 } ChannelStats;
98 
99 typedef struct AudioStatsContext {
100  const AVClass *class;
101  ChannelStats *chstats;
102  int nb_channels;
103  uint64_t tc_samples;
104  double time_constant;
105  double mult;
106  int metadata;
107  int used;
108  int reset_count;
109  int nb_frames;
110  int maxbitdepth;
111  int measure_perchannel;
112  int measure_overall;
113  int is_float;
114  int is_double;
115 } AudioStatsContext;
116 
117 #define OFFSET(x) offsetof(AudioStatsContext, x)
118 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
119 
120 static const AVOption astats_options[] = {
121  { "length", "set the window length", OFFSET(time_constant), AV_OPT_TYPE_DOUBLE, {.dbl=.05}, 0, 10, FLAGS },
122  { "metadata", "inject metadata in the filtergraph", OFFSET(metadata), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
123  { "reset", "Set the number of frames over which cumulative stats are calculated before being reset", OFFSET(reset_count), AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX, FLAGS },
124  { "measure_perchannel", "Select the parameters which are measured per channel", OFFSET(measure_perchannel), AV_OPT_TYPE_FLAGS, {.i64=MEASURE_ALL}, 0, UINT_MAX, FLAGS, "measure" },
125  { "none" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_NONE }, 0, 0, FLAGS, "measure" },
126  { "all" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_ALL }, 0, 0, FLAGS, "measure" },
127  { "Bit_depth" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_BIT_DEPTH }, 0, 0, FLAGS, "measure" },
128  { "Crest_factor" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_CREST_FACTOR }, 0, 0, FLAGS, "measure" },
129  { "DC_offset" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_DC_OFFSET }, 0, 0, FLAGS, "measure" },
130  { "Dynamic_range" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_DYNAMIC_RANGE }, 0, 0, FLAGS, "measure" },
131  { "Entropy" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_ENTROPY }, 0, 0, FLAGS, "measure" },
132  { "Flat_factor" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_FLAT_FACTOR }, 0, 0, FLAGS, "measure" },
133  { "Max_difference" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_MAX_DIFFERENCE }, 0, 0, FLAGS, "measure" },
134  { "Max_level" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_MAX_LEVEL }, 0, 0, FLAGS, "measure" },
135  { "Mean_difference" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_MEAN_DIFFERENCE }, 0, 0, FLAGS, "measure" },
136  { "Min_difference" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_MIN_DIFFERENCE }, 0, 0, FLAGS, "measure" },
137  { "Min_level" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_MIN_LEVEL }, 0, 0, FLAGS, "measure" },
138  { "Noise_floor" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_NOISE_FLOOR }, 0, 0, FLAGS, "measure" },
139  { "Noise_floor_count" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_NOISE_FLOOR_COUNT }, 0, 0, FLAGS, "measure" },
140  { "Number_of_Infs" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_NUMBER_OF_INFS }, 0, 0, FLAGS, "measure" },
141  { "Number_of_NaNs" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_NUMBER_OF_NANS }, 0, 0, FLAGS, "measure" },
142  { "Number_of_denormals" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_NUMBER_OF_DENORMALS }, 0, 0, FLAGS, "measure" },
143  { "Number_of_samples" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_NUMBER_OF_SAMPLES }, 0, 0, FLAGS, "measure" },
144  { "Peak_count" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_PEAK_COUNT }, 0, 0, FLAGS, "measure" },
145  { "Peak_level" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_PEAK_LEVEL }, 0, 0, FLAGS, "measure" },
146  { "RMS_difference" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_RMS_DIFFERENCE }, 0, 0, FLAGS, "measure" },
147  { "RMS_level" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_RMS_LEVEL }, 0, 0, FLAGS, "measure" },
148  { "RMS_peak" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_RMS_PEAK }, 0, 0, FLAGS, "measure" },
149  { "RMS_trough" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_RMS_TROUGH }, 0, 0, FLAGS, "measure" },
150  { "Zero_crossings" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_ZERO_CROSSINGS }, 0, 0, FLAGS, "measure" },
151  { "Zero_crossings_rate" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_ZERO_CROSSINGS_RATE }, 0, 0, FLAGS, "measure" },
152  { "Abs_Peak_count" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_ABS_PEAK_COUNT }, 0, 0, FLAGS, "measure" },
153  { "measure_overall", "Select the parameters which are measured overall", OFFSET(measure_overall), AV_OPT_TYPE_FLAGS, {.i64=MEASURE_ALL}, 0, UINT_MAX, FLAGS, "measure" },
154  { NULL }
155 };
156 
157 AVFILTER_DEFINE_CLASS(astats);
158 
159 static void reset_stats(AudioStatsContext *s)
160 {
161  int c;
162 
163  for (c = 0; c < s->nb_channels; c++) {
164  ChannelStats *p = &s->chstats[c];
165 
166  p->min = p->nmin = p->min_sigma_x2 = DBL_MAX;
167  p->max = p->nmax = p->max_sigma_x2 =-DBL_MAX;
168  p->abs_peak = 0;
169  p->min_non_zero = DBL_MAX;
170  p->min_diff = DBL_MAX;
171  p->max_diff = 0;
172  p->sigma_x = 0;
173  p->sigma_x2 = 0;
174  p->avg_sigma_x2 = 0;
175  p->min_run = 0;
176  p->max_run = 0;
177  p->min_runs = 0;
178  p->max_runs = 0;
179  p->diff1_sum = 0;
180  p->diff1_sum_x2 = 0;
181  p->mask = 0;
182  p->imask = 0xFFFFFFFFFFFFFFFF;
183  p->min_count = 0;
184  p->max_count = 0;
185  p->abs_peak_count = 0;
186  p->zero_runs = 0;
187  p->nb_samples = 0;
188  p->nb_nans = 0;
189  p->nb_infs = 0;
190  p->nb_denormals = 0;
191  p->last = NAN;
192  p->noise_floor = NAN;
193  p->noise_floor_count = 0;
194  p->entropy = 0;
195  p->win_pos = 0;
196  p->sorted_front = 0;
197  p->sorted_back = 0;
198  memset(p->win_samples, 0, s->tc_samples * sizeof(*p->win_samples));
199  memset(p->ehistogram, 0, sizeof(p->ehistogram));
200  for (int n = 0; n < s->tc_samples; n++)
201  p->sorted_samples[n] = -1.0;
202  }
203 }
204 
205 static int config_output(AVFilterLink *outlink)
206 {
207  AudioStatsContext *s = outlink->src->priv;
208 
209  s->chstats = av_calloc(sizeof(*s->chstats), outlink->ch_layout.nb_channels);
210  if (!s->chstats)
211  return AVERROR(ENOMEM);
212 
213  s->tc_samples = FFMAX(s->time_constant * outlink->sample_rate + .5, 1);
214  s->nb_channels = outlink->ch_layout.nb_channels;
215 
216  for (int i = 0; i < s->nb_channels; i++) {
217  ChannelStats *p = &s->chstats[i];
218 
219  p->win_samples = av_calloc(s->tc_samples, sizeof(*p->win_samples));
220  if (!p->win_samples)
221  return AVERROR(ENOMEM);
222 
223  p->sorted_samples = av_calloc(s->tc_samples, sizeof(*p->sorted_samples));
224  if (!p->sorted_samples)
225  return AVERROR(ENOMEM);
226  }
227 
228  s->mult = exp((-1 / s->time_constant / outlink->sample_rate));
229  s->nb_frames = 0;
230  s->maxbitdepth = av_get_bytes_per_sample(outlink->format) * 8;
231  s->is_double = outlink->format == AV_SAMPLE_FMT_DBL ||
232  outlink->format == AV_SAMPLE_FMT_DBLP;
233 
234  s->is_float = outlink->format == AV_SAMPLE_FMT_FLT ||
235  outlink->format == AV_SAMPLE_FMT_FLTP;
236 
237  reset_stats(s);
238 
239  return 0;
240 }
241 
242 static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
243 {
244  unsigned result = s->maxbitdepth;
245 
246  mask = mask & (~imask);
247 
248  for (; result && !(mask & 1); --result, mask >>= 1);
249 
250  depth->den = result;
251  depth->num = 0;
252 
253  for (; result; --result, mask >>= 1)
254  if (mask & 1)
255  depth->num++;
256 }
257 
258 static double calc_entropy(AudioStatsContext *s, ChannelStats *p)
259 {
260  double entropy = 0.;
261 
262  for (int i = 0; i < HISTOGRAM_SIZE; i++) {
263  double entry = p->ehistogram[i] / ((double)p->nb_samples);
264 
265  if (entry > 1e-8)
266  entropy += entry * log2(entry);
267  }
268 
269  return -entropy / log2(HISTOGRAM_SIZE);
270 }
271 
272 static double calc_noise_floor(double *ss, double x, double px,
273  int n, int *ffront, int *bback)
274 {
275  double r, ax = fabs(x);
276  int front = *ffront;
277  int back = *bback;
278  int empty = front == back && ss[front] == -1.0;
279 
280  if (!empty && fabs(px) == ss[front]) {
281  ss[front] = -1.0;
282  if (back != front) {
283  front--;
284  if (front < 0)
285  front = n - 1;
286  }
287  empty = front == back;
288  }
289 
290  if (!empty && ax >= ss[front]) {
291  while (1) {
292  ss[front] = -1.0;
293  if (back == front) {
294  empty = 1;
295  break;
296  }
297  front--;
298  if (front < 0)
299  front = n - 1;
300  }
301  }
302 
303  while (!empty && ax >= ss[back]) {
304  ss[back] = -1.0;
305  if (back == front) {
306  empty = 1;
307  break;
308  }
309  back++;
310  if (back >= n)
311  back = 0;
312  }
313 
314  if (!empty) {
315  back--;
316  if (back < 0)
317  back = n - 1;
318  }
319 
320  ss[back] = ax;
321  r = ss[front];
322 
323  *ffront = front;
324  *bback = back;
325 
326  return r;
327 }
328 
329 static inline void update_minmax(AudioStatsContext *s, ChannelStats *p, double d)
330 {
331  if (d < p->min)
332  p->min = d;
333  if (d > p->max)
334  p->max = d;
335 }
336 
337 static inline void update_stat(AudioStatsContext *s, ChannelStats *p, double d, double nd, int64_t i)
338 {
339  double abs_d = FFABS(d);
340  double drop, noise_floor;
341  int index;
342 
343  if (p->abs_peak < abs_d) {
344  p->abs_peak = abs_d;
345  p->abs_peak_count = 1;
346  } else if (p->abs_peak == abs_d) {
347  p->abs_peak_count++;
348  }
349  if (d < p->min) {
350  p->min = d;
351  p->nmin = nd;
352  p->min_run = 1;
353  p->min_runs = 0;
354  p->min_count = 1;
355  } else if (d == p->min) {
356  p->min_count++;
357  p->min_run = d == p->last ? p->min_run + 1 : 1;
358  } else if (p->last == p->min) {
359  p->min_runs += p->min_run * p->min_run;
360  }
361 
362  if (d != 0 && FFABS(d) < p->min_non_zero)
363  p->min_non_zero = FFABS(d);
364 
365  if (d > p->max) {
366  p->max = d;
367  p->nmax = nd;
368  p->max_run = 1;
369  p->max_runs = 0;
370  p->max_count = 1;
371  } else if (d == p->max) {
372  p->max_count++;
373  p->max_run = d == p->last ? p->max_run + 1 : 1;
374  } else if (p->last == p->max) {
375  p->max_runs += p->max_run * p->max_run;
376  }
377 
378  if (d != 0) {
379  p->zero_runs += FFSIGN(d) != FFSIGN(p->last_non_zero);
380  p->last_non_zero = d;
381  }
382 
383  p->sigma_x += nd;
384  p->sigma_x2 += nd * nd;
385  p->avg_sigma_x2 = p->avg_sigma_x2 * s->mult + (1.0 - s->mult) * nd * nd;
386  if (!isnan(p->last)) {
387  p->min_diff = FFMIN(p->min_diff, fabs(d - p->last));
388  p->max_diff = FFMAX(p->max_diff, fabs(d - p->last));
389  p->diff1_sum += fabs(d - p->last);
390  p->diff1_sum_x2 += (d - p->last) * (d - p->last);
391  }
392  p->last = d;
393  p->mask |= i;
394  p->imask &= i;
395 
396  drop = p->win_samples[p->win_pos];
397  p->win_samples[p->win_pos] = nd;
398  index = av_clip(lrint(av_clipd(FFABS(nd), 0.0, 1.0) * HISTOGRAM_MAX), 0, HISTOGRAM_MAX);
399  p->max_index = FFMAX(p->max_index, index);
400  p->ehistogram[index]++;
401  p->win_pos++;
402 
403  if (p->win_pos >= s->tc_samples)
404  p->win_pos = 0;
405 
406  if (p->nb_samples >= s->tc_samples) {
407  p->max_sigma_x2 = FFMAX(p->max_sigma_x2, p->avg_sigma_x2);
408  p->min_sigma_x2 = FFMIN(p->min_sigma_x2, p->avg_sigma_x2);
409  }
410  p->nb_samples++;
411 
412  noise_floor = calc_noise_floor(p->sorted_samples, nd, drop,
413  s->tc_samples, &p->sorted_front, &p->sorted_back);
414  if (p->nb_samples >= s->tc_samples) {
415  if (isnan(p->noise_floor)) {
416  p->noise_floor = noise_floor;
417  p->noise_floor_count = 1;
418  } else {
419  if (noise_floor < p->noise_floor) {
420  p->noise_floor = noise_floor;
421  p->noise_floor_count = 1;
422  } else if (noise_floor == p->noise_floor) {
423  p->noise_floor_count++;
424  }
425  }
426  }
427 }
428 
429 static inline void update_float_stat(AudioStatsContext *s, ChannelStats *p, float d)
430 {
431  int type = fpclassify(d);
432 
433  p->nb_nans += type == FP_NAN;
434  p->nb_infs += type == FP_INFINITE;
435  p->nb_denormals += type == FP_SUBNORMAL;
436 }
437 
438 static inline void update_double_stat(AudioStatsContext *s, ChannelStats *p, double d)
439 {
440  int type = fpclassify(d);
441 
442  p->nb_nans += type == FP_NAN;
443  p->nb_infs += type == FP_INFINITE;
444  p->nb_denormals += type == FP_SUBNORMAL;
445 }
446 
447 static void set_meta(AVDictionary **metadata, int chan, const char *key,
448  const char *fmt, double val)
449 {
450  uint8_t value[128];
451  uint8_t key2[128];
452 
453  snprintf(value, sizeof(value), fmt, val);
454  if (chan)
455  snprintf(key2, sizeof(key2), "lavfi.astats.%d.%s", chan, key);
456  else
457  snprintf(key2, sizeof(key2), "lavfi.astats.%s", key);
458  av_dict_set(metadata, key2, value, 0);
459 }
460 
461 #define LINEAR_TO_DB(x) (log10(x) * 20)
462 
463 static void set_metadata(AudioStatsContext *s, AVDictionary **metadata)
464 {
465  uint64_t mask = 0, imask = 0xFFFFFFFFFFFFFFFF, min_count = 0, max_count = 0, nb_samples = 0, noise_floor_count = 0;
466  uint64_t nb_nans = 0, nb_infs = 0, nb_denormals = 0;
467  uint64_t abs_peak_count = 0;
468  double min_runs = 0, max_runs = 0,
469  min = DBL_MAX, max =-DBL_MAX, min_diff = DBL_MAX, max_diff = 0,
470  nmin = DBL_MAX, nmax =-DBL_MAX,
471  max_sigma_x = 0,
472  diff1_sum = 0,
473  diff1_sum_x2 = 0,
474  sigma_x2 = 0,
475  noise_floor = 0,
476  entropy = 0,
477  min_sigma_x2 = DBL_MAX,
478  max_sigma_x2 =-DBL_MAX;
479  AVRational depth;
480  int c;
481 
482  for (c = 0; c < s->nb_channels; c++) {
483  ChannelStats *p = &s->chstats[c];
484 
485  if (p->nb_samples < s->tc_samples)
486  p->min_sigma_x2 = p->max_sigma_x2 = p->sigma_x2 / p->nb_samples;
487 
488  min = FFMIN(min, p->min);
489  max = FFMAX(max, p->max);
490  nmin = FFMIN(nmin, p->nmin);
491  nmax = FFMAX(nmax, p->nmax);
492  min_diff = FFMIN(min_diff, p->min_diff);
493  max_diff = FFMAX(max_diff, p->max_diff);
494  diff1_sum += p->diff1_sum;
495  diff1_sum_x2 += p->diff1_sum_x2;
496  min_sigma_x2 = FFMIN(min_sigma_x2, p->min_sigma_x2);
497  max_sigma_x2 = FFMAX(max_sigma_x2, p->max_sigma_x2);
498  sigma_x2 += p->sigma_x2;
499  noise_floor = FFMAX(noise_floor, p->noise_floor);
500  noise_floor_count += p->noise_floor_count;
501  p->entropy = calc_entropy(s, p);
502  entropy += p->entropy;
503  min_count += p->min_count;
504  max_count += p->max_count;
505  abs_peak_count += p->abs_peak_count;
506  min_runs += p->min_runs;
507  max_runs += p->max_runs;
508  mask |= p->mask;
509  imask &= p->imask;
510  nb_samples += p->nb_samples;
511  nb_nans += p->nb_nans;
512  nb_infs += p->nb_infs;
513  nb_denormals += p->nb_denormals;
514  if (fabs(p->sigma_x) > fabs(max_sigma_x))
515  max_sigma_x = p->sigma_x;
516 
517  if (s->measure_perchannel & MEASURE_DC_OFFSET)
518  set_meta(metadata, c + 1, "DC_offset", "%f", p->sigma_x / p->nb_samples);
519  if (s->measure_perchannel & MEASURE_MIN_LEVEL)
520  set_meta(metadata, c + 1, "Min_level", "%f", p->min);
521  if (s->measure_perchannel & MEASURE_MAX_LEVEL)
522  set_meta(metadata, c + 1, "Max_level", "%f", p->max);
523  if (s->measure_perchannel & MEASURE_MIN_DIFFERENCE)
524  set_meta(metadata, c + 1, "Min_difference", "%f", p->min_diff);
525  if (s->measure_perchannel & MEASURE_MAX_DIFFERENCE)
526  set_meta(metadata, c + 1, "Max_difference", "%f", p->max_diff);
527  if (s->measure_perchannel & MEASURE_MEAN_DIFFERENCE)
528  set_meta(metadata, c + 1, "Mean_difference", "%f", p->diff1_sum / (p->nb_samples - 1));
529  if (s->measure_perchannel & MEASURE_RMS_DIFFERENCE)
530  set_meta(metadata, c + 1, "RMS_difference", "%f", sqrt(p->diff1_sum_x2 / (p->nb_samples - 1)));
531  if (s->measure_perchannel & MEASURE_PEAK_LEVEL)
532  set_meta(metadata, c + 1, "Peak_level", "%f", LINEAR_TO_DB(FFMAX(-p->nmin, p->nmax)));
533  if (s->measure_perchannel & MEASURE_RMS_LEVEL)
534  set_meta(metadata, c + 1, "RMS_level", "%f", LINEAR_TO_DB(sqrt(p->sigma_x2 / p->nb_samples)));
535  if (s->measure_perchannel & MEASURE_RMS_PEAK)
536  set_meta(metadata, c + 1, "RMS_peak", "%f", LINEAR_TO_DB(sqrt(p->max_sigma_x2)));
537  if (s->measure_perchannel & MEASURE_RMS_TROUGH)
538  set_meta(metadata, c + 1, "RMS_trough", "%f", LINEAR_TO_DB(sqrt(p->min_sigma_x2)));
539  if (s->measure_perchannel & MEASURE_CREST_FACTOR)
540  set_meta(metadata, c + 1, "Crest_factor", "%f", p->sigma_x2 ? FFMAX(-p->min, p->max) / sqrt(p->sigma_x2 / p->nb_samples) : 1);
541  if (s->measure_perchannel & MEASURE_FLAT_FACTOR)
542  set_meta(metadata, c + 1, "Flat_factor", "%f", LINEAR_TO_DB((p->min_runs + p->max_runs) / (p->min_count + p->max_count)));
543  if (s->measure_perchannel & MEASURE_PEAK_COUNT)
544  set_meta(metadata, c + 1, "Peak_count", "%f", (float)(p->min_count + p->max_count));
545  if (s->measure_perchannel & MEASURE_ABS_PEAK_COUNT)
546  set_meta(metadata, c + 1, "Peak_count", "%f", p->abs_peak_count);
547  if (s->measure_perchannel & MEASURE_NOISE_FLOOR)
548  set_meta(metadata, c + 1, "Noise_floor", "%f", LINEAR_TO_DB(p->noise_floor));
549  if (s->measure_perchannel & MEASURE_NOISE_FLOOR_COUNT)
550  set_meta(metadata, c + 1, "Noise_floor_count", "%f", p->noise_floor_count);
551  if (s->measure_perchannel & MEASURE_ENTROPY)
552  set_meta(metadata, c + 1, "Entropy", "%f", p->entropy);
553  if (s->measure_perchannel & MEASURE_BIT_DEPTH) {
554  bit_depth(s, p->mask, p->imask, &depth);
555  set_meta(metadata, c + 1, "Bit_depth", "%f", depth.num);
556  set_meta(metadata, c + 1, "Bit_depth2", "%f", depth.den);
557  }
558  if (s->measure_perchannel & MEASURE_DYNAMIC_RANGE)
559  set_meta(metadata, c + 1, "Dynamic_range", "%f", LINEAR_TO_DB(2 * FFMAX(FFABS(p->min), FFABS(p->max))/ p->min_non_zero));
560  if (s->measure_perchannel & MEASURE_ZERO_CROSSINGS)
561  set_meta(metadata, c + 1, "Zero_crossings", "%f", p->zero_runs);
562  if (s->measure_perchannel & MEASURE_ZERO_CROSSINGS_RATE)
563  set_meta(metadata, c + 1, "Zero_crossings_rate", "%f", p->zero_runs/(double)p->nb_samples);
564  if ((s->is_float || s->is_double) && s->measure_perchannel & MEASURE_NUMBER_OF_NANS)
565  set_meta(metadata, c + 1, "Number of NaNs", "%f", p->nb_nans);
566  if ((s->is_float || s->is_double) && s->measure_perchannel & MEASURE_NUMBER_OF_INFS)
567  set_meta(metadata, c + 1, "Number of Infs", "%f", p->nb_infs);
568  if ((s->is_float || s->is_double) && s->measure_perchannel & MEASURE_NUMBER_OF_DENORMALS)
569  set_meta(metadata, c + 1, "Number of denormals", "%f", p->nb_denormals);
570  }
571 
572  if (s->measure_overall & MEASURE_DC_OFFSET)
573  set_meta(metadata, 0, "Overall.DC_offset", "%f", max_sigma_x / (nb_samples / s->nb_channels));
574  if (s->measure_overall & MEASURE_MIN_LEVEL)
575  set_meta(metadata, 0, "Overall.Min_level", "%f", min);
576  if (s->measure_overall & MEASURE_MAX_LEVEL)
577  set_meta(metadata, 0, "Overall.Max_level", "%f", max);
578  if (s->measure_overall & MEASURE_MIN_DIFFERENCE)
579  set_meta(metadata, 0, "Overall.Min_difference", "%f", min_diff);
580  if (s->measure_overall & MEASURE_MAX_DIFFERENCE)
581  set_meta(metadata, 0, "Overall.Max_difference", "%f", max_diff);
582  if (s->measure_overall & MEASURE_MEAN_DIFFERENCE)
583  set_meta(metadata, 0, "Overall.Mean_difference", "%f", diff1_sum / (nb_samples - s->nb_channels));
584  if (s->measure_overall & MEASURE_RMS_DIFFERENCE)
585  set_meta(metadata, 0, "Overall.RMS_difference", "%f", sqrt(diff1_sum_x2 / (nb_samples - s->nb_channels)));
586  if (s->measure_overall & MEASURE_PEAK_LEVEL)
587  set_meta(metadata, 0, "Overall.Peak_level", "%f", LINEAR_TO_DB(FFMAX(-nmin, nmax)));
588  if (s->measure_overall & MEASURE_RMS_LEVEL)
589  set_meta(metadata, 0, "Overall.RMS_level", "%f", LINEAR_TO_DB(sqrt(sigma_x2 / nb_samples)));
590  if (s->measure_overall & MEASURE_RMS_PEAK)
591  set_meta(metadata, 0, "Overall.RMS_peak", "%f", LINEAR_TO_DB(sqrt(max_sigma_x2)));
592  if (s->measure_overall & MEASURE_RMS_TROUGH)
593  set_meta(metadata, 0, "Overall.RMS_trough", "%f", LINEAR_TO_DB(sqrt(min_sigma_x2)));
594  if (s->measure_overall & MEASURE_FLAT_FACTOR)
595  set_meta(metadata, 0, "Overall.Flat_factor", "%f", LINEAR_TO_DB((min_runs + max_runs) / (min_count + max_count)));
596  if (s->measure_overall & MEASURE_PEAK_COUNT)
597  set_meta(metadata, 0, "Overall.Peak_count", "%f", (float)(min_count + max_count) / (double)s->nb_channels);
598  if (s->measure_overall & MEASURE_ABS_PEAK_COUNT)
599  set_meta(metadata, 0, "Overall.Abs_Peak_count", "%f", (float)(abs_peak_count) / (double)s->nb_channels);
600  if (s->measure_overall & MEASURE_NOISE_FLOOR)
601  set_meta(metadata, 0, "Overall.Noise_floor", "%f", LINEAR_TO_DB(noise_floor));
602  if (s->measure_overall & MEASURE_NOISE_FLOOR_COUNT)
603  set_meta(metadata, 0, "Overall.Noise_floor_count", "%f", noise_floor_count / (double)s->nb_channels);
604  if (s->measure_overall & MEASURE_ENTROPY)
605  set_meta(metadata, 0, "Overall.Entropy", "%f", entropy / (double)s->nb_channels);
606  if (s->measure_overall & MEASURE_BIT_DEPTH) {
607  bit_depth(s, mask, imask, &depth);
608  set_meta(metadata, 0, "Overall.Bit_depth", "%f", depth.num);
609  set_meta(metadata, 0, "Overall.Bit_depth2", "%f", depth.den);
610  }
611  if (s->measure_overall & MEASURE_NUMBER_OF_SAMPLES)
612  set_meta(metadata, 0, "Overall.Number_of_samples", "%f", nb_samples / s->nb_channels);
613  if ((s->is_float || s->is_double) && s->measure_overall & MEASURE_NUMBER_OF_NANS)
614  set_meta(metadata, 0, "Number of NaNs", "%f", nb_nans / (float)s->nb_channels);
615  if ((s->is_float || s->is_double) && s->measure_overall & MEASURE_NUMBER_OF_INFS)
616  set_meta(metadata, 0, "Number of Infs", "%f", nb_infs / (float)s->nb_channels);
617  if ((s->is_float || s->is_double) && s->measure_overall & MEASURE_NUMBER_OF_DENORMALS)
618  set_meta(metadata, 0, "Number of denormals", "%f", nb_denormals / (float)s->nb_channels);
619 }
620 
621 #define UPDATE_STATS_P(type, update_func, update_float, channel_func) \
622  for (int c = start; c < end; c++) { \
623  ChannelStats *p = &s->chstats[c]; \
624  const type *src = (const type *)data[c]; \
625  const type * const srcend = src + samples; \
626  for (; src < srcend; src++) { \
627  update_func; \
628  update_float; \
629  } \
630  channel_func; \
631  }
632 
633 #define UPDATE_STATS_I(type, update_func, update_float, channel_func) \
634  for (int c = start; c < end; c++) { \
635  ChannelStats *p = &s->chstats[c]; \
636  const type *src = (const type *)data[0]; \
637  const type * const srcend = src + samples * channels; \
638  for (src += c; src < srcend; src += channels) { \
639  update_func; \
640  update_float; \
641  } \
642  channel_func; \
643  }
644 
645 #define UPDATE_STATS(planar, type, sample, normalizer_suffix, int_sample) \
646  if ((s->measure_overall | s->measure_perchannel) & ~MEASURE_MINMAXPEAK) { \
647  UPDATE_STATS_##planar(type, update_stat(s, p, sample, sample normalizer_suffix, int_sample), s->is_float ? update_float_stat(s, p, sample) : s->is_double ? update_double_stat(s, p, sample) : (void)NULL, ); \
648  } else { \
649  UPDATE_STATS_##planar(type, update_minmax(s, p, sample), , p->nmin = p->min normalizer_suffix; p->nmax = p->max normalizer_suffix;); \
650  }
651 
652 static int filter_channel(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
653 {
654  AudioStatsContext *s = ctx->priv;
655  AVFilterLink *inlink = ctx->inputs[0];
656  AVFrame *buf = arg;
657  const uint8_t * const * const data = (const uint8_t * const *)buf->extended_data;
658  const int channels = s->nb_channels;
659  const int samples = buf->nb_samples;
660  const int start = (buf->ch_layout.nb_channels * jobnr) / nb_jobs;
661  const int end = (buf->ch_layout.nb_channels * (jobnr+1)) / nb_jobs;
662 
663  switch (inlink->format) {
664  case AV_SAMPLE_FMT_DBLP:
665  UPDATE_STATS(P, double, *src, , llrint(*src * (UINT64_C(1) << 63)));
666  break;
667  case AV_SAMPLE_FMT_DBL:
668  UPDATE_STATS(I, double, *src, , llrint(*src * (UINT64_C(1) << 63)));
669  break;
670  case AV_SAMPLE_FMT_FLTP:
671  UPDATE_STATS(P, float, *src, , llrint(*src * (UINT64_C(1) << 31)));
672  break;
673  case AV_SAMPLE_FMT_FLT:
674  UPDATE_STATS(I, float, *src, , llrint(*src * (UINT64_C(1) << 31)));
675  break;
676  case AV_SAMPLE_FMT_S64P:
677  UPDATE_STATS(P, int64_t, *src, / (double)INT64_MAX, *src);
678  break;
679  case AV_SAMPLE_FMT_S64:
680  UPDATE_STATS(I, int64_t, *src, / (double)INT64_MAX, *src);
681  break;
682  case AV_SAMPLE_FMT_S32P:
683  UPDATE_STATS(P, int32_t, *src, / (double)INT32_MAX, *src);
684  break;
685  case AV_SAMPLE_FMT_S32:
686  UPDATE_STATS(I, int32_t, *src, / (double)INT32_MAX, *src);
687  break;
688  case AV_SAMPLE_FMT_S16P:
689  UPDATE_STATS(P, int16_t, *src, / (double)INT16_MAX, *src);
690  break;
691  case AV_SAMPLE_FMT_S16:
692  UPDATE_STATS(I, int16_t, *src, / (double)INT16_MAX, *src);
693  break;
694  }
695 
696  return 0;
697 }
698 
699 static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
700 {
701  AVFilterContext *ctx = inlink->dst;
702  AudioStatsContext *s = ctx->priv;
703  AVDictionary **metadata = &buf->metadata;
704 
705  if (s->reset_count > 0) {
706  if (s->nb_frames >= s->reset_count) {
707  reset_stats(s);
708  s->nb_frames = 0;
709  }
710  s->nb_frames++;
711  }
712 
713  if (s->used == 0)
714  s->used = buf->nb_samples > 0;
715  ff_filter_execute(ctx, filter_channel, buf, NULL,
716  FFMIN(inlink->ch_layout.nb_channels, ff_filter_get_nb_threads(ctx)));
717 
718  if (s->metadata)
719  set_metadata(s, metadata);
720 
721  return ff_filter_frame(inlink->dst->outputs[0], buf);
722 }
723 
724 static void print_stats(AVFilterContext *ctx)
725 {
726  AudioStatsContext *s = ctx->priv;
727  uint64_t mask = 0, imask = 0xFFFFFFFFFFFFFFFF, min_count = 0, max_count = 0, nb_samples = 0, noise_floor_count = 0;
728  uint64_t nb_nans = 0, nb_infs = 0, nb_denormals = 0, abs_peak_count = 0;
729  double min_runs = 0, max_runs = 0,
730  min = DBL_MAX, max =-DBL_MAX, min_diff = DBL_MAX, max_diff = 0,
731  nmin = DBL_MAX, nmax =-DBL_MAX,
732  max_sigma_x = 0,
733  diff1_sum_x2 = 0,
734  diff1_sum = 0,
735  sigma_x2 = 0,
736  noise_floor = 0,
737  entropy = 0,
738  min_sigma_x2 = DBL_MAX,
739  max_sigma_x2 =-DBL_MAX;
740  AVRational depth;
741  int c;
742 
743  for (c = 0; c < s->nb_channels; c++) {
744  ChannelStats *p = &s->chstats[c];
745 
746  if (p->nb_samples == 0 && !s->used)
747  continue;
748 
749  if (p->nb_samples < s->tc_samples)
750  p->min_sigma_x2 = p->max_sigma_x2 = p->sigma_x2 / p->nb_samples;
751 
752  min = FFMIN(min, p->min);
753  max = FFMAX(max, p->max);
754  nmin = FFMIN(nmin, p->nmin);
755  nmax = FFMAX(nmax, p->nmax);
756  min_diff = FFMIN(min_diff, p->min_diff);
757  max_diff = FFMAX(max_diff, p->max_diff);
758  diff1_sum_x2 += p->diff1_sum_x2;
759  diff1_sum += p->diff1_sum;
760  min_sigma_x2 = FFMIN(min_sigma_x2, p->min_sigma_x2);
761  max_sigma_x2 = FFMAX(max_sigma_x2, p->max_sigma_x2);
762  sigma_x2 += p->sigma_x2;
763  noise_floor = FFMAX(noise_floor, p->noise_floor);
764  p->entropy = calc_entropy(s, p);
765  entropy += p->entropy;
766  min_count += p->min_count;
767  max_count += p->max_count;
768  abs_peak_count += p->abs_peak_count;
769  noise_floor_count += p->noise_floor_count;
770  min_runs += p->min_runs;
771  max_runs += p->max_runs;
772  mask |= p->mask;
773  imask &= p->imask;
774  nb_samples += p->nb_samples;
775  nb_nans += p->nb_nans;
776  nb_infs += p->nb_infs;
777  nb_denormals += p->nb_denormals;
778  if (fabs(p->sigma_x) > fabs(max_sigma_x))
779  max_sigma_x = p->sigma_x;
780 
781  if (s->measure_perchannel != MEASURE_NONE)
782  av_log(ctx, AV_LOG_INFO, "Channel: %d\n", c + 1);
783  if (s->measure_perchannel & MEASURE_DC_OFFSET)
784  av_log(ctx, AV_LOG_INFO, "DC offset: %f\n", p->sigma_x / p->nb_samples);
785  if (s->measure_perchannel & MEASURE_MIN_LEVEL)
786  av_log(ctx, AV_LOG_INFO, "Min level: %f\n", p->min);
787  if (s->measure_perchannel & MEASURE_MAX_LEVEL)
788  av_log(ctx, AV_LOG_INFO, "Max level: %f\n", p->max);
789  if (s->measure_perchannel & MEASURE_MIN_DIFFERENCE)
790  av_log(ctx, AV_LOG_INFO, "Min difference: %f\n", p->min_diff);
791  if (s->measure_perchannel & MEASURE_MAX_DIFFERENCE)
792  av_log(ctx, AV_LOG_INFO, "Max difference: %f\n", p->max_diff);
793  if (s->measure_perchannel & MEASURE_MEAN_DIFFERENCE)
794  av_log(ctx, AV_LOG_INFO, "Mean difference: %f\n", p->diff1_sum / (p->nb_samples - 1));
795  if (s->measure_perchannel & MEASURE_RMS_DIFFERENCE)
796  av_log(ctx, AV_LOG_INFO, "RMS difference: %f\n", sqrt(p->diff1_sum_x2 / (p->nb_samples - 1)));
797  if (s->measure_perchannel & MEASURE_PEAK_LEVEL)
798  av_log(ctx, AV_LOG_INFO, "Peak level dB: %f\n", LINEAR_TO_DB(FFMAX(-p->nmin, p->nmax)));
799  if (s->measure_perchannel & MEASURE_RMS_LEVEL)
800  av_log(ctx, AV_LOG_INFO, "RMS level dB: %f\n", LINEAR_TO_DB(sqrt(p->sigma_x2 / p->nb_samples)));
801  if (s->measure_perchannel & MEASURE_RMS_PEAK)
802  av_log(ctx, AV_LOG_INFO, "RMS peak dB: %f\n", LINEAR_TO_DB(sqrt(p->max_sigma_x2)));
803  if (s->measure_perchannel & MEASURE_RMS_TROUGH)
804  if (p->min_sigma_x2 != 1)
805  av_log(ctx, AV_LOG_INFO, "RMS trough dB: %f\n",LINEAR_TO_DB(sqrt(p->min_sigma_x2)));
806  if (s->measure_perchannel & MEASURE_CREST_FACTOR)
807  av_log(ctx, AV_LOG_INFO, "Crest factor: %f\n", p->sigma_x2 ? FFMAX(-p->nmin, p->nmax) / sqrt(p->sigma_x2 / p->nb_samples) : 1);
808  if (s->measure_perchannel & MEASURE_FLAT_FACTOR)
809  av_log(ctx, AV_LOG_INFO, "Flat factor: %f\n", LINEAR_TO_DB((p->min_runs + p->max_runs) / (p->min_count + p->max_count)));
810  if (s->measure_perchannel & MEASURE_PEAK_COUNT)
811  av_log(ctx, AV_LOG_INFO, "Peak count: %"PRId64"\n", p->min_count + p->max_count);
812  if (s->measure_perchannel & MEASURE_ABS_PEAK_COUNT)
813  av_log(ctx, AV_LOG_INFO, "Abs Peak count: %"PRId64"\n", p->abs_peak_count);
814  if (s->measure_perchannel & MEASURE_NOISE_FLOOR)
815  av_log(ctx, AV_LOG_INFO, "Noise floor dB: %f\n", LINEAR_TO_DB(p->noise_floor));
816  if (s->measure_perchannel & MEASURE_NOISE_FLOOR_COUNT)
817  av_log(ctx, AV_LOG_INFO, "Noise floor count: %"PRId64"\n", p->noise_floor_count);
818  if (s->measure_perchannel & MEASURE_ENTROPY)
819  av_log(ctx, AV_LOG_INFO, "Entropy: %f\n", p->entropy);
820  if (s->measure_perchannel & MEASURE_BIT_DEPTH) {
821  bit_depth(s, p->mask, p->imask, &depth);
822  av_log(ctx, AV_LOG_INFO, "Bit depth: %u/%u\n", depth.num, depth.den);
823  }
824  if (s->measure_perchannel & MEASURE_DYNAMIC_RANGE)
825  av_log(ctx, AV_LOG_INFO, "Dynamic range: %f\n", LINEAR_TO_DB(2 * FFMAX(FFABS(p->min), FFABS(p->max))/ p->min_non_zero));
826  if (s->measure_perchannel & MEASURE_ZERO_CROSSINGS)
827  av_log(ctx, AV_LOG_INFO, "Zero crossings: %"PRId64"\n", p->zero_runs);
828  if (s->measure_perchannel & MEASURE_ZERO_CROSSINGS_RATE)
829  av_log(ctx, AV_LOG_INFO, "Zero crossings rate: %f\n", p->zero_runs/(double)p->nb_samples);
830  if ((s->is_float || s->is_double) && s->measure_perchannel & MEASURE_NUMBER_OF_NANS)
831  av_log(ctx, AV_LOG_INFO, "Number of NaNs: %"PRId64"\n", p->nb_nans);
832  if ((s->is_float || s->is_double) && s->measure_perchannel & MEASURE_NUMBER_OF_INFS)
833  av_log(ctx, AV_LOG_INFO, "Number of Infs: %"PRId64"\n", p->nb_infs);
834  if ((s->is_float || s->is_double) && s->measure_perchannel & MEASURE_NUMBER_OF_DENORMALS)
835  av_log(ctx, AV_LOG_INFO, "Number of denormals: %"PRId64"\n", p->nb_denormals);
836  }
837 
838  if (nb_samples == 0 && !s->used)
839  return;
840 
841  if (s->measure_overall != MEASURE_NONE)
842  av_log(ctx, AV_LOG_INFO, "Overall\n");
843  if (s->measure_overall & MEASURE_DC_OFFSET)
844  av_log(ctx, AV_LOG_INFO, "DC offset: %f\n", max_sigma_x / (nb_samples / s->nb_channels));
845  if (s->measure_overall & MEASURE_MIN_LEVEL)
846  av_log(ctx, AV_LOG_INFO, "Min level: %f\n", min);
847  if (s->measure_overall & MEASURE_MAX_LEVEL)
848  av_log(ctx, AV_LOG_INFO, "Max level: %f\n", max);
849  if (s->measure_overall & MEASURE_MIN_DIFFERENCE)
850  av_log(ctx, AV_LOG_INFO, "Min difference: %f\n", min_diff);
851  if (s->measure_overall & MEASURE_MAX_DIFFERENCE)
852  av_log(ctx, AV_LOG_INFO, "Max difference: %f\n", max_diff);
853  if (s->measure_overall & MEASURE_MEAN_DIFFERENCE)
854  av_log(ctx, AV_LOG_INFO, "Mean difference: %f\n", diff1_sum / (nb_samples - s->nb_channels));
855  if (s->measure_overall & MEASURE_RMS_DIFFERENCE)
856  av_log(ctx, AV_LOG_INFO, "RMS difference: %f\n", sqrt(diff1_sum_x2 / (nb_samples - s->nb_channels)));
857  if (s->measure_overall & MEASURE_PEAK_LEVEL)
858  av_log(ctx, AV_LOG_INFO, "Peak level dB: %f\n", LINEAR_TO_DB(FFMAX(-nmin, nmax)));
859  if (s->measure_overall & MEASURE_RMS_LEVEL)
860  av_log(ctx, AV_LOG_INFO, "RMS level dB: %f\n", LINEAR_TO_DB(sqrt(sigma_x2 / nb_samples)));
861  if (s->measure_overall & MEASURE_RMS_PEAK)
862  av_log(ctx, AV_LOG_INFO, "RMS peak dB: %f\n", LINEAR_TO_DB(sqrt(max_sigma_x2)));
863  if (s->measure_overall & MEASURE_RMS_TROUGH)
864  if (min_sigma_x2 != 1)
865  av_log(ctx, AV_LOG_INFO, "RMS trough dB: %f\n", LINEAR_TO_DB(sqrt(min_sigma_x2)));
866  if (s->measure_overall & MEASURE_FLAT_FACTOR)
867  av_log(ctx, AV_LOG_INFO, "Flat factor: %f\n", LINEAR_TO_DB((min_runs + max_runs) / (min_count + max_count)));
868  if (s->measure_overall & MEASURE_PEAK_COUNT)
869  av_log(ctx, AV_LOG_INFO, "Peak count: %f\n", (min_count + max_count) / (double)s->nb_channels);
870  if (s->measure_overall & MEASURE_ABS_PEAK_COUNT)
871  av_log(ctx, AV_LOG_INFO, "Abs Peak count: %f\n", abs_peak_count / (double)s->nb_channels);
872  if (s->measure_overall & MEASURE_NOISE_FLOOR)
873  av_log(ctx, AV_LOG_INFO, "Noise floor dB: %f\n", LINEAR_TO_DB(noise_floor));
874  if (s->measure_overall & MEASURE_NOISE_FLOOR_COUNT)
875  av_log(ctx, AV_LOG_INFO, "Noise floor count: %f\n", noise_floor_count / (double)s->nb_channels);
876  if (s->measure_overall & MEASURE_ENTROPY)
877  av_log(ctx, AV_LOG_INFO, "Entropy: %f\n", entropy / (double)s->nb_channels);
878  if (s->measure_overall & MEASURE_BIT_DEPTH) {
879  bit_depth(s, mask, imask, &depth);
880  av_log(ctx, AV_LOG_INFO, "Bit depth: %u/%u\n", depth.num, depth.den);
881  }
882  if (s->measure_overall & MEASURE_NUMBER_OF_SAMPLES)
883  av_log(ctx, AV_LOG_INFO, "Number of samples: %"PRId64"\n", nb_samples / s->nb_channels);
884  if ((s->is_float || s->is_double) && s->measure_overall & MEASURE_NUMBER_OF_NANS)
885  av_log(ctx, AV_LOG_INFO, "Number of NaNs: %f\n", nb_nans / (float)s->nb_channels);
886  if ((s->is_float || s->is_double) && s->measure_overall & MEASURE_NUMBER_OF_INFS)
887  av_log(ctx, AV_LOG_INFO, "Number of Infs: %f\n", nb_infs / (float)s->nb_channels);
888  if ((s->is_float || s->is_double) && s->measure_overall & MEASURE_NUMBER_OF_DENORMALS)
889  av_log(ctx, AV_LOG_INFO, "Number of denormals: %f\n", nb_denormals / (float)s->nb_channels);
890 }
891 
892 static av_cold void uninit(AVFilterContext *ctx)
893 {
894  AudioStatsContext *s = ctx->priv;
895 
896  if (s->nb_channels)
897  print_stats(ctx);
898  if (s->chstats) {
899  for (int i = 0; i < s->nb_channels; i++) {
900  ChannelStats *p = &s->chstats[i];
901 
902  av_freep(&p->win_samples);
903  av_freep(&p->sorted_samples);
904  }
905  }
906  av_freep(&s->chstats);
907 }
908 
909 static const AVFilterPad astats_inputs[] = {
910  {
911  .name = "default",
912  .type = AVMEDIA_TYPE_AUDIO,
913  .filter_frame = filter_frame,
914  },
915 };
916 
917 static const AVFilterPad astats_outputs[] = {
918  {
919  .name = "default",
920  .type = AVMEDIA_TYPE_AUDIO,
921  .config_props = config_output,
922  },
923 };
924 
925 const AVFilter ff_af_astats = {
926  .name = "astats",
927  .description = NULL_IF_CONFIG_SMALL("Show time domain statistics about audio frames."),
928  .priv_size = sizeof(AudioStatsContext),
929  .priv_class = &astats_class,
930  .uninit = uninit,
931  FILTER_INPUTS(astats_inputs),
932  FILTER_OUTPUTS(astats_outputs),
933  FILTER_SAMPLEFMTS(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16P,
934  AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32P,
935  AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64P,
936  AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLTP,
937  AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBLP),
938  .flags = AVFILTER_FLAG_SLICE_THREADS | AVFILTER_FLAG_METADATA_ONLY,
939 };
ChannelStats::nmax
double nmax
Definition: af_astats.c:72
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
bit_depth
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
Definition: af_astats.c:242
av_clip
#define av_clip
Definition: common.h:96
AudioStatsContext::nb_channels
int nb_channels
Definition: af_astats.c:102
set_meta
static void set_meta(AVDictionary **metadata, int chan, const char *key, const char *fmt, double val)
Definition: af_astats.c:447
r
const char * r
Definition: vf_curves.c:126
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
MEASURE_PEAK_COUNT
#define MEASURE_PEAK_COUNT
Definition: af_astats.c:49
AudioStatsContext::is_double
int is_double
Definition: af_astats.c:114
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:978
astats_options
static const AVOption astats_options[]
Definition: af_astats.c:120
AudioStatsContext::maxbitdepth
int maxbitdepth
Definition: af_astats.c:110
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
MEASURE_RMS_TROUGH
#define MEASURE_RMS_TROUGH
Definition: af_astats.c:46
MEASURE_MIN_LEVEL
#define MEASURE_MIN_LEVEL
Definition: af_astats.c:37
ChannelStats::diff1_sum
double diff1_sum
Definition: af_astats.c:76
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
MEASURE_ALL
#define MEASURE_ALL
Definition: af_astats.c:33
MEASURE_NONE
#define MEASURE_NONE
Definition: af_astats.c:34
AudioStatsContext::is_float
int is_float
Definition: af_astats.c:113
AVOption
AVOption.
Definition: opt.h:251
ChannelStats::diff1_sum_x2
double diff1_sum_x2
Definition: af_astats.c:77
ChannelStats::sorted_back
int sorted_back
Definition: af_astats.c:92
AV_SAMPLE_FMT_S32P
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
Definition: samplefmt.h:65
data
const char data[16]
Definition: mxf.c:148
config_output
static int config_output(AVFilterLink *outlink)
Definition: af_astats.c:205
AudioStatsContext::tc_samples
uint64_t tc_samples
Definition: af_astats.c:103
float.h
max
#define max(a, b)
Definition: cuda_runtime.h:33
AVDictionary
Definition: dict.c:34
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:170
ChannelStats::max_sigma_x2
double max_sigma_x2
Definition: af_astats.c:70
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:311
ChannelStats::abs_peak_count
uint64_t abs_peak_count
Definition: af_astats.c:81
reset_stats
static void reset_stats(AudioStatsContext *s)
Definition: af_astats.c:159
ChannelStats::last_non_zero
double last_non_zero
Definition: af_astats.c:67
update_stat
static void update_stat(AudioStatsContext *s, ChannelStats *p, double d, double nd, int64_t i)
Definition: af_astats.c:337
calc_noise_floor
static double calc_noise_floor(double *ss, double x, double px, int n, int *ffront, int *bback)
Definition: af_astats.c:272
AVFilterContext::priv
void * priv
private data for use by the filter
Definition: avfilter.h:412
FFSIGN
#define FFSIGN(a)
Definition: common.h:66
ChannelStats::nb_nans
uint64_t nb_nans
Definition: af_astats.c:85
update_minmax
static void update_minmax(AudioStatsContext *s, ChannelStats *p, double d)
Definition: af_astats.c:329
val
static double val(void *priv, double ch)
Definition: aeval.c:78
AVFrame::ch_layout
AVChannelLayout ch_layout
Channel layout of the audio data.
Definition: frame.h:802
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
AV_SAMPLE_FMT_S64P
@ AV_SAMPLE_FMT_S64P
signed 64 bits, planar
Definition: samplefmt.h:69
ss
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:202
ChannelStats::ehistogram
uint64_t ehistogram[HISTOGRAM_SIZE]
Definition: af_astats.c:90
OFFSET
#define OFFSET(x)
Definition: af_astats.c:117
ChannelStats::avg_sigma_x2
double avg_sigma_x2
Definition: af_astats.c:70
AVRational::num
int num
Numerator.
Definition: rational.h:59
ChannelStats::mask
uint64_t mask
Definition: af_astats.c:79
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:47
ChannelStats::nmin
double nmin
Definition: af_astats.c:72
LINEAR_TO_DB
#define LINEAR_TO_DB(x)
Definition: af_astats.c:461
lrint
#define lrint
Definition: tablegen.h:53
av_cold
#define av_cold
Definition: attributes.h:90
ChannelStats::win_pos
int win_pos
Definition: af_astats.c:93
mask
static const uint16_t mask[17]
Definition: lzw.c:38
ChannelStats::entropy
double entropy
Definition: af_astats.c:96
ChannelStats::last
double last
Definition: af_astats.c:66
AudioStatsContext::mult
double mult
Definition: af_astats.c:105
MEASURE_ABS_PEAK_COUNT
#define MEASURE_ABS_PEAK_COUNT
Definition: af_astats.c:61
s
#define s(width, name)
Definition: cbs_vp9.c:198
AudioStatsContext::measure_overall
int measure_overall
Definition: af_astats.c:112
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Definition: opt.h:227
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
Definition: af_astats.c:699
calc_entropy
static double calc_entropy(AudioStatsContext *s, ChannelStats *p)
Definition: af_astats.c:258
ctx
AVFormatContext * ctx
Definition: movenc.c:48
UPDATE_STATS
#define UPDATE_STATS(planar, type, sample, normalizer_suffix, int_sample)
Definition: af_astats.c:645
channels
channels
Definition: aptx.h:31
ChannelStats::max
double max
Definition: af_astats.c:71
update_double_stat
static void update_double_stat(AudioStatsContext *s, ChannelStats *p, double d)
Definition: af_astats.c:438
ChannelStats::max_index
int max_index
Definition: af_astats.c:94
HISTOGRAM_MAX
#define HISTOGRAM_MAX
Definition: af_astats.c:31
update_float_stat
static void update_float_stat(AudioStatsContext *s, ChannelStats *p, float d)
Definition: af_astats.c:429
key
const char * key
Definition: hwcontext_opencl.c:174
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: af_astats.c:892
NAN
#define NAN
Definition: mathematics.h:115
ChannelStats::min_diff
double min_diff
Definition: af_astats.c:75
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:192
arg
const char * arg
Definition: jacosubdec.c:67
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:65
ChannelStats::min_count
uint64_t min_count
Definition: af_astats.c:80
MEASURE_RMS_DIFFERENCE
#define MEASURE_RMS_DIFFERENCE
Definition: af_astats.c:42
ChannelStats::sigma_x
double sigma_x
Definition: af_astats.c:69
ChannelStats::noise_floor_count
uint64_t noise_floor_count
Definition: af_astats.c:82
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
NULL
#define NULL
Definition: coverity.c:32
MEASURE_NOISE_FLOOR_COUNT
#define MEASURE_NOISE_FLOOR_COUNT
Definition: af_astats.c:59
ChannelStats::win_samples
double * win_samples
Definition: af_astats.c:88
MEASURE_ZERO_CROSSINGS_RATE
#define MEASURE_ZERO_CROSSINGS_RATE
Definition: af_astats.c:53
MEASURE_DC_OFFSET
#define MEASURE_DC_OFFSET
Definition: af_astats.c:36
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
isnan
#define isnan(x)
Definition: libm.h:340
ChannelStats::min_runs
double min_runs
Definition: af_astats.c:74
AudioStatsContext::used
int used
Definition: af_astats.c:107
double
double
Definition: af_crystalizer.c:131
ChannelStats::sorted_front
int sorted_front
Definition: af_astats.c:91
exp
int8_t exp
Definition: eval.c:72
index
int index
Definition: gxfenc.c:89
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
FLAGS
#define FLAGS
Definition: af_astats.c:118
MEASURE_FLAT_FACTOR
#define MEASURE_FLAT_FACTOR
Definition: af_astats.c:48
AudioStatsContext::measure_perchannel
int measure_perchannel
Definition: af_astats.c:111
HISTOGRAM_SIZE
#define HISTOGRAM_SIZE
Definition: af_astats.c:30
AudioStatsContext
Definition: af_astats.c:99
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:106
P
#define P
MEASURE_DYNAMIC_RANGE
#define MEASURE_DYNAMIC_RANGE
Definition: af_astats.c:51
ChannelStats::nb_samples
uint64_t nb_samples
Definition: af_astats.c:84
MEASURE_NUMBER_OF_SAMPLES
#define MEASURE_NUMBER_OF_SAMPLES
Definition: af_astats.c:54
MEASURE_ENTROPY
#define MEASURE_ENTROPY
Definition: af_astats.c:60
MEASURE_RMS_PEAK
#define MEASURE_RMS_PEAK
Definition: af_astats.c:45
ChannelStats::sorted_samples
double * sorted_samples
Definition: af_astats.c:89
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:64
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
internal.h
ChannelStats::max_diff
double max_diff
Definition: af_astats.c:75
astats_inputs
static const AVFilterPad astats_inputs[]
Definition: af_astats.c:909
ChannelStats::min_sigma_x2
double min_sigma_x2
Definition: af_astats.c:70
MEASURE_MEAN_DIFFERENCE
#define MEASURE_MEAN_DIFFERENCE
Definition: af_astats.c:41
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:420
ChannelStats
Definition: af_astats.c:65
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:244
MEASURE_NUMBER_OF_DENORMALS
#define MEASURE_NUMBER_OF_DENORMALS
Definition: af_astats.c:57
av_get_bytes_per_sample
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:108
ff_af_astats
const AVFilter ff_af_astats
Definition: af_astats.c:925
ChannelStats::min_run
double min_run
Definition: af_astats.c:73
filter_channel
static int filter_channel(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: af_astats.c:652
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:401
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:786
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
MEASURE_PEAK_LEVEL
#define MEASURE_PEAK_LEVEL
Definition: af_astats.c:43
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
ChannelStats::max_run
double max_run
Definition: af_astats.c:73
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:58
set_metadata
static void set_metadata(AudioStatsContext *s, AVDictionary **metadata)
Definition: af_astats.c:463
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:53
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:262
ChannelStats::max_runs
double max_runs
Definition: af_astats.c:74
log2
#define log2(x)
Definition: libm.h:404
AVFilter
Filter definition.
Definition: avfilter.h:166
MEASURE_RMS_LEVEL
#define MEASURE_RMS_LEVEL
Definition: af_astats.c:44
MEASURE_NUMBER_OF_NANS
#define MEASURE_NUMBER_OF_NANS
Definition: af_astats.c:55
MEASURE_BIT_DEPTH
#define MEASURE_BIT_DEPTH
Definition: af_astats.c:50
AudioStatsContext::nb_frames
int nb_frames
Definition: af_astats.c:109
ChannelStats::abs_peak
double abs_peak
Definition: af_astats.c:78
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
avfilter.h
AVFrame::metadata
AVDictionary * metadata
metadata.
Definition: frame.h:708
AVFILTER_FLAG_METADATA_ONLY
#define AVFILTER_FLAG_METADATA_ONLY
The filter is a "metadata" filter - it does not modify the frame data in any way.
Definition: avfilter.h:133
AV_SAMPLE_FMT_DBLP
@ AV_SAMPLE_FMT_DBLP
double, planar
Definition: samplefmt.h:67
AudioStatsContext::reset_count
int reset_count
Definition: af_astats.c:108
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
AVFilterContext
An instance of a filter.
Definition: avfilter.h:397
MEASURE_NUMBER_OF_INFS
#define MEASURE_NUMBER_OF_INFS
Definition: af_astats.c:56
AVFILTER_FLAG_SLICE_THREADS
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:117
ChannelStats::noise_floor
double noise_floor
Definition: af_astats.c:95
MEASURE_NOISE_FLOOR
#define MEASURE_NOISE_FLOOR
Definition: af_astats.c:58
audio.h
AudioStatsContext::metadata
int metadata
Definition: af_astats.c:106
llrint
#define llrint(x)
Definition: libm.h:394
ChannelStats::nb_denormals
uint64_t nb_denormals
Definition: af_astats.c:87
ChannelStats::sigma_x2
double sigma_x2
Definition: af_astats.c:69
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(astats)
print_stats
static void print_stats(AVFilterContext *ctx)
Definition: af_astats.c:724
MEASURE_MAX_LEVEL
#define MEASURE_MAX_LEVEL
Definition: af_astats.c:38
MEASURE_MIN_DIFFERENCE
#define MEASURE_MIN_DIFFERENCE
Definition: af_astats.c:39
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:193
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:88
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AudioStatsContext::chstats
ChannelStats * chstats
Definition: af_astats.c:101
d
d
Definition: ffmpeg_filter.c:331
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:224
int32_t
int32_t
Definition: audioconvert.c:56
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ChannelStats::zero_runs
uint64_t zero_runs
Definition: af_astats.c:83
MEASURE_CREST_FACTOR
#define MEASURE_CREST_FACTOR
Definition: af_astats.c:47
ChannelStats::imask
uint64_t imask
Definition: af_astats.c:79
AV_SAMPLE_FMT_DBL
@ AV_SAMPLE_FMT_DBL
double
Definition: samplefmt.h:61
ff_filter_execute
static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: internal.h:144
ChannelStats::min
double min
Definition: af_astats.c:71
AudioStatsContext::time_constant
double time_constant
Definition: af_astats.c:104
AV_SAMPLE_FMT_S32
@ AV_SAMPLE_FMT_S32
signed 32 bits
Definition: samplefmt.h:59
ChannelStats::max_count
uint64_t max_count
Definition: af_astats.c:80
ChannelStats::min_non_zero
double min_non_zero
Definition: af_astats.c:68
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
snprintf
#define snprintf
Definition: snprintf.h:34
AV_SAMPLE_FMT_FLT
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:60
MEASURE_MAX_DIFFERENCE
#define MEASURE_MAX_DIFFERENCE
Definition: af_astats.c:40
astats_outputs
static const AVFilterPad astats_outputs[]
Definition: af_astats.c:917
ChannelStats::nb_infs
uint64_t nb_infs
Definition: af_astats.c:86
AV_SAMPLE_FMT_S64
@ AV_SAMPLE_FMT_S64
signed 64 bits
Definition: samplefmt.h:68
av_clipd
av_clipd
Definition: af_crystalizer.c:131
MEASURE_ZERO_CROSSINGS
#define MEASURE_ZERO_CROSSINGS
Definition: af_astats.c:52
FILTER_SAMPLEFMTS
#define FILTER_SAMPLEFMTS(...)
Definition: internal.h:180
min
float min
Definition: vorbis_enc_data.h:429
Generated on Sat Sep 23 2023 19:22:00 for FFmpeg by   doxygen 1.8.17