GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavfilter/af_astats.c Lines: 0 503 0.0 %
Date: 2020-08-14 10:39:37 Branches: 0 571 0.0 %

Line Branch Exec Source
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(FFABS(nd) * 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(FFABS(drop) * 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
};