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