git.sesse.net Git - ffmpeg/blob - libavfilter/af_astats.c

   1 /*
   2  * Copyright (c) 2009 Rob Sykes <robs@users.sourceforge.net>
   3  * Copyright (c) 2013 Paul B Mahol
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include <float.h>
  23 #include <math.h>
  24
  25 #include "libavutil/opt.h"
  26 #include "audio.h"
  27 #include "avfilter.h"
  28 #include "internal.h"
  29
  30 #define HISTOGRAM_SIZE                  8192
  31 #define HISTOGRAM_MAX                   (HISTOGRAM_SIZE-1)
  32
  33 #define MEASURE_ALL                     UINT_MAX
  34 #define MEASURE_NONE                           0
  35
  36 #define MEASURE_DC_OFFSET               (1 <<  0)
  37 #define MEASURE_MIN_LEVEL               (1 <<  1)
  38 #define MEASURE_MAX_LEVEL               (1 <<  2)
  39 #define MEASURE_MIN_DIFFERENCE          (1 <<  3)
  40 #define MEASURE_MAX_DIFFERENCE          (1 <<  4)
  41 #define MEASURE_MEAN_DIFFERENCE         (1 <<  5)
  42 #define MEASURE_RMS_DIFFERENCE          (1 <<  6)
  43 #define MEASURE_PEAK_LEVEL              (1 <<  7)
  44 #define MEASURE_RMS_LEVEL               (1 <<  8)
  45 #define MEASURE_RMS_PEAK                (1 <<  9)
  46 #define MEASURE_RMS_TROUGH              (1 << 10)
  47 #define MEASURE_CREST_FACTOR            (1 << 11)
  48 #define MEASURE_FLAT_FACTOR             (1 << 12)
  49 #define MEASURE_PEAK_COUNT              (1 << 13)
  50 #define MEASURE_BIT_DEPTH               (1 << 14)
  51 #define MEASURE_DYNAMIC_RANGE           (1 << 15)
  52 #define MEASURE_ZERO_CROSSINGS          (1 << 16)
  53 #define MEASURE_ZERO_CROSSINGS_RATE     (1 << 17)
  54 #define MEASURE_NUMBER_OF_SAMPLES       (1 << 18)
  55 #define MEASURE_NUMBER_OF_NANS          (1 << 19)
  56 #define MEASURE_NUMBER_OF_INFS          (1 << 20)
  57 #define MEASURE_NUMBER_OF_DENORMALS     (1 << 21)
  58 #define MEASURE_NOISE_FLOOR             (1 << 22)
  59 #define MEASURE_NOISE_FLOOR_COUNT       (1 << 23)
  60
  61 #define MEASURE_MINMAXPEAK              (MEASURE_MIN_LEVEL | MEASURE_MAX_LEVEL | MEASURE_PEAK_LEVEL)
  62
  63 typedef struct ChannelStats {
  64     double last;
  65     double last_non_zero;
  66     double min_non_zero;
  67     double sigma_x, sigma_x2;
  68     double avg_sigma_x2, min_sigma_x2, max_sigma_x2;
  69     double min, max;
  70     double nmin, nmax;
  71     double min_run, max_run;
  72     double min_runs, max_runs;
  73     double min_diff, max_diff;
  74     double diff1_sum;
  75     double diff1_sum_x2;
  76     uint64_t mask, imask;
  77     uint64_t min_count, max_count;
  78     uint64_t noise_floor_count;
  79     uint64_t zero_runs;
  80     uint64_t nb_samples;
  81     uint64_t nb_nans;
  82     uint64_t nb_infs;
  83     uint64_t nb_denormals;
  84     double *win_samples;
  85     unsigned histogram[HISTOGRAM_SIZE];
  86     int win_pos;
  87     int max_index;
  88     double noise_floor;
  89 } ChannelStats;
  90
  91 typedef struct AudioStatsContext {
  92     const AVClass *class;
  93     ChannelStats *chstats;
  94     int nb_channels;
  95     uint64_t tc_samples;
  96     double time_constant;
  97     double mult;
  98     int metadata;
  99     int reset_count;
 100     int nb_frames;
 101     int maxbitdepth;
 102     int measure_perchannel;
 103     int measure_overall;
 104     int is_float;
 105     int is_double;
 106 } AudioStatsContext;
 107
 108 #define OFFSET(x) offsetof(AudioStatsContext, x)
 109 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
 110
 111 static const AVOption astats_options[] = {
 112     { "length", "set the window length", OFFSET(time_constant), AV_OPT_TYPE_DOUBLE, {.dbl=.05}, .01, 10, FLAGS },
 113     { "metadata", "inject metadata in the filtergraph", OFFSET(metadata), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
 114     { "reset", "recalculate stats after this many frames", OFFSET(reset_count), AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX, FLAGS },
 115     { "measure_perchannel", "only measure_perchannel these per-channel statistics", OFFSET(measure_perchannel), AV_OPT_TYPE_FLAGS, {.i64=MEASURE_ALL}, 0, UINT_MAX, FLAGS, "measure" },
 116       { "none"                      , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_NONE                }, 0, 0, FLAGS, "measure" },
 117       { "all"                       , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_ALL                 }, 0, 0, FLAGS, "measure" },
 118       { "DC_offset"                 , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_DC_OFFSET           }, 0, 0, FLAGS, "measure" },
 119       { "Min_level"                 , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_MIN_LEVEL           }, 0, 0, FLAGS, "measure" },
 120       { "Max_level"                 , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_MAX_LEVEL           }, 0, 0, FLAGS, "measure" },
 121       { "Min_difference"            , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_MIN_DIFFERENCE      }, 0, 0, FLAGS, "measure" },
 122       { "Max_difference"            , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_MAX_DIFFERENCE      }, 0, 0, FLAGS, "measure" },
 123       { "Mean_difference"           , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_MEAN_DIFFERENCE     }, 0, 0, FLAGS, "measure" },
 124       { "RMS_difference"            , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_RMS_DIFFERENCE      }, 0, 0, FLAGS, "measure" },
 125       { "Peak_level"                , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_PEAK_LEVEL          }, 0, 0, FLAGS, "measure" },
 126       { "RMS_level"                 , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_RMS_LEVEL           }, 0, 0, FLAGS, "measure" },
 127       { "RMS_peak"                  , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_RMS_PEAK            }, 0, 0, FLAGS, "measure" },
 128       { "RMS_trough"                , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_RMS_TROUGH          }, 0, 0, FLAGS, "measure" },
 129       { "Crest_factor"              , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_CREST_FACTOR        }, 0, 0, FLAGS, "measure" },
 130       { "Flat_factor"               , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_FLAT_FACTOR         }, 0, 0, FLAGS, "measure" },
 131       { "Peak_count"                , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_PEAK_COUNT          }, 0, 0, FLAGS, "measure" },
 132       { "Bit_depth"                 , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_BIT_DEPTH           }, 0, 0, FLAGS, "measure" },
 133       { "Dynamic_range"             , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_DYNAMIC_RANGE       }, 0, 0, FLAGS, "measure" },
 134       { "Zero_crossings"            , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_ZERO_CROSSINGS      }, 0, 0, FLAGS, "measure" },
 135       { "Zero_crossings_rate"       , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_ZERO_CROSSINGS_RATE }, 0, 0, FLAGS, "measure" },
 136       { "Noise_floor"               , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_NOISE_FLOOR         }, 0, 0, FLAGS, "measure" },
 137       { "Noise_floor_count"         , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_NOISE_FLOOR_COUNT   }, 0, 0, FLAGS, "measure" },
 138       { "Number_of_samples"         , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_NUMBER_OF_SAMPLES   }, 0, 0, FLAGS, "measure" },
 139       { "Number_of_NaNs"            , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_NUMBER_OF_NANS      }, 0, 0, FLAGS, "measure" },
 140       { "Number_of_Infs"            , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_NUMBER_OF_INFS      }, 0, 0, FLAGS, "measure" },
 141       { "Number_of_denormals"       , "", 0, AV_OPT_TYPE_CONST, {.i64=MEASURE_NUMBER_OF_DENORMALS }, 0, 0, FLAGS, "measure" },
 142     { "measure_overall", "only measure_perchannel these overall statistics", OFFSET(measure_overall), AV_OPT_TYPE_FLAGS, {.i64=MEASURE_ALL}, 0, UINT_MAX, FLAGS, "measure" },
 143     { NULL }
 144 };
 145
 146 AVFILTER_DEFINE_CLASS(astats);
 147
 148 static int query_formats(AVFilterContext *ctx)
 149 {
 150     AVFilterFormats *formats;
 151     AVFilterChannelLayouts *layouts;
 152     static const enum AVSampleFormat sample_fmts[] = {
 153         AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16P,
 154         AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32P,
 155         AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64P,
 156         AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLTP,
 157         AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBLP,
 158         AV_SAMPLE_FMT_NONE
 159     };
 160     int ret;
 161
 162     layouts = ff_all_channel_counts();
 163     if (!layouts)
 164         return AVERROR(ENOMEM);
 165     ret = ff_set_common_channel_layouts(ctx, layouts);
 166     if (ret < 0)
 167         return ret;
 168
 169     formats = ff_make_format_list(sample_fmts);
 170     if (!formats)
 171         return AVERROR(ENOMEM);
 172     ret = ff_set_common_formats(ctx, formats);
 173     if (ret < 0)
 174         return ret;
 175
 176     formats = ff_all_samplerates();
 177     if (!formats)
 178         return AVERROR(ENOMEM);
 179     return ff_set_common_samplerates(ctx, formats);
 180 }
 181
 182 static void reset_stats(AudioStatsContext *s)
 183 {
 184     int c;
 185
 186     for (c = 0; c < s->nb_channels; c++) {
 187         ChannelStats *p = &s->chstats[c];
 188
 189         p->min = p->nmin = p->min_sigma_x2 = DBL_MAX;
 190         p->max = p->nmax = p->max_sigma_x2 =-DBL_MAX;
 191         p->min_non_zero = DBL_MAX;
 192         p->min_diff = DBL_MAX;
 193         p->max_diff = 0;
 194         p->sigma_x = 0;
 195         p->sigma_x2 = 0;
 196         p->avg_sigma_x2 = 0;
 197         p->min_run = 0;
 198         p->max_run = 0;
 199         p->min_runs = 0;
 200         p->max_runs = 0;
 201         p->diff1_sum = 0;
 202         p->diff1_sum_x2 = 0;
 203         p->mask = 0;
 204         p->imask = 0xFFFFFFFFFFFFFFFF;
 205         p->min_count = 0;
 206         p->max_count = 0;
 207         p->zero_runs = 0;
 208         p->nb_samples = 0;
 209         p->nb_nans = 0;
 210         p->nb_infs = 0;
 211         p->nb_denormals = 0;
 212         p->last = NAN;
 213         p->noise_floor = NAN;
 214         p->noise_floor_count = 0;
 215         p->win_pos = 0;
 216         memset(p->win_samples, 0, s->tc_samples * sizeof(*p->win_samples));
 217         memset(p->histogram, 0, sizeof(p->histogram));
 218     }
 219 }
 220
 221 static int config_output(AVFilterLink *outlink)
 222 {
 223     AudioStatsContext *s = outlink->src->priv;
 224
 225     s->chstats = av_calloc(sizeof(*s->chstats), outlink->channels);
 226     if (!s->chstats)
 227         return AVERROR(ENOMEM);
 228
 229     s->tc_samples = 5 * s->time_constant * outlink->sample_rate + .5;
 230     s->nb_channels = outlink->channels;
 231
 232     for (int i = 0; i < s->nb_channels; i++) {
 233         ChannelStats *p = &s->chstats[i];
 234
 235         p->win_samples = av_calloc(s->tc_samples, sizeof(*p->win_samples));
 236         if (!p->win_samples)
 237             return AVERROR(ENOMEM);
 238     }
 239
 240     s->mult = exp((-1 / s->time_constant / outlink->sample_rate));
 241     s->nb_frames = 0;
 242     s->maxbitdepth = av_get_bytes_per_sample(outlink->format) * 8;
 243     s->is_double = outlink->format == AV_SAMPLE_FMT_DBL  ||
 244                    outlink->format == AV_SAMPLE_FMT_DBLP;
 245
 246     s->is_float = outlink->format == AV_SAMPLE_FMT_FLT  ||
 247                   outlink->format == AV_SAMPLE_FMT_FLTP;
 248
 249     reset_stats(s);
 250
 251     return 0;
 252 }
 253
 254 static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
 255 {
 256     unsigned result = s->maxbitdepth;
 257
 258     mask = mask & (~imask);
 259
 260     for (; result && !(mask & 1); --result, mask >>= 1);
 261
 262     depth->den = result;
 263     depth->num = 0;
 264
 265     for (; result; --result, mask >>= 1)
 266         if (mask & 1)
 267             depth->num++;
 268 }
 269
 270 static inline void update_minmax(AudioStatsContext *s, ChannelStats *p, double d)
 271 {
 272     if (d < p->min)
 273         p->min = d;
 274     if (d > p->max)
 275         p->max = d;
 276 }
 277
 278 static inline void update_stat(AudioStatsContext *s, ChannelStats *p, double d, double nd, int64_t i)
 279 {
 280     double drop;
 281     int index;
 282
 283     if (d < p->min) {
 284         p->min = d;
 285         p->nmin = nd;
 286         p->min_run = 1;
 287         p->min_runs = 0;
 288         p->min_count = 1;
 289     } else if (d == p->min) {
 290         p->min_count++;
 291         p->min_run = d == p->last ? p->min_run + 1 : 1;
 292     } else if (p->last == p->min) {
 293         p->min_runs += p->min_run * p->min_run;
 294     }
 295
 296     if (d != 0 && FFABS(d) < p->min_non_zero)
 297         p->min_non_zero = FFABS(d);
 298
 299     if (d > p->max) {
 300         p->max = d;
 301         p->nmax = nd;
 302         p->max_run = 1;
 303         p->max_runs = 0;
 304         p->max_count = 1;
 305     } else if (d == p->max) {
 306         p->max_count++;
 307         p->max_run = d == p->last ? p->max_run + 1 : 1;
 308     } else if (p->last == p->max) {
 309         p->max_runs += p->max_run * p->max_run;
 310     }
 311
 312     if (d != 0) {
 313         p->zero_runs += FFSIGN(d) != FFSIGN(p->last_non_zero);
 314         p->last_non_zero = d;
 315     }
 316
 317     p->sigma_x += nd;
 318     p->sigma_x2 += nd * nd;
 319     p->avg_sigma_x2 = p->avg_sigma_x2 * s->mult + (1.0 - s->mult) * nd * nd;
 320     if (!isnan(p->last)) {
 321         p->min_diff = FFMIN(p->min_diff, fabs(d - p->last));
 322         p->max_diff = FFMAX(p->max_diff, fabs(d - p->last));
 323         p->diff1_sum += fabs(d - p->last);
 324         p->diff1_sum_x2 += (d - p->last) * (d - p->last);
 325     }
 326     p->last = d;
 327     p->mask |= i;
 328     p->imask &= i;
 329
 330     drop = p->win_samples[p->win_pos];
 331     p->win_samples[p->win_pos] = nd;
 332     index = av_clip(lrint(av_clipd(FFABS(nd), 0.0, 1.0) * HISTOGRAM_MAX), 0, HISTOGRAM_MAX);
 333     p->max_index = FFMAX(p->max_index, index);
 334     p->histogram[index]++;
 335     if (!isnan(p->noise_floor))
 336         p->histogram[av_clip(lrint(av_clipd(FFABS(drop), 0.0, 1.0) * HISTOGRAM_MAX), 0, HISTOGRAM_MAX)]--;
 337     p->win_pos++;
 338
 339     while (p->histogram[p->max_index] == 0)
 340         p->max_index--;
 341     if (p->win_pos >= s->tc_samples || !isnan(p->noise_floor)) {
 342         double noise_floor = 1.;
 343
 344         for (int i = p->max_index; i >= 0; i--) {
 345             if (p->histogram[i]) {
 346                 noise_floor = i / (double)HISTOGRAM_MAX;
 347                 break;
 348             }
 349         }
 350
 351         if (isnan(p->noise_floor)) {
 352             p->noise_floor = noise_floor;
 353             p->noise_floor_count = 1;
 354         } else {
 355             if (noise_floor < p->noise_floor) {
 356                 p->noise_floor = noise_floor;
 357                 p->noise_floor_count = 1;
 358             } else if (noise_floor == p->noise_floor) {
 359                 p->noise_floor_count++;
 360             }
 361         }
 362     }
 363
 364     if (p->win_pos >= s->tc_samples) {
 365         p->win_pos = 0;
 366     }
 367
 368     if (p->nb_samples >= s->tc_samples) {
 369         p->max_sigma_x2 = FFMAX(p->max_sigma_x2, p->avg_sigma_x2);
 370         p->min_sigma_x2 = FFMIN(p->min_sigma_x2, p->avg_sigma_x2);
 371     }
 372     p->nb_samples++;
 373 }
 374
 375 static inline void update_float_stat(AudioStatsContext *s, ChannelStats *p, float d)
 376 {
 377     int type = fpclassify(d);
 378
 379     p->nb_nans      += type == FP_NAN;
 380     p->nb_infs      += type == FP_INFINITE;
 381     p->nb_denormals += type == FP_SUBNORMAL;
 382 }
 383
 384 static inline void update_double_stat(AudioStatsContext *s, ChannelStats *p, double d)
 385 {
 386     int type = fpclassify(d);
 387
 388     p->nb_nans      += type == FP_NAN;
 389     p->nb_infs      += type == FP_INFINITE;
 390     p->nb_denormals += type == FP_SUBNORMAL;
 391 }
 392
 393 static void set_meta(AVDictionary **metadata, int chan, const char *key,
 394                      const char *fmt, double val)
 395 {
 396     uint8_t value[128];
 397     uint8_t key2[128];
 398
 399     snprintf(value, sizeof(value), fmt, val);
 400     if (chan)
 401         snprintf(key2, sizeof(key2), "lavfi.astats.%d.%s", chan, key);
 402     else
 403         snprintf(key2, sizeof(key2), "lavfi.astats.%s", key);
 404     av_dict_set(metadata, key2, value, 0);
 405 }
 406
 407 #define LINEAR_TO_DB(x) (log10(x) * 20)
 408
 409 static void set_metadata(AudioStatsContext *s, AVDictionary **metadata)
 410 {
 411     uint64_t mask = 0, imask = 0xFFFFFFFFFFFFFFFF, min_count = 0, max_count = 0, nb_samples = 0, noise_floor_count = 0;
 412     uint64_t nb_nans = 0, nb_infs = 0, nb_denormals = 0;
 413     double min_runs = 0, max_runs = 0,
 414            min = DBL_MAX, max =-DBL_MAX, min_diff = DBL_MAX, max_diff = 0,
 415            nmin = DBL_MAX, nmax =-DBL_MAX,
 416            max_sigma_x = 0,
 417            diff1_sum = 0,
 418            diff1_sum_x2 = 0,
 419            sigma_x = 0,
 420            sigma_x2 = 0,
 421            noise_floor = 0,
 422            min_sigma_x2 = DBL_MAX,
 423            max_sigma_x2 =-DBL_MAX;
 424     AVRational depth;
 425     int c;
 426
 427     for (c = 0; c < s->nb_channels; c++) {
 428         ChannelStats *p = &s->chstats[c];
 429
 430         if (p->nb_samples < s->tc_samples)
 431             p->min_sigma_x2 = p->max_sigma_x2 = p->sigma_x2 / p->nb_samples;
 432
 433         min = FFMIN(min, p->min);
 434         max = FFMAX(max, p->max);
 435         nmin = FFMIN(nmin, p->nmin);
 436         nmax = FFMAX(nmax, p->nmax);
 437         min_diff = FFMIN(min_diff, p->min_diff);
 438         max_diff = FFMAX(max_diff, p->max_diff);
 439         diff1_sum += p->diff1_sum;
 440         diff1_sum_x2 += p->diff1_sum_x2;
 441         min_sigma_x2 = FFMIN(min_sigma_x2, p->min_sigma_x2);
 442         max_sigma_x2 = FFMAX(max_sigma_x2, p->max_sigma_x2);
 443         sigma_x += p->sigma_x;
 444         sigma_x2 += p->sigma_x2;
 445         noise_floor = FFMAX(noise_floor, p->noise_floor);
 446         noise_floor_count += p->noise_floor_count;
 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         nb_nans += p->nb_nans;
 455         nb_infs += p->nb_infs;
 456         nb_denormals += p->nb_denormals;
 457         if (fabs(p->sigma_x) > fabs(max_sigma_x))
 458             max_sigma_x = p->sigma_x;
 459
 460         if (s->measure_perchannel & MEASURE_DC_OFFSET)
 461             set_meta(metadata, c + 1, "DC_offset", "%f", p->sigma_x / p->nb_samples);
 462         if (s->measure_perchannel & MEASURE_MIN_LEVEL)
 463             set_meta(metadata, c + 1, "Min_level", "%f", p->min);
 464         if (s->measure_perchannel & MEASURE_MAX_LEVEL)
 465             set_meta(metadata, c + 1, "Max_level", "%f", p->max);
 466         if (s->measure_perchannel & MEASURE_MIN_DIFFERENCE)
 467             set_meta(metadata, c + 1, "Min_difference", "%f", p->min_diff);
 468         if (s->measure_perchannel & MEASURE_MAX_DIFFERENCE)
 469             set_meta(metadata, c + 1, "Max_difference", "%f", p->max_diff);
 470         if (s->measure_perchannel & MEASURE_MEAN_DIFFERENCE)
 471             set_meta(metadata, c + 1, "Mean_difference", "%f", p->diff1_sum / (p->nb_samples - 1));
 472         if (s->measure_perchannel & MEASURE_RMS_DIFFERENCE)
 473             set_meta(metadata, c + 1, "RMS_difference", "%f", sqrt(p->diff1_sum_x2 / (p->nb_samples - 1)));
 474         if (s->measure_perchannel & MEASURE_PEAK_LEVEL)
 475             set_meta(metadata, c + 1, "Peak_level", "%f", LINEAR_TO_DB(FFMAX(-p->nmin, p->nmax)));
 476         if (s->measure_perchannel & MEASURE_RMS_LEVEL)
 477             set_meta(metadata, c + 1, "RMS_level", "%f", LINEAR_TO_DB(sqrt(p->sigma_x2 / p->nb_samples)));
 478         if (s->measure_perchannel & MEASURE_RMS_PEAK)
 479             set_meta(metadata, c + 1, "RMS_peak", "%f", LINEAR_TO_DB(sqrt(p->max_sigma_x2)));
 480         if (s->measure_perchannel & MEASURE_RMS_TROUGH)
 481             set_meta(metadata, c + 1, "RMS_trough", "%f", LINEAR_TO_DB(sqrt(p->min_sigma_x2)));
 482         if (s->measure_perchannel & MEASURE_CREST_FACTOR)
 483             set_meta(metadata, c + 1, "Crest_factor", "%f", p->sigma_x2 ? FFMAX(-p->min, p->max) / sqrt(p->sigma_x2 / p->nb_samples) : 1);
 484         if (s->measure_perchannel & MEASURE_FLAT_FACTOR)
 485             set_meta(metadata, c + 1, "Flat_factor", "%f", LINEAR_TO_DB((p->min_runs + p->max_runs) / (p->min_count + p->max_count)));
 486         if (s->measure_perchannel & MEASURE_PEAK_COUNT)
 487             set_meta(metadata, c + 1, "Peak_count", "%f", (float)(p->min_count + p->max_count));
 488         if (s->measure_perchannel & MEASURE_NOISE_FLOOR)
 489             set_meta(metadata, c + 1, "Noise_floor", "%f", LINEAR_TO_DB(p->noise_floor));
 490         if (s->measure_perchannel & MEASURE_NOISE_FLOOR_COUNT)
 491             set_meta(metadata, c + 1, "Noise_floor_count", "%f", p->noise_floor_count);
 492         if (s->measure_perchannel & MEASURE_BIT_DEPTH) {
 493             bit_depth(s, p->mask, p->imask, &depth);
 494             set_meta(metadata, c + 1, "Bit_depth", "%f", depth.num);
 495             set_meta(metadata, c + 1, "Bit_depth2", "%f", depth.den);
 496         }
 497         if (s->measure_perchannel & MEASURE_DYNAMIC_RANGE)
 498             set_meta(metadata, c + 1, "Dynamic_range", "%f", LINEAR_TO_DB(2 * FFMAX(FFABS(p->min), FFABS(p->max))/ p->min_non_zero));
 499         if (s->measure_perchannel & MEASURE_ZERO_CROSSINGS)
 500             set_meta(metadata, c + 1, "Zero_crossings", "%f", p->zero_runs);
 501         if (s->measure_perchannel & MEASURE_ZERO_CROSSINGS_RATE)
 502             set_meta(metadata, c + 1, "Zero_crossings_rate", "%f", p->zero_runs/(double)p->nb_samples);
 503         if ((s->is_float || s->is_double) && s->measure_perchannel & MEASURE_NUMBER_OF_NANS)
 504             set_meta(metadata, c + 1, "Number of NaNs", "%f", p->nb_nans);
 505         if ((s->is_float || s->is_double) && s->measure_perchannel & MEASURE_NUMBER_OF_INFS)
 506             set_meta(metadata, c + 1, "Number of Infs", "%f", p->nb_infs);
 507         if ((s->is_float || s->is_double) && s->measure_perchannel & MEASURE_NUMBER_OF_DENORMALS)
 508             set_meta(metadata, c + 1, "Number of denormals", "%f", p->nb_denormals);
 509     }
 510
 511     if (s->measure_overall & MEASURE_DC_OFFSET)
 512         set_meta(metadata, 0, "Overall.DC_offset", "%f", max_sigma_x / (nb_samples / s->nb_channels));
 513     if (s->measure_overall & MEASURE_MIN_LEVEL)
 514         set_meta(metadata, 0, "Overall.Min_level", "%f", min);
 515     if (s->measure_overall & MEASURE_MAX_LEVEL)
 516         set_meta(metadata, 0, "Overall.Max_level", "%f", max);
 517     if (s->measure_overall & MEASURE_MIN_DIFFERENCE)
 518         set_meta(metadata, 0, "Overall.Min_difference", "%f", min_diff);
 519     if (s->measure_overall & MEASURE_MAX_DIFFERENCE)
 520         set_meta(metadata, 0, "Overall.Max_difference", "%f", max_diff);
 521     if (s->measure_overall & MEASURE_MEAN_DIFFERENCE)
 522         set_meta(metadata, 0, "Overall.Mean_difference", "%f", diff1_sum / (nb_samples - s->nb_channels));
 523     if (s->measure_overall & MEASURE_RMS_DIFFERENCE)
 524         set_meta(metadata, 0, "Overall.RMS_difference", "%f", sqrt(diff1_sum_x2 / (nb_samples - s->nb_channels)));
 525     if (s->measure_overall & MEASURE_PEAK_LEVEL)
 526         set_meta(metadata, 0, "Overall.Peak_level", "%f", LINEAR_TO_DB(FFMAX(-nmin, nmax)));
 527     if (s->measure_overall & MEASURE_RMS_LEVEL)
 528         set_meta(metadata, 0, "Overall.RMS_level", "%f", LINEAR_TO_DB(sqrt(sigma_x2 / nb_samples)));
 529     if (s->measure_overall & MEASURE_RMS_PEAK)
 530         set_meta(metadata, 0, "Overall.RMS_peak", "%f", LINEAR_TO_DB(sqrt(max_sigma_x2)));
 531     if (s->measure_overall & MEASURE_RMS_TROUGH)
 532         set_meta(metadata, 0, "Overall.RMS_trough", "%f", LINEAR_TO_DB(sqrt(min_sigma_x2)));
 533     if (s->measure_overall & MEASURE_FLAT_FACTOR)
 534         set_meta(metadata, 0, "Overall.Flat_factor", "%f", LINEAR_TO_DB((min_runs + max_runs) / (min_count + max_count)));
 535     if (s->measure_overall & MEASURE_PEAK_COUNT)
 536         set_meta(metadata, 0, "Overall.Peak_count", "%f", (float)(min_count + max_count) / (double)s->nb_channels);
 537     if (s->measure_overall & MEASURE_NOISE_FLOOR)
 538         set_meta(metadata, 0, "Overall.Noise_floor", "%f", LINEAR_TO_DB(noise_floor));
 539     if (s->measure_overall & MEASURE_NOISE_FLOOR_COUNT)
 540         set_meta(metadata, 0, "Overall.Noise_floor_count", "%f", noise_floor_count / (double)s->nb_channels);
 541     if (s->measure_overall & MEASURE_BIT_DEPTH) {
 542         bit_depth(s, mask, imask, &depth);
 543         set_meta(metadata, 0, "Overall.Bit_depth", "%f", depth.num);
 544         set_meta(metadata, 0, "Overall.Bit_depth2", "%f", depth.den);
 545     }
 546     if (s->measure_overall & MEASURE_NUMBER_OF_SAMPLES)
 547         set_meta(metadata, 0, "Overall.Number_of_samples", "%f", nb_samples / s->nb_channels);
 548     if ((s->is_float || s->is_double) && s->measure_overall & MEASURE_NUMBER_OF_NANS)
 549         set_meta(metadata, 0, "Number of NaNs", "%f", nb_nans / (float)s->nb_channels);
 550     if ((s->is_float || s->is_double) && s->measure_overall & MEASURE_NUMBER_OF_INFS)
 551         set_meta(metadata, 0, "Number of Infs", "%f", nb_infs / (float)s->nb_channels);
 552     if ((s->is_float || s->is_double) && s->measure_overall & MEASURE_NUMBER_OF_DENORMALS)
 553         set_meta(metadata, 0, "Number of denormals", "%f", nb_denormals / (float)s->nb_channels);
 554 }
 555
 556 #define UPDATE_STATS_P(type, update_func, update_float, channel_func)           \
 557     for (int c = start; c < end; c++) {                                         \
 558         ChannelStats *p = &s->chstats[c];                                       \
 559         const type *src = (const type *)data[c];                                \
 560         const type * const srcend = src + samples;                              \
 561         for (; src < srcend; src++) {                                           \
 562             update_func;                                                        \
 563             update_float;                                                       \
 564         }                                                                       \
 565         channel_func;                                                           \
 566     }
 567
 568 #define UPDATE_STATS_I(type, update_func, update_float, channel_func)           \
 569     for (int c = start; c < end; c++) {                                         \
 570         ChannelStats *p = &s->chstats[c];                                       \
 571         const type *src = (const type *)data[0];                                \
 572         const type * const srcend = src + samples * channels;                   \
 573         for (src += c; src < srcend; src += channels) {                         \
 574             update_func;                                                        \
 575             update_float;                                                       \
 576         }                                                                       \
 577         channel_func;                                                           \
 578     }
 579
 580 #define UPDATE_STATS(planar, type, sample, normalizer_suffix, int_sample) \
 581     if ((s->measure_overall | s->measure_perchannel) & ~MEASURE_MINMAXPEAK) {                          \
 582         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, ); \
 583     } else {                                                                                           \
 584         UPDATE_STATS_##planar(type, update_minmax(s, p, sample), , p->nmin = p->min normalizer_suffix; p->nmax = p->max normalizer_suffix;); \
 585     }
 586
 587 static int filter_channel(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
 588 {
 589     AudioStatsContext *s = ctx->priv;
 590     AVFilterLink *inlink = ctx->inputs[0];
 591     AVFrame *buf = arg;
 592     const uint8_t * const * const data = (const uint8_t * const *)buf->extended_data;
 593     const int channels = s->nb_channels;
 594     const int samples = buf->nb_samples;
 595     const int start = (buf->channels * jobnr) / nb_jobs;
 596     const int end = (buf->channels * (jobnr+1)) / nb_jobs;
 597
 598     switch (inlink->format) {
 599     case AV_SAMPLE_FMT_DBLP:
 600         UPDATE_STATS(P, double, *src, , llrint(*src * (UINT64_C(1) << 63)));
 601         break;
 602     case AV_SAMPLE_FMT_DBL:
 603         UPDATE_STATS(I, double, *src, , llrint(*src * (UINT64_C(1) << 63)));
 604         break;
 605     case AV_SAMPLE_FMT_FLTP:
 606         UPDATE_STATS(P, float, *src, , llrint(*src * (UINT64_C(1) << 31)));
 607         break;
 608     case AV_SAMPLE_FMT_FLT:
 609         UPDATE_STATS(I, float, *src, , llrint(*src * (UINT64_C(1) << 31)));
 610         break;
 611     case AV_SAMPLE_FMT_S64P:
 612         UPDATE_STATS(P, int64_t, *src, / (double)INT64_MAX, *src);
 613         break;
 614     case AV_SAMPLE_FMT_S64:
 615         UPDATE_STATS(I, int64_t, *src, / (double)INT64_MAX, *src);
 616         break;
 617     case AV_SAMPLE_FMT_S32P:
 618         UPDATE_STATS(P, int32_t, *src, / (double)INT32_MAX, *src);
 619         break;
 620     case AV_SAMPLE_FMT_S32:
 621         UPDATE_STATS(I, int32_t, *src, / (double)INT32_MAX, *src);
 622         break;
 623     case AV_SAMPLE_FMT_S16P:
 624         UPDATE_STATS(P, int16_t, *src, / (double)INT16_MAX, *src);
 625         break;
 626     case AV_SAMPLE_FMT_S16:
 627         UPDATE_STATS(I, int16_t, *src, / (double)INT16_MAX, *src);
 628         break;
 629     }
 630
 631     return 0;
 632 }
 633
 634 static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
 635 {
 636     AVFilterContext *ctx = inlink->dst;
 637     AudioStatsContext *s = ctx->priv;
 638     AVDictionary **metadata = &buf->metadata;
 639
 640     if (s->reset_count > 0) {
 641         if (s->nb_frames >= s->reset_count) {
 642             reset_stats(s);
 643             s->nb_frames = 0;
 644         }
 645         s->nb_frames++;
 646     }
 647
 648     ctx->internal->execute(ctx, filter_channel, buf, NULL, FFMIN(inlink->channels, ff_filter_get_nb_threads(ctx)));
 649
 650     if (s->metadata)
 651         set_metadata(s, metadata);
 652
 653     return ff_filter_frame(inlink->dst->outputs[0], buf);
 654 }
 655
 656 static void print_stats(AVFilterContext *ctx)
 657 {
 658     AudioStatsContext *s = ctx->priv;
 659     uint64_t mask = 0, imask = 0xFFFFFFFFFFFFFFFF, min_count = 0, max_count = 0, nb_samples = 0, noise_floor_count = 0;
 660     uint64_t nb_nans = 0, nb_infs = 0, nb_denormals = 0;
 661     double min_runs = 0, max_runs = 0,
 662            min = DBL_MAX, max =-DBL_MAX, min_diff = DBL_MAX, max_diff = 0,
 663            nmin = DBL_MAX, nmax =-DBL_MAX,
 664            max_sigma_x = 0,
 665            diff1_sum_x2 = 0,
 666            diff1_sum = 0,
 667            sigma_x = 0,
 668            sigma_x2 = 0,
 669            noise_floor = 0,
 670            min_sigma_x2 = DBL_MAX,
 671            max_sigma_x2 =-DBL_MAX;
 672     AVRational depth;
 673     int c;
 674
 675     for (c = 0; c < s->nb_channels; c++) {
 676         ChannelStats *p = &s->chstats[c];
 677
 678         if (p->nb_samples < s->tc_samples)
 679             p->min_sigma_x2 = p->max_sigma_x2 = p->sigma_x2 / p->nb_samples;
 680
 681         min = FFMIN(min, p->min);
 682         max = FFMAX(max, p->max);
 683         nmin = FFMIN(nmin, p->nmin);
 684         nmax = FFMAX(nmax, p->nmax);
 685         min_diff = FFMIN(min_diff, p->min_diff);
 686         max_diff = FFMAX(max_diff, p->max_diff);
 687         diff1_sum_x2 += p->diff1_sum_x2;
 688         diff1_sum += p->diff1_sum;
 689         min_sigma_x2 = FFMIN(min_sigma_x2, p->min_sigma_x2);
 690         max_sigma_x2 = FFMAX(max_sigma_x2, p->max_sigma_x2);
 691         sigma_x += p->sigma_x;
 692         sigma_x2 += p->sigma_x2;
 693         noise_floor = FFMAX(noise_floor, p->noise_floor);
 694         min_count += p->min_count;
 695         max_count += p->max_count;
 696         noise_floor_count += p->noise_floor_count;
 697         min_runs += p->min_runs;
 698         max_runs += p->max_runs;
 699         mask |= p->mask;
 700         imask &= p->imask;
 701         nb_samples += p->nb_samples;
 702         nb_nans += p->nb_nans;
 703         nb_infs += p->nb_infs;
 704         nb_denormals += p->nb_denormals;
 705         if (fabs(p->sigma_x) > fabs(max_sigma_x))
 706             max_sigma_x = p->sigma_x;
 707
 708         av_log(ctx, AV_LOG_INFO, "Channel: %d\n", c + 1);
 709         if (s->measure_perchannel & MEASURE_DC_OFFSET)
 710             av_log(ctx, AV_LOG_INFO, "DC offset: %f\n", p->sigma_x / p->nb_samples);
 711         if (s->measure_perchannel & MEASURE_MIN_LEVEL)
 712             av_log(ctx, AV_LOG_INFO, "Min level: %f\n", p->min);
 713         if (s->measure_perchannel & MEASURE_MAX_LEVEL)
 714             av_log(ctx, AV_LOG_INFO, "Max level: %f\n", p->max);
 715         if (s->measure_perchannel & MEASURE_MIN_DIFFERENCE)
 716             av_log(ctx, AV_LOG_INFO, "Min difference: %f\n", p->min_diff);
 717         if (s->measure_perchannel & MEASURE_MAX_DIFFERENCE)
 718             av_log(ctx, AV_LOG_INFO, "Max difference: %f\n", p->max_diff);
 719         if (s->measure_perchannel & MEASURE_MEAN_DIFFERENCE)
 720             av_log(ctx, AV_LOG_INFO, "Mean difference: %f\n", p->diff1_sum / (p->nb_samples - 1));
 721         if (s->measure_perchannel & MEASURE_RMS_DIFFERENCE)
 722             av_log(ctx, AV_LOG_INFO, "RMS difference: %f\n", sqrt(p->diff1_sum_x2 / (p->nb_samples - 1)));
 723         if (s->measure_perchannel & MEASURE_PEAK_LEVEL)
 724             av_log(ctx, AV_LOG_INFO, "Peak level dB: %f\n", LINEAR_TO_DB(FFMAX(-p->nmin, p->nmax)));
 725         if (s->measure_perchannel & MEASURE_RMS_LEVEL)
 726             av_log(ctx, AV_LOG_INFO, "RMS level dB: %f\n", LINEAR_TO_DB(sqrt(p->sigma_x2 / p->nb_samples)));
 727         if (s->measure_perchannel & MEASURE_RMS_PEAK)
 728             av_log(ctx, AV_LOG_INFO, "RMS peak dB: %f\n", LINEAR_TO_DB(sqrt(p->max_sigma_x2)));
 729         if (s->measure_perchannel & MEASURE_RMS_TROUGH)
 730             if (p->min_sigma_x2 != 1)
 731                 av_log(ctx, AV_LOG_INFO, "RMS trough dB: %f\n",LINEAR_TO_DB(sqrt(p->min_sigma_x2)));
 732         if (s->measure_perchannel & MEASURE_CREST_FACTOR)
 733             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);
 734         if (s->measure_perchannel & MEASURE_FLAT_FACTOR)
 735             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)));
 736         if (s->measure_perchannel & MEASURE_PEAK_COUNT)
 737             av_log(ctx, AV_LOG_INFO, "Peak count: %"PRId64"\n", p->min_count + p->max_count);
 738         if (s->measure_perchannel & MEASURE_NOISE_FLOOR)
 739             av_log(ctx, AV_LOG_INFO, "Noise floor dB: %f\n", LINEAR_TO_DB(p->noise_floor));
 740         if (s->measure_perchannel & MEASURE_NOISE_FLOOR_COUNT)
 741             av_log(ctx, AV_LOG_INFO, "Noise floor count: %"PRId64"\n", p->noise_floor_count);
 742         if (s->measure_perchannel & MEASURE_BIT_DEPTH) {
 743             bit_depth(s, p->mask, p->imask, &depth);
 744             av_log(ctx, AV_LOG_INFO, "Bit depth: %u/%u\n", depth.num, depth.den);
 745         }
 746         if (s->measure_perchannel & MEASURE_DYNAMIC_RANGE)
 747             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));
 748         if (s->measure_perchannel & MEASURE_ZERO_CROSSINGS)
 749             av_log(ctx, AV_LOG_INFO, "Zero crossings: %"PRId64"\n", p->zero_runs);
 750         if (s->measure_perchannel & MEASURE_ZERO_CROSSINGS_RATE)
 751             av_log(ctx, AV_LOG_INFO, "Zero crossings rate: %f\n", p->zero_runs/(double)p->nb_samples);
 752         if ((s->is_float || s->is_double) && s->measure_perchannel & MEASURE_NUMBER_OF_NANS)
 753             av_log(ctx, AV_LOG_INFO, "Number of NaNs: %"PRId64"\n", p->nb_nans);
 754         if ((s->is_float || s->is_double) && s->measure_perchannel & MEASURE_NUMBER_OF_INFS)
 755             av_log(ctx, AV_LOG_INFO, "Number of Infs: %"PRId64"\n", p->nb_infs);
 756         if ((s->is_float || s->is_double) && s->measure_perchannel & MEASURE_NUMBER_OF_DENORMALS)
 757             av_log(ctx, AV_LOG_INFO, "Number of denormals: %"PRId64"\n", p->nb_denormals);
 758     }
 759
 760     av_log(ctx, AV_LOG_INFO, "Overall\n");
 761     if (s->measure_overall & MEASURE_DC_OFFSET)
 762         av_log(ctx, AV_LOG_INFO, "DC offset: %f\n", max_sigma_x / (nb_samples / s->nb_channels));
 763     if (s->measure_overall & MEASURE_MIN_LEVEL)
 764         av_log(ctx, AV_LOG_INFO, "Min level: %f\n", min);
 765     if (s->measure_overall & MEASURE_MAX_LEVEL)
 766         av_log(ctx, AV_LOG_INFO, "Max level: %f\n", max);
 767     if (s->measure_overall & MEASURE_MIN_DIFFERENCE)
 768         av_log(ctx, AV_LOG_INFO, "Min difference: %f\n", min_diff);
 769     if (s->measure_overall & MEASURE_MAX_DIFFERENCE)
 770         av_log(ctx, AV_LOG_INFO, "Max difference: %f\n", max_diff);
 771     if (s->measure_overall & MEASURE_MEAN_DIFFERENCE)
 772         av_log(ctx, AV_LOG_INFO, "Mean difference: %f\n", diff1_sum / (nb_samples - s->nb_channels));
 773     if (s->measure_overall & MEASURE_RMS_DIFFERENCE)
 774         av_log(ctx, AV_LOG_INFO, "RMS difference: %f\n", sqrt(diff1_sum_x2 / (nb_samples - s->nb_channels)));
 775     if (s->measure_overall & MEASURE_PEAK_LEVEL)
 776         av_log(ctx, AV_LOG_INFO, "Peak level dB: %f\n", LINEAR_TO_DB(FFMAX(-nmin, nmax)));
 777     if (s->measure_overall & MEASURE_RMS_LEVEL)
 778         av_log(ctx, AV_LOG_INFO, "RMS level dB: %f\n", LINEAR_TO_DB(sqrt(sigma_x2 / nb_samples)));
 779     if (s->measure_overall & MEASURE_RMS_PEAK)
 780         av_log(ctx, AV_LOG_INFO, "RMS peak dB: %f\n", LINEAR_TO_DB(sqrt(max_sigma_x2)));
 781     if (s->measure_overall & MEASURE_RMS_TROUGH)
 782         if (min_sigma_x2 != 1)
 783             av_log(ctx, AV_LOG_INFO, "RMS trough dB: %f\n", LINEAR_TO_DB(sqrt(min_sigma_x2)));
 784     if (s->measure_overall & MEASURE_FLAT_FACTOR)
 785         av_log(ctx, AV_LOG_INFO, "Flat factor: %f\n", LINEAR_TO_DB((min_runs + max_runs) / (min_count + max_count)));
 786     if (s->measure_overall & MEASURE_PEAK_COUNT)
 787         av_log(ctx, AV_LOG_INFO, "Peak count: %f\n", (min_count + max_count) / (double)s->nb_channels);
 788     if (s->measure_overall & MEASURE_NOISE_FLOOR)
 789         av_log(ctx, AV_LOG_INFO, "Noise floor dB: %f\n", LINEAR_TO_DB(noise_floor));
 790     if (s->measure_overall & MEASURE_NOISE_FLOOR_COUNT)
 791         av_log(ctx, AV_LOG_INFO, "Noise floor count: %f\n", noise_floor_count / (double)s->nb_channels);
 792     if (s->measure_overall & MEASURE_BIT_DEPTH) {
 793         bit_depth(s, mask, imask, &depth);
 794         av_log(ctx, AV_LOG_INFO, "Bit depth: %u/%u\n", depth.num, depth.den);
 795     }
 796     if (s->measure_overall & MEASURE_NUMBER_OF_SAMPLES)
 797         av_log(ctx, AV_LOG_INFO, "Number of samples: %"PRId64"\n", nb_samples / s->nb_channels);
 798     if ((s->is_float || s->is_double) && s->measure_overall & MEASURE_NUMBER_OF_NANS)
 799         av_log(ctx, AV_LOG_INFO, "Number of NaNs: %f\n", nb_nans / (float)s->nb_channels);
 800     if ((s->is_float || s->is_double) && s->measure_overall & MEASURE_NUMBER_OF_INFS)
 801         av_log(ctx, AV_LOG_INFO, "Number of Infs: %f\n", nb_infs / (float)s->nb_channels);
 802     if ((s->is_float || s->is_double) && s->measure_overall & MEASURE_NUMBER_OF_DENORMALS)
 803         av_log(ctx, AV_LOG_INFO, "Number of denormals: %f\n", nb_denormals / (float)s->nb_channels);
 804 }
 805
 806 static av_cold void uninit(AVFilterContext *ctx)
 807 {
 808     AudioStatsContext *s = ctx->priv;
 809
 810     if (s->nb_channels)
 811         print_stats(ctx);
 812     if (s->chstats) {
 813         for (int i = 0; i < s->nb_channels; i++) {
 814             ChannelStats *p = &s->chstats[i];
 815
 816             av_freep(&p->win_samples);
 817         }
 818     }
 819     av_freep(&s->chstats);
 820 }
 821
 822 static const AVFilterPad astats_inputs[] = {
 823     {
 824         .name         = "default",
 825         .type         = AVMEDIA_TYPE_AUDIO,
 826         .filter_frame = filter_frame,
 827     },
 828     { NULL }
 829 };
 830
 831 static const AVFilterPad astats_outputs[] = {
 832     {
 833         .name         = "default",
 834         .type         = AVMEDIA_TYPE_AUDIO,
 835         .config_props = config_output,
 836     },
 837     { NULL }
 838 };
 839
 840 AVFilter ff_af_astats = {
 841     .name          = "astats",
 842     .description   = NULL_IF_CONFIG_SMALL("Show time domain statistics about audio frames."),
 843     .query_formats = query_formats,
 844     .priv_size     = sizeof(AudioStatsContext),
 845     .priv_class    = &astats_class,
 846     .uninit        = uninit,
 847     .inputs        = astats_inputs,
 848     .outputs       = astats_outputs,
 849     .flags         = AVFILTER_FLAG_SLICE_THREADS,
 850 };