git.sesse.net Git - ffmpeg/blob - 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     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 };