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