FFmpeg
af_asoftclip.c
Go to the documentation of this file.
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 #include "formats.h"
27 
28 #define MAX_OVERSAMPLE 64
29 
30 enum ASoftClipTypes {
31  ASC_HARD = -1,
32  ASC_TANH,
33  ASC_ATAN,
34  ASC_CUBIC,
35  ASC_EXP,
36  ASC_ALG,
37  ASC_QUINTIC,
38  ASC_SIN,
39  ASC_ERF,
40  NB_TYPES,
41 };
42 
43 typedef struct Lowpass {
44  float fb0, fb1, fb2;
45  float fa0, fa1, fa2;
46 
47  double db0, db1, db2;
48  double da0, da1, da2;
49 } Lowpass;
50 
51 typedef struct ASoftClipContext {
52  const AVClass *class;
53 
54  int type;
55  int oversample;
56  int64_t delay;
57  double threshold;
58  double output;
59  double param;
60 
61  Lowpass lowpass[MAX_OVERSAMPLE];
62  AVFrame *frame[2];
63 
64  void (*filter)(struct ASoftClipContext *s, void **dst, const void **src,
65  int nb_samples, int channels, int start, int end);
66 } ASoftClipContext;
67 
68 #define OFFSET(x) offsetof(ASoftClipContext, x)
69 #define A AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
70 
71 static const AVOption asoftclip_options[] = {
72  { "type", "set softclip type", OFFSET(type), AV_OPT_TYPE_INT, {.i64=0}, -1, NB_TYPES-1, A, "types" },
73  { "hard", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_HARD}, 0, 0, A, "types" },
74  { "tanh", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_TANH}, 0, 0, A, "types" },
75  { "atan", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_ATAN}, 0, 0, A, "types" },
76  { "cubic", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_CUBIC}, 0, 0, A, "types" },
77  { "exp", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_EXP}, 0, 0, A, "types" },
78  { "alg", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_ALG}, 0, 0, A, "types" },
79  { "quintic", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_QUINTIC},0, 0, A, "types" },
80  { "sin", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_SIN}, 0, 0, A, "types" },
81  { "erf", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ASC_ERF}, 0, 0, A, "types" },
82  { "threshold", "set softclip threshold", OFFSET(threshold), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0.000001, 1, A },
83  { "output", "set softclip output gain", OFFSET(output), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0.000001, 16, A },
84  { "param", "set softclip parameter", OFFSET(param), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0.01, 3, A },
85  { "oversample", "set oversample factor", OFFSET(oversample), AV_OPT_TYPE_INT, {.i64=1}, 1, MAX_OVERSAMPLE, A },
86  { NULL }
87 };
88 
89 AVFILTER_DEFINE_CLASS(asoftclip);
90 
91 static void get_lowpass(Lowpass *s,
92  double frequency,
93  double sample_rate)
94 {
95  double w0 = 2 * M_PI * frequency / sample_rate;
96  double alpha = sin(w0) / (2 * 0.8);
97  double factor;
98 
99  s->da0 = 1 + alpha;
100  s->da1 = -2 * cos(w0);
101  s->da2 = 1 - alpha;
102  s->db0 = (1 - cos(w0)) / 2;
103  s->db1 = 1 - cos(w0);
104  s->db2 = (1 - cos(w0)) / 2;
105 
106  s->da1 /= s->da0;
107  s->da2 /= s->da0;
108  s->db0 /= s->da0;
109  s->db1 /= s->da0;
110  s->db2 /= s->da0;
111  s->da0 /= s->da0;
112 
113  factor = (s->da0 + s->da1 + s->da2) / (s->db0 + s->db1 + s->db2);
114  s->db0 *= factor;
115  s->db1 *= factor;
116  s->db2 *= factor;
117 
118  s->fa0 = s->da0;
119  s->fa1 = s->da1;
120  s->fa2 = s->da2;
121  s->fb0 = s->db0;
122  s->fb1 = s->db1;
123  s->fb2 = s->db2;
124 }
125 
126 static inline float run_lowpassf(const Lowpass *const s,
127  float src, float *w)
128 {
129  float dst;
130 
131  dst = src * s->fb0 + w[0];
132  w[0] = s->fb1 * src + w[1] - s->fa1 * dst;
133  w[1] = s->fb2 * src - s->fa2 * dst;
134 
135  return dst;
136 }
137 
138 static void filter_flt(ASoftClipContext *s,
139  void **dptr, const void **sptr,
140  int nb_samples, int channels,
141  int start, int end)
142 {
143  const int oversample = s->oversample;
144  const int nb_osamples = nb_samples * oversample;
145  const float scale = oversample > 1 ? oversample * 0.5f : 1.f;
146  float threshold = s->threshold;
147  float gain = s->output * threshold;
148  float factor = 1.f / threshold;
149  float param = s->param;
150 
151  for (int c = start; c < end; c++) {
152  float *w = (float *)(s->frame[0]->extended_data[c]) + 2 * (oversample - 1);
153  const float *src = sptr[c];
154  float *dst = dptr[c];
155 
156  for (int n = 0; n < nb_samples; n++) {
157  dst[oversample * n] = src[n];
158 
159  for (int m = 1; m < oversample; m++)
160  dst[oversample * n + m] = 0.f;
161  }
162 
163  for (int n = 0; n < nb_osamples && oversample > 1; n++)
164  dst[n] = run_lowpassf(&s->lowpass[oversample - 1], dst[n], w);
165 
166  switch (s->type) {
167  case ASC_HARD:
168  for (int n = 0; n < nb_osamples; n++) {
169  dst[n] = av_clipf(dst[n] * factor, -1.f, 1.f);
170  dst[n] *= gain;
171  }
172  break;
173  case ASC_TANH:
174  for (int n = 0; n < nb_osamples; n++) {
175  dst[n] = tanhf(dst[n] * factor * param);
176  dst[n] *= gain;
177  }
178  break;
179  case ASC_ATAN:
180  for (int n = 0; n < nb_osamples; n++) {
181  dst[n] = 2.f / M_PI * atanf(dst[n] * factor * param);
182  dst[n] *= gain;
183  }
184  break;
185  case ASC_CUBIC:
186  for (int n = 0; n < nb_osamples; n++) {
187  float sample = dst[n] * factor;
188 
189  if (FFABS(sample) >= 1.5f)
190  dst[n] = FFSIGN(sample);
191  else
192  dst[n] = sample - 0.1481f * powf(sample, 3.f);
193  dst[n] *= gain;
194  }
195  break;
196  case ASC_EXP:
197  for (int n = 0; n < nb_osamples; n++) {
198  dst[n] = 2.f / (1.f + expf(-2.f * dst[n] * factor)) - 1.;
199  dst[n] *= gain;
200  }
201  break;
202  case ASC_ALG:
203  for (int n = 0; n < nb_osamples; n++) {
204  float sample = dst[n] * factor;
205 
206  dst[n] = sample / (sqrtf(param + sample * sample));
207  dst[n] *= gain;
208  }
209  break;
210  case ASC_QUINTIC:
211  for (int n = 0; n < nb_osamples; n++) {
212  float sample = dst[n] * factor;
213 
214  if (FFABS(sample) >= 1.25)
215  dst[n] = FFSIGN(sample);
216  else
217  dst[n] = sample - 0.08192f * powf(sample, 5.f);
218  dst[n] *= gain;
219  }
220  break;
221  case ASC_SIN:
222  for (int n = 0; n < nb_osamples; n++) {
223  float sample = dst[n] * factor;
224 
225  if (FFABS(sample) >= M_PI_2)
226  dst[n] = FFSIGN(sample);
227  else
228  dst[n] = sinf(sample);
229  dst[n] *= gain;
230  }
231  break;
232  case ASC_ERF:
233  for (int n = 0; n < nb_osamples; n++) {
234  dst[n] = erff(dst[n] * factor);
235  dst[n] *= gain;
236  }
237  break;
238  default:
239  av_assert0(0);
240  }
241 
242  w = (float *)(s->frame[1]->extended_data[c]) + 2 * (oversample - 1);
243  for (int n = 0; n < nb_osamples && oversample > 1; n++)
244  dst[n] = run_lowpassf(&s->lowpass[oversample - 1], dst[n], w);
245 
246  for (int n = 0; n < nb_samples; n++)
247  dst[n] = dst[n * oversample] * scale;
248  }
249 }
250 
251 static inline double run_lowpassd(const Lowpass *const s,
252  double src, double *w)
253 {
254  double dst;
255 
256  dst = src * s->db0 + w[0];
257  w[0] = s->db1 * src + w[1] - s->da1 * dst;
258  w[1] = s->db2 * src - s->da2 * dst;
259 
260  return dst;
261 }
262 
263 static void filter_dbl(ASoftClipContext *s,
264  void **dptr, const void **sptr,
265  int nb_samples, int channels,
266  int start, int end)
267 {
268  const int oversample = s->oversample;
269  const int nb_osamples = nb_samples * oversample;
270  const double scale = oversample > 1 ? oversample * 0.5 : 1.;
271  double threshold = s->threshold;
272  double gain = s->output * threshold;
273  double factor = 1. / threshold;
274  double param = s->param;
275 
276  for (int c = start; c < end; c++) {
277  double *w = (double *)(s->frame[0]->extended_data[c]) + 2 * (oversample - 1);
278  const double *src = sptr[c];
279  double *dst = dptr[c];
280 
281  for (int n = 0; n < nb_samples; n++) {
282  dst[oversample * n] = src[n];
283 
284  for (int m = 1; m < oversample; m++)
285  dst[oversample * n + m] = 0.f;
286  }
287 
288  for (int n = 0; n < nb_osamples && oversample > 1; n++)
289  dst[n] = run_lowpassd(&s->lowpass[oversample - 1], dst[n], w);
290 
291  switch (s->type) {
292  case ASC_HARD:
293  for (int n = 0; n < nb_osamples; n++) {
294  dst[n] = av_clipd(dst[n] * factor, -1., 1.);
295  dst[n] *= gain;
296  }
297  break;
298  case ASC_TANH:
299  for (int n = 0; n < nb_osamples; n++) {
300  dst[n] = tanh(dst[n] * factor * param);
301  dst[n] *= gain;
302  }
303  break;
304  case ASC_ATAN:
305  for (int n = 0; n < nb_osamples; n++) {
306  dst[n] = 2. / M_PI * atan(dst[n] * factor * param);
307  dst[n] *= gain;
308  }
309  break;
310  case ASC_CUBIC:
311  for (int n = 0; n < nb_osamples; n++) {
312  double sample = dst[n] * factor;
313 
314  if (FFABS(sample) >= 1.5)
315  dst[n] = FFSIGN(sample);
316  else
317  dst[n] = sample - 0.1481 * pow(sample, 3.);
318  dst[n] *= gain;
319  }
320  break;
321  case ASC_EXP:
322  for (int n = 0; n < nb_osamples; n++) {
323  dst[n] = 2. / (1. + exp(-2. * dst[n] * factor)) - 1.;
324  dst[n] *= gain;
325  }
326  break;
327  case ASC_ALG:
328  for (int n = 0; n < nb_osamples; n++) {
329  double sample = dst[n] * factor;
330 
331  dst[n] = sample / (sqrt(param + sample * sample));
332  dst[n] *= gain;
333  }
334  break;
335  case ASC_QUINTIC:
336  for (int n = 0; n < nb_osamples; n++) {
337  double sample = dst[n] * factor;
338 
339  if (FFABS(sample) >= 1.25)
340  dst[n] = FFSIGN(sample);
341  else
342  dst[n] = sample - 0.08192 * pow(sample, 5.);
343  dst[n] *= gain;
344  }
345  break;
346  case ASC_SIN:
347  for (int n = 0; n < nb_osamples; n++) {
348  double sample = dst[n] * factor;
349 
350  if (FFABS(sample) >= M_PI_2)
351  dst[n] = FFSIGN(sample);
352  else
353  dst[n] = sin(sample);
354  dst[n] *= gain;
355  }
356  break;
357  case ASC_ERF:
358  for (int n = 0; n < nb_osamples; n++) {
359  dst[n] = erf(dst[n] * factor);
360  dst[n] *= gain;
361  }
362  break;
363  default:
364  av_assert0(0);
365  }
366 
367  w = (double *)(s->frame[1]->extended_data[c]) + 2 * (oversample - 1);
368  for (int n = 0; n < nb_osamples && oversample > 1; n++)
369  dst[n] = run_lowpassd(&s->lowpass[oversample - 1], dst[n], w);
370 
371  for (int n = 0; n < nb_samples; n++)
372  dst[n] = dst[n * oversample] * scale;
373  }
374 }
375 
376 static int config_input(AVFilterLink *inlink)
377 {
378  AVFilterContext *ctx = inlink->dst;
379  ASoftClipContext *s = ctx->priv;
380 
381  switch (inlink->format) {
382  case AV_SAMPLE_FMT_FLTP: s->filter = filter_flt; break;
383  case AV_SAMPLE_FMT_DBLP: s->filter = filter_dbl; break;
384  default: av_assert0(0);
385  }
386 
387  s->frame[0] = ff_get_audio_buffer(inlink, 2 * MAX_OVERSAMPLE);
388  s->frame[1] = ff_get_audio_buffer(inlink, 2 * MAX_OVERSAMPLE);
389  if (!s->frame[0] || !s->frame[1])
390  return AVERROR(ENOMEM);
391 
392  for (int i = 0; i < MAX_OVERSAMPLE; i++) {
393  get_lowpass(&s->lowpass[i], inlink->sample_rate / 2, inlink->sample_rate * (i + 1));
394  }
395 
396  return 0;
397 }
398 
399 typedef struct ThreadData {
400  AVFrame *in, *out;
401  int nb_samples;
402  int channels;
403 } ThreadData;
404 
405 static int filter_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
406 {
407  ASoftClipContext *s = ctx->priv;
408  ThreadData *td = arg;
409  AVFrame *out = td->out;
410  AVFrame *in = td->in;
411  const int channels = td->channels;
412  const int nb_samples = td->nb_samples;
413  const int start = (channels * jobnr) / nb_jobs;
414  const int end = (channels * (jobnr+1)) / nb_jobs;
415 
416  s->filter(s, (void **)out->extended_data, (const void **)in->extended_data,
417  nb_samples, channels, start, end);
418 
419  return 0;
420 }
421 
422 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
423 {
424  AVFilterContext *ctx = inlink->dst;
425  ASoftClipContext *s = ctx->priv;
426  AVFilterLink *outlink = ctx->outputs[0];
427  int nb_samples, channels;
428  ThreadData td;
429  AVFrame *out;
430 
431  if (av_frame_is_writable(in) && s->oversample == 1) {
432  out = in;
433  } else {
434  out = ff_get_audio_buffer(outlink, in->nb_samples * s->oversample);
435  if (!out) {
436  av_frame_free(&in);
437  return AVERROR(ENOMEM);
438  }
439  av_frame_copy_props(out, in);
440  }
441 
442  nb_samples = in->nb_samples;
443  channels = in->ch_layout.nb_channels;
444 
445  td.in = in;
446  td.out = out;
447  td.nb_samples = nb_samples;
448  td.channels = channels;
449  ff_filter_execute(ctx, filter_channels, &td, NULL,
450  FFMIN(channels, ff_filter_get_nb_threads(ctx)));
451 
452  if (out != in)
453  av_frame_free(&in);
454 
455  out->nb_samples /= s->oversample;
456  return ff_filter_frame(outlink, out);
457 }
458 
459 static av_cold void uninit(AVFilterContext *ctx)
460 {
461  ASoftClipContext *s = ctx->priv;
462 
463  av_frame_free(&s->frame[0]);
464  av_frame_free(&s->frame[1]);
465 }
466 
467 static const AVFilterPad inputs[] = {
468  {
469  .name = "default",
470  .type = AVMEDIA_TYPE_AUDIO,
471  .filter_frame = filter_frame,
472  .config_props = config_input,
473  },
474 };
475 
476 static const AVFilterPad outputs[] = {
477  {
478  .name = "default",
479  .type = AVMEDIA_TYPE_AUDIO,
480  },
481 };
482 
483 const AVFilter ff_af_asoftclip = {
484  .name = "asoftclip",
485  .description = NULL_IF_CONFIG_SMALL("Audio Soft Clipper."),
486  .priv_size = sizeof(ASoftClipContext),
487  .priv_class = &asoftclip_class,
488  FILTER_INPUTS(inputs),
489  FILTER_OUTPUTS(outputs),
490  FILTER_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_DBLP),
491  .uninit = uninit,
492  .process_command = ff_filter_process_command,
493  .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC |
494  AVFILTER_FLAG_SLICE_THREADS,
495 };
ff_get_audio_buffer
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
Definition: audio.c:100
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
MAX_OVERSAMPLE
#define MAX_OVERSAMPLE
Definition: af_asoftclip.c:28
td
#define td
Definition: regdef.h:70
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: af_asoftclip.c:459
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
NB_TYPES
@ NB_TYPES
Definition: af_asoftclip.c:40
opt.h
ASC_EXP
@ ASC_EXP
Definition: af_asoftclip.c:35
out
FILE * out
Definition: movenc.c:54
ASoftClipContext::output
double output
Definition: af_asoftclip.c:58
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:999
output
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
Definition: filter_design.txt:225
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
config_input
static int config_input(AVFilterLink *inlink)
Definition: af_asoftclip.c:376
outputs
static const AVFilterPad outputs[]
Definition: af_asoftclip.c:476
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:116
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
w
uint8_t w
Definition: llviddspenc.c:38
M_PI_2
#define M_PI_2
Definition: mathematics.h:55
AVOption
AVOption.
Definition: opt.h:251
expf
#define expf(x)
Definition: libm.h:283
asoftclip_options
static const AVOption asoftclip_options[]
Definition: af_asoftclip.c:71
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:175
ThreadData::out
AVFrame * out
Definition: af_adeclick.c:473
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:300
ThreadData::in
AVFrame * in
Definition: af_adecorrelate.c:154
ThreadData::channels
int channels
Definition: af_asoftclip.c:402
Lowpass::db1
double db1
Definition: af_asoftclip.c:47
sample_rate
sample_rate
Definition: ffmpeg_filter.c:155
ASC_ALG
@ ASC_ALG
Definition: af_asoftclip.c:36
formats.h
run_lowpassd
static double run_lowpassd(const Lowpass *const s, double src, double *w)
Definition: af_asoftclip.c:251
Lowpass::db0
double db0
Definition: af_asoftclip.c:47
FFSIGN
#define FFSIGN(a)
Definition: common.h:65
Lowpass::fb2
float fb2
Definition: af_asoftclip.c:44
AVFrame::ch_layout
AVChannelLayout ch_layout
Channel layout of the audio data.
Definition: frame.h:709
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
ASC_TANH
@ ASC_TANH
Definition: af_asoftclip.c:32
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
OFFSET
#define OFFSET(x)
Definition: af_asoftclip.c:68
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:49
ASoftClipContext::oversample
int oversample
Definition: af_asoftclip.c:55
avassert.h
av_cold
#define av_cold
Definition: attributes.h:90
ASC_ATAN
@ ASC_ATAN
Definition: af_asoftclip.c:33
s
#define s(width, name)
Definition: cbs_vp9.c:256
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Definition: opt.h:227
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
ThreadData::nb_samples
int nb_samples
Definition: af_asoftclip.c:401
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
ctx
AVFormatContext * ctx
Definition: movenc.c:48
channels
channels
Definition: aptx.h:32
Lowpass::fb0
float fb0
Definition: af_asoftclip.c:44
ASoftClipContext
Definition: af_asoftclip.c:51
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:190
arg
const char * arg
Definition: jacosubdec.c:67
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:64
filter_dbl
static void filter_dbl(ASoftClipContext *s, void **dptr, const void **sptr, int nb_samples, int channels, int start, int end)
Definition: af_asoftclip.c:263
inputs
static const AVFilterPad inputs[]
Definition: af_asoftclip.c:467
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
ASC_CUBIC
@ ASC_CUBIC
Definition: af_asoftclip.c:34
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:603
ASoftClipContext::type
int type
Definition: af_asoftclip.c:54
ASoftClipContext::filter
void(* filter)(struct ASoftClipContext *s, void **dst, const void **src, int nb_samples, int channels, int start, int end)
Definition: af_asoftclip.c:64
A
#define A
Definition: af_asoftclip.c:69
run_lowpassf
static float run_lowpassf(const Lowpass *const s, float src, float *w)
Definition: af_asoftclip.c:126
Lowpass
Definition: af_asoftclip.c:43
sqrtf
static __device__ float sqrtf(float a)
Definition: cuda_runtime.h:184
Lowpass::fa1
float fa1
Definition: af_asoftclip.c:45
ASC_QUINTIC
@ ASC_QUINTIC
Definition: af_asoftclip.c:37
sinf
#define sinf(x)
Definition: libm.h:419
av_clipf
av_clipf
Definition: af_crystalizer.c:122
exp
int8_t exp
Definition: eval.c:72
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(asoftclip)
f
f
Definition: af_crystalizer.c:122
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
powf
#define powf(x, y)
Definition: libm.h:50
sample
#define sample
Definition: flacdsp_template.c:44
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:533
ASoftClipContext::threshold
double threshold
Definition: af_asoftclip.c:57
ff_filter_process_command
int ff_filter_process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Generic processing of user supplied commands that are set in the same way as the filter options.
Definition: avfilter.c:863
ASC_ERF
@ ASC_ERF
Definition: af_asoftclip.c:39
Lowpass::fa0
float fa0
Definition: af_asoftclip.c:45
Lowpass::fb1
float fb1
Definition: af_asoftclip.c:44
ASC_SIN
@ ASC_SIN
Definition: af_asoftclip.c:38
M_PI
#define M_PI
Definition: mathematics.h:52
Lowpass::da1
double da1
Definition: af_asoftclip.c:48
AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
Some filters support a generic "enable" expression option that can be used to enable or disable a fil...
Definition: avfilter.h:152
ff_af_asoftclip
const AVFilter ff_af_asoftclip
Definition: af_asoftclip.c:483
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:405
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:386
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:783
atanf
#define atanf(x)
Definition: libm.h:40
ThreadData
Used for passing data between threads.
Definition: dsddec.c:68
Lowpass::db2
double db2
Definition: af_asoftclip.c:47
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
ASoftClipContext::frame
AVFrame * frame[2]
Definition: af_asoftclip.c:62
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:55
erf
static double erf(double z)
erf function Algorithm taken from the Boost project, source: http://www.boost.org/doc/libs/1_46_1/boo...
Definition: libm.h:121
AVFilter
Filter definition.
Definition: avfilter.h:171
ASoftClipTypes
ASoftClipTypes
Definition: af_asoftclip.c:30
Lowpass::fa2
float fa2
Definition: af_asoftclip.c:45
channel_layout.h
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
avfilter.h
AV_SAMPLE_FMT_DBLP
@ AV_SAMPLE_FMT_DBLP
double, planar
Definition: samplefmt.h:67
filter_flt
static void filter_flt(ASoftClipContext *s, void **dptr, const void **sptr, int nb_samples, int channels, int start, int end)
Definition: af_asoftclip.c:138
AVFilterContext
An instance of a filter.
Definition: avfilter.h:408
factor
static const int factor[16]
Definition: vf_pp7.c:76
AVFILTER_FLAG_SLICE_THREADS
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:127
audio.h
filter_channels
static int filter_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: af_asoftclip.c:405
ASoftClipContext::param
double param
Definition: af_asoftclip.c:59
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
Lowpass::da2
double da2
Definition: af_asoftclip.c:48
get_lowpass
static void get_lowpass(Lowpass *s, double frequency, double sample_rate)
Definition: af_asoftclip.c:91
ASoftClipContext::delay
int64_t delay
Definition: af_asoftclip.c:56
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:191
Lowpass::da0
double da0
Definition: af_asoftclip.c:48
ASoftClipContext::lowpass
Lowpass lowpass[MAX_OVERSAMPLE]
Definition: af_asoftclip.c:61
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
ASC_HARD
@ ASC_HARD
Definition: af_asoftclip.c:31
ff_filter_execute
static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: internal.h:142
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: af_asoftclip.c:422
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
av_clipd
av_clipd
Definition: af_crystalizer.c:132
FILTER_SAMPLEFMTS
#define FILTER_SAMPLEFMTS(...)
Definition: internal.h:178
Generated on Wed Aug 17 2022 19:21:27 for FFmpeg by   doxygen 1.8.17