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 sigma_x, sigma_x2;
33  double min, max;
34  double nmin, nmax;
35  double min_run, max_run;
36  double min_runs, max_runs;
37  double min_diff, max_diff;
38  double diff1_sum;
39  double diff1_sum_x2;
40  uint64_t mask, imask;
41  uint64_t min_count, max_count;
42  uint64_t nb_samples;
43 } ChannelStats;
44 
45 typedef struct AudioStatsContext {
46  const AVClass *class;
49  uint64_t tc_samples;
50  double time_constant;
51  double mult;
52  int metadata;
54  int nb_frames;
57 
58 #define OFFSET(x) offsetof(AudioStatsContext, x)
59 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
60 
61 static const AVOption astats_options[] = {
62  { "length", "set the window length", OFFSET(time_constant), AV_OPT_TYPE_DOUBLE, {.dbl=.05}, .01, 10, FLAGS },
63  { "metadata", "inject metadata in the filtergraph", OFFSET(metadata), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
64  { "reset", "recalculate stats after this many frames", OFFSET(reset_count), AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX, FLAGS },
65  { NULL }
66 };
67 
68 AVFILTER_DEFINE_CLASS(astats);
69 
71 {
74  static const enum AVSampleFormat sample_fmts[] = {
81  };
82  int ret;
83 
84  layouts = ff_all_channel_counts();
85  if (!layouts)
86  return AVERROR(ENOMEM);
87  ret = ff_set_common_channel_layouts(ctx, layouts);
88  if (ret < 0)
89  return ret;
90 
91  formats = ff_make_format_list(sample_fmts);
92  if (!formats)
93  return AVERROR(ENOMEM);
94  ret = ff_set_common_formats(ctx, formats);
95  if (ret < 0)
96  return ret;
97 
98  formats = ff_all_samplerates();
99  if (!formats)
100  return AVERROR(ENOMEM);
101  return ff_set_common_samplerates(ctx, formats);
102 }
103 
105 {
106  int c;
107 
108  for (c = 0; c < s->nb_channels; c++) {
109  ChannelStats *p = &s->chstats[c];
110 
111  p->min = p->nmin = p->min_sigma_x2 = DBL_MAX;
112  p->max = p->nmax = p->max_sigma_x2 = DBL_MIN;
113  p->min_diff = DBL_MAX;
114  p->max_diff = DBL_MIN;
115  p->sigma_x = 0;
116  p->sigma_x2 = 0;
117  p->avg_sigma_x2 = 0;
118  p->min_sigma_x2 = 0;
119  p->max_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 > p->max) {
184  p->max = d;
185  p->nmax = nd;
186  p->max_run = 1;
187  p->max_runs = 0;
188  p->max_count = 1;
189  } else if (d == p->max) {
190  p->max_count++;
191  p->max_run = d == p->last ? p->max_run + 1 : 1;
192  } else if (p->last == p->max) {
193  p->max_runs += p->max_run * p->max_run;
194  }
195 
196  p->sigma_x += nd;
197  p->sigma_x2 += nd * nd;
198  p->avg_sigma_x2 = p->avg_sigma_x2 * s->mult + (1.0 - s->mult) * nd * nd;
199  p->min_diff = FFMIN(p->min_diff, fabs(d - p->last));
200  p->max_diff = FFMAX(p->max_diff, fabs(d - p->last));
201  p->diff1_sum += fabs(d - p->last);
202  p->diff1_sum_x2 += (d - p->last) * (d - p->last);
203  p->last = d;
204  p->mask |= i;
205  p->imask &= i;
206 
207  if (p->nb_samples >= s->tc_samples) {
210  }
211  p->nb_samples++;
212 }
213 
214 static void set_meta(AVDictionary **metadata, int chan, const char *key,
215  const char *fmt, double val)
216 {
217  uint8_t value[128];
218  uint8_t key2[128];
219 
220  snprintf(value, sizeof(value), fmt, val);
221  if (chan)
222  snprintf(key2, sizeof(key2), "lavfi.astats.%d.%s", chan, key);
223  else
224  snprintf(key2, sizeof(key2), "lavfi.astats.%s", key);
225  av_dict_set(metadata, key2, value, 0);
226 }
227 
228 #define LINEAR_TO_DB(x) (log10(x) * 20)
229 
230 static void set_metadata(AudioStatsContext *s, AVDictionary **metadata)
231 {
232  uint64_t mask = 0, imask = 0xFFFFFFFFFFFFFFFF, min_count = 0, max_count = 0, nb_samples = 0;
233  double min_runs = 0, max_runs = 0,
234  min = DBL_MAX, max = DBL_MIN, min_diff = DBL_MAX, max_diff = 0,
235  nmin = DBL_MAX, nmax = DBL_MIN,
236  max_sigma_x = 0,
237  diff1_sum = 0,
238  diff1_sum_x2 = 0,
239  sigma_x = 0,
240  sigma_x2 = 0,
241  min_sigma_x2 = DBL_MAX,
242  max_sigma_x2 = DBL_MIN;
244  int c;
245 
246  for (c = 0; c < s->nb_channels; c++) {
247  ChannelStats *p = &s->chstats[c];
248 
249  if (p->nb_samples < s->tc_samples)
250  p->min_sigma_x2 = p->max_sigma_x2 = p->sigma_x2 / p->nb_samples;
251 
252  min = FFMIN(min, p->min);
253  max = FFMAX(max, p->max);
254  nmin = FFMIN(nmin, p->nmin);
255  nmax = FFMAX(nmax, p->nmax);
256  min_diff = FFMIN(min_diff, p->min_diff);
257  max_diff = FFMAX(max_diff, p->max_diff);
258  diff1_sum += p->diff1_sum;
259  diff1_sum_x2 += p->diff1_sum_x2;
260  min_sigma_x2 = FFMIN(min_sigma_x2, p->min_sigma_x2);
261  max_sigma_x2 = FFMAX(max_sigma_x2, p->max_sigma_x2);
262  sigma_x += p->sigma_x;
263  sigma_x2 += p->sigma_x2;
264  min_count += p->min_count;
265  max_count += p->max_count;
266  min_runs += p->min_runs;
267  max_runs += p->max_runs;
268  mask |= p->mask;
269  imask &= p->imask;
270  nb_samples += p->nb_samples;
271  if (fabs(p->sigma_x) > fabs(max_sigma_x))
272  max_sigma_x = p->sigma_x;
273 
274  set_meta(metadata, c + 1, "DC_offset", "%f", p->sigma_x / p->nb_samples);
275  set_meta(metadata, c + 1, "Min_level", "%f", p->min);
276  set_meta(metadata, c + 1, "Max_level", "%f", p->max);
277  set_meta(metadata, c + 1, "Min_difference", "%f", p->min_diff);
278  set_meta(metadata, c + 1, "Max_difference", "%f", p->max_diff);
279  set_meta(metadata, c + 1, "Mean_difference", "%f", p->diff1_sum / (p->nb_samples - 1));
280  set_meta(metadata, c + 1, "RMS_difference", "%f", sqrt(p->diff1_sum_x2 / (p->nb_samples - 1)));
281  set_meta(metadata, c + 1, "Peak_level", "%f", LINEAR_TO_DB(FFMAX(-p->nmin, p->nmax)));
282  set_meta(metadata, c + 1, "RMS_level", "%f", LINEAR_TO_DB(sqrt(p->sigma_x2 / p->nb_samples)));
283  set_meta(metadata, c + 1, "RMS_peak", "%f", LINEAR_TO_DB(sqrt(p->max_sigma_x2)));
284  set_meta(metadata, c + 1, "RMS_trough", "%f", LINEAR_TO_DB(sqrt(p->min_sigma_x2)));
285  set_meta(metadata, c + 1, "Crest_factor", "%f", p->sigma_x2 ? FFMAX(-p->min, p->max) / sqrt(p->sigma_x2 / p->nb_samples) : 1);
286  set_meta(metadata, c + 1, "Flat_factor", "%f", LINEAR_TO_DB((p->min_runs + p->max_runs) / (p->min_count + p->max_count)));
287  set_meta(metadata, c + 1, "Peak_count", "%f", (float)(p->min_count + p->max_count));
288  bit_depth(s, p->mask, p->imask, &depth);
289  set_meta(metadata, c + 1, "Bit_depth", "%f", depth.num);
290  set_meta(metadata, c + 1, "Bit_depth2", "%f", depth.den);
291  }
292 
293  set_meta(metadata, 0, "Overall.DC_offset", "%f", max_sigma_x / (nb_samples / s->nb_channels));
294  set_meta(metadata, 0, "Overall.Min_level", "%f", min);
295  set_meta(metadata, 0, "Overall.Max_level", "%f", max);
296  set_meta(metadata, 0, "Overall.Min_difference", "%f", min_diff);
297  set_meta(metadata, 0, "Overall.Max_difference", "%f", max_diff);
298  set_meta(metadata, 0, "Overall.Mean_difference", "%f", diff1_sum / (nb_samples - s->nb_channels));
299  set_meta(metadata, 0, "Overall.RMS_difference", "%f", sqrt(diff1_sum_x2 / (nb_samples - s->nb_channels)));
300  set_meta(metadata, 0, "Overall.Peak_level", "%f", LINEAR_TO_DB(FFMAX(-nmin, nmax)));
301  set_meta(metadata, 0, "Overall.RMS_level", "%f", LINEAR_TO_DB(sqrt(sigma_x2 / nb_samples)));
302  set_meta(metadata, 0, "Overall.RMS_peak", "%f", LINEAR_TO_DB(sqrt(max_sigma_x2)));
303  set_meta(metadata, 0, "Overall.RMS_trough", "%f", LINEAR_TO_DB(sqrt(min_sigma_x2)));
304  set_meta(metadata, 0, "Overall.Flat_factor", "%f", LINEAR_TO_DB((min_runs + max_runs) / (min_count + max_count)));
305  set_meta(metadata, 0, "Overall.Peak_count", "%f", (float)(min_count + max_count) / (double)s->nb_channels);
306  bit_depth(s, mask, imask, &depth);
307  set_meta(metadata, 0, "Overall.Bit_depth", "%f", depth.num);
308  set_meta(metadata, 0, "Overall.Bit_depth2", "%f", depth.den);
309  set_meta(metadata, 0, "Overall.Number_of_samples", "%f", nb_samples / s->nb_channels);
310 }
311 
312 static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
313 {
314  AudioStatsContext *s = inlink->dst->priv;
315  AVDictionary **metadata = &buf->metadata;
316  const int channels = s->nb_channels;
317  int i, c;
318 
319  if (s->reset_count > 0) {
320  if (s->nb_frames >= s->reset_count) {
321  reset_stats(s);
322  s->nb_frames = 0;
323  }
324  s->nb_frames++;
325  }
326 
327  switch (inlink->format) {
328  case AV_SAMPLE_FMT_DBLP:
329  for (c = 0; c < channels; c++) {
330  ChannelStats *p = &s->chstats[c];
331  const double *src = (const double *)buf->extended_data[c];
332 
333  for (i = 0; i < buf->nb_samples; i++, src++)
334  update_stat(s, p, *src, *src, llrint(*src * (UINT64_C(1) << 63)));
335  }
336  break;
337  case AV_SAMPLE_FMT_DBL: {
338  const double *src = (const double *)buf->extended_data[0];
339 
340  for (i = 0; i < buf->nb_samples; i++) {
341  for (c = 0; c < channels; c++, src++)
342  update_stat(s, &s->chstats[c], *src, *src, llrint(*src * (UINT64_C(1) << 63)));
343  }}
344  break;
345  case AV_SAMPLE_FMT_FLTP:
346  for (c = 0; c < channels; c++) {
347  ChannelStats *p = &s->chstats[c];
348  const float *src = (const float *)buf->extended_data[c];
349 
350  for (i = 0; i < buf->nb_samples; i++, src++)
351  update_stat(s, p, *src, *src, llrint(*src * (UINT64_C(1) << 31)));
352  }
353  break;
354  case AV_SAMPLE_FMT_FLT: {
355  const float *src = (const float *)buf->extended_data[0];
356 
357  for (i = 0; i < buf->nb_samples; i++) {
358  for (c = 0; c < channels; c++, src++)
359  update_stat(s, &s->chstats[c], *src, *src, llrint(*src * (UINT64_C(1) << 31)));
360  }}
361  break;
362  case AV_SAMPLE_FMT_S64P:
363  for (c = 0; c < channels; c++) {
364  ChannelStats *p = &s->chstats[c];
365  const int64_t *src = (const int64_t *)buf->extended_data[c];
366 
367  for (i = 0; i < buf->nb_samples; i++, src++)
368  update_stat(s, p, *src, *src / (double)INT64_MAX, *src);
369  }
370  break;
371  case AV_SAMPLE_FMT_S64: {
372  const int64_t *src = (const int64_t *)buf->extended_data[0];
373 
374  for (i = 0; i < buf->nb_samples; i++) {
375  for (c = 0; c < channels; c++, src++)
376  update_stat(s, &s->chstats[c], *src, *src / (double)INT64_MAX, *src);
377  }}
378  break;
379  case AV_SAMPLE_FMT_S32P:
380  for (c = 0; c < channels; c++) {
381  ChannelStats *p = &s->chstats[c];
382  const int32_t *src = (const int32_t *)buf->extended_data[c];
383 
384  for (i = 0; i < buf->nb_samples; i++, src++)
385  update_stat(s, p, *src, *src / (double)INT32_MAX, *src);
386  }
387  break;
388  case AV_SAMPLE_FMT_S32: {
389  const int32_t *src = (const int32_t *)buf->extended_data[0];
390 
391  for (i = 0; i < buf->nb_samples; i++) {
392  for (c = 0; c < channels; c++, src++)
393  update_stat(s, &s->chstats[c], *src, *src / (double)INT32_MAX, *src);
394  }}
395  break;
396  case AV_SAMPLE_FMT_S16P:
397  for (c = 0; c < channels; c++) {
398  ChannelStats *p = &s->chstats[c];
399  const int16_t *src = (const int16_t *)buf->extended_data[c];
400 
401  for (i = 0; i < buf->nb_samples; i++, src++)
402  update_stat(s, p, *src, *src / (double)INT16_MAX, *src);
403  }
404  break;
405  case AV_SAMPLE_FMT_S16: {
406  const int16_t *src = (const int16_t *)buf->extended_data[0];
407 
408  for (i = 0; i < buf->nb_samples; i++) {
409  for (c = 0; c < channels; c++, src++)
410  update_stat(s, &s->chstats[c], *src, *src / (double)INT16_MAX, *src);
411  }}
412  break;
413  }
414 
415  if (s->metadata)
416  set_metadata(s, metadata);
417 
418  return ff_filter_frame(inlink->dst->outputs[0], buf);
419 }
420 
422 {
423  AudioStatsContext *s = ctx->priv;
424  uint64_t mask = 0, imask = 0xFFFFFFFFFFFFFFFF, min_count = 0, max_count = 0, nb_samples = 0;
425  double min_runs = 0, max_runs = 0,
426  min = DBL_MAX, max = DBL_MIN, min_diff = DBL_MAX, max_diff = 0,
427  nmin = DBL_MAX, nmax = DBL_MIN,
428  max_sigma_x = 0,
429  diff1_sum_x2 = 0,
430  diff1_sum = 0,
431  sigma_x = 0,
432  sigma_x2 = 0,
433  min_sigma_x2 = DBL_MAX,
434  max_sigma_x2 = DBL_MIN;
436  int c;
437 
438  for (c = 0; c < s->nb_channels; c++) {
439  ChannelStats *p = &s->chstats[c];
440 
441  if (p->nb_samples < s->tc_samples)
442  p->min_sigma_x2 = p->max_sigma_x2 = p->sigma_x2 / p->nb_samples;
443 
444  min = FFMIN(min, p->min);
445  max = FFMAX(max, p->max);
446  nmin = FFMIN(nmin, p->nmin);
447  nmax = FFMAX(nmax, p->nmax);
448  min_diff = FFMIN(min_diff, p->min_diff);
449  max_diff = FFMAX(max_diff, p->max_diff);
450  diff1_sum_x2 += p->diff1_sum_x2;
451  diff1_sum += p->diff1_sum;
452  min_sigma_x2 = FFMIN(min_sigma_x2, p->min_sigma_x2);
453  max_sigma_x2 = FFMAX(max_sigma_x2, p->max_sigma_x2);
454  sigma_x += p->sigma_x;
455  sigma_x2 += p->sigma_x2;
456  min_count += p->min_count;
457  max_count += p->max_count;
458  min_runs += p->min_runs;
459  max_runs += p->max_runs;
460  mask |= p->mask;
461  imask &= p->imask;
462  nb_samples += p->nb_samples;
463  if (fabs(p->sigma_x) > fabs(max_sigma_x))
464  max_sigma_x = p->sigma_x;
465 
466  av_log(ctx, AV_LOG_INFO, "Channel: %d\n", c + 1);
467  av_log(ctx, AV_LOG_INFO, "DC offset: %f\n", p->sigma_x / p->nb_samples);
468  av_log(ctx, AV_LOG_INFO, "Min level: %f\n", p->min);
469  av_log(ctx, AV_LOG_INFO, "Max level: %f\n", p->max);
470  av_log(ctx, AV_LOG_INFO, "Min difference: %f\n", p->min_diff);
471  av_log(ctx, AV_LOG_INFO, "Max difference: %f\n", p->max_diff);
472  av_log(ctx, AV_LOG_INFO, "Mean difference: %f\n", p->diff1_sum / (p->nb_samples - 1));
473  av_log(ctx, AV_LOG_INFO, "RMS difference: %f\n", sqrt(p->diff1_sum_x2 / (p->nb_samples - 1)));
474  av_log(ctx, AV_LOG_INFO, "Peak level dB: %f\n", LINEAR_TO_DB(FFMAX(-p->nmin, p->nmax)));
475  av_log(ctx, AV_LOG_INFO, "RMS level dB: %f\n", LINEAR_TO_DB(sqrt(p->sigma_x2 / p->nb_samples)));
476  av_log(ctx, AV_LOG_INFO, "RMS peak dB: %f\n", LINEAR_TO_DB(sqrt(p->max_sigma_x2)));
477  if (p->min_sigma_x2 != 1)
478  av_log(ctx, AV_LOG_INFO, "RMS trough dB: %f\n",LINEAR_TO_DB(sqrt(p->min_sigma_x2)));
479  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);
480  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)));
481  av_log(ctx, AV_LOG_INFO, "Peak count: %"PRId64"\n", p->min_count + p->max_count);
482  bit_depth(s, p->mask, p->imask, &depth);
483  av_log(ctx, AV_LOG_INFO, "Bit depth: %u/%u\n", depth.num, depth.den);
484  }
485 
486  av_log(ctx, AV_LOG_INFO, "Overall\n");
487  av_log(ctx, AV_LOG_INFO, "DC offset: %f\n", max_sigma_x / (nb_samples / s->nb_channels));
488  av_log(ctx, AV_LOG_INFO, "Min level: %f\n", min);
489  av_log(ctx, AV_LOG_INFO, "Max level: %f\n", max);
490  av_log(ctx, AV_LOG_INFO, "Min difference: %f\n", min_diff);
491  av_log(ctx, AV_LOG_INFO, "Max difference: %f\n", max_diff);
492  av_log(ctx, AV_LOG_INFO, "Mean difference: %f\n", diff1_sum / (nb_samples - s->nb_channels));
493  av_log(ctx, AV_LOG_INFO, "RMS difference: %f\n", sqrt(diff1_sum_x2 / (nb_samples - s->nb_channels)));
494  av_log(ctx, AV_LOG_INFO, "Peak level dB: %f\n", LINEAR_TO_DB(FFMAX(-nmin, nmax)));
495  av_log(ctx, AV_LOG_INFO, "RMS level dB: %f\n", LINEAR_TO_DB(sqrt(sigma_x2 / nb_samples)));
496  av_log(ctx, AV_LOG_INFO, "RMS peak dB: %f\n", LINEAR_TO_DB(sqrt(max_sigma_x2)));
497  if (min_sigma_x2 != 1)
498  av_log(ctx, AV_LOG_INFO, "RMS trough dB: %f\n", LINEAR_TO_DB(sqrt(min_sigma_x2)));
499  av_log(ctx, AV_LOG_INFO, "Flat factor: %f\n", LINEAR_TO_DB((min_runs + max_runs) / (min_count + max_count)));
500  av_log(ctx, AV_LOG_INFO, "Peak count: %f\n", (min_count + max_count) / (double)s->nb_channels);
501  bit_depth(s, mask, imask, &depth);
502  av_log(ctx, AV_LOG_INFO, "Bit depth: %u/%u\n", depth.num, depth.den);
503  av_log(ctx, AV_LOG_INFO, "Number of samples: %"PRId64"\n", nb_samples / s->nb_channels);
504 }
505 
507 {
508  AudioStatsContext *s = ctx->priv;
509 
510  if (s->nb_channels)
511  print_stats(ctx);
512  av_freep(&s->chstats);
513 }
514 
515 static const AVFilterPad astats_inputs[] = {
516  {
517  .name = "default",
518  .type = AVMEDIA_TYPE_AUDIO,
519  .filter_frame = filter_frame,
520  },
521  { NULL }
522 };
523 
524 static const AVFilterPad astats_outputs[] = {
525  {
526  .name = "default",
527  .type = AVMEDIA_TYPE_AUDIO,
528  .config_props = config_output,
529  },
530  { NULL }
531 };
532 
534  .name = "astats",
535  .description = NULL_IF_CONFIG_SMALL("Show time domain statistics about audio frames."),
536  .query_formats = query_formats,
537  .priv_size = sizeof(AudioStatsContext),
538  .priv_class = &astats_class,
539  .uninit = uninit,
540  .inputs = astats_inputs,
541  .outputs = astats_outputs,
542 };
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:194
AVOption.
Definition: opt.h:246
const char * fmt
Definition: avisynth_c.h:769
static int query_formats(AVFilterContext *ctx)
Definition: af_astats.c:70
AVFilter ff_af_astats
Definition: af_astats.c:533
Main libavfilter public API header.
#define OFFSET(x)
Definition: af_astats.c:58
double min_run
Definition: af_astats.c:35
double min
Definition: af_astats.c:33
int num
Numerator.
Definition: rational.h:59
double, planar
Definition: samplefmt.h:70
double max_sigma_x2
Definition: af_astats.c:32
#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:230
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
ChannelStats * chstats
Definition: af_astats.c:47
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:1125
uint8_t
#define av_cold
Definition: attributes.h:82
AVOptions.
double nmin
Definition: af_astats.c:34
static const AVFilterPad astats_inputs[]
Definition: af_astats.c:515
#define LINEAR_TO_DB(x)
Definition: af_astats.c:228
double diff1_sum_x2
Definition: af_astats.c:39
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:481
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:312
static av_cold void uninit(AVFilterContext *ctx)
Definition: af_astats.c:506
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:179
void * priv
private data for use by the filter
Definition: avfilter.h:338
AVFILTER_DEFINE_CLASS(astats)
uint64_t tc_samples
Definition: af_astats.c:49
double max
Definition: af_astats.c:33
#define FFMAX(a, b)
Definition: common.h:94
int8_t exp
Definition: eval.c:65
int depth
Definition: v4l.c:62
double sigma_x2
Definition: af_astats.c:31
static void print_stats(AVFilterContext *ctx)
Definition: af_astats.c:421
#define FFMIN(a, b)
Definition: common.h:96
signed 32 bits, planar
Definition: samplefmt.h:68
double min_sigma_x2
Definition: af_astats.c:32
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:36
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:104
uint64_t max_count
Definition: af_astats.c:41
static const AVFilterPad outputs[]
Definition: af_afftfilt.c:389
double sigma_x
Definition: af_astats.c:31
double nmax
Definition: af_astats.c:34
A list of supported channel layouts.
Definition: formats.h:85
static const AVOption astats_options[]
Definition: af_astats.c:61
double min_diff
Definition: af_astats.c:37
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
static const AVFilterPad inputs[]
Definition: af_afftfilt.c:379
uint64_t mask
Definition: af_astats.c:40
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:32
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:35
Rational number (pair of numerator and denominator).
Definition: rational.h:58
double max_diff
Definition: af_astats.c:37
const char * name
Filter name.
Definition: avfilter.h:148
#define snprintf
Definition: snprintf.h:34
#define FLAGS
Definition: af_astats.c:59
double last
Definition: af_astats.c:30
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:335
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:50
uint64_t nb_samples
Definition: af_astats.c:42
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:214
int den
Denominator.
Definition: rational.h:60
uint64_t min_count
Definition: af_astats.c:41
double min_runs
Definition: af_astats.c:36
double diff1_sum
Definition: af_astats.c:38
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:323
static const AVFilterPad astats_outputs[]
Definition: af_astats.c:524
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:241
float min
uint64_t imask
Definition: af_astats.c:40
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:260
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:230