GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavfilter/af_loudnorm.c Lines: 0 464 0.0 %
Date: 2020-10-23 17:01:47 Branches: 0 310 0.0 %

Line Branch Exec Source
1
/*
2
 * Copyright (c) 2016 Kyle Swanson <k@ylo.ph>.
3
 *
4
 * This file is part of FFmpeg.
5
 *
6
 * FFmpeg is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2.1 of the License, or (at your option) any later version.
10
 *
11
 * FFmpeg is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with FFmpeg; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
 */
20
21
/* http://k.ylo.ph/2016/04/04/loudnorm.html */
22
23
#include "libavutil/opt.h"
24
#include "avfilter.h"
25
#include "internal.h"
26
#include "audio.h"
27
#include "ebur128.h"
28
29
enum FrameType {
30
    FIRST_FRAME,
31
    INNER_FRAME,
32
    FINAL_FRAME,
33
    LINEAR_MODE,
34
    FRAME_NB
35
};
36
37
enum LimiterState {
38
    OUT,
39
    ATTACK,
40
    SUSTAIN,
41
    RELEASE,
42
    STATE_NB
43
};
44
45
enum PrintFormat {
46
    NONE,
47
    JSON,
48
    SUMMARY,
49
    PF_NB
50
};
51
52
typedef struct LoudNormContext {
53
    const AVClass *class;
54
    double target_i;
55
    double target_lra;
56
    double target_tp;
57
    double measured_i;
58
    double measured_lra;
59
    double measured_tp;
60
    double measured_thresh;
61
    double offset;
62
    int linear;
63
    int dual_mono;
64
    enum PrintFormat print_format;
65
66
    double *buf;
67
    int buf_size;
68
    int buf_index;
69
    int prev_buf_index;
70
71
    double delta[30];
72
    double weights[21];
73
    double prev_delta;
74
    int index;
75
76
    double gain_reduction[2];
77
    double *limiter_buf;
78
    double *prev_smp;
79
    int limiter_buf_index;
80
    int limiter_buf_size;
81
    enum LimiterState limiter_state;
82
    int peak_index;
83
    int env_index;
84
    int env_cnt;
85
    int attack_length;
86
    int release_length;
87
88
    int64_t pts;
89
    enum FrameType frame_type;
90
    int above_threshold;
91
    int prev_nb_samples;
92
    int channels;
93
94
    FFEBUR128State *r128_in;
95
    FFEBUR128State *r128_out;
96
} LoudNormContext;
97
98
#define OFFSET(x) offsetof(LoudNormContext, x)
99
#define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
100
101
static const AVOption loudnorm_options[] = {
102
    { "I",                "set integrated loudness target",    OFFSET(target_i),         AV_OPT_TYPE_DOUBLE,  {.dbl = -24.},   -70.,       -5.,  FLAGS },
103
    { "i",                "set integrated loudness target",    OFFSET(target_i),         AV_OPT_TYPE_DOUBLE,  {.dbl = -24.},   -70.,       -5.,  FLAGS },
104
    { "LRA",              "set loudness range target",         OFFSET(target_lra),       AV_OPT_TYPE_DOUBLE,  {.dbl =  7.},     1.,        20.,  FLAGS },
105
    { "lra",              "set loudness range target",         OFFSET(target_lra),       AV_OPT_TYPE_DOUBLE,  {.dbl =  7.},     1.,        20.,  FLAGS },
106
    { "TP",               "set maximum true peak",             OFFSET(target_tp),        AV_OPT_TYPE_DOUBLE,  {.dbl = -2.},    -9.,         0.,  FLAGS },
107
    { "tp",               "set maximum true peak",             OFFSET(target_tp),        AV_OPT_TYPE_DOUBLE,  {.dbl = -2.},    -9.,         0.,  FLAGS },
108
    { "measured_I",       "measured IL of input file",         OFFSET(measured_i),       AV_OPT_TYPE_DOUBLE,  {.dbl =  0.},    -99.,        0.,  FLAGS },
109
    { "measured_i",       "measured IL of input file",         OFFSET(measured_i),       AV_OPT_TYPE_DOUBLE,  {.dbl =  0.},    -99.,        0.,  FLAGS },
110
    { "measured_LRA",     "measured LRA of input file",        OFFSET(measured_lra),     AV_OPT_TYPE_DOUBLE,  {.dbl =  0.},     0.,        99.,  FLAGS },
111
    { "measured_lra",     "measured LRA of input file",        OFFSET(measured_lra),     AV_OPT_TYPE_DOUBLE,  {.dbl =  0.},     0.,        99.,  FLAGS },
112
    { "measured_TP",      "measured true peak of input file",  OFFSET(measured_tp),      AV_OPT_TYPE_DOUBLE,  {.dbl =  99.},   -99.,       99.,  FLAGS },
113
    { "measured_tp",      "measured true peak of input file",  OFFSET(measured_tp),      AV_OPT_TYPE_DOUBLE,  {.dbl =  99.},   -99.,       99.,  FLAGS },
114
    { "measured_thresh",  "measured threshold of input file",  OFFSET(measured_thresh),  AV_OPT_TYPE_DOUBLE,  {.dbl = -70.},   -99.,        0.,  FLAGS },
115
    { "offset",           "set offset gain",                   OFFSET(offset),           AV_OPT_TYPE_DOUBLE,  {.dbl =  0.},    -99.,       99.,  FLAGS },
116
    { "linear",           "normalize linearly if possible",    OFFSET(linear),           AV_OPT_TYPE_BOOL,    {.i64 =  1},        0,         1,  FLAGS },
117
    { "dual_mono",        "treat mono input as dual-mono",     OFFSET(dual_mono),        AV_OPT_TYPE_BOOL,    {.i64 =  0},        0,         1,  FLAGS },
118
    { "print_format",     "set print format for stats",        OFFSET(print_format),     AV_OPT_TYPE_INT,     {.i64 =  NONE},  NONE,  PF_NB -1,  FLAGS, "print_format" },
119
    {     "none",         0,                                   0,                        AV_OPT_TYPE_CONST,   {.i64 =  NONE},     0,         0,  FLAGS, "print_format" },
120
    {     "json",         0,                                   0,                        AV_OPT_TYPE_CONST,   {.i64 =  JSON},     0,         0,  FLAGS, "print_format" },
121
    {     "summary",      0,                                   0,                        AV_OPT_TYPE_CONST,   {.i64 =  SUMMARY},  0,         0,  FLAGS, "print_format" },
122
    { NULL }
123
};
124
125
AVFILTER_DEFINE_CLASS(loudnorm);
126
127
static inline int frame_size(int sample_rate, int frame_len_msec)
128
{
129
    const int frame_size = round((double)sample_rate * (frame_len_msec / 1000.0));
130
    return frame_size + (frame_size % 2);
131
}
132
133
static void init_gaussian_filter(LoudNormContext *s)
134
{
135
    double total_weight = 0.0;
136
    const double sigma = 3.5;
137
    double adjust;
138
    int i;
139
140
    const int offset = 21 / 2;
141
    const double c1 = 1.0 / (sigma * sqrt(2.0 * M_PI));
142
    const double c2 = 2.0 * pow(sigma, 2.0);
143
144
    for (i = 0; i < 21; i++) {
145
        const int x = i - offset;
146
        s->weights[i] = c1 * exp(-(pow(x, 2.0) / c2));
147
        total_weight += s->weights[i];
148
    }
149
150
    adjust = 1.0 / total_weight;
151
    for (i = 0; i < 21; i++)
152
        s->weights[i] *= adjust;
153
}
154
155
static double gaussian_filter(LoudNormContext *s, int index)
156
{
157
    double result = 0.;
158
    int i;
159
160
    index = index - 10 > 0 ? index - 10 : index + 20;
161
    for (i = 0; i < 21; i++)
162
        result += s->delta[((index + i) < 30) ? (index + i) : (index + i - 30)] * s->weights[i];
163
164
    return result;
165
}
166
167
static void detect_peak(LoudNormContext *s, int offset, int nb_samples, int channels, int *peak_delta, double *peak_value)
168
{
169
    int n, c, i, index;
170
    double ceiling;
171
    double *buf;
172
173
    *peak_delta = -1;
174
    buf = s->limiter_buf;
175
    ceiling = s->target_tp;
176
177
    index = s->limiter_buf_index + (offset * channels) + (1920 * channels);
178
    if (index >= s->limiter_buf_size)
179
        index -= s->limiter_buf_size;
180
181
    if (s->frame_type == FIRST_FRAME) {
182
        for (c = 0; c < channels; c++)
183
            s->prev_smp[c] = fabs(buf[index + c - channels]);
184
    }
185
186
    for (n = 0; n < nb_samples; n++) {
187
        for (c = 0; c < channels; c++) {
188
            double this, next, max_peak;
189
190
            this = fabs(buf[(index + c) < s->limiter_buf_size ? (index + c) : (index + c - s->limiter_buf_size)]);
191
            next = fabs(buf[(index + c + channels) < s->limiter_buf_size ? (index + c + channels) : (index + c + channels - s->limiter_buf_size)]);
192
193
            if ((s->prev_smp[c] <= this) && (next <= this) && (this > ceiling) && (n > 0)) {
194
                int detected;
195
196
                detected = 1;
197
                for (i = 2; i < 12; i++) {
198
                    next = fabs(buf[(index + c + (i * channels)) < s->limiter_buf_size ? (index + c + (i * channels)) : (index + c + (i * channels) - s->limiter_buf_size)]);
199
                    if (next > this) {
200
                        detected = 0;
201
                        break;
202
                    }
203
                }
204
205
                if (!detected)
206
                    continue;
207
208
                for (c = 0; c < channels; c++) {
209
                    if (c == 0 || fabs(buf[index + c]) > max_peak)
210
                        max_peak = fabs(buf[index + c]);
211
212
                    s->prev_smp[c] = fabs(buf[(index + c) < s->limiter_buf_size ? (index + c) : (index + c - s->limiter_buf_size)]);
213
                }
214
215
                *peak_delta = n;
216
                s->peak_index = index;
217
                *peak_value = max_peak;
218
                return;
219
            }
220
221
            s->prev_smp[c] = this;
222
        }
223
224
        index += channels;
225
        if (index >= s->limiter_buf_size)
226
            index -= s->limiter_buf_size;
227
    }
228
}
229
230
static void true_peak_limiter(LoudNormContext *s, double *out, int nb_samples, int channels)
231
{
232
    int n, c, index, peak_delta, smp_cnt;
233
    double ceiling, peak_value;
234
    double *buf;
235
236
    buf = s->limiter_buf;
237
    ceiling = s->target_tp;
238
    index = s->limiter_buf_index;
239
    smp_cnt = 0;
240
241
    if (s->frame_type == FIRST_FRAME) {
242
        double max;
243
244
        max = 0.;
245
        for (n = 0; n < 1920; n++) {
246
            for (c = 0; c < channels; c++) {
247
              max = fabs(buf[c]) > max ? fabs(buf[c]) : max;
248
            }
249
            buf += channels;
250
        }
251
252
        if (max > ceiling) {
253
            s->gain_reduction[1] = ceiling / max;
254
            s->limiter_state = SUSTAIN;
255
            buf = s->limiter_buf;
256
257
            for (n = 0; n < 1920; n++) {
258
                for (c = 0; c < channels; c++) {
259
                    double env;
260
                    env = s->gain_reduction[1];
261
                    buf[c] *= env;
262
                }
263
                buf += channels;
264
            }
265
        }
266
267
        buf = s->limiter_buf;
268
    }
269
270
    do {
271
272
        switch(s->limiter_state) {
273
        case OUT:
274
            detect_peak(s, smp_cnt, nb_samples - smp_cnt, channels, &peak_delta, &peak_value);
275
            if (peak_delta != -1) {
276
                s->env_cnt = 0;
277
                smp_cnt += (peak_delta - s->attack_length);
278
                s->gain_reduction[0] = 1.;
279
                s->gain_reduction[1] = ceiling / peak_value;
280
                s->limiter_state = ATTACK;
281
282
                s->env_index = s->peak_index - (s->attack_length * channels);
283
                if (s->env_index < 0)
284
                    s->env_index += s->limiter_buf_size;
285
286
                s->env_index += (s->env_cnt * channels);
287
                if (s->env_index > s->limiter_buf_size)
288
                    s->env_index -= s->limiter_buf_size;
289
290
            } else {
291
                smp_cnt = nb_samples;
292
            }
293
            break;
294
295
        case ATTACK:
296
            for (; s->env_cnt < s->attack_length; s->env_cnt++) {
297
                for (c = 0; c < channels; c++) {
298
                    double env;
299
                    env = s->gain_reduction[0] - ((double) s->env_cnt / (s->attack_length - 1) * (s->gain_reduction[0] - s->gain_reduction[1]));
300
                    buf[s->env_index + c] *= env;
301
                }
302
303
                s->env_index += channels;
304
                if (s->env_index >= s->limiter_buf_size)
305
                    s->env_index -= s->limiter_buf_size;
306
307
                smp_cnt++;
308
                if (smp_cnt >= nb_samples) {
309
                    s->env_cnt++;
310
                    break;
311
                }
312
            }
313
314
            if (smp_cnt < nb_samples) {
315
                s->env_cnt = 0;
316
                s->attack_length = 1920;
317
                s->limiter_state = SUSTAIN;
318
            }
319
            break;
320
321
        case SUSTAIN:
322
            detect_peak(s, smp_cnt, nb_samples, channels, &peak_delta, &peak_value);
323
            if (peak_delta == -1) {
324
                s->limiter_state = RELEASE;
325
                s->gain_reduction[0] = s->gain_reduction[1];
326
                s->gain_reduction[1] = 1.;
327
                s->env_cnt = 0;
328
                break;
329
            } else {
330
                double gain_reduction;
331
                gain_reduction = ceiling / peak_value;
332
333
                if (gain_reduction < s->gain_reduction[1]) {
334
                    s->limiter_state = ATTACK;
335
336
                    s->attack_length = peak_delta;
337
                    if (s->attack_length <= 1)
338
                        s->attack_length =  2;
339
340
                    s->gain_reduction[0] = s->gain_reduction[1];
341
                    s->gain_reduction[1] = gain_reduction;
342
                    s->env_cnt = 0;
343
                    break;
344
                }
345
346
                for (s->env_cnt = 0; s->env_cnt < peak_delta; s->env_cnt++) {
347
                    for (c = 0; c < channels; c++) {
348
                        double env;
349
                        env = s->gain_reduction[1];
350
                        buf[s->env_index + c] *= env;
351
                    }
352
353
                    s->env_index += channels;
354
                    if (s->env_index >= s->limiter_buf_size)
355
                        s->env_index -= s->limiter_buf_size;
356
357
                    smp_cnt++;
358
                    if (smp_cnt >= nb_samples) {
359
                        s->env_cnt++;
360
                        break;
361
                    }
362
                }
363
            }
364
            break;
365
366
        case RELEASE:
367
            for (; s->env_cnt < s->release_length; s->env_cnt++) {
368
                for (c = 0; c < channels; c++) {
369
                    double env;
370
                    env = s->gain_reduction[0] + (((double) s->env_cnt / (s->release_length - 1)) * (s->gain_reduction[1] - s->gain_reduction[0]));
371
                    buf[s->env_index + c] *= env;
372
                }
373
374
                s->env_index += channels;
375
                if (s->env_index >= s->limiter_buf_size)
376
                    s->env_index -= s->limiter_buf_size;
377
378
                smp_cnt++;
379
                if (smp_cnt >= nb_samples) {
380
                    s->env_cnt++;
381
                    break;
382
                }
383
            }
384
385
            if (smp_cnt < nb_samples) {
386
                s->env_cnt = 0;
387
                s->limiter_state = OUT;
388
            }
389
390
            break;
391
        }
392
393
    } while (smp_cnt < nb_samples);
394
395
    for (n = 0; n < nb_samples; n++) {
396
        for (c = 0; c < channels; c++) {
397
            out[c] = buf[index + c];
398
            if (fabs(out[c]) > ceiling) {
399
                out[c] = ceiling * (out[c] < 0 ? -1 : 1);
400
            }
401
        }
402
        out += channels;
403
        index += channels;
404
        if (index >= s->limiter_buf_size)
405
            index -= s->limiter_buf_size;
406
    }
407
}
408
409
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
410
{
411
    AVFilterContext *ctx = inlink->dst;
412
    LoudNormContext *s = ctx->priv;
413
    AVFilterLink *outlink = ctx->outputs[0];
414
    AVFrame *out;
415
    const double *src;
416
    double *dst;
417
    double *buf;
418
    double *limiter_buf;
419
    int i, n, c, subframe_length, src_index;
420
    double gain, gain_next, env_global, env_shortterm,
421
    global, shortterm, lra, relative_threshold;
422
423
    if (av_frame_is_writable(in)) {
424
        out = in;
425
    } else {
426
        out = ff_get_audio_buffer(outlink, in->nb_samples);
427
        if (!out) {
428
            av_frame_free(&in);
429
            return AVERROR(ENOMEM);
430
        }
431
        av_frame_copy_props(out, in);
432
    }
433
434
    if (s->pts == AV_NOPTS_VALUE)
435
        s->pts = in->pts;
436
437
    out->pts = s->pts;
438
    src = (const double *)in->data[0];
439
    dst = (double *)out->data[0];
440
    buf = s->buf;
441
    limiter_buf = s->limiter_buf;
442
443
    ff_ebur128_add_frames_double(s->r128_in, src, in->nb_samples);
444
445
    if (s->frame_type == FIRST_FRAME && in->nb_samples < frame_size(inlink->sample_rate, 3000)) {
446
        double offset, offset_tp, true_peak;
447
448
        ff_ebur128_loudness_global(s->r128_in, &global);
449
        for (c = 0; c < inlink->channels; c++) {
450
            double tmp;
451
            ff_ebur128_sample_peak(s->r128_in, c, &tmp);
452
            if (c == 0 || tmp > true_peak)
453
                true_peak = tmp;
454
        }
455
456
        offset    = pow(10., (s->target_i - global) / 20.);
457
        offset_tp = true_peak * offset;
458
        s->offset = offset_tp < s->target_tp ? offset : s->target_tp - true_peak;
459
        s->frame_type = LINEAR_MODE;
460
    }
461
462
    switch (s->frame_type) {
463
    case FIRST_FRAME:
464
        for (n = 0; n < in->nb_samples; n++) {
465
            for (c = 0; c < inlink->channels; c++) {
466
                buf[s->buf_index + c] = src[c];
467
            }
468
            src += inlink->channels;
469
            s->buf_index += inlink->channels;
470
        }
471
472
        ff_ebur128_loudness_shortterm(s->r128_in, &shortterm);
473
474
        if (shortterm < s->measured_thresh) {
475
            s->above_threshold = 0;
476
            env_shortterm = shortterm <= -70. ? 0. : s->target_i - s->measured_i;
477
        } else {
478
            s->above_threshold = 1;
479
            env_shortterm = shortterm <= -70. ? 0. : s->target_i - shortterm;
480
        }
481
482
        for (n = 0; n < 30; n++)
483
            s->delta[n] = pow(10., env_shortterm / 20.);
484
        s->prev_delta = s->delta[s->index];
485
486
        s->buf_index =
487
        s->limiter_buf_index = 0;
488
489
        for (n = 0; n < (s->limiter_buf_size / inlink->channels); n++) {
490
            for (c = 0; c < inlink->channels; c++) {
491
                limiter_buf[s->limiter_buf_index + c] = buf[s->buf_index + c] * s->delta[s->index] * s->offset;
492
            }
493
            s->limiter_buf_index += inlink->channels;
494
            if (s->limiter_buf_index >= s->limiter_buf_size)
495
                s->limiter_buf_index -= s->limiter_buf_size;
496
497
            s->buf_index += inlink->channels;
498
        }
499
500
        subframe_length = frame_size(inlink->sample_rate, 100);
501
        true_peak_limiter(s, dst, subframe_length, inlink->channels);
502
        ff_ebur128_add_frames_double(s->r128_out, dst, subframe_length);
503
504
        s->pts +=
505
        out->nb_samples =
506
        inlink->min_samples =
507
        inlink->max_samples =
508
        inlink->partial_buf_size = subframe_length;
509
510
        s->frame_type = INNER_FRAME;
511
        break;
512
513
    case INNER_FRAME:
514
        gain      = gaussian_filter(s, s->index + 10 < 30 ? s->index + 10 : s->index + 10 - 30);
515
        gain_next = gaussian_filter(s, s->index + 11 < 30 ? s->index + 11 : s->index + 11 - 30);
516
517
        for (n = 0; n < in->nb_samples; n++) {
518
            for (c = 0; c < inlink->channels; c++) {
519
                buf[s->prev_buf_index + c] = src[c];
520
                limiter_buf[s->limiter_buf_index + c] = buf[s->buf_index + c] * (gain + (((double) n / in->nb_samples) * (gain_next - gain))) * s->offset;
521
            }
522
            src += inlink->channels;
523
524
            s->limiter_buf_index += inlink->channels;
525
            if (s->limiter_buf_index >= s->limiter_buf_size)
526
                s->limiter_buf_index -= s->limiter_buf_size;
527
528
            s->prev_buf_index += inlink->channels;
529
            if (s->prev_buf_index >= s->buf_size)
530
                s->prev_buf_index -= s->buf_size;
531
532
            s->buf_index += inlink->channels;
533
            if (s->buf_index >= s->buf_size)
534
                s->buf_index -= s->buf_size;
535
        }
536
537
        subframe_length = (frame_size(inlink->sample_rate, 100) - in->nb_samples) * inlink->channels;
538
        s->limiter_buf_index = s->limiter_buf_index + subframe_length < s->limiter_buf_size ? s->limiter_buf_index + subframe_length : s->limiter_buf_index + subframe_length - s->limiter_buf_size;
539
540
        true_peak_limiter(s, dst, in->nb_samples, inlink->channels);
541
        ff_ebur128_add_frames_double(s->r128_out, dst, in->nb_samples);
542
543
        ff_ebur128_loudness_range(s->r128_in, &lra);
544
        ff_ebur128_loudness_global(s->r128_in, &global);
545
        ff_ebur128_loudness_shortterm(s->r128_in, &shortterm);
546
        ff_ebur128_relative_threshold(s->r128_in, &relative_threshold);
547
548
        if (s->above_threshold == 0) {
549
            double shortterm_out;
550
551
            if (shortterm > s->measured_thresh)
552
                s->prev_delta *= 1.0058;
553
554
            ff_ebur128_loudness_shortterm(s->r128_out, &shortterm_out);
555
            if (shortterm_out >= s->target_i)
556
                s->above_threshold = 1;
557
        }
558
559
        if (shortterm < relative_threshold || shortterm <= -70. || s->above_threshold == 0) {
560
            s->delta[s->index] = s->prev_delta;
561
        } else {
562
            env_global = fabs(shortterm - global) < (s->target_lra / 2.) ? shortterm - global : (s->target_lra / 2.) * ((shortterm - global) < 0 ? -1 : 1);
563
            env_shortterm = s->target_i - shortterm;
564
            s->delta[s->index] = pow(10., (env_global + env_shortterm) / 20.);
565
        }
566
567
        s->prev_delta = s->delta[s->index];
568
        s->index++;
569
        if (s->index >= 30)
570
            s->index -= 30;
571
        s->prev_nb_samples = in->nb_samples;
572
        s->pts += in->nb_samples;
573
        break;
574
575
    case FINAL_FRAME:
576
        gain = gaussian_filter(s, s->index + 10 < 30 ? s->index + 10 : s->index + 10 - 30);
577
        s->limiter_buf_index = 0;
578
        src_index = 0;
579
580
        for (n = 0; n < s->limiter_buf_size / inlink->channels; n++) {
581
            for (c = 0; c < inlink->channels; c++) {
582
                s->limiter_buf[s->limiter_buf_index + c] = src[src_index + c] * gain * s->offset;
583
            }
584
            src_index += inlink->channels;
585
586
            s->limiter_buf_index += inlink->channels;
587
            if (s->limiter_buf_index >= s->limiter_buf_size)
588
                s->limiter_buf_index -= s->limiter_buf_size;
589
        }
590
591
        subframe_length = frame_size(inlink->sample_rate, 100);
592
        for (i = 0; i < in->nb_samples / subframe_length; i++) {
593
            true_peak_limiter(s, dst, subframe_length, inlink->channels);
594
595
            for (n = 0; n < subframe_length; n++) {
596
                for (c = 0; c < inlink->channels; c++) {
597
                    if (src_index < (in->nb_samples * inlink->channels)) {
598
                        limiter_buf[s->limiter_buf_index + c] = src[src_index + c] * gain * s->offset;
599
                    } else {
600
                        limiter_buf[s->limiter_buf_index + c] = 0.;
601
                    }
602
                }
603
604
                if (src_index < (in->nb_samples * inlink->channels))
605
                    src_index += inlink->channels;
606
607
                s->limiter_buf_index += inlink->channels;
608
                if (s->limiter_buf_index >= s->limiter_buf_size)
609
                    s->limiter_buf_index -= s->limiter_buf_size;
610
            }
611
612
            dst += (subframe_length * inlink->channels);
613
        }
614
615
        dst = (double *)out->data[0];
616
        ff_ebur128_add_frames_double(s->r128_out, dst, in->nb_samples);
617
        break;
618
619
    case LINEAR_MODE:
620
        for (n = 0; n < in->nb_samples; n++) {
621
            for (c = 0; c < inlink->channels; c++) {
622
                dst[c] = src[c] * s->offset;
623
            }
624
            src += inlink->channels;
625
            dst += inlink->channels;
626
        }
627
628
        dst = (double *)out->data[0];
629
        ff_ebur128_add_frames_double(s->r128_out, dst, in->nb_samples);
630
        s->pts += in->nb_samples;
631
        break;
632
    }
633
634
    if (in != out)
635
        av_frame_free(&in);
636
637
    return ff_filter_frame(outlink, out);
638
}
639
640
static int request_frame(AVFilterLink *outlink)
641
{
642
    int ret;
643
    AVFilterContext *ctx = outlink->src;
644
    AVFilterLink *inlink = ctx->inputs[0];
645
    LoudNormContext *s = ctx->priv;
646
647
    ret = ff_request_frame(inlink);
648
    if (ret == AVERROR_EOF && s->frame_type == INNER_FRAME) {
649
        double *src;
650
        double *buf;
651
        int nb_samples, n, c, offset;
652
        AVFrame *frame;
653
654
        nb_samples  = (s->buf_size / inlink->channels) - s->prev_nb_samples;
655
        nb_samples -= (frame_size(inlink->sample_rate, 100) - s->prev_nb_samples);
656
657
        frame = ff_get_audio_buffer(outlink, nb_samples);
658
        if (!frame)
659
            return AVERROR(ENOMEM);
660
        frame->nb_samples = nb_samples;
661
662
        buf = s->buf;
663
        src = (double *)frame->data[0];
664
665
        offset  = ((s->limiter_buf_size / inlink->channels) - s->prev_nb_samples) * inlink->channels;
666
        offset -= (frame_size(inlink->sample_rate, 100) - s->prev_nb_samples) * inlink->channels;
667
        s->buf_index = s->buf_index - offset < 0 ? s->buf_index - offset + s->buf_size : s->buf_index - offset;
668
669
        for (n = 0; n < nb_samples; n++) {
670
            for (c = 0; c < inlink->channels; c++) {
671
                src[c] = buf[s->buf_index + c];
672
            }
673
            src += inlink->channels;
674
            s->buf_index += inlink->channels;
675
            if (s->buf_index >= s->buf_size)
676
                s->buf_index -= s->buf_size;
677
        }
678
679
        s->frame_type = FINAL_FRAME;
680
        ret = filter_frame(inlink, frame);
681
    }
682
    return ret;
683
}
684
685
static int query_formats(AVFilterContext *ctx)
686
{
687
    LoudNormContext *s = ctx->priv;
688
    AVFilterFormats *formats;
689
    AVFilterChannelLayouts *layouts;
690
    AVFilterLink *inlink = ctx->inputs[0];
691
    AVFilterLink *outlink = ctx->outputs[0];
692
    static const int input_srate[] = {192000, -1};
693
    static const enum AVSampleFormat sample_fmts[] = {
694
        AV_SAMPLE_FMT_DBL,
695
        AV_SAMPLE_FMT_NONE
696
    };
697
    int ret;
698
699
    layouts = ff_all_channel_counts();
700
    if (!layouts)
701
        return AVERROR(ENOMEM);
702
    ret = ff_set_common_channel_layouts(ctx, layouts);
703
    if (ret < 0)
704
        return ret;
705
706
    formats = ff_make_format_list(sample_fmts);
707
    if (!formats)
708
        return AVERROR(ENOMEM);
709
    ret = ff_set_common_formats(ctx, formats);
710
    if (ret < 0)
711
        return ret;
712
713
    if (s->frame_type != LINEAR_MODE) {
714
        formats = ff_make_format_list(input_srate);
715
        if (!formats)
716
            return AVERROR(ENOMEM);
717
        ret = ff_formats_ref(formats, &inlink->outcfg.samplerates);
718
        if (ret < 0)
719
            return ret;
720
        ret = ff_formats_ref(formats, &outlink->incfg.samplerates);
721
        if (ret < 0)
722
            return ret;
723
    }
724
725
    return 0;
726
}
727
728
static int config_input(AVFilterLink *inlink)
729
{
730
    AVFilterContext *ctx = inlink->dst;
731
    LoudNormContext *s = ctx->priv;
732
733
    s->r128_in = ff_ebur128_init(inlink->channels, inlink->sample_rate, 0, FF_EBUR128_MODE_I | FF_EBUR128_MODE_S | FF_EBUR128_MODE_LRA | FF_EBUR128_MODE_SAMPLE_PEAK);
734
    if (!s->r128_in)
735
        return AVERROR(ENOMEM);
736
737
    s->r128_out = ff_ebur128_init(inlink->channels, inlink->sample_rate, 0, FF_EBUR128_MODE_I | FF_EBUR128_MODE_S | FF_EBUR128_MODE_LRA | FF_EBUR128_MODE_SAMPLE_PEAK);
738
    if (!s->r128_out)
739
        return AVERROR(ENOMEM);
740
741
    if (inlink->channels == 1 && s->dual_mono) {
742
        ff_ebur128_set_channel(s->r128_in,  0, FF_EBUR128_DUAL_MONO);
743
        ff_ebur128_set_channel(s->r128_out, 0, FF_EBUR128_DUAL_MONO);
744
    }
745
746
    s->buf_size = frame_size(inlink->sample_rate, 3000) * inlink->channels;
747
    s->buf = av_malloc_array(s->buf_size, sizeof(*s->buf));
748
    if (!s->buf)
749
        return AVERROR(ENOMEM);
750
751
    s->limiter_buf_size = frame_size(inlink->sample_rate, 210) * inlink->channels;
752
    s->limiter_buf = av_malloc_array(s->buf_size, sizeof(*s->limiter_buf));
753
    if (!s->limiter_buf)
754
        return AVERROR(ENOMEM);
755
756
    s->prev_smp = av_malloc_array(inlink->channels, sizeof(*s->prev_smp));
757
    if (!s->prev_smp)
758
        return AVERROR(ENOMEM);
759
760
    init_gaussian_filter(s);
761
762
    if (s->frame_type != LINEAR_MODE) {
763
        inlink->min_samples =
764
        inlink->max_samples =
765
        inlink->partial_buf_size = frame_size(inlink->sample_rate, 3000);
766
    }
767
768
    s->pts = AV_NOPTS_VALUE;
769
    s->buf_index =
770
    s->prev_buf_index =
771
    s->limiter_buf_index = 0;
772
    s->channels = inlink->channels;
773
    s->index = 1;
774
    s->limiter_state = OUT;
775
    s->offset = pow(10., s->offset / 20.);
776
    s->target_tp = pow(10., s->target_tp / 20.);
777
    s->attack_length = frame_size(inlink->sample_rate, 10);
778
    s->release_length = frame_size(inlink->sample_rate, 100);
779
780
    return 0;
781
}
782
783
static av_cold int init(AVFilterContext *ctx)
784
{
785
    LoudNormContext *s = ctx->priv;
786
    s->frame_type = FIRST_FRAME;
787
788
    if (s->linear) {
789
        double offset, offset_tp;
790
        offset    = s->target_i - s->measured_i;
791
        offset_tp = s->measured_tp + offset;
792
793
        if (s->measured_tp != 99 && s->measured_thresh != -70 && s->measured_lra != 0 && s->measured_i != 0) {
794
            if ((offset_tp <= s->target_tp) && (s->measured_lra <= s->target_lra)) {
795
                s->frame_type = LINEAR_MODE;
796
                s->offset = offset;
797
            }
798
        }
799
    }
800
801
    return 0;
802
}
803
804
static av_cold void uninit(AVFilterContext *ctx)
805
{
806
    LoudNormContext *s = ctx->priv;
807
    double i_in, i_out, lra_in, lra_out, thresh_in, thresh_out, tp_in, tp_out;
808
    int c;
809
810
    if (!s->r128_in || !s->r128_out)
811
        goto end;
812
813
    ff_ebur128_loudness_range(s->r128_in, &lra_in);
814
    ff_ebur128_loudness_global(s->r128_in, &i_in);
815
    ff_ebur128_relative_threshold(s->r128_in, &thresh_in);
816
    for (c = 0; c < s->channels; c++) {
817
        double tmp;
818
        ff_ebur128_sample_peak(s->r128_in, c, &tmp);
819
        if ((c == 0) || (tmp > tp_in))
820
            tp_in = tmp;
821
    }
822
823
    ff_ebur128_loudness_range(s->r128_out, &lra_out);
824
    ff_ebur128_loudness_global(s->r128_out, &i_out);
825
    ff_ebur128_relative_threshold(s->r128_out, &thresh_out);
826
    for (c = 0; c < s->channels; c++) {
827
        double tmp;
828
        ff_ebur128_sample_peak(s->r128_out, c, &tmp);
829
        if ((c == 0) || (tmp > tp_out))
830
            tp_out = tmp;
831
    }
832
833
    switch(s->print_format) {
834
    case NONE:
835
        break;
836
837
    case JSON:
838
        av_log(ctx, AV_LOG_INFO,
839
            "\n{\n"
840
            "\t\"input_i\" : \"%.2f\",\n"
841
            "\t\"input_tp\" : \"%.2f\",\n"
842
            "\t\"input_lra\" : \"%.2f\",\n"
843
            "\t\"input_thresh\" : \"%.2f\",\n"
844
            "\t\"output_i\" : \"%.2f\",\n"
845
            "\t\"output_tp\" : \"%+.2f\",\n"
846
            "\t\"output_lra\" : \"%.2f\",\n"
847
            "\t\"output_thresh\" : \"%.2f\",\n"
848
            "\t\"normalization_type\" : \"%s\",\n"
849
            "\t\"target_offset\" : \"%.2f\"\n"
850
            "}\n",
851
            i_in,
852
            20. * log10(tp_in),
853
            lra_in,
854
            thresh_in,
855
            i_out,
856
            20. * log10(tp_out),
857
            lra_out,
858
            thresh_out,
859
            s->frame_type == LINEAR_MODE ? "linear" : "dynamic",
860
            s->target_i - i_out
861
        );
862
        break;
863
864
    case SUMMARY:
865
        av_log(ctx, AV_LOG_INFO,
866
            "\n"
867
            "Input Integrated:   %+6.1f LUFS\n"
868
            "Input True Peak:    %+6.1f dBTP\n"
869
            "Input LRA:          %6.1f LU\n"
870
            "Input Threshold:    %+6.1f LUFS\n"
871
            "\n"
872
            "Output Integrated:  %+6.1f LUFS\n"
873
            "Output True Peak:   %+6.1f dBTP\n"
874
            "Output LRA:         %6.1f LU\n"
875
            "Output Threshold:   %+6.1f LUFS\n"
876
            "\n"
877
            "Normalization Type:   %s\n"
878
            "Target Offset:      %+6.1f LU\n",
879
            i_in,
880
            20. * log10(tp_in),
881
            lra_in,
882
            thresh_in,
883
            i_out,
884
            20. * log10(tp_out),
885
            lra_out,
886
            thresh_out,
887
            s->frame_type == LINEAR_MODE ? "Linear" : "Dynamic",
888
            s->target_i - i_out
889
        );
890
        break;
891
    }
892
893
end:
894
    if (s->r128_in)
895
        ff_ebur128_destroy(&s->r128_in);
896
    if (s->r128_out)
897
        ff_ebur128_destroy(&s->r128_out);
898
    av_freep(&s->limiter_buf);
899
    av_freep(&s->prev_smp);
900
    av_freep(&s->buf);
901
}
902
903
static const AVFilterPad avfilter_af_loudnorm_inputs[] = {
904
    {
905
        .name         = "default",
906
        .type         = AVMEDIA_TYPE_AUDIO,
907
        .config_props = config_input,
908
        .filter_frame = filter_frame,
909
    },
910
    { NULL }
911
};
912
913
static const AVFilterPad avfilter_af_loudnorm_outputs[] = {
914
    {
915
        .name          = "default",
916
        .request_frame = request_frame,
917
        .type          = AVMEDIA_TYPE_AUDIO,
918
    },
919
    { NULL }
920
};
921
922
AVFilter ff_af_loudnorm = {
923
    .name          = "loudnorm",
924
    .description   = NULL_IF_CONFIG_SMALL("EBU R128 loudness normalization"),
925
    .priv_size     = sizeof(LoudNormContext),
926
    .priv_class    = &loudnorm_class,
927
    .query_formats = query_formats,
928
    .init          = init,
929
    .uninit        = uninit,
930
    .inputs        = avfilter_af_loudnorm_inputs,
931
    .outputs       = avfilter_af_loudnorm_outputs,
932
};