FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavfilter/af_asoftclip.c
Date: 2024-04-23 16:28:37
Exec Total Coverage
Lines: 0 253 0.0%
Functions: 0 9 0.0%
Branches: 0 135 0.0%
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, .unit = "types" },
72 { "hard", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_HARD}, 0, 0, A, .unit = "types" },
73 { "tanh", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_TANH}, 0, 0, A, .unit = "types" },
74 { "atan", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_ATAN}, 0, 0, A, .unit = "types" },
75 { "cubic", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_CUBIC}, 0, 0, A, .unit = "types" },
76 { "exp", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_EXP}, 0, 0, A, .unit = "types" },
77 { "alg", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_ALG}, 0, 0, A, .unit = "types" },
78 { "quintic", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_QUINTIC},0, 0, A, .unit = "types" },
79 { "sin", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_SIN}, 0, 0, A, .unit = "types" },
80 { "erf", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_ERF}, 0, 0, A, .unit = "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