FFmpeg coverage

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