FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 
24 #include "libavutil/opt.h"
25 #include "audio.h"
26 #include "avfilter.h"
27 #include "internal.h"
28 
29 typedef struct ChannelStats {
30  double last;
31  double min_non_zero;
32  double sigma_x, sigma_x2;
34  double min, max;
35  double nmin, nmax;
36  double min_run, max_run;
37  double min_runs, max_runs;
38  double min_diff, max_diff;
39  double diff1_sum;
40  double diff1_sum_x2;
41  uint64_t mask, imask;
42  uint64_t min_count, max_count;
43  uint64_t nb_samples;
44 } ChannelStats;
45 
46 typedef struct AudioStatsContext {
47  const AVClass *class;
50  uint64_t tc_samples;
51  double time_constant;
52  double mult;
53  int metadata;
55  int nb_frames;
58 
59 #define OFFSET(x) offsetof(AudioStatsContext, x)
60 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
61 
62 static const AVOption astats_options[] = {
63  { "length", "set the window length", OFFSET(time_constant), AV_OPT_TYPE_DOUBLE, {.dbl=.05}, .01, 10, FLAGS },
64  { "metadata", "inject metadata in the filtergraph", OFFSET(metadata), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
65  { "reset", "recalculate stats after this many frames", OFFSET(reset_count), AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX, FLAGS },
66  { NULL }
67 };
68 
69 AVFILTER_DEFINE_CLASS(astats);
70 
72 {
75  static const enum AVSampleFormat sample_fmts[] = {
82  };
83  int ret;
84 
85  layouts = ff_all_channel_counts();
86  if (!layouts)
87  return AVERROR(ENOMEM);
88  ret = ff_set_common_channel_layouts(ctx, layouts);
89  if (ret < 0)
90  return ret;
91 
92  formats = ff_make_format_list(sample_fmts);
93  if (!formats)
94  return AVERROR(ENOMEM);
95  ret = ff_set_common_formats(ctx, formats);
96  if (ret < 0)
97  return ret;
98 
99  formats = ff_all_samplerates();
100  if (!formats)
101  return AVERROR(ENOMEM);
102  return ff_set_common_samplerates(ctx, formats);
103 }
104 
106 {
107  int c;
108 
109  for (c = 0; c < s->nb_channels; c++) {
110  ChannelStats *p = &s->chstats[c];
111 
112  p->min = p->nmin = p->min_sigma_x2 = DBL_MAX;
113  p->max = p->nmax = p->max_sigma_x2 = DBL_MIN;
114  p->min_non_zero = DBL_MAX;
115  p->min_diff = DBL_MAX;
116  p->max_diff = DBL_MIN;
117  p->sigma_x = 0;
118  p->sigma_x2 = 0;
119  p->avg_sigma_x2 = 0;
120  p->min_run = 0;
121  p->max_run = 0;
122  p->min_runs = 0;
123  p->max_runs = 0;
124  p->diff1_sum = 0;
125  p->diff1_sum_x2 = 0;
126  p->mask = 0;
127  p->imask = 0xFFFFFFFFFFFFFFFF;
128  p->min_count = 0;
129  p->max_count = 0;
130  p->nb_samples = 0;
131  }
132 }
133 
134 static int config_output(AVFilterLink *outlink)
135 {
136  AudioStatsContext *s = outlink->src->priv;
137 
138  s->chstats = av_calloc(sizeof(*s->chstats), outlink->channels);
139  if (!s->chstats)
140  return AVERROR(ENOMEM);
141  s->nb_channels = outlink->channels;
142  s->mult = exp((-1 / s->time_constant / outlink->sample_rate));
143  s->tc_samples = 5 * s->time_constant * outlink->sample_rate + .5;
144  s->nb_frames = 0;
145  s->maxbitdepth = av_get_bytes_per_sample(outlink->format) * 8;
146 
147  reset_stats(s);
148 
149  return 0;
150 }
151 
152 static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
153 {
154  unsigned result = s->maxbitdepth;
155 
156  mask = mask & (~imask);
157 
158  for (; result && !(mask & 1); --result, mask >>= 1);
159 
160  depth->den = result;
161  depth->num = 0;
162 
163  for (; result; --result, mask >>= 1)
164  if (mask & 1)
165  depth->num++;
166 }
167 
168 static inline void update_stat(AudioStatsContext *s, ChannelStats *p, double d, double nd, int64_t i)
169 {
170  if (d < p->min) {
171  p->min = d;
172  p->nmin = nd;
173  p->min_run = 1;
174  p->min_runs = 0;
175  p->min_count = 1;
176  } else if (d == p->min) {
177  p->min_count++;
178  p->min_run = d == p->last ? p->min_run + 1 : 1;
179  } else if (p->last == p->min) {
180  p->min_runs += p->min_run * p->min_run;
181  }
182 
183  if (d != 0 && FFABS(d) < p->min_non_zero)
184  p->min_non_zero = FFABS(d);
185 
186  if (d > p->max) {
187  p->max = d;
188  p->nmax = nd;
189  p->max_run = 1;
190  p->max_runs = 0;
191  p->max_count = 1;
192  } else if (d == p->max) {
193  p->max_count++;
194  p->max_run = d == p->last ? p->max_run + 1 : 1;
195  } else if (p->last == p->max) {
196  p->max_runs += p->max_run * p->max_run;
197  }
198 
199  p->sigma_x += nd;
200  p->sigma_x2 += nd * nd;
201  p->avg_sigma_x2 = p->avg_sigma_x2 * s->mult + (1.0 - s->mult) * nd * nd;
202  p->min_diff = FFMIN(p->min_diff, fabs(d - p->last));
203  p->max_diff = FFMAX(p->max_diff, fabs(d - p->last));
204  p->diff1_sum += fabs(d - p->last);
205  p->diff1_sum_x2 += (d - p->last) * (d - p->last);
206  p->last = d;
207  p->mask |= i;
208  p->imask &= i;
209 
210  if (p->nb_samples >= s->tc_samples) {
213  }
214  p->nb_samples++;
215 }
216 
217 static void set_meta(AVDictionary **metadata, int chan, const char *key,
218  const char *fmt, double val)
219 {
220  uint8_t value[128];
221  uint8_t key2[128];
222 
223  snprintf(value, sizeof(value), fmt, val);
224  if (chan)
225  snprintf(key2, sizeof(key2), "lavfi.astats.%d.%s", chan, key);
226  else
227  snprintf(key2, sizeof(key2), "lavfi.astats.%s", key);
228  av_dict_set(metadata, key2, value, 0);
229 }
230 
231 #define LINEAR_TO_DB(x) (log10(x) * 20)
232 
233 static void set_metadata(AudioStatsContext *s, AVDictionary **metadata)
234 {
235  uint64_t mask = 0, imask = 0xFFFFFFFFFFFFFFFF, min_count = 0, max_count = 0, nb_samples = 0;
236  double min_runs = 0, max_runs = 0,
237  min = DBL_MAX, max = DBL_MIN, min_diff = DBL_MAX, max_diff = 0,
238  nmin = DBL_MAX, nmax = DBL_MIN,
239  max_sigma_x = 0,
240  diff1_sum = 0,
241  diff1_sum_x2 = 0,
242  sigma_x = 0,
243  sigma_x2 = 0,
244  min_sigma_x2 = DBL_MAX,
245  max_sigma_x2 = DBL_MIN;
246  AVRational depth;
247  int c;
248 
249  for (c = 0; c < s->nb_channels; c++) {
250  ChannelStats *p = &s->chstats[c];
251 
252  if (p->nb_samples < s->tc_samples)
253  p->min_sigma_x2 = p->max_sigma_x2 = p->sigma_x2 / p->nb_samples;
254 
255  min = FFMIN(min, p->min);
256  max = FFMAX(max, p->max);
257  nmin = FFMIN(nmin, p->nmin);
258  nmax = FFMAX(nmax, p->nmax);
259  min_diff = FFMIN(min_diff, p->min_diff);
260  max_diff = FFMAX(max_diff, p->max_diff);
261  diff1_sum += p->diff1_sum;
262  diff1_sum_x2 += p->diff1_sum_x2;
263  min_sigma_x2 = FFMIN(min_sigma_x2, p->min_sigma_x2);
264  max_sigma_x2 = FFMAX(max_sigma_x2, p->max_sigma_x2);
265  sigma_x += p->sigma_x;
266  sigma_x2 += p->sigma_x2;
267  min_count += p->min_count;
268  max_count += p->max_count;
269  min_runs += p->min_runs;
270  max_runs += p->max_runs;
271  mask |= p->mask;
272  imask &= p->imask;
273  nb_samples += p->nb_samples;
274  if (fabs(p->sigma_x) > fabs(max_sigma_x))
275  max_sigma_x = p->sigma_x;
276 
277  set_meta(metadata, c + 1, "DC_offset", "%f", p->sigma_x / p->nb_samples);
278  set_meta(metadata, c + 1, "Min_level", "%f", p->min);
279  set_meta(metadata, c + 1, "Max_level", "%f", p->max);
280  set_meta(metadata, c + 1, "Min_difference", "%f", p->min_diff);
281  set_meta(metadata, c + 1, "Max_difference", "%f", p->max_diff);
282  set_meta(metadata, c + 1, "Mean_difference", "%f", p->diff1_sum / (p->nb_samples - 1));
283  set_meta(metadata, c + 1, "RMS_difference", "%f", sqrt(p->diff1_sum_x2 / (p->nb_samples - 1)));
284  set_meta(metadata, c + 1, "Peak_level", "%f", LINEAR_TO_DB(FFMAX(-p->nmin, p->nmax)));
285  set_meta(metadata, c + 1, "RMS_level", "%f", LINEAR_TO_DB(sqrt(p->sigma_x2 / p->nb_samples)));
286  set_meta(metadata, c + 1, "RMS_peak", "%f", LINEAR_TO_DB(sqrt(p->max_sigma_x2)));
287  set_meta(metadata, c + 1, "RMS_trough", "%f", LINEAR_TO_DB(sqrt(p->min_sigma_x2)));
288  set_meta(metadata, c + 1, "Crest_factor", "%f", p->sigma_x2 ? FFMAX(-p->min, p->max) / sqrt(p->sigma_x2 / p->nb_samples) : 1);
289  set_meta(metadata, c + 1, "Flat_factor", "%f", LINEAR_TO_DB((p->min_runs + p->max_runs) / (p->min_count + p->max_count)));
290  set_meta(metadata, c + 1, "Peak_count", "%f", (float)(p->min_count + p->max_count));
291  bit_depth(s, p->mask, p->imask, &depth);
292  set_meta(metadata, c + 1, "Bit_depth", "%f", depth.num);
293  set_meta(metadata, c + 1, "Bit_depth2", "%f", depth.den);
294  set_meta(metadata, c + 1, "Dynamic_range", "%f", LINEAR_TO_DB(2 * FFMAX(FFABS(p->min), FFABS(p->max))/ p->min_non_zero));
295  }
296 
297  set_meta(metadata, 0, "Overall.DC_offset", "%f", max_sigma_x / (nb_samples / s->nb_channels));
298  set_meta(metadata, 0, "Overall.Min_level", "%f", min);
299  set_meta(metadata, 0, "Overall.Max_level", "%f", max);
300  set_meta(metadata, 0, "Overall.Min_difference", "%f", min_diff);
301  set_meta(metadata, 0, "Overall.Max_difference", "%f", max_diff);
302  set_meta(metadata, 0, "Overall.Mean_difference", "%f", diff1_sum / (nb_samples - s->nb_channels));
303  set_meta(metadata, 0, "Overall.RMS_difference", "%f", sqrt(diff1_sum_x2 / (nb_samples - s->nb_channels)));
304  set_meta(metadata, 0, "Overall.Peak_level", "%f", LINEAR_TO_DB(FFMAX(-nmin, nmax)));
305  set_meta(metadata, 0, "Overall.RMS_level", "%f", LINEAR_TO_DB(sqrt(sigma_x2 / nb_samples)));
306  set_meta(metadata, 0, "Overall.RMS_peak", "%f", LINEAR_TO_DB(sqrt(max_sigma_x2)));
307  set_meta(metadata, 0, "Overall.RMS_trough", "%f", LINEAR_TO_DB(sqrt(min_sigma_x2)));
308  set_meta(metadata, 0, "Overall.Flat_factor", "%f", LINEAR_TO_DB((min_runs + max_runs) / (min_count + max_count)));
309  set_meta(metadata, 0, "Overall.Peak_count", "%f", (float)(min_count + max_count) / (double)s->nb_channels);
310  bit_depth(s, mask, imask, &depth);
311  set_meta(metadata, 0, "Overall.Bit_depth", "%f", depth.num);
312  set_meta(metadata, 0, "Overall.Bit_depth2", "%f", depth.den);
313  set_meta(metadata, 0, "Overall.Number_of_samples", "%f", nb_samples / s->nb_channels);
314 }
315 
316 static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
317 {
318  AudioStatsContext *s = inlink->dst->priv;
319  AVDictionary **metadata = &buf->metadata;
320  const int channels = s->nb_channels;
321  int i, c;
322 
323  if (s->reset_count > 0) {
324  if (s->nb_frames >= s->reset_count) {
325  reset_stats(s);
326  s->nb_frames = 0;
327  }
328  s->nb_frames++;
329  }
330 
331  switch (inlink->format) {
332  case AV_SAMPLE_FMT_DBLP:
333  for (c = 0; c < channels; c++) {
334  ChannelStats *p = &s->chstats[c];
335  const double *src = (const double *)buf->extended_data[c];
336 
337  for (i = 0; i < buf->nb_samples; i++, src++)
338  update_stat(s, p, *src, *src, llrint(*src * (UINT64_C(1) << 63)));
339  }
340  break;
341  case AV_SAMPLE_FMT_DBL: {
342  const double *src = (const double *)buf->extended_data[0];
343 
344  for (i = 0; i < buf->nb_samples; i++) {
345  for (c = 0; c < channels; c++, src++)
346  update_stat(s, &s->chstats[c], *src, *src, llrint(*src * (UINT64_C(1) << 63)));
347  }}
348  break;
349  case AV_SAMPLE_FMT_FLTP:
350  for (c = 0; c < channels; c++) {
351  ChannelStats *p = &s->chstats[c];
352  const float *src = (const float *)buf->extended_data[c];
353 
354  for (i = 0; i < buf->nb_samples; i++, src++)
355  update_stat(s, p, *src, *src, llrint(*src * (UINT64_C(1) << 31)));
356  }
357  break;
358  case AV_SAMPLE_FMT_FLT: {
359  const float *src = (const float *)buf->extended_data[0];
360 
361  for (i = 0; i < buf->nb_samples; i++) {
362  for (c = 0; c < channels; c++, src++)
363  update_stat(s, &s->chstats[c], *src, *src, llrint(*src * (UINT64_C(1) << 31)));
364  }}
365  break;
366  case AV_SAMPLE_FMT_S64P:
367  for (c = 0; c < channels; c++) {
368  ChannelStats *p = &s->chstats[c];
369  const int64_t *src = (const int64_t *)buf->extended_data[c];
370 
371  for (i = 0; i < buf->nb_samples; i++, src++)
372  update_stat(s, p, *src, *src / (double)INT64_MAX, *src);
373  }
374  break;
375  case AV_SAMPLE_FMT_S64: {
376  const int64_t *src = (const int64_t *)buf->extended_data[0];
377 
378  for (i = 0; i < buf->nb_samples; i++) {
379  for (c = 0; c < channels; c++, src++)
380  update_stat(s, &s->chstats[c], *src, *src / (double)INT64_MAX, *src);
381  }}
382  break;
383  case AV_SAMPLE_FMT_S32P:
384  for (c = 0; c < channels; c++) {
385  ChannelStats *p = &s->chstats[c];
386  const int32_t *src = (const int32_t *)buf->extended_data[c];
387 
388  for (i = 0; i < buf->nb_samples; i++, src++)
389  update_stat(s, p, *src, *src / (double)INT32_MAX, *src);
390  }
391  break;
392  case AV_SAMPLE_FMT_S32: {
393  const int32_t *src = (const int32_t *)buf->extended_data[0];
394 
395  for (i = 0; i < buf->nb_samples; i++) {
396  for (c = 0; c < channels; c++, src++)
397  update_stat(s, &s->chstats[c], *src, *src / (double)INT32_MAX, *src);
398  }}
399  break;
400  case AV_SAMPLE_FMT_S16P:
401  for (c = 0; c < channels; c++) {
402  ChannelStats *p = &s->chstats[c];
403  const int16_t *src = (const int16_t *)buf->extended_data[c];
404 
405  for (i = 0; i < buf->nb_samples; i++, src++)
406  update_stat(s, p, *src, *src / (double)INT16_MAX, *src);
407  }
408  break;
409  case AV_SAMPLE_FMT_S16: {
410  const int16_t *src = (const int16_t *)buf->extended_data[0];
411 
412  for (i = 0; i < buf->nb_samples; i++) {
413  for (c = 0; c < channels; c++, src++)
414  update_stat(s, &s->chstats[c], *src, *src / (double)INT16_MAX, *src);
415  }}
416  break;
417  }
418 
419  if (s->metadata)
420  set_metadata(s, metadata);
421 
422  return ff_filter_frame(inlink->dst->outputs[0], buf);
423 }
424 
426 {
427  AudioStatsContext *s = ctx->priv;
428  uint64_t mask = 0, imask = 0xFFFFFFFFFFFFFFFF, min_count = 0, max_count = 0, nb_samples = 0;
429  double min_runs = 0, max_runs = 0,
430  min = DBL_MAX, max = DBL_MIN, min_diff = DBL_MAX, max_diff = 0,
431  nmin = DBL_MAX, nmax = DBL_MIN,
432  max_sigma_x = 0,
433  diff1_sum_x2 = 0,
434  diff1_sum = 0,
435  sigma_x = 0,
436  sigma_x2 = 0,
437  min_sigma_x2 = DBL_MAX,
438  max_sigma_x2 = DBL_MIN;
439  AVRational depth;
440  int c;
441 
442  for (c = 0; c < s->nb_channels; c++) {
443  ChannelStats *p = &s->chstats[c];
444 
445  if (p->nb_samples < s->tc_samples)
446  p->min_sigma_x2 = p->max_sigma_x2 = p->sigma_x2 / p->nb_samples;
447 
448  min = FFMIN(min, p->min);
449  max = FFMAX(max, p->max);
450  nmin = FFMIN(nmin, p->nmin);
451  nmax = FFMAX(nmax, p->nmax);
452  min_diff = FFMIN(min_diff, p->min_diff);
453  max_diff = FFMAX(max_diff, p->max_diff);
454  diff1_sum_x2 += p->diff1_sum_x2;
455  diff1_sum += p->diff1_sum;
456  min_sigma_x2 = FFMIN(min_sigma_x2, p->min_sigma_x2);
457  max_sigma_x2 = FFMAX(max_sigma_x2, p->max_sigma_x2);
458  sigma_x += p->sigma_x;
459  sigma_x2 += p->sigma_x2;
460  min_count += p->min_count;
461  max_count += p->max_count;
462  min_runs += p->min_runs;
463  max_runs += p->max_runs;
464  mask |= p->mask;
465  imask &= p->imask;
466  nb_samples += p->nb_samples;
467  if (fabs(p->sigma_x) > fabs(max_sigma_x))
468  max_sigma_x = p->sigma_x;
469 
470  av_log(ctx, AV_LOG_INFO, "Channel: %d\n", c + 1);
471  av_log(ctx, AV_LOG_INFO, "DC offset: %f\n", p->sigma_x / p->nb_samples);
472  av_log(ctx, AV_LOG_INFO, "Min level: %f\n", p->min);
473  av_log(ctx, AV_LOG_INFO, "Max level: %f\n", p->max);
474  av_log(ctx, AV_LOG_INFO, "Min difference: %f\n", p->min_diff);
475  av_log(ctx, AV_LOG_INFO, "Max difference: %f\n", p->max_diff);
476  av_log(ctx, AV_LOG_INFO, "Mean difference: %f\n", p->diff1_sum / (p->nb_samples - 1));
477  av_log(ctx, AV_LOG_INFO, "RMS difference: %f\n", sqrt(p->diff1_sum_x2 / (p->nb_samples - 1)));
478  av_log(ctx, AV_LOG_INFO, "Peak level dB: %f\n", LINEAR_TO_DB(FFMAX(-p->nmin, p->nmax)));
479  av_log(ctx, AV_LOG_INFO, "RMS level dB: %f\n", LINEAR_TO_DB(sqrt(p->sigma_x2 / p->nb_samples)));
480  av_log(ctx, AV_LOG_INFO, "RMS peak dB: %f\n", LINEAR_TO_DB(sqrt(p->max_sigma_x2)));
481  if (p->min_sigma_x2 != 1)
482  av_log(ctx, AV_LOG_INFO, "RMS trough dB: %f\n",LINEAR_TO_DB(sqrt(p->min_sigma_x2)));
483  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);
484  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)));
485  av_log(ctx, AV_LOG_INFO, "Peak count: %"PRId64"\n", p->min_count + p->max_count);
486  bit_depth(s, p->mask, p->imask, &depth);
487  av_log(ctx, AV_LOG_INFO, "Bit depth: %u/%u\n", depth.num, depth.den);
488  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));
489  }
490 
491  av_log(ctx, AV_LOG_INFO, "Overall\n");
492  av_log(ctx, AV_LOG_INFO, "DC offset: %f\n", max_sigma_x / (nb_samples / s->nb_channels));
493  av_log(ctx, AV_LOG_INFO, "Min level: %f\n", min);
494  av_log(ctx, AV_LOG_INFO, "Max level: %f\n", max);
495  av_log(ctx, AV_LOG_INFO, "Min difference: %f\n", min_diff);
496  av_log(ctx, AV_LOG_INFO, "Max difference: %f\n", max_diff);
497  av_log(ctx, AV_LOG_INFO, "Mean difference: %f\n", diff1_sum / (nb_samples - s->nb_channels));
498  av_log(ctx, AV_LOG_INFO, "RMS difference: %f\n", sqrt(diff1_sum_x2 / (nb_samples - s->nb_channels)));
499  av_log(ctx, AV_LOG_INFO, "Peak level dB: %f\n", LINEAR_TO_DB(FFMAX(-nmin, nmax)));
500  av_log(ctx, AV_LOG_INFO, "RMS level dB: %f\n", LINEAR_TO_DB(sqrt(sigma_x2 / nb_samples)));
501  av_log(ctx, AV_LOG_INFO, "RMS peak dB: %f\n", LINEAR_TO_DB(sqrt(max_sigma_x2)));
502  if (min_sigma_x2 != 1)
503  av_log(ctx, AV_LOG_INFO, "RMS trough dB: %f\n", LINEAR_TO_DB(sqrt(min_sigma_x2)));
504  av_log(ctx, AV_LOG_INFO, "Flat factor: %f\n", LINEAR_TO_DB((min_runs + max_runs) / (min_count + max_count)));
505  av_log(ctx, AV_LOG_INFO, "Peak count: %f\n", (min_count + max_count) / (double)s->nb_channels);
506  bit_depth(s, mask, imask, &depth);
507  av_log(ctx, AV_LOG_INFO, "Bit depth: %u/%u\n", depth.num, depth.den);
508  av_log(ctx, AV_LOG_INFO, "Number of samples: %"PRId64"\n", nb_samples / s->nb_channels);
509 }
510 
512 {
513  AudioStatsContext *s = ctx->priv;
514 
515  if (s->nb_channels)
516  print_stats(ctx);
517  av_freep(&s->chstats);
518 }
519 
520 static const AVFilterPad astats_inputs[] = {
521  {
522  .name = "default",
523  .type = AVMEDIA_TYPE_AUDIO,
524  .filter_frame = filter_frame,
525  },
526  { NULL }
527 };
528 
529 static const AVFilterPad astats_outputs[] = {
530  {
531  .name = "default",
532  .type = AVMEDIA_TYPE_AUDIO,
533  .config_props = config_output,
534  },
535  { NULL }
536 };
537 
539  .name = "astats",
540  .description = NULL_IF_CONFIG_SMALL("Show time domain statistics about audio frames."),
541  .query_formats = query_formats,
542  .priv_size = sizeof(AudioStatsContext),
543  .priv_class = &astats_class,
544  .uninit = uninit,
545  .inputs = astats_inputs,
546  .outputs = astats_outputs,
547 };
float, planar
Definition: samplefmt.h:69
#define NULL
Definition: coverity.c:32
int ff_set_common_channel_layouts(AVFilterContext *ctx, AVFilterChannelLayouts *layouts)
A helper for query_formats() which sets all links to the same list of channel layouts/sample rates...
Definition: formats.c:549
const char const char void * val
Definition: avisynth_c.h:771
const char * s
Definition: avisynth_c.h:768
This structure describes decoded (raw) audio or video data.
Definition: frame.h:201
AVOption.
Definition: opt.h:246
const char * fmt
Definition: avisynth_c.h:769
static int query_formats(AVFilterContext *ctx)
Definition: af_astats.c:71
AVFilter ff_af_astats
Definition: af_astats.c:538
Main libavfilter public API header.
#define OFFSET(x)
Definition: af_astats.c:59
double min_run
Definition: af_astats.c:36
channels
Definition: aptx.c:30
double min
Definition: af_astats.c:34
int num
Numerator.
Definition: rational.h:59
double, planar
Definition: samplefmt.h:70
double max_sigma_x2
Definition: af_astats.c:33
const char * key
#define src
Definition: vp8dsp.c:254
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:244
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
ChannelStats * chstats
Definition: af_astats.c:48
const char * name
Pad name.
Definition: internal.h:60
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1113
uint8_t
#define av_cold
Definition: attributes.h:82
AVOptions.
double nmin
Definition: af_astats.c:35
static const AVFilterPad astats_inputs[]
Definition: af_astats.c:520
#define LINEAR_TO_DB(x)
Definition: af_astats.c:231
double diff1_sum_x2
Definition: af_astats.c:40
static void update_stat(AudioStatsContext *s, ChannelStats *p, double d, double nd, int64_t i)
Definition: af_astats.c:168
AVDictionary * metadata
metadata.
Definition: frame.h:488
signed 32 bits
Definition: samplefmt.h:62
#define av_log(a,...)
A filter pad used for either input or output.
Definition: internal.h:54
static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
Definition: af_astats.c:316
static av_cold void uninit(AVFilterContext *ctx)
Definition: af_astats.c:511
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:568
static const uint16_t mask[17]
Definition: lzw.c:38
#define AVERROR(e)
Definition: error.h:43
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
void * priv
private data for use by the filter
Definition: avfilter.h:353
AVFILTER_DEFINE_CLASS(astats)
uint64_t tc_samples
Definition: af_astats.c:50
double max
Definition: af_astats.c:34
#define FFMAX(a, b)
Definition: common.h:94
int8_t exp
Definition: eval.c:72
double sigma_x2
Definition: af_astats.c:32
static void print_stats(AVFilterContext *ctx)
Definition: af_astats.c:425
#define FFMIN(a, b)
Definition: common.h:96
signed 32 bits, planar
Definition: samplefmt.h:68
double min_sigma_x2
Definition: af_astats.c:33
signed 64 bits
Definition: samplefmt.h:71
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:109
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
Definition: af_astats.c:152
double max_runs
Definition: af_astats.c:37
int32_t
AVFormatContext * ctx
Definition: movenc.c:48
static int config_output(AVFilterLink *outlink)
Definition: af_astats.c:134
static void reset_stats(AudioStatsContext *s)
Definition: af_astats.c:105
uint64_t max_count
Definition: af_astats.c:42
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
static const AVFilterPad inputs[]
Definition: af_acontrast.c:193
double sigma_x
Definition: af_astats.c:32
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
double nmax
Definition: af_astats.c:35
A list of supported channel layouts.
Definition: formats.h:85
static const AVOption astats_options[]
Definition: af_astats.c:62
double min_diff
Definition: af_astats.c:38
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
uint64_t mask
Definition: af_astats.c:41
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
void * buf
Definition: avisynth_c.h:690
#define llrint(x)
Definition: libm.h:394
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
double avg_sigma_x2
Definition: af_astats.c:33
Describe the class of an AVClass context structure.
Definition: log.h:67
Filter definition.
Definition: avfilter.h:144
double max_run
Definition: af_astats.c:36
Rational number (pair of numerator and denominator).
Definition: rational.h:58
double max_diff
Definition: af_astats.c:38
double min_non_zero
Definition: af_astats.c:31
const char * name
Filter name.
Definition: avfilter.h:148
#define snprintf
Definition: snprintf.h:34
#define FLAGS
Definition: af_astats.c:60
double last
Definition: af_astats.c:30
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:434
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:395
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
double time_constant
Definition: af_astats.c:51
uint64_t nb_samples
Definition: af_astats.c:43
signed 16 bits
Definition: samplefmt.h:61
static double c[64]
static void set_meta(AVDictionary **metadata, int chan, const char *key, const char *fmt, double val)
Definition: af_astats.c:217
int den
Denominator.
Definition: rational.h:60
uint64_t min_count
Definition: af_astats.c:42
double min_runs
Definition: af_astats.c:37
double diff1_sum
Definition: af_astats.c:39
A list of supported formats for one end of a filter link.
Definition: formats.h:64
signed 64 bits, planar
Definition: samplefmt.h:72
An instance of a filter.
Definition: avfilter.h:338
static const AVFilterPad astats_outputs[]
Definition: af_astats.c:529
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:701
#define av_freep(p)
signed 16 bits, planar
Definition: samplefmt.h:67
formats
Definition: signature.h:48
internal API functions
AVFilterChannelLayouts * ff_all_channel_counts(void)
Construct an AVFilterChannelLayouts coding for any channel layout, with known or unknown disposition...
Definition: formats.c:410
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:248
float min
uint64_t imask
Definition: af_astats.c:41
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:267
for(j=16;j >0;--j)
int ff_set_common_samplerates(AVFilterContext *ctx, AVFilterFormats *samplerates)
Definition: formats.c:556
static void set_metadata(AudioStatsContext *s, AVDictionary **metadata)
Definition: af_astats.c:233