FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavfilter/af_asoftclip.c
Date: 2024-07-24 19:24:46
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