FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavfilter/af_sidechaincompress.c
Date: 2022-12-05 20:26:17
Exec Total Coverage
Lines: 0 154 0.0%
Functions: 0 9 0.0%
Branches: 0 96 0.0%

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, "mode" },
79 { "downward",0, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, A|F|R, "mode" },
80 { "upward", 0, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, A|F|R, "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, "link" },
88 { "average", 0, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, A|F|R, "link" },
89 { "maximum", 0, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, A|F|R, "link" },
90 { "detection", "set detection", OFFSET(detection), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, A|F|R, "detection" },
91 { "peak", 0, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, A|F|R, "detection" },
92 { "rms", 0, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, A|F|R, "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