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