FFmpeg coverage

Line	Branch	Exec	Source
1			/*
2			* Copyright (c) 2019 The FFmpeg Project
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			#include "libavutil/avassert.h"
22			#include "libavutil/channel_layout.h"
23			#include "libavutil/opt.h"
24			#include "avfilter.h"
25			#include "audio.h"
26
27			#define MAX_OVERSAMPLE 64
28
29			enum ASoftClipTypes {
30			ASC_HARD = -1,
31			ASC_TANH,
32			ASC_ATAN,
33			ASC_CUBIC,
34			ASC_EXP,
35			ASC_ALG,
36			ASC_QUINTIC,
37			ASC_SIN,
38			ASC_ERF,
39			NB_TYPES,
40			};
41
42			typedef struct Lowpass {
43			float fb0, fb1, fb2;
44			float fa0, fa1, fa2;
45
46			double db0, db1, db2;
47			double da0, da1, da2;
48			} Lowpass;
49
50			typedef struct ASoftClipContext {
51			const AVClass *class;
52
53			int type;
54			int oversample;
55			int64_t delay;
56			double threshold;
57			double output;
58			double param;
59
60			Lowpass lowpass[MAX_OVERSAMPLE];
61			AVFrame *frame[2];
62
63			void (*filter)(struct ASoftClipContext *s, void **dst, const void **src,
64			int nb_samples, int channels, int start, int end);
65			} ASoftClipContext;
66
67			#define OFFSET(x) offsetof(ASoftClipContext, x)
68			#define A AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
69
70			static const AVOption asoftclip_options[] = {
71			{ "type", "set softclip type", OFFSET(type), AV_OPT_TYPE_INT, {.i64=0}, -1, NB_TYPES-1, A, "types" },
72			{ "hard", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_HARD}, 0, 0, A, "types" },
73			{ "tanh", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_TANH}, 0, 0, A, "types" },
74			{ "atan", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_ATAN}, 0, 0, A, "types" },
75			{ "cubic", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_CUBIC}, 0, 0, A, "types" },
76			{ "exp", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_EXP}, 0, 0, A, "types" },
77			{ "alg", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_ALG}, 0, 0, A, "types" },
78			{ "quintic", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_QUINTIC},0, 0, A, "types" },
79			{ "sin", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_SIN}, 0, 0, A, "types" },
80			{ "erf", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_ERF}, 0, 0, A, "types" },
81			{ "threshold", "set softclip threshold", OFFSET(threshold), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0.000001, 1, A },
82			{ "output", "set softclip output gain", OFFSET(output), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0.000001, 16, A },
83			{ "param", "set softclip parameter", OFFSET(param), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0.01, 3, A },
84			{ "oversample", "set oversample factor", OFFSET(oversample), AV_OPT_TYPE_INT, {.i64=1}, 1, MAX_OVERSAMPLE, A },
85			{ NULL }
86			};
87
88			AVFILTER_DEFINE_CLASS(asoftclip);
89
90		✗	static void get_lowpass(Lowpass *s,
91			double frequency,
92			double sample_rate)
93			{
94		✗	double w0 = 2 * M_PI * frequency / sample_rate;
95		✗	double alpha = sin(w0) / (2 * 0.8);
96			double factor;
97
98		✗	s->da0 = 1 + alpha;
99		✗	s->da1 = -2 * cos(w0);
100		✗	s->da2 = 1 - alpha;
101		✗	s->db0 = (1 - cos(w0)) / 2;
102		✗	s->db1 = 1 - cos(w0);
103		✗	s->db2 = (1 - cos(w0)) / 2;
104
105		✗	s->da1 /= s->da0;
106		✗	s->da2 /= s->da0;
107		✗	s->db0 /= s->da0;
108		✗	s->db1 /= s->da0;
109		✗	s->db2 /= s->da0;
110		✗	s->da0 /= s->da0;
111
112		✗	factor = (s->da0 + s->da1 + s->da2) / (s->db0 + s->db1 + s->db2);
113		✗	s->db0 *= factor;
114		✗	s->db1 *= factor;
115		✗	s->db2 *= factor;
116
117		✗	s->fa0 = s->da0;
118		✗	s->fa1 = s->da1;
119		✗	s->fa2 = s->da2;
120		✗	s->fb0 = s->db0;
121		✗	s->fb1 = s->db1;
122		✗	s->fb2 = s->db2;
123		✗	}
124
125		✗	static inline float run_lowpassf(const Lowpass *const s,
126			float src, float *w)
127			{
128			float dst;
129
130		✗	dst = src * s->fb0 + w[0];
131		✗	w[0] = s->fb1 * src + w[1] - s->fa1 * dst;
132		✗	w[1] = s->fb2 * src - s->fa2 * dst;
133
134		✗	return dst;
135			}
136
137		✗	static void filter_flt(ASoftClipContext *s,
138			void **dptr, const void **sptr,
139			int nb_samples, int channels,
140			int start, int end)
141			{
142		✗	const int oversample = s->oversample;
143		✗	const int nb_osamples = nb_samples * oversample;
144		✗	const float scale = oversample > 1 ? oversample * 0.5f : 1.f;
145		✗	float threshold = s->threshold;
146		✗	float gain = s->output * threshold;
147		✗	float factor = 1.f / threshold;
148		✗	float param = s->param;
149
150		✗	for (int c = start; c < end; c++) {
151		✗	float *w = (float *)(s->frame[0]->extended_data[c]) + 2 * (oversample - 1);
152		✗	const float *src = sptr[c];
153		✗	float *dst = dptr[c];
154
155		✗	for (int n = 0; n < nb_samples; n++) {
156		✗	dst[oversample * n] = src[n];
157
158		✗	for (int m = 1; m < oversample; m++)
159		✗	dst[oversample * n + m] = 0.f;
160			}
161
162		✗	for (int n = 0; n < nb_osamples && oversample > 1; n++)
163		✗	dst[n] = run_lowpassf(&s->lowpass[oversample - 1], dst[n], w);
164
165		✗	switch (s->type) {
166		✗	case ASC_HARD:
167		✗	for (int n = 0; n < nb_osamples; n++) {
168		✗	dst[n] = av_clipf(dst[n] * factor, -1.f, 1.f);
169		✗	dst[n] *= gain;
170			}
171		✗	break;
172		✗	case ASC_TANH:
173		✗	for (int n = 0; n < nb_osamples; n++) {
174		✗	dst[n] = tanhf(dst[n] * factor * param);
175		✗	dst[n] *= gain;
176			}
177		✗	break;
178		✗	case ASC_ATAN:
179		✗	for (int n = 0; n < nb_osamples; n++) {
180		✗	dst[n] = 2.f / M_PI * atanf(dst[n] * factor * param);
181		✗	dst[n] *= gain;
182			}
183		✗	break;
184		✗	case ASC_CUBIC:
185		✗	for (int n = 0; n < nb_osamples; n++) {
186		✗	float sample = dst[n] * factor;
187
188		✗	if (FFABS(sample) >= 1.5f)
189		✗	dst[n] = FFSIGN(sample);
190			else
191		✗	dst[n] = sample - 0.1481f * powf(sample, 3.f);
192		✗	dst[n] *= gain;
193			}
194		✗	break;
195		✗	case ASC_EXP:
196		✗	for (int n = 0; n < nb_osamples; n++) {
197		✗	dst[n] = 2.f / (1.f + expf(-2.f * dst[n] * factor)) - 1.;
198		✗	dst[n] *= gain;
199			}
200		✗	break;
201		✗	case ASC_ALG:
202		✗	for (int n = 0; n < nb_osamples; n++) {
203		✗	float sample = dst[n] * factor;
204
205		✗	dst[n] = sample / (sqrtf(param + sample * sample));
206		✗	dst[n] *= gain;
207			}
208		✗	break;
209		✗	case ASC_QUINTIC:
210		✗	for (int n = 0; n < nb_osamples; n++) {
211		✗	float sample = dst[n] * factor;
212
213		✗	if (FFABS(sample) >= 1.25)
214		✗	dst[n] = FFSIGN(sample);
215			else
216		✗	dst[n] = sample - 0.08192f * powf(sample, 5.f);
217		✗	dst[n] *= gain;
218			}
219		✗	break;
220		✗	case ASC_SIN:
221		✗	for (int n = 0; n < nb_osamples; n++) {
222		✗	float sample = dst[n] * factor;
223
224		✗	if (FFABS(sample) >= M_PI_2)
225		✗	dst[n] = FFSIGN(sample);
226			else
227		✗	dst[n] = sinf(sample);
228		✗	dst[n] *= gain;
229			}
230		✗	break;
231		✗	case ASC_ERF:
232		✗	for (int n = 0; n < nb_osamples; n++) {
233		✗	dst[n] = erff(dst[n] * factor);
234		✗	dst[n] *= gain;
235			}
236		✗	break;
237		✗	default:
238		✗	av_assert0(0);
239			}
240
241		✗	w = (float *)(s->frame[1]->extended_data[c]) + 2 * (oversample - 1);
242		✗	for (int n = 0; n < nb_osamples && oversample > 1; n++)
243		✗	dst[n] = run_lowpassf(&s->lowpass[oversample - 1], dst[n], w);
244
245		✗	for (int n = 0; n < nb_samples; n++)
246		✗	dst[n] = dst[n * oversample] * scale;
247			}
248		✗	}
249
250		✗	static inline double run_lowpassd(const Lowpass *const s,
251			double src, double *w)
252			{
253			double dst;
254
255		✗	dst = src * s->db0 + w[0];
256		✗	w[0] = s->db1 * src + w[1] - s->da1 * dst;
257		✗	w[1] = s->db2 * src - s->da2 * dst;
258
259		✗	return dst;
260			}
261
262		✗	static void filter_dbl(ASoftClipContext *s,
263			void **dptr, const void **sptr,
264			int nb_samples, int channels,
265			int start, int end)
266			{
267		✗	const int oversample = s->oversample;
268		✗	const int nb_osamples = nb_samples * oversample;
269		✗	const double scale = oversample > 1 ? oversample * 0.5 : 1.;
270		✗	double threshold = s->threshold;
271		✗	double gain = s->output * threshold;
272		✗	double factor = 1. / threshold;
273		✗	double param = s->param;
274
275		✗	for (int c = start; c < end; c++) {
276		✗	double *w = (double *)(s->frame[0]->extended_data[c]) + 2 * (oversample - 1);
277		✗	const double *src = sptr[c];
278		✗	double *dst = dptr[c];
279
280		✗	for (int n = 0; n < nb_samples; n++) {
281		✗	dst[oversample * n] = src[n];
282
283		✗	for (int m = 1; m < oversample; m++)
284		✗	dst[oversample * n + m] = 0.f;
285			}
286
287		✗	for (int n = 0; n < nb_osamples && oversample > 1; n++)
288		✗	dst[n] = run_lowpassd(&s->lowpass[oversample - 1], dst[n], w);
289
290		✗	switch (s->type) {
291		✗	case ASC_HARD:
292		✗	for (int n = 0; n < nb_osamples; n++) {
293		✗	dst[n] = av_clipd(dst[n] * factor, -1., 1.);
294		✗	dst[n] *= gain;
295			}
296		✗	break;
297		✗	case ASC_TANH:
298		✗	for (int n = 0; n < nb_osamples; n++) {
299		✗	dst[n] = tanh(dst[n] * factor * param);
300		✗	dst[n] *= gain;
301			}
302		✗	break;
303		✗	case ASC_ATAN:
304		✗	for (int n = 0; n < nb_osamples; n++) {
305		✗	dst[n] = 2. / M_PI * atan(dst[n] * factor * param);
306		✗	dst[n] *= gain;
307			}
308		✗	break;
309		✗	case ASC_CUBIC:
310		✗	for (int n = 0; n < nb_osamples; n++) {
311		✗	double sample = dst[n] * factor;
312
313		✗	if (FFABS(sample) >= 1.5)
314		✗	dst[n] = FFSIGN(sample);
315			else
316		✗	dst[n] = sample - 0.1481 * pow(sample, 3.);
317		✗	dst[n] *= gain;
318			}
319		✗	break;
320		✗	case ASC_EXP:
321		✗	for (int n = 0; n < nb_osamples; n++) {
322		✗	dst[n] = 2. / (1. + exp(-2. * dst[n] * factor)) - 1.;
323		✗	dst[n] *= gain;
324			}
325		✗	break;
326		✗	case ASC_ALG:
327		✗	for (int n = 0; n < nb_osamples; n++) {
328		✗	double sample = dst[n] * factor;
329
330		✗	dst[n] = sample / (sqrt(param + sample * sample));
331		✗	dst[n] *= gain;
332			}
333		✗	break;
334		✗	case ASC_QUINTIC:
335		✗	for (int n = 0; n < nb_osamples; n++) {
336		✗	double sample = dst[n] * factor;
337
338		✗	if (FFABS(sample) >= 1.25)
339		✗	dst[n] = FFSIGN(sample);
340			else
341		✗	dst[n] = sample - 0.08192 * pow(sample, 5.);
342		✗	dst[n] *= gain;
343			}
344		✗	break;
345		✗	case ASC_SIN:
346		✗	for (int n = 0; n < nb_osamples; n++) {
347		✗	double sample = dst[n] * factor;
348
349		✗	if (FFABS(sample) >= M_PI_2)
350		✗	dst[n] = FFSIGN(sample);
351			else
352		✗	dst[n] = sin(sample);
353		✗	dst[n] *= gain;
354			}
355		✗	break;
356		✗	case ASC_ERF:
357		✗	for (int n = 0; n < nb_osamples; n++) {
358		✗	dst[n] = erf(dst[n] * factor);
359		✗	dst[n] *= gain;
360			}
361		✗	break;
362		✗	default:
363		✗	av_assert0(0);
364			}
365
366		✗	w = (double *)(s->frame[1]->extended_data[c]) + 2 * (oversample - 1);
367		✗	for (int n = 0; n < nb_osamples && oversample > 1; n++)
368		✗	dst[n] = run_lowpassd(&s->lowpass[oversample - 1], dst[n], w);
369
370		✗	for (int n = 0; n < nb_samples; n++)
371		✗	dst[n] = dst[n * oversample] * scale;
372			}
373		✗	}
374
375		✗	static int config_input(AVFilterLink *inlink)
376			{
377		✗	AVFilterContext *ctx = inlink->dst;
378		✗	ASoftClipContext *s = ctx->priv;
379
380		✗	switch (inlink->format) {
381		✗	case AV_SAMPLE_FMT_FLTP: s->filter = filter_flt; break;
382		✗	case AV_SAMPLE_FMT_DBLP: s->filter = filter_dbl; break;
383		✗	default: av_assert0(0);
384			}
385
386		✗	s->frame[0] = ff_get_audio_buffer(inlink, 2 * MAX_OVERSAMPLE);
387		✗	s->frame[1] = ff_get_audio_buffer(inlink, 2 * MAX_OVERSAMPLE);
388		✗	if (!s->frame[0] || !s->frame[1])
389		✗	return AVERROR(ENOMEM);
390
391		✗	for (int i = 0; i < MAX_OVERSAMPLE; i++) {
392		✗	get_lowpass(&s->lowpass[i], inlink->sample_rate / 2, inlink->sample_rate * (i + 1));
393			}
394
395		✗	return 0;
396			}
397
398			typedef struct ThreadData {
399			AVFrame *in, *out;
400			int nb_samples;
401			int channels;
402			} ThreadData;
403
404		✗	static int filter_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
405			{
406		✗	ASoftClipContext *s = ctx->priv;
407		✗	ThreadData *td = arg;
408		✗	AVFrame *out = td->out;
409		✗	AVFrame *in = td->in;
410		✗	const int channels = td->channels;
411		✗	const int nb_samples = td->nb_samples;
412		✗	const int start = (channels * jobnr) / nb_jobs;
413		✗	const int end = (channels * (jobnr+1)) / nb_jobs;
414
415		✗	s->filter(s, (void **)out->extended_data, (const void **)in->extended_data,
416			nb_samples, channels, start, end);
417
418		✗	return 0;
419			}
420
421		✗	static int filter_frame(AVFilterLink *inlink, AVFrame *in)
422			{
423		✗	AVFilterContext *ctx = inlink->dst;
424		✗	ASoftClipContext *s = ctx->priv;
425		✗	AVFilterLink *outlink = ctx->outputs[0];
426			int nb_samples, channels;
427			ThreadData td;
428			AVFrame *out;
429
430		✗	if (av_frame_is_writable(in) && s->oversample == 1) {
431		✗	out = in;
432			} else {
433		✗	out = ff_get_audio_buffer(outlink, in->nb_samples * s->oversample);
434		✗	if (!out) {
435		✗	av_frame_free(&in);
436		✗	return AVERROR(ENOMEM);
437			}
438		✗	av_frame_copy_props(out, in);
439			}
440
441		✗	nb_samples = in->nb_samples;
442		✗	channels = in->ch_layout.nb_channels;
443
444		✗	td.in = in;
445		✗	td.out = out;
446		✗	td.nb_samples = nb_samples;
447		✗	td.channels = channels;
448		✗	ff_filter_execute(ctx, filter_channels, &td, NULL,
449		✗	FFMIN(channels, ff_filter_get_nb_threads(ctx)));
450
451		✗	if (out != in)
452		✗	av_frame_free(&in);
453
454		✗	out->nb_samples /= s->oversample;
455		✗	return ff_filter_frame(outlink, out);
456			}
457
458		✗	static av_cold void uninit(AVFilterContext *ctx)
459			{
460		✗	ASoftClipContext *s = ctx->priv;
461
462		✗	av_frame_free(&s->frame[0]);
463		✗	av_frame_free(&s->frame[1]);
464		✗	}
465
466			static const AVFilterPad inputs[] = {
467			{
468			.name = "default",
469			.type = AVMEDIA_TYPE_AUDIO,
470			.filter_frame = filter_frame,
471			.config_props = config_input,
472			},
473			};
474
475			const AVFilter ff_af_asoftclip = {
476			.name = "asoftclip",
477			.description = NULL_IF_CONFIG_SMALL("Audio Soft Clipper."),
478			.priv_size = sizeof(ASoftClipContext),
479			.priv_class = &asoftclip_class,
480			FILTER_INPUTS(inputs),
481			FILTER_OUTPUTS(ff_audio_default_filterpad),
482			FILTER_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_DBLP),
483			.uninit = uninit,
484			.process_command = ff_filter_process_command,
485			.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC |
486			AVFILTER_FLAG_SLICE_THREADS,
487			};
488