FFmpeg coverage

Line	Branch	Exec	Source
1			/*
2			* Copyright (C) 2001-2010 Krzysztof Foltman, Markus Schmidt, Thor Harald Johansen and others
3			* Copyright (c) 2015 Paul B Mahol
4			*
5			* This file is part of FFmpeg.
6			*
7			* FFmpeg is free software; you can redistribute it and/or
8			* modify it under the terms of the GNU Lesser General Public
9			* License as published by the Free Software Foundation; either
10			* version 2.1 of the License, or (at your option) any later version.
11			*
12			* FFmpeg is distributed in the hope that it will be useful,
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15			* Lesser General Public License for more details.
16			*
17			* You should have received a copy of the GNU Lesser General Public
18			* License along with FFmpeg; if not, write to the Free Software
19			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20			*/
21
22			/**
23			* @file
24			* Audio (Sidechain) Compressor filter
25			*/
26
27			#include "config_components.h"
28
29			#include "libavutil/audio_fifo.h"
30			#include "libavutil/channel_layout.h"
31			#include "libavutil/common.h"
32			#include "libavutil/opt.h"
33
34			#include "audio.h"
35			#include "avfilter.h"
36			#include "filters.h"
37			#include "formats.h"
38			#include "hermite.h"
39			#include "internal.h"
40
41			typedef struct SidechainCompressContext {
42			const AVClass *class;
43
44			double level_in;
45			double level_sc;
46			double attack, attack_coeff;
47			double release, release_coeff;
48			double lin_slope;
49			double ratio;
50			double threshold;
51			double makeup;
52			double mix;
53			double thres;
54			double knee;
55			double knee_start;
56			double knee_stop;
57			double lin_knee_start;
58			double lin_knee_stop;
59			double adj_knee_start;
60			double adj_knee_stop;
61			double compressed_knee_start;
62			double compressed_knee_stop;
63			int link;
64			int detection;
65			int mode;
66
67			AVAudioFifo *fifo[2];
68			int64_t pts;
69			} SidechainCompressContext;
70
71			#define OFFSET(x) offsetof(SidechainCompressContext, x)
72			#define A AV_OPT_FLAG_AUDIO_PARAM
73			#define F AV_OPT_FLAG_FILTERING_PARAM
74			#define R AV_OPT_FLAG_RUNTIME_PARAM
75
76			static const AVOption options[] = {
77			{ "level_in", "set input gain", OFFSET(level_in), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0.015625, 64, A|F|R },
78			{ "mode", "set mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, A|F|R, .unit = "mode" },
79			{ "downward",0, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, A|F|R, .unit = "mode" },
80			{ "upward", 0, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, A|F|R, .unit = "mode" },
81			{ "threshold", "set threshold", OFFSET(threshold), AV_OPT_TYPE_DOUBLE, {.dbl=0.125}, 0.000976563, 1, A|F|R },
82			{ "ratio", "set ratio", OFFSET(ratio), AV_OPT_TYPE_DOUBLE, {.dbl=2}, 1, 20, A|F|R },
83			{ "attack", "set attack", OFFSET(attack), AV_OPT_TYPE_DOUBLE, {.dbl=20}, 0.01, 2000, A|F|R },
84			{ "release", "set release", OFFSET(release), AV_OPT_TYPE_DOUBLE, {.dbl=250}, 0.01, 9000, A|F|R },
85			{ "makeup", "set make up gain", OFFSET(makeup), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 1, 64, A|F|R },
86			{ "knee", "set knee", OFFSET(knee), AV_OPT_TYPE_DOUBLE, {.dbl=2.82843}, 1, 8, A|F|R },
87			{ "link", "set link type", OFFSET(link), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, A|F|R, .unit = "link" },
88			{ "average", 0, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, A|F|R, .unit = "link" },
89			{ "maximum", 0, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, A|F|R, .unit = "link" },
90			{ "detection", "set detection", OFFSET(detection), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, A|F|R, .unit = "detection" },
91			{ "peak", 0, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, A|F|R, .unit = "detection" },
92			{ "rms", 0, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, A|F|R, .unit = "detection" },
93			{ "level_sc", "set sidechain gain", OFFSET(level_sc), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0.015625, 64, A|F|R },
94			{ "mix", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, A|F|R },
95			{ NULL }
96			};
97
98			AVFILTER_DEFINE_CLASS_EXT(sidechaincompress_acompressor,
99			"acompressor/sidechaincompress",
100			options);
101
102			// A fake infinity value (because real infinity may break some hosts)
103			#define FAKE_INFINITY (65536.0 * 65536.0)
104
105			// Check for infinity (with appropriate-ish tolerance)
106			#define IS_FAKE_INFINITY(value) (fabs(value-FAKE_INFINITY) < 1.0)
107
108		✗	static double output_gain(double lin_slope, double ratio, double thres,
109			double knee, double knee_start, double knee_stop,
110			double compressed_knee_start,
111			double compressed_knee_stop,
112			int detection, int mode)
113			{
114		✗	double slope = log(lin_slope);
115		✗	double gain = 0.0;
116		✗	double delta = 0.0;
117
118		✗	if (detection)
119		✗	slope *= 0.5;
120
121		✗	if (IS_FAKE_INFINITY(ratio)) {
122		✗	gain = thres;
123		✗	delta = 0.0;
124			} else {
125		✗	gain = (slope - thres) / ratio + thres;
126		✗	delta = 1.0 / ratio;
127			}
128
129		✗	if (mode) {
130		✗	if (knee > 1.0 && slope > knee_start)
131		✗	gain = hermite_interpolation(slope, knee_stop, knee_start,
132			knee_stop, compressed_knee_start,
133			1.0, delta);
134			} else {
135		✗	if (knee > 1.0 && slope < knee_stop)
136		✗	gain = hermite_interpolation(slope, knee_start, knee_stop,
137			knee_start, compressed_knee_stop,
138			1.0, delta);
139			}
140
141		✗	return exp(gain - slope);
142			}
143
144		✗	static int compressor_config_output(AVFilterLink *outlink)
145			{
146		✗	AVFilterContext *ctx = outlink->src;
147		✗	SidechainCompressContext *s = ctx->priv;
148
149		✗	s->thres = log(s->threshold);
150		✗	s->lin_knee_start = s->threshold / sqrt(s->knee);
151		✗	s->lin_knee_stop = s->threshold * sqrt(s->knee);
152		✗	s->adj_knee_start = s->lin_knee_start * s->lin_knee_start;
153		✗	s->adj_knee_stop = s->lin_knee_stop * s->lin_knee_stop;
154		✗	s->knee_start = log(s->lin_knee_start);
155		✗	s->knee_stop = log(s->lin_knee_stop);
156		✗	s->compressed_knee_start = (s->knee_start - s->thres) / s->ratio + s->thres;
157		✗	s->compressed_knee_stop = (s->knee_stop - s->thres) / s->ratio + s->thres;
158
159		✗	s->attack_coeff = FFMIN(1., 1. / (s->attack * outlink->sample_rate / 4000.));
160		✗	s->release_coeff = FFMIN(1., 1. / (s->release * outlink->sample_rate / 4000.));
161
162		✗	return 0;
163			}
164
165		✗	static void compressor(SidechainCompressContext *s,
166			const double *src, double *dst, const double *scsrc, int nb_samples,
167			double level_in, double level_sc,
168			AVFilterLink *inlink, AVFilterLink *sclink)
169			{
170		✗	const double makeup = s->makeup;
171		✗	const double mix = s->mix;
172			int i, c;
173
174		✗	for (i = 0; i < nb_samples; i++) {
175		✗	double abs_sample, gain = 1.0;
176			double detector;
177			int detected;
178
179		✗	abs_sample = fabs(scsrc[0] * level_sc);
180
181		✗	if (s->link == 1) {
182		✗	for (c = 1; c < sclink->ch_layout.nb_channels; c++)
183		✗	abs_sample = FFMAX(fabs(scsrc[c] * level_sc), abs_sample);
184			} else {
185		✗	for (c = 1; c < sclink->ch_layout.nb_channels; c++)
186		✗	abs_sample += fabs(scsrc[c] * level_sc);
187
188		✗	abs_sample /= sclink->ch_layout.nb_channels;
189			}
190
191		✗	if (s->detection)
192		✗	abs_sample *= abs_sample;
193
194		✗	s->lin_slope += (abs_sample - s->lin_slope) * (abs_sample > s->lin_slope ? s->attack_coeff : s->release_coeff);
195
196		✗	if (s->mode) {
197		✗	detector = (s->detection ? s->adj_knee_stop : s->lin_knee_stop);
198		✗	detected = s->lin_slope < detector;
199			} else {
200		✗	detector = (s->detection ? s->adj_knee_start : s->lin_knee_start);
201		✗	detected = s->lin_slope > detector;
202			}
203
204		✗	if (s->lin_slope > 0.0 && detected)
205		✗	gain = output_gain(s->lin_slope, s->ratio, s->thres, s->knee,
206			s->knee_start, s->knee_stop,
207			s->compressed_knee_start,
208			s->compressed_knee_stop,
209			s->detection, s->mode);
210
211		✗	for (c = 0; c < inlink->ch_layout.nb_channels; c++)
212		✗	dst[c] = src[c] * level_in * (gain * makeup * mix + (1. - mix));
213
214		✗	src += inlink->ch_layout.nb_channels;
215		✗	dst += inlink->ch_layout.nb_channels;
216		✗	scsrc += sclink->ch_layout.nb_channels;
217			}
218		✗	}
219
220		✗	static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
221			char *res, int res_len, int flags)
222			{
223			int ret;
224
225		✗	ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
226		✗	if (ret < 0)
227		✗	return ret;
228
229		✗	compressor_config_output(ctx->outputs[0]);
230
231		✗	return 0;
232			}
233
234			#if CONFIG_SIDECHAINCOMPRESS_FILTER
235		✗	static int activate(AVFilterContext *ctx)
236			{
237		✗	SidechainCompressContext *s = ctx->priv;
238		✗	AVFrame *out = NULL, *in[2] = { NULL };
239			int ret, i, nb_samples;
240			double *dst;
241
242		✗	FF_FILTER_FORWARD_STATUS_BACK_ALL(ctx->outputs[0], ctx);
243		✗	if ((ret = ff_inlink_consume_frame(ctx->inputs[0], &in[0])) > 0) {
244		✗	av_audio_fifo_write(s->fifo[0], (void **)in[0]->extended_data,
245		✗	in[0]->nb_samples);
246		✗	av_frame_free(&in[0]);
247			}
248		✗	if (ret < 0)
249		✗	return ret;
250		✗	if ((ret = ff_inlink_consume_frame(ctx->inputs[1], &in[1])) > 0) {
251		✗	av_audio_fifo_write(s->fifo[1], (void **)in[1]->extended_data,
252		✗	in[1]->nb_samples);
253		✗	av_frame_free(&in[1]);
254			}
255		✗	if (ret < 0)
256		✗	return ret;
257
258		✗	nb_samples = FFMIN(av_audio_fifo_size(s->fifo[0]), av_audio_fifo_size(s->fifo[1]));
259		✗	if (nb_samples) {
260		✗	out = ff_get_audio_buffer(ctx->outputs[0], nb_samples);
261		✗	if (!out)
262		✗	return AVERROR(ENOMEM);
263		✗	for (i = 0; i < 2; i++) {
264		✗	in[i] = ff_get_audio_buffer(ctx->inputs[i], nb_samples);
265		✗	if (!in[i]) {
266		✗	av_frame_free(&in[0]);
267		✗	av_frame_free(&in[1]);
268		✗	av_frame_free(&out);
269		✗	return AVERROR(ENOMEM);
270			}
271		✗	av_audio_fifo_read(s->fifo[i], (void **)in[i]->data, nb_samples);
272			}
273
274		✗	dst = (double *)out->data[0];
275		✗	out->pts = s->pts;
276		✗	s->pts += av_rescale_q(nb_samples, (AVRational){1, ctx->outputs[0]->sample_rate}, ctx->outputs[0]->time_base);
277
278		✗	compressor(s, (double *)in[0]->data[0], dst,
279		✗	(double *)in[1]->data[0], nb_samples,
280			s->level_in, s->level_sc,
281		✗	ctx->inputs[0], ctx->inputs[1]);
282
283		✗	av_frame_free(&in[0]);
284		✗	av_frame_free(&in[1]);
285
286		✗	ret = ff_filter_frame(ctx->outputs[0], out);
287		✗	if (ret < 0)
288		✗	return ret;
289			}
290		✗	FF_FILTER_FORWARD_STATUS(ctx->inputs[0], ctx->outputs[0]);
291		✗	FF_FILTER_FORWARD_STATUS(ctx->inputs[1], ctx->outputs[0]);
292		✗	if (ff_outlink_frame_wanted(ctx->outputs[0])) {
293		✗	if (!av_audio_fifo_size(s->fifo[0]))
294		✗	ff_inlink_request_frame(ctx->inputs[0]);
295		✗	if (!av_audio_fifo_size(s->fifo[1]))
296		✗	ff_inlink_request_frame(ctx->inputs[1]);
297			}
298		✗	return 0;
299			}
300
301		✗	static int query_formats(AVFilterContext *ctx)
302			{
303			static const enum AVSampleFormat sample_fmts[] = {
304			AV_SAMPLE_FMT_DBL,
305			AV_SAMPLE_FMT_NONE
306			};
307		✗	int ret = ff_channel_layouts_ref(ff_all_channel_counts(),
308		✗	&ctx->inputs[1]->outcfg.channel_layouts);
309		✗	if (ret < 0)
310		✗	return ret;
311
312			/* This will link the channel properties of the main input and the output;
313			* it won't touch the second input as its channel_layouts is already set. */
314		✗	if ((ret = ff_set_common_all_channel_counts(ctx)) < 0)
315		✗	return ret;
316
317		✗	if ((ret = ff_set_common_formats_from_list(ctx, sample_fmts)) < 0)
318		✗	return ret;
319
320		✗	return ff_set_common_all_samplerates(ctx);
321			}
322
323		✗	static int config_output(AVFilterLink *outlink)
324			{
325		✗	AVFilterContext *ctx = outlink->src;
326		✗	SidechainCompressContext *s = ctx->priv;
327
328		✗	outlink->time_base = ctx->inputs[0]->time_base;
329
330		✗	s->fifo[0] = av_audio_fifo_alloc(ctx->inputs[0]->format, ctx->inputs[0]->ch_layout.nb_channels, 1024);
331		✗	s->fifo[1] = av_audio_fifo_alloc(ctx->inputs[1]->format, ctx->inputs[1]->ch_layout.nb_channels, 1024);
332		✗	if (!s->fifo[0] || !s->fifo[1])
333		✗	return AVERROR(ENOMEM);
334
335		✗	compressor_config_output(outlink);
336
337		✗	return 0;
338			}
339
340		✗	static av_cold void uninit(AVFilterContext *ctx)
341			{
342		✗	SidechainCompressContext *s = ctx->priv;
343
344		✗	av_audio_fifo_free(s->fifo[0]);
345		✗	av_audio_fifo_free(s->fifo[1]);
346		✗	}
347
348			static const AVFilterPad sidechaincompress_inputs[] = {
349			{
350			.name = "main",
351			.type = AVMEDIA_TYPE_AUDIO,
352			},{
353			.name = "sidechain",
354			.type = AVMEDIA_TYPE_AUDIO,
355			},
356			};
357
358			static const AVFilterPad sidechaincompress_outputs[] = {
359			{
360			.name = "default",
361			.type = AVMEDIA_TYPE_AUDIO,
362			.config_props = config_output,
363			},
364			};
365
366			const AVFilter ff_af_sidechaincompress = {
367			.name = "sidechaincompress",
368			.description = NULL_IF_CONFIG_SMALL("Sidechain compressor."),
369			.priv_class = &sidechaincompress_acompressor_class,
370			.priv_size = sizeof(SidechainCompressContext),
371			.activate = activate,
372			.uninit = uninit,
373			FILTER_INPUTS(sidechaincompress_inputs),
374			FILTER_OUTPUTS(sidechaincompress_outputs),
375			FILTER_QUERY_FUNC(query_formats),
376			.process_command = process_command,
377			};
378			#endif /* CONFIG_SIDECHAINCOMPRESS_FILTER */
379
380			#if CONFIG_ACOMPRESSOR_FILTER
381		✗	static int acompressor_filter_frame(AVFilterLink *inlink, AVFrame *in)
382			{
383		✗	const double *src = (const double *)in->data[0];
384		✗	AVFilterContext *ctx = inlink->dst;
385		✗	SidechainCompressContext *s = ctx->priv;
386		✗	AVFilterLink *outlink = ctx->outputs[0];
387			AVFrame *out;
388			double *dst;
389
390		✗	if (av_frame_is_writable(in)) {
391		✗	out = in;
392			} else {
393		✗	out = ff_get_audio_buffer(outlink, in->nb_samples);
394		✗	if (!out) {
395		✗	av_frame_free(&in);
396		✗	return AVERROR(ENOMEM);
397			}
398		✗	av_frame_copy_props(out, in);
399			}
400		✗	dst = (double *)out->data[0];
401
402		✗	compressor(s, src, dst, src, in->nb_samples,
403			s->level_in, s->level_in,
404			inlink, inlink);
405
406		✗	if (out != in)
407		✗	av_frame_free(&in);
408		✗	return ff_filter_frame(outlink, out);
409			}
410
411			static const AVFilterPad acompressor_inputs[] = {
412			{
413			.name = "default",
414			.type = AVMEDIA_TYPE_AUDIO,
415			.filter_frame = acompressor_filter_frame,
416			},
417			};
418
419			static const AVFilterPad acompressor_outputs[] = {
420			{
421			.name = "default",
422			.type = AVMEDIA_TYPE_AUDIO,
423			.config_props = compressor_config_output,
424			},
425			};
426
427			const AVFilter ff_af_acompressor = {
428			.name = "acompressor",
429			.description = NULL_IF_CONFIG_SMALL("Audio compressor."),
430			.priv_class = &sidechaincompress_acompressor_class,
431			.priv_size = sizeof(SidechainCompressContext),
432			FILTER_INPUTS(acompressor_inputs),
433			FILTER_OUTPUTS(acompressor_outputs),
434			FILTER_SINGLE_SAMPLEFMT(AV_SAMPLE_FMT_DBL),
435			.process_command = process_command,
436			};
437			#endif /* CONFIG_ACOMPRESSOR_FILTER */
438