FFmpeg  4.2.2
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 MEASURE_ALL UINT_MAX
31 #define MEASURE_NONE 0
32 
33 #define MEASURE_DC_OFFSET (1 << 0)
34 #define MEASURE_MIN_LEVEL (1 << 1)
35 #define MEASURE_MAX_LEVEL (1 << 2)
36 #define MEASURE_MIN_DIFFERENCE (1 << 3)
37 #define MEASURE_MAX_DIFFERENCE (1 << 4)
38 #define MEASURE_MEAN_DIFFERENCE (1 << 5)
39 #define MEASURE_RMS_DIFFERENCE (1 << 6)
40 #define MEASURE_PEAK_LEVEL (1 << 7)
41 #define MEASURE_RMS_LEVEL (1 << 8)
42 #define MEASURE_RMS_PEAK (1 << 9)
43 #define MEASURE_RMS_TROUGH (1 << 10)
44 #define MEASURE_CREST_FACTOR (1 << 11)
45 #define MEASURE_FLAT_FACTOR (1 << 12)
46 #define MEASURE_PEAK_COUNT (1 << 13)
47 #define MEASURE_BIT_DEPTH (1 << 14)
48 #define MEASURE_DYNAMIC_RANGE (1 << 15)
49 #define MEASURE_ZERO_CROSSINGS (1 << 16)
50 #define MEASURE_ZERO_CROSSINGS_RATE (1 << 17)
51 #define MEASURE_NUMBER_OF_SAMPLES (1 << 18)
52 #define MEASURE_NUMBER_OF_NANS (1 << 19)
53 #define MEASURE_NUMBER_OF_INFS (1 << 20)
54 #define MEASURE_NUMBER_OF_DENORMALS (1 << 21)
55 
56 #define MEASURE_MINMAXPEAK (MEASURE_MIN_LEVEL | MEASURE_MAX_LEVEL | MEASURE_PEAK_LEVEL)
57 
58 typedef struct ChannelStats {
59  double last;
60  double last_non_zero;
61  double min_non_zero;
62  double sigma_x, sigma_x2;
64  double min, max;
65  double nmin, nmax;
66  double min_run, max_run;
67  double min_runs, max_runs;
68  double min_diff, max_diff;
69  double diff1_sum;
70  double diff1_sum_x2;
71  uint64_t mask, imask;
72  uint64_t min_count, max_count;
73  uint64_t zero_runs;
74  uint64_t nb_samples;
75  uint64_t nb_nans;
76  uint64_t nb_infs;
77  uint64_t nb_denormals;
78 } ChannelStats;
79 
80 typedef struct AudioStatsContext {
81  const AVClass *class;
84  uint64_t tc_samples;
85  double time_constant;
86  double mult;
87  int metadata;
89  int nb_frames;
93  int is_float;
94  int is_double;
96 
97 #define OFFSET(x) offsetof(AudioStatsContext, x)
98 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
99 
100 static const AVOption astats_options[] = {
101  { "length", "set the window length", OFFSET(time_constant), AV_OPT_TYPE_DOUBLE, {.dbl=.05}, .01, 10, FLAGS },
102  { "metadata", "inject metadata in the filtergraph", OFFSET(metadata), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
103  { "reset", "recalculate stats after this many frames", OFFSET(reset_count), AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX, FLAGS },
104  { "measure_perchannel", "only measure_perchannel these per-channel statistics", OFFSET(measure_perchannel), AV_OPT_TYPE_FLAGS, {.i64=MEASURE_ALL}, 0, UINT_MAX, FLAGS, "measure" },
105  { "none" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_NONE }, 0, 0, FLAGS, "measure" },
106  { "all" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_ALL }, 0, 0, FLAGS, "measure" },
107  { "DC_offset" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_DC_OFFSET }, 0, 0, FLAGS, "measure" },
108  { "Min_level" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_MIN_LEVEL }, 0, 0, FLAGS, "measure" },
109  { "Max_level" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_MAX_LEVEL }, 0, 0, FLAGS, "measure" },
110  { "Min_difference" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_MIN_DIFFERENCE }, 0, 0, FLAGS, "measure" },
111  { "Max_difference" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_MAX_DIFFERENCE }, 0, 0, FLAGS, "measure" },
112  { "Mean_difference" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_MEAN_DIFFERENCE }, 0, 0, FLAGS, "measure" },
113  { "RMS_difference" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_RMS_DIFFERENCE }, 0, 0, FLAGS, "measure" },
114  { "Peak_level" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_PEAK_LEVEL }, 0, 0, FLAGS, "measure" },
115  { "RMS_level" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_RMS_LEVEL }, 0, 0, FLAGS, "measure" },
116  { "RMS_peak" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_RMS_PEAK }, 0, 0, FLAGS, "measure" },
117  { "RMS_trough" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_RMS_TROUGH }, 0, 0, FLAGS, "measure" },
118  { "Crest_factor" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_CREST_FACTOR }, 0, 0, FLAGS, "measure" },
119  { "Flat_factor" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_FLAT_FACTOR }, 0, 0, FLAGS, "measure" },
120  { "Peak_count" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_PEAK_COUNT }, 0, 0, FLAGS, "measure" },
121  { "Bit_depth" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_BIT_DEPTH }, 0, 0, FLAGS, "measure" },
122  { "Dynamic_range" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_DYNAMIC_RANGE }, 0, 0, FLAGS, "measure" },
123  { "Zero_crossings" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_ZERO_CROSSINGS }, 0, 0, FLAGS, "measure" },
124  { "Zero_crossings_rate" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_ZERO_CROSSINGS_RATE }, 0, 0, FLAGS, "measure" },
125  { "Number_of_samples" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_NUMBER_OF_SAMPLES }, 0, 0, FLAGS, "measure" },
126  { "Number_of_NaNs" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_NUMBER_OF_NANS }, 0, 0, FLAGS, "measure" },
127  { "Number_of_Infs" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_NUMBER_OF_INFS }, 0, 0, FLAGS, "measure" },
128  { "Number_of_denormals" , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_NUMBER_OF_DENORMALS }, 0, 0, FLAGS, "measure" },
129  { "measure_overall", "only measure_perchannel these overall statistics", OFFSET(measure_overall), AV_OPT_TYPE_FLAGS, {.i64=MEASURE_ALL}, 0, UINT_MAX, FLAGS, "measure" },
130  { NULL }
131 };
132 
133 AVFILTER_DEFINE_CLASS(astats);
134 
136 {
139  static const enum AVSampleFormat sample_fmts[] = {
146  };
147  int ret;
148 
149  layouts = ff_all_channel_counts();
150  if (!layouts)
151  return AVERROR(ENOMEM);
152  ret = ff_set_common_channel_layouts(ctx, layouts);
153  if (ret < 0)
154  return ret;
155 
156  formats = ff_make_format_list(sample_fmts);
157  if (!formats)
158  return AVERROR(ENOMEM);
159  ret = ff_set_common_formats(ctx, formats);
160  if (ret < 0)
161  return ret;
162 
163  formats = ff_all_samplerates();
164  if (!formats)
165  return AVERROR(ENOMEM);
166  return ff_set_common_samplerates(ctx, formats);
167 }
168 
170 {
171  int c;
172 
173  for (c = 0; c < s->nb_channels; c++) {
174  ChannelStats *p = &s->chstats[c];
175 
176  p->min = p->nmin = p->min_sigma_x2 = DBL_MAX;
177  p->max = p->nmax = p->max_sigma_x2 =-DBL_MAX;
178  p->min_non_zero = DBL_MAX;
179  p->min_diff = DBL_MAX;
180  p->max_diff = 0;
181  p->sigma_x = 0;
182  p->sigma_x2 = 0;
183  p->avg_sigma_x2 = 0;
184  p->min_run = 0;
185  p->max_run = 0;
186  p->min_runs = 0;
187  p->max_runs = 0;
188  p->diff1_sum = 0;
189  p->diff1_sum_x2 = 0;
190  p->mask = 0;
191  p->imask = 0xFFFFFFFFFFFFFFFF;
192  p->min_count = 0;
193  p->max_count = 0;
194  p->zero_runs = 0;
195  p->nb_samples = 0;
196  p->nb_nans = 0;
197  p->nb_infs = 0;
198  p->nb_denormals = 0;
199  p->last = NAN;
200  }
201 }
202 
203 static int config_output(AVFilterLink *outlink)
204 {
205  AudioStatsContext *s = outlink->src->priv;
206 
207  s->chstats = av_calloc(sizeof(*s->chstats), outlink->channels);
208  if (!s->chstats)
209  return AVERROR(ENOMEM);
210  s->nb_channels = outlink->channels;
211  s->mult = exp((-1 / s->time_constant / outlink->sample_rate));
212  s->tc_samples = 5 * s->time_constant * outlink->sample_rate + .5;
213  s->nb_frames = 0;
214  s->maxbitdepth = av_get_bytes_per_sample(outlink->format) * 8;
215  s->is_double = outlink->format == AV_SAMPLE_FMT_DBL ||
216  outlink->format == AV_SAMPLE_FMT_DBLP;
217 
218  s->is_float = outlink->format == AV_SAMPLE_FMT_FLT ||
219  outlink->format == AV_SAMPLE_FMT_FLTP;
220 
221  reset_stats(s);
222 
223  return 0;
224 }
225 
226 static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
227 {
228  unsigned result = s->maxbitdepth;
229 
230  mask = mask & (~imask);
231 
232  for (; result && !(mask & 1); --result, mask >>= 1);
233 
234  depth->den = result;
235  depth->num = 0;
236 
237  for (; result; --result, mask >>= 1)
238  if (mask & 1)
239  depth->num++;
240 }
241 
242 static inline void update_minmax(AudioStatsContext *s, ChannelStats *p, double d)
243 {
244  if (d < p->min)
245  p->min = d;
246  if (d > p->max)
247  p->max = d;
248 }
249 
250 static inline void update_stat(AudioStatsContext *s, ChannelStats *p, double d, double nd, int64_t i)
251 {
252  if (d < p->min) {
253  p->min = d;
254  p->nmin = nd;
255  p->min_run = 1;
256  p->min_runs = 0;
257  p->min_count = 1;
258  } else if (d == p->min) {
259  p->min_count++;
260  p->min_run = d == p->last ? p->min_run + 1 : 1;
261  } else if (p->last == p->min) {
262  p->min_runs += p->min_run * p->min_run;
263  }
264 
265  if (d != 0 && FFABS(d) < p->min_non_zero)
266  p->min_non_zero = FFABS(d);
267 
268  if (d > p->max) {
269  p->max = d;
270  p->nmax = nd;
271  p->max_run = 1;
272  p->max_runs = 0;
273  p->max_count = 1;
274  } else if (d == p->max) {
275  p->max_count++;
276  p->max_run = d == p->last ? p->max_run + 1 : 1;
277  } else if (p->last == p->max) {
278  p->max_runs += p->max_run * p->max_run;
279  }
280 
281  if (d != 0) {
282  p->zero_runs += FFSIGN(d) != FFSIGN(p->last_non_zero);
283  p->last_non_zero = d;
284  }
285 
286  p->sigma_x += nd;
287  p->sigma_x2 += nd * nd;
288  p->avg_sigma_x2 = p->avg_sigma_x2 * s->mult + (1.0 - s->mult) * nd * nd;
289  if (!isnan(p->last)) {
290  p->min_diff = FFMIN(p->min_diff, fabs(d - p->last));
291  p->max_diff = FFMAX(p->max_diff, fabs(d - p->last));
292  p->diff1_sum += fabs(d - p->last);
293  p->diff1_sum_x2 += (d - p->last) * (d - p->last);
294  }
295  p->last = d;
296  p->mask |= i;
297  p->imask &= i;
298 
299  if (p->nb_samples >= s->tc_samples) {
302  }
303  p->nb_samples++;
304 }
305 
306 static inline void update_float_stat(AudioStatsContext *s, ChannelStats *p, float d)
307 {
308  int type = fpclassify(d);
309 
310  p->nb_nans += type == FP_NAN;
311  p->nb_infs += type == FP_INFINITE;
312  p->nb_denormals += type == FP_SUBNORMAL;
313 }
314 
315 static inline void update_double_stat(AudioStatsContext *s, ChannelStats *p, double d)
316 {
317  int type = fpclassify(d);
318 
319  p->nb_nans += type == FP_NAN;
320  p->nb_infs += type == FP_INFINITE;
321  p->nb_denormals += type == FP_SUBNORMAL;
322 }
323 
324 static void set_meta(AVDictionary **metadata, int chan, const char *key,
325  const char *fmt, double val)
326 {
327  uint8_t value[128];
328  uint8_t key2[128];
329 
330  snprintf(value, sizeof(value), fmt, val);
331  if (chan)
332  snprintf(key2, sizeof(key2), "lavfi.astats.%d.%s", chan, key);
333  else
334  snprintf(key2, sizeof(key2), "lavfi.astats.%s", key);
335  av_dict_set(metadata, key2, value, 0);
336 }
337 
338 #define LINEAR_TO_DB(x) (log10(x) * 20)
339 
340 static void set_metadata(AudioStatsContext *s, AVDictionary **metadata)
341 {
342  uint64_t mask = 0, imask = 0xFFFFFFFFFFFFFFFF, min_count = 0, max_count = 0, nb_samples = 0;
343  uint64_t nb_nans = 0, nb_infs = 0, nb_denormals = 0;
344  double min_runs = 0, max_runs = 0,
345  min = DBL_MAX, max =-DBL_MAX, min_diff = DBL_MAX, max_diff = 0,
346  nmin = DBL_MAX, nmax =-DBL_MAX,
347  max_sigma_x = 0,
348  diff1_sum = 0,
349  diff1_sum_x2 = 0,
350  sigma_x = 0,
351  sigma_x2 = 0,
352  min_sigma_x2 = DBL_MAX,
353  max_sigma_x2 =-DBL_MAX;
354  AVRational depth;
355  int c;
356 
357  for (c = 0; c < s->nb_channels; c++) {
358  ChannelStats *p = &s->chstats[c];
359 
360  if (p->nb_samples < s->tc_samples)
361  p->min_sigma_x2 = p->max_sigma_x2 = p->sigma_x2 / p->nb_samples;
362 
363  min = FFMIN(min, p->min);
364  max = FFMAX(max, p->max);
365  nmin = FFMIN(nmin, p->nmin);
366  nmax = FFMAX(nmax, p->nmax);
367  min_diff = FFMIN(min_diff, p->min_diff);
368  max_diff = FFMAX(max_diff, p->max_diff);
369  diff1_sum += p->diff1_sum;
372  max_sigma_x2 = FFMAX(max_sigma_x2, p->max_sigma_x2);
373  sigma_x += p->sigma_x;
374  sigma_x2 += p->sigma_x2;
375  min_count += p->min_count;
376  max_count += p->max_count;
377  min_runs += p->min_runs;
378  max_runs += p->max_runs;
379  mask |= p->mask;
380  imask &= p->imask;
381  nb_samples += p->nb_samples;
382  nb_nans += p->nb_nans;
383  nb_infs += p->nb_infs;
385  if (fabs(p->sigma_x) > fabs(max_sigma_x))
386  max_sigma_x = p->sigma_x;
387 
389  set_meta(metadata, c + 1, "DC_offset", "%f", p->sigma_x / p->nb_samples);
391  set_meta(metadata, c + 1, "Min_level", "%f", p->min);
393  set_meta(metadata, c + 1, "Max_level", "%f", p->max);
395  set_meta(metadata, c + 1, "Min_difference", "%f", p->min_diff);
397  set_meta(metadata, c + 1, "Max_difference", "%f", p->max_diff);
399  set_meta(metadata, c + 1, "Mean_difference", "%f", p->diff1_sum / (p->nb_samples - 1));
401  set_meta(metadata, c + 1, "RMS_difference", "%f", sqrt(p->diff1_sum_x2 / (p->nb_samples - 1)));
403  set_meta(metadata, c + 1, "Peak_level", "%f", LINEAR_TO_DB(FFMAX(-p->nmin, p->nmax)));
405  set_meta(metadata, c + 1, "RMS_level", "%f", LINEAR_TO_DB(sqrt(p->sigma_x2 / p->nb_samples)));
407  set_meta(metadata, c + 1, "RMS_peak", "%f", LINEAR_TO_DB(sqrt(p->max_sigma_x2)));
409  set_meta(metadata, c + 1, "RMS_trough", "%f", LINEAR_TO_DB(sqrt(p->min_sigma_x2)));
411  set_meta(metadata, c + 1, "Crest_factor", "%f", p->sigma_x2 ? FFMAX(-p->min, p->max) / sqrt(p->sigma_x2 / p->nb_samples) : 1);
413  set_meta(metadata, c + 1, "Flat_factor", "%f", LINEAR_TO_DB((p->min_runs + p->max_runs) / (p->min_count + p->max_count)));
415  set_meta(metadata, c + 1, "Peak_count", "%f", (float)(p->min_count + p->max_count));
417  bit_depth(s, p->mask, p->imask, &depth);
418  set_meta(metadata, c + 1, "Bit_depth", "%f", depth.num);
419  set_meta(metadata, c + 1, "Bit_depth2", "%f", depth.den);
420  }
422  set_meta(metadata, c + 1, "Dynamic_range", "%f", LINEAR_TO_DB(2 * FFMAX(FFABS(p->min), FFABS(p->max))/ p->min_non_zero));
424  set_meta(metadata, c + 1, "Zero_crossings", "%f", p->zero_runs);
426  set_meta(metadata, c + 1, "Zero_crossings_rate", "%f", p->zero_runs/(double)p->nb_samples);
428  set_meta(metadata, c + 1, "Number of NaNs", "%f", p->nb_nans);
430  set_meta(metadata, c + 1, "Number of Infs", "%f", p->nb_infs);
432  set_meta(metadata, c + 1, "Number of denormals", "%f", p->nb_denormals);
433  }
434 
436  set_meta(metadata, 0, "Overall.DC_offset", "%f", max_sigma_x / (nb_samples / s->nb_channels));
438  set_meta(metadata, 0, "Overall.Min_level", "%f", min);
440  set_meta(metadata, 0, "Overall.Max_level", "%f", max);
442  set_meta(metadata, 0, "Overall.Min_difference", "%f", min_diff);
444  set_meta(metadata, 0, "Overall.Max_difference", "%f", max_diff);
446  set_meta(metadata, 0, "Overall.Mean_difference", "%f", diff1_sum / (nb_samples - s->nb_channels));
448  set_meta(metadata, 0, "Overall.RMS_difference", "%f", sqrt(diff1_sum_x2 / (nb_samples - s->nb_channels)));
450  set_meta(metadata, 0, "Overall.Peak_level", "%f", LINEAR_TO_DB(FFMAX(-nmin, nmax)));
452  set_meta(metadata, 0, "Overall.RMS_level", "%f", LINEAR_TO_DB(sqrt(sigma_x2 / nb_samples)));
454  set_meta(metadata, 0, "Overall.RMS_peak", "%f", LINEAR_TO_DB(sqrt(max_sigma_x2)));
456  set_meta(metadata, 0, "Overall.RMS_trough", "%f", LINEAR_TO_DB(sqrt(min_sigma_x2)));
458  set_meta(metadata, 0, "Overall.Flat_factor", "%f", LINEAR_TO_DB((min_runs + max_runs) / (min_count + max_count)));
460  set_meta(metadata, 0, "Overall.Peak_count", "%f", (float)(min_count + max_count) / (double)s->nb_channels);
462  bit_depth(s, mask, imask, &depth);
463  set_meta(metadata, 0, "Overall.Bit_depth", "%f", depth.num);
464  set_meta(metadata, 0, "Overall.Bit_depth2", "%f", depth.den);
465  }
467  set_meta(metadata, 0, "Overall.Number_of_samples", "%f", nb_samples / s->nb_channels);
469  set_meta(metadata, 0, "Number of NaNs", "%f", nb_nans / (float)s->nb_channels);
471  set_meta(metadata, 0, "Number of Infs", "%f", nb_infs / (float)s->nb_channels);
473  set_meta(metadata, 0, "Number of denormals", "%f", nb_denormals / (float)s->nb_channels);
474 }
475 
476 #define UPDATE_STATS_P(type, update_func, update_float, channel_func) \
477  for (int c = 0; c < channels; c++) { \
478  ChannelStats *p = &s->chstats[c]; \
479  const type *src = (const type *)data[c]; \
480  const type * const srcend = src + samples; \
481  for (; src < srcend; src++) { \
482  update_func; \
483  update_float; \
484  } \
485  channel_func; \
486  }
487 
488 #define UPDATE_STATS_I(type, update_func, update_float, channel_func) \
489  for (int c = 0; c < channels; c++) { \
490  ChannelStats *p = &s->chstats[c]; \
491  const type *src = (const type *)data[0]; \
492  const type * const srcend = src + samples * channels; \
493  for (src += c; src < srcend; src += channels) { \
494  update_func; \
495  update_float; \
496  } \
497  channel_func; \
498  }
499 
500 #define UPDATE_STATS(planar, type, sample, normalizer_suffix, int_sample) \
501  if ((s->measure_overall | s->measure_perchannel) & ~MEASURE_MINMAXPEAK) { \
502  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, ); \
503  } else { \
504  UPDATE_STATS_##planar(type, update_minmax(s, p, sample), , p->nmin = p->min normalizer_suffix; p->nmax = p->max normalizer_suffix;); \
505  }
506 
507 static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
508 {
509  AudioStatsContext *s = inlink->dst->priv;
510  AVDictionary **metadata = &buf->metadata;
511  const int channels = s->nb_channels;
512  const int samples = buf->nb_samples;
513  const uint8_t * const * const data = (const uint8_t * const *)buf->extended_data;
514 
515  if (s->reset_count > 0) {
516  if (s->nb_frames >= s->reset_count) {
517  reset_stats(s);
518  s->nb_frames = 0;
519  }
520  s->nb_frames++;
521  }
522 
523  switch (inlink->format) {
524  case AV_SAMPLE_FMT_DBLP:
525  UPDATE_STATS(P, double, *src, , llrint(*src * (UINT64_C(1) << 63)));
526  break;
527  case AV_SAMPLE_FMT_DBL:
528  UPDATE_STATS(I, double, *src, , llrint(*src * (UINT64_C(1) << 63)));
529  break;
530  case AV_SAMPLE_FMT_FLTP:
531  UPDATE_STATS(P, float, *src, , llrint(*src * (UINT64_C(1) << 31)));
532  break;
533  case AV_SAMPLE_FMT_FLT:
534  UPDATE_STATS(I, float, *src, , llrint(*src * (UINT64_C(1) << 31)));
535  break;
536  case AV_SAMPLE_FMT_S64P:
537  UPDATE_STATS(P, int64_t, *src, / (double)INT64_MAX, *src);
538  break;
539  case AV_SAMPLE_FMT_S64:
540  UPDATE_STATS(I, int64_t, *src, / (double)INT64_MAX, *src);
541  break;
542  case AV_SAMPLE_FMT_S32P:
543  UPDATE_STATS(P, int32_t, *src, / (double)INT32_MAX, *src);
544  break;
545  case AV_SAMPLE_FMT_S32:
546  UPDATE_STATS(I, int32_t, *src, / (double)INT32_MAX, *src);
547  break;
548  case AV_SAMPLE_FMT_S16P:
549  UPDATE_STATS(P, int16_t, *src, / (double)INT16_MAX, *src);
550  break;
551  case AV_SAMPLE_FMT_S16:
552  UPDATE_STATS(I, int16_t, *src, / (double)INT16_MAX, *src);
553  break;
554  }
555 
556  if (s->metadata)
557  set_metadata(s, metadata);
558 
559  return ff_filter_frame(inlink->dst->outputs[0], buf);
560 }
561 
563 {
564  AudioStatsContext *s = ctx->priv;
565  uint64_t mask = 0, imask = 0xFFFFFFFFFFFFFFFF, min_count = 0, max_count = 0, nb_samples = 0;
566  uint64_t nb_nans = 0, nb_infs = 0, nb_denormals = 0;
567  double min_runs = 0, max_runs = 0,
568  min = DBL_MAX, max =-DBL_MAX, min_diff = DBL_MAX, max_diff = 0,
569  nmin = DBL_MAX, nmax =-DBL_MAX,
570  max_sigma_x = 0,
571  diff1_sum_x2 = 0,
572  diff1_sum = 0,
573  sigma_x = 0,
574  sigma_x2 = 0,
575  min_sigma_x2 = DBL_MAX,
576  max_sigma_x2 =-DBL_MAX;
577  AVRational depth;
578  int c;
579 
580  for (c = 0; c < s->nb_channels; c++) {
581  ChannelStats *p = &s->chstats[c];
582 
583  if (p->nb_samples < s->tc_samples)
584  p->min_sigma_x2 = p->max_sigma_x2 = p->sigma_x2 / p->nb_samples;
585 
586  min = FFMIN(min, p->min);
587  max = FFMAX(max, p->max);
588  nmin = FFMIN(nmin, p->nmin);
589  nmax = FFMAX(nmax, p->nmax);
590  min_diff = FFMIN(min_diff, p->min_diff);
591  max_diff = FFMAX(max_diff, p->max_diff);
593  diff1_sum += p->diff1_sum;
595  max_sigma_x2 = FFMAX(max_sigma_x2, p->max_sigma_x2);
596  sigma_x += p->sigma_x;
597  sigma_x2 += p->sigma_x2;
598  min_count += p->min_count;
599  max_count += p->max_count;
600  min_runs += p->min_runs;
601  max_runs += p->max_runs;
602  mask |= p->mask;
603  imask &= p->imask;
604  nb_samples += p->nb_samples;
605  nb_nans += p->nb_nans;
606  nb_infs += p->nb_infs;
608  if (fabs(p->sigma_x) > fabs(max_sigma_x))
609  max_sigma_x = p->sigma_x;
610 
611  av_log(ctx, AV_LOG_INFO, "Channel: %d\n", c + 1);
613  av_log(ctx, AV_LOG_INFO, "DC offset: %f\n", p->sigma_x / p->nb_samples);
615  av_log(ctx, AV_LOG_INFO, "Min level: %f\n", p->min);
617  av_log(ctx, AV_LOG_INFO, "Max level: %f\n", p->max);
619  av_log(ctx, AV_LOG_INFO, "Min difference: %f\n", p->min_diff);
621  av_log(ctx, AV_LOG_INFO, "Max difference: %f\n", p->max_diff);
623  av_log(ctx, AV_LOG_INFO, "Mean difference: %f\n", p->diff1_sum / (p->nb_samples - 1));
625  av_log(ctx, AV_LOG_INFO, "RMS difference: %f\n", sqrt(p->diff1_sum_x2 / (p->nb_samples - 1)));
627  av_log(ctx, AV_LOG_INFO, "Peak level dB: %f\n", LINEAR_TO_DB(FFMAX(-p->nmin, p->nmax)));
629  av_log(ctx, AV_LOG_INFO, "RMS level dB: %f\n", LINEAR_TO_DB(sqrt(p->sigma_x2 / p->nb_samples)));
631  av_log(ctx, AV_LOG_INFO, "RMS peak dB: %f\n", LINEAR_TO_DB(sqrt(p->max_sigma_x2)));
633  if (p->min_sigma_x2 != 1)
634  av_log(ctx, AV_LOG_INFO, "RMS trough dB: %f\n",LINEAR_TO_DB(sqrt(p->min_sigma_x2)));
636  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);
638  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)));
640  av_log(ctx, AV_LOG_INFO, "Peak count: %"PRId64"\n", p->min_count + p->max_count);
642  bit_depth(s, p->mask, p->imask, &depth);
643  av_log(ctx, AV_LOG_INFO, "Bit depth: %u/%u\n", depth.num, depth.den);
644  }
646  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));
648  av_log(ctx, AV_LOG_INFO, "Zero crossings: %"PRId64"\n", p->zero_runs);
650  av_log(ctx, AV_LOG_INFO, "Zero crossings rate: %f\n", p->zero_runs/(double)p->nb_samples);
652  av_log(ctx, AV_LOG_INFO, "Number of NaNs: %"PRId64"\n", p->nb_nans);
654  av_log(ctx, AV_LOG_INFO, "Number of Infs: %"PRId64"\n", p->nb_infs);
656  av_log(ctx, AV_LOG_INFO, "Number of denormals: %"PRId64"\n", p->nb_denormals);
657  }
658 
659  av_log(ctx, AV_LOG_INFO, "Overall\n");
661  av_log(ctx, AV_LOG_INFO, "DC offset: %f\n", max_sigma_x / (nb_samples / s->nb_channels));
663  av_log(ctx, AV_LOG_INFO, "Min level: %f\n", min);
665  av_log(ctx, AV_LOG_INFO, "Max level: %f\n", max);
667  av_log(ctx, AV_LOG_INFO, "Min difference: %f\n", min_diff);
669  av_log(ctx, AV_LOG_INFO, "Max difference: %f\n", max_diff);
671  av_log(ctx, AV_LOG_INFO, "Mean difference: %f\n", diff1_sum / (nb_samples - s->nb_channels));
673  av_log(ctx, AV_LOG_INFO, "RMS difference: %f\n", sqrt(diff1_sum_x2 / (nb_samples - s->nb_channels)));
675  av_log(ctx, AV_LOG_INFO, "Peak level dB: %f\n", LINEAR_TO_DB(FFMAX(-nmin, nmax)));
677  av_log(ctx, AV_LOG_INFO, "RMS level dB: %f\n", LINEAR_TO_DB(sqrt(sigma_x2 / nb_samples)));
679  av_log(ctx, AV_LOG_INFO, "RMS peak dB: %f\n", LINEAR_TO_DB(sqrt(max_sigma_x2)));
681  if (min_sigma_x2 != 1)
682  av_log(ctx, AV_LOG_INFO, "RMS trough dB: %f\n", LINEAR_TO_DB(sqrt(min_sigma_x2)));
684  av_log(ctx, AV_LOG_INFO, "Flat factor: %f\n", LINEAR_TO_DB((min_runs + max_runs) / (min_count + max_count)));
686  av_log(ctx, AV_LOG_INFO, "Peak count: %f\n", (min_count + max_count) / (double)s->nb_channels);
688  bit_depth(s, mask, imask, &depth);
689  av_log(ctx, AV_LOG_INFO, "Bit depth: %u/%u\n", depth.num, depth.den);
690  }
692  av_log(ctx, AV_LOG_INFO, "Number of samples: %"PRId64"\n", nb_samples / s->nb_channels);
694  av_log(ctx, AV_LOG_INFO, "Number of NaNs: %f\n", nb_nans / (float)s->nb_channels);
696  av_log(ctx, AV_LOG_INFO, "Number of Infs: %f\n", nb_infs / (float)s->nb_channels);
698  av_log(ctx, AV_LOG_INFO, "Number of denormals: %f\n", nb_denormals / (float)s->nb_channels);
699 }
700 
702 {
703  AudioStatsContext *s = ctx->priv;
704 
705  if (s->nb_channels)
706  print_stats(ctx);
707  av_freep(&s->chstats);
708 }
709 
710 static const AVFilterPad astats_inputs[] = {
711  {
712  .name = "default",
713  .type = AVMEDIA_TYPE_AUDIO,
714  .filter_frame = filter_frame,
715  },
716  { NULL }
717 };
718 
719 static const AVFilterPad astats_outputs[] = {
720  {
721  .name = "default",
722  .type = AVMEDIA_TYPE_AUDIO,
723  .config_props = config_output,
724  },
725  { NULL }
726 };
727 
729  .name = "astats",
730  .description = NULL_IF_CONFIG_SMALL("Show time domain statistics about audio frames."),
731  .query_formats = query_formats,
732  .priv_size = sizeof(AudioStatsContext),
733  .priv_class = &astats_class,
734  .uninit = uninit,
735  .inputs = astats_inputs,
736  .outputs = astats_outputs,
737 };
float, planar
Definition: samplefmt.h:69
#define MEASURE_NUMBER_OF_INFS
Definition: af_astats.c:53
#define NULL
Definition: coverity.c:32
int ff_set_common_channel_layouts(AVFilterContext *ctx, AVFilterChannelLayouts *layouts)
A helper for query_formats() which sets all links to the same list of channel layouts/sample rates...
Definition: formats.c:549
const char const char void * val
Definition: avisynth_c.h:863
#define P
#define MEASURE_NONE
Definition: af_astats.c:31
#define MEASURE_DYNAMIC_RANGE
Definition: af_astats.c:48
#define MEASURE_RMS_PEAK
Definition: af_astats.c:42
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
AVOption.
Definition: opt.h:246
const char * fmt
Definition: avisynth_c.h:861
static int query_formats(AVFilterContext *ctx)
Definition: af_astats.c:135
AVFilter ff_af_astats
Definition: af_astats.c:728
Main libavfilter public API header.
#define OFFSET(x)
Definition: af_astats.c:97
double min_run
Definition: af_astats.c:66
channels
Definition: aptx.c:30
#define MEASURE_MAX_DIFFERENCE
Definition: af_astats.c:37
double min
Definition: af_astats.c:64
int num
Numerator.
Definition: rational.h:59
#define MEASURE_RMS_DIFFERENCE
Definition: af_astats.c:39
#define MEASURE_NUMBER_OF_NANS
Definition: af_astats.c:52
double, planar
Definition: samplefmt.h:70
double max_sigma_x2
Definition: af_astats.c:63
const char * key
static void update_minmax(AudioStatsContext *s, ChannelStats *p, double d)
Definition: af_astats.c:242
#define src
Definition: vp8dsp.c:254
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:244
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
ChannelStats * chstats
Definition: af_astats.c:82
uint64_t nb_infs
Definition: af_astats.c:76
const char * name
Pad name.
Definition: internal.h:60
#define MEASURE_MEAN_DIFFERENCE
Definition: af_astats.c:38
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1080
#define MEASURE_NUMBER_OF_DENORMALS
Definition: af_astats.c:54
uint8_t
#define av_cold
Definition: attributes.h:82
AVOptions.
#define MEASURE_RMS_LEVEL
Definition: af_astats.c:41
double nmin
Definition: af_astats.c:65
static const AVFilterPad astats_inputs[]
Definition: af_astats.c:710
#define LINEAR_TO_DB(x)
Definition: af_astats.c:338
double diff1_sum_x2
Definition: af_astats.c:70
static void update_stat(AudioStatsContext *s, ChannelStats *p, double d, double nd, int64_t i)
Definition: af_astats.c:250
const char data[16]
Definition: mxf.c:91
uint64_t nb_nans
Definition: af_astats.c:75
AVDictionary * metadata
metadata.
Definition: frame.h:581
#define MEASURE_PEAK_LEVEL
Definition: af_astats.c:40
signed 32 bits
Definition: samplefmt.h:62
#define av_log(a,...)
#define MEASURE_PEAK_COUNT
Definition: af_astats.c:46
A filter pad used for either input or output.
Definition: internal.h:54
static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
Definition: af_astats.c:507
static av_cold void uninit(AVFilterContext *ctx)
Definition: af_astats.c:701
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:568
#define AVERROR(e)
Definition: error.h:43
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
void * priv
private data for use by the filter
Definition: avfilter.h:353
#define MEASURE_NUMBER_OF_SAMPLES
Definition: af_astats.c:51
#define MEASURE_BIT_DEPTH
Definition: af_astats.c:47
AVFILTER_DEFINE_CLASS(astats)
int measure_perchannel
Definition: af_astats.c:91
uint64_t tc_samples
Definition: af_astats.c:84
double max
Definition: af_astats.c:64
#define FFMAX(a, b)
Definition: common.h:94
int8_t exp
Definition: eval.c:72
double last_non_zero
Definition: af_astats.c:60
#define MEASURE_DC_OFFSET
Definition: af_astats.c:33
double sigma_x2
Definition: af_astats.c:62
#define MEASURE_ALL
Definition: af_astats.c:30
static void print_stats(AVFilterContext *ctx)
Definition: af_astats.c:562
#define UPDATE_STATS(planar, type, sample, normalizer_suffix, int_sample)
Definition: af_astats.c:500
#define NAN
Definition: mathematics.h:64
#define FFMIN(a, b)
Definition: common.h:96
signed 32 bits, planar
Definition: samplefmt.h:68
double min_sigma_x2
Definition: af_astats.c:63
signed 64 bits
Definition: samplefmt.h:71
#define FFSIGN(a)
Definition: common.h:73
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
Definition: af_astats.c:226
double max_runs
Definition: af_astats.c:67
int32_t
AVFormatContext * ctx
Definition: movenc.c:48
static void update_float_stat(AudioStatsContext *s, ChannelStats *p, float d)
Definition: af_astats.c:306
static int config_output(AVFilterLink *outlink)
Definition: af_astats.c:203
static void reset_stats(AudioStatsContext *s)
Definition: af_astats.c:169
uint64_t max_count
Definition: af_astats.c:72
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
#define MEASURE_ZERO_CROSSINGS_RATE
Definition: af_astats.c:50
static const AVFilterPad inputs[]
Definition: af_acontrast.c:193
if(ret< 0)
Definition: vf_mcdeint.c:279
double sigma_x
Definition: af_astats.c:62
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
double nmax
Definition: af_astats.c:65
A list of supported channel layouts.
Definition: formats.h:85
#define MEASURE_FLAT_FACTOR
Definition: af_astats.c:45
static const AVOption astats_options[]
Definition: af_astats.c:100
double min_diff
Definition: af_astats.c:68
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
uint64_t mask
Definition: af_astats.c:71
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
void * buf
Definition: avisynth_c.h:766
#define llrint(x)
Definition: libm.h:394
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:70
double avg_sigma_x2
Definition: af_astats.c:63
double value
Definition: eval.c:98
Describe the class of an AVClass context structure.
Definition: log.h:67
Filter definition.
Definition: avfilter.h:144
double max_run
Definition: af_astats.c:66
Rational number (pair of numerator and denominator).
Definition: rational.h:58
double max_diff
Definition: af_astats.c:68
#define isnan(x)
Definition: libm.h:340
double min_non_zero
Definition: af_astats.c:61
cl_device_type type
const char * name
Filter name.
Definition: avfilter.h:148
#define snprintf
Definition: snprintf.h:34
#define FLAGS
Definition: af_astats.c:98
double last
Definition: af_astats.c:59
uint64_t nb_denormals
Definition: af_astats.c:77
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:434
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:395
#define MEASURE_RMS_TROUGH
Definition: af_astats.c:43
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
double time_constant
Definition: af_astats.c:85
static void update_double_stat(AudioStatsContext *s, ChannelStats *p, double d)
Definition: af_astats.c:315
uint64_t nb_samples
Definition: af_astats.c:74
#define MEASURE_MIN_LEVEL
Definition: af_astats.c:34
signed 16 bits
Definition: samplefmt.h:61
static double c[64]
static void set_meta(AVDictionary **metadata, int chan, const char *key, const char *fmt, double val)
Definition: af_astats.c:324
int den
Denominator.
Definition: rational.h:60
uint64_t min_count
Definition: af_astats.c:72
double min_runs
Definition: af_astats.c:67
double diff1_sum
Definition: af_astats.c:69
A list of supported formats for one end of a filter link.
Definition: formats.h:64
signed 64 bits, planar
Definition: samplefmt.h:72
An instance of a filter.
Definition: avfilter.h:338
static const AVFilterPad astats_outputs[]
Definition: af_astats.c:719
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:701
#define av_freep(p)
signed 16 bits, planar
Definition: samplefmt.h:67
#define MEASURE_CREST_FACTOR
Definition: af_astats.c:44
#define MEASURE_MAX_LEVEL
Definition: af_astats.c:35
formats
Definition: signature.h:48
#define MEASURE_ZERO_CROSSINGS
Definition: af_astats.c:49
internal API functions
AVFilterChannelLayouts * ff_all_channel_counts(void)
Construct an AVFilterChannelLayouts coding for any channel layout, with known or unknown disposition...
Definition: formats.c:410
#define MEASURE_MIN_DIFFERENCE
Definition: af_astats.c:36
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:342
uint64_t imask
Definition: af_astats.c:71
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
uint64_t zero_runs
Definition: af_astats.c:73
int ff_set_common_samplerates(AVFilterContext *ctx, AVFilterFormats *samplerates)
Definition: formats.c:556
static void set_metadata(AudioStatsContext *s, AVDictionary **metadata)
Definition: af_astats.c:340