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