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