FFmpeg
af_asupercut.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2005 Boðaç Topaktaþ
3  * Copyright (c) 2020 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 
23 #include "libavutil/ffmath.h"
24 #include "libavutil/opt.h"
25 #include "avfilter.h"
26 #include "audio.h"
27 #include "formats.h"
28 
29 typedef struct BiquadCoeffs {
30  double a1, a2;
31  double b0, b1, b2;
32 } BiquadCoeffs;
33 
34 typedef struct ASuperCutContext {
35  const AVClass *class;
36 
37  double cutoff;
38  double level;
39  double qfactor;
40  int order;
41 
43  int bypass;
44 
46 
48 
49  int (*filter_channels)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
51 
53 {
54  static const enum AVSampleFormat sample_fmts[] = {
58  };
60  if (ret < 0)
61  return ret;
62 
64  if (ret < 0)
65  return ret;
66 
68 }
69 
70 static void calc_q_factors(int n, double *q)
71 {
72  for (int i = 0; i < n / 2; i++)
73  q[i] = 1. / (-2. * cos(M_PI * (2. * (i + 1) + n - 1.) / (2. * n)));
74 }
75 
77 {
78  ASuperCutContext *s = ctx->priv;
79  AVFilterLink *inlink = ctx->inputs[0];
80  double w0 = s->cutoff / inlink->sample_rate;
81  double K = tan(M_PI * w0);
82  double q[10];
83 
84  s->bypass = w0 >= 0.5;
85  if (s->bypass)
86  return 0;
87 
88  if (!strcmp(ctx->filter->name, "asubcut")) {
89  s->filter_count = s->order / 2 + (s->order & 1);
90 
91  calc_q_factors(s->order, q);
92 
93  if (s->order & 1) {
94  BiquadCoeffs *coeffs = &s->coeffs[0];
95  double omega = 2. * tan(M_PI * w0);
96 
97  coeffs->b0 = 2. / (2. + omega);
98  coeffs->b1 = -coeffs->b0;
99  coeffs->b2 = 0.;
100  coeffs->a1 = -(omega - 2.) / (2. + omega);
101  coeffs->a2 = 0.;
102  }
103 
104  for (int b = (s->order & 1); b < s->filter_count; b++) {
105  BiquadCoeffs *coeffs = &s->coeffs[b];
106  const int idx = b - (s->order & 1);
107  double norm = 1.0 / (1.0 + K / q[idx] + K * K);
108 
109  coeffs->b0 = norm;
110  coeffs->b1 = -2.0 * coeffs->b0;
111  coeffs->b2 = coeffs->b0;
112  coeffs->a1 = -2.0 * (K * K - 1.0) * norm;
113  coeffs->a2 = -(1.0 - K / q[idx] + K * K) * norm;
114  }
115  } else if (!strcmp(ctx->filter->name, "asupercut")) {
116  s->filter_count = s->order / 2 + (s->order & 1);
117 
118  calc_q_factors(s->order, q);
119 
120  if (s->order & 1) {
121  BiquadCoeffs *coeffs = &s->coeffs[0];
122  double omega = 2. * tan(M_PI * w0);
123 
124  coeffs->b0 = omega / (2. + omega);
125  coeffs->b1 = coeffs->b0;
126  coeffs->b2 = 0.;
127  coeffs->a1 = -(omega - 2.) / (2. + omega);
128  coeffs->a2 = 0.;
129  }
130 
131  for (int b = (s->order & 1); b < s->filter_count; b++) {
132  BiquadCoeffs *coeffs = &s->coeffs[b];
133  const int idx = b - (s->order & 1);
134  double norm = 1.0 / (1.0 + K / q[idx] + K * K);
135 
136  coeffs->b0 = K * K * norm;
137  coeffs->b1 = 2.0 * coeffs->b0;
138  coeffs->b2 = coeffs->b0;
139  coeffs->a1 = -2.0 * (K * K - 1.0) * norm;
140  coeffs->a2 = -(1.0 - K / q[idx] + K * K) * norm;
141  }
142  } else if (!strcmp(ctx->filter->name, "asuperpass")) {
143  double alpha, beta, gamma, theta;
144  double theta_0 = 2. * M_PI * (s->cutoff / inlink->sample_rate);
145  double d_E;
146 
147  s->filter_count = s->order / 2;
148  d_E = (2. * tan(theta_0 / (2. * s->qfactor))) / sin(theta_0);
149 
150  for (int b = 0; b < s->filter_count; b += 2) {
151  double D = 2. * sin(((b + 1) * M_PI) / (2. * s->filter_count));
152  double A = (1. + pow((d_E / 2.), 2)) / (D * d_E / 2.);
153  double d = sqrt((d_E * D) / (A + sqrt(A * A - 1.)));
154  double B = D * (d_E / 2.) / d;
155  double W = B + sqrt(B * B - 1.);
156 
157  for (int j = 0; j < 2; j++) {
158  BiquadCoeffs *coeffs = &s->coeffs[b + j];
159 
160  if (j == 1)
161  theta = 2. * atan(tan(theta_0 / 2.) / W);
162  else
163  theta = 2. * atan(W * tan(theta_0 / 2.));
164 
165  beta = 0.5 * ((1. - (d / 2.) * sin(theta)) / (1. + (d / 2.) * sin(theta)));
166  gamma = (0.5 + beta) * cos(theta);
167  alpha = 0.5 * (0.5 - beta) * sqrt(1. + pow((W - (1. / W)) / d, 2.));
168 
169  coeffs->a1 = 2. * gamma;
170  coeffs->a2 = -2. * beta;
171  coeffs->b0 = 2. * alpha;
172  coeffs->b1 = 0.;
173  coeffs->b2 = -2. * alpha;
174  }
175  }
176  } else if (!strcmp(ctx->filter->name, "asuperstop")) {
177  double alpha, beta, gamma, theta;
178  double theta_0 = 2. * M_PI * (s->cutoff / inlink->sample_rate);
179  double d_E;
180 
181  s->filter_count = s->order / 2;
182  d_E = (2. * tan(theta_0 / (2. * s->qfactor))) / sin(theta_0);
183 
184  for (int b = 0; b < s->filter_count; b += 2) {
185  double D = 2. * sin(((b + 1) * M_PI) / (2. * s->filter_count));
186  double A = (1. + pow((d_E / 2.), 2)) / (D * d_E / 2.);
187  double d = sqrt((d_E * D) / (A + sqrt(A * A - 1.)));
188  double B = D * (d_E / 2.) / d;
189  double W = B + sqrt(B * B - 1.);
190 
191  for (int j = 0; j < 2; j++) {
192  BiquadCoeffs *coeffs = &s->coeffs[b + j];
193 
194  if (j == 1)
195  theta = 2. * atan(tan(theta_0 / 2.) / W);
196  else
197  theta = 2. * atan(W * tan(theta_0 / 2.));
198 
199  beta = 0.5 * ((1. - (d / 2.) * sin(theta)) / (1. + (d / 2.) * sin(theta)));
200  gamma = (0.5 + beta) * cos(theta);
201  alpha = 0.5 * (0.5 + beta) * ((1. - cos(theta)) / (1. - cos(theta_0)));
202 
203  coeffs->a1 = 2. * gamma;
204  coeffs->a2 = -2. * beta;
205  coeffs->b0 = 2. * alpha;
206  coeffs->b1 = -4. * alpha * cos(theta_0);
207  coeffs->b2 = 2. * alpha;
208  }
209  }
210  }
211 
212  return 0;
213 }
214 
215 typedef struct ThreadData {
216  AVFrame *in, *out;
217 } ThreadData;
218 
219 #define FILTER(name, type) \
220 static int filter_channels_## name(AVFilterContext *ctx, void *arg, \
221  int jobnr, int nb_jobs) \
222 { \
223  ASuperCutContext *s = ctx->priv; \
224  ThreadData *td = arg; \
225  AVFrame *out = td->out; \
226  AVFrame *in = td->in; \
227  const int start = (in->channels * jobnr) / nb_jobs; \
228  const int end = (in->channels * (jobnr+1)) / nb_jobs; \
229  const double level = s->level; \
230  \
231  for (int ch = start; ch < end; ch++) { \
232  const type *src = (const type *)in->extended_data[ch]; \
233  type *dst = (type *)out->extended_data[ch]; \
234  \
235  for (int b = 0; b < s->filter_count; b++) { \
236  BiquadCoeffs *coeffs = &s->coeffs[b]; \
237  const type a1 = coeffs->a1; \
238  const type a2 = coeffs->a2; \
239  const type b0 = coeffs->b0; \
240  const type b1 = coeffs->b1; \
241  const type b2 = coeffs->b2; \
242  type *w = ((type *)s->w->extended_data[ch]) + b * 2; \
243  \
244  for (int n = 0; n < in->nb_samples; n++) { \
245  type sin = b ? dst[n] : src[n] * level; \
246  type sout = sin * b0 + w[0]; \
247  \
248  w[0] = b1 * sin + w[1] + a1 * sout; \
249  w[1] = b2 * sin + a2 * sout; \
250  \
251  dst[n] = sout; \
252  } \
253  } \
254  } \
255  \
256  return 0; \
257 }
258 
259 FILTER(fltp, float)
260 FILTER(dblp, double)
261 
263 {
264  AVFilterContext *ctx = inlink->dst;
265  ASuperCutContext *s = ctx->priv;
266 
267  switch (inlink->format) {
268  case AV_SAMPLE_FMT_FLTP: s->filter_channels = filter_channels_fltp; break;
269  case AV_SAMPLE_FMT_DBLP: s->filter_channels = filter_channels_dblp; break;
270  }
271 
272  s->w = ff_get_audio_buffer(inlink, 2 * 10);
273  if (!s->w)
274  return AVERROR(ENOMEM);
275 
276  return get_coeffs(ctx);
277 }
278 
280 {
281  AVFilterContext *ctx = inlink->dst;
282  ASuperCutContext *s = ctx->priv;
283  AVFilterLink *outlink = ctx->outputs[0];
284  ThreadData td;
285  AVFrame *out;
286 
287  if (s->bypass)
288  return ff_filter_frame(outlink, in);
289 
290  if (av_frame_is_writable(in)) {
291  out = in;
292  } else {
293  out = ff_get_audio_buffer(outlink, in->nb_samples);
294  if (!out) {
295  av_frame_free(&in);
296  return AVERROR(ENOMEM);
297  }
299  }
300 
301  td.in = in; td.out = out;
302  ff_filter_execute(ctx, s->filter_channels, &td, NULL,
304 
305  if (out != in)
306  av_frame_free(&in);
307  return ff_filter_frame(outlink, out);
308 }
309 
310 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
311  char *res, int res_len, int flags)
312 {
313  int ret;
314 
315  ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
316  if (ret < 0)
317  return ret;
318 
319  return get_coeffs(ctx);
320 }
321 
323 {
324  ASuperCutContext *s = ctx->priv;
325 
326  av_frame_free(&s->w);
327 }
328 
329 #define OFFSET(x) offsetof(ASuperCutContext, x)
330 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
331 
332 static const AVOption asupercut_options[] = {
333  { "cutoff", "set cutoff frequency", OFFSET(cutoff), AV_OPT_TYPE_DOUBLE, {.dbl=20000}, 20000, 192000, FLAGS },
334  { "order", "set filter order", OFFSET(order), AV_OPT_TYPE_INT, {.i64=10}, 3, 20, FLAGS },
335  { "level", "set input level", OFFSET(level), AV_OPT_TYPE_DOUBLE, {.dbl=1.}, 0., 1., FLAGS },
336  { NULL }
337 };
338 
339 AVFILTER_DEFINE_CLASS(asupercut);
340 
341 static const AVFilterPad inputs[] = {
342  {
343  .name = "default",
344  .type = AVMEDIA_TYPE_AUDIO,
345  .filter_frame = filter_frame,
346  .config_props = config_input,
347  },
348 };
349 
350 static const AVFilterPad outputs[] = {
351  {
352  .name = "default",
353  .type = AVMEDIA_TYPE_AUDIO,
354  },
355 };
356 
358  .name = "asupercut",
359  .description = NULL_IF_CONFIG_SMALL("Cut super frequencies."),
360  .query_formats = query_formats,
361  .priv_size = sizeof(ASuperCutContext),
362  .priv_class = &asupercut_class,
363  .uninit = uninit,
366  .process_command = process_command,
369 };
370 
371 static const AVOption asubcut_options[] = {
372  { "cutoff", "set cutoff frequency", OFFSET(cutoff), AV_OPT_TYPE_DOUBLE, {.dbl=20}, 2, 200, FLAGS },
373  { "order", "set filter order", OFFSET(order), AV_OPT_TYPE_INT, {.i64=10}, 3, 20, FLAGS },
374  { "level", "set input level", OFFSET(level), AV_OPT_TYPE_DOUBLE, {.dbl=1.}, 0., 1., FLAGS },
375  { NULL }
376 };
377 
378 AVFILTER_DEFINE_CLASS(asubcut);
379 
381  .name = "asubcut",
382  .description = NULL_IF_CONFIG_SMALL("Cut subwoofer frequencies."),
383  .query_formats = query_formats,
384  .priv_size = sizeof(ASuperCutContext),
385  .priv_class = &asubcut_class,
386  .uninit = uninit,
389  .process_command = process_command,
392 };
393 
395  { "centerf","set center frequency", OFFSET(cutoff), AV_OPT_TYPE_DOUBLE, {.dbl=1000}, 2, 999999, FLAGS },
396  { "order", "set filter order", OFFSET(order), AV_OPT_TYPE_INT, {.i64=4}, 4, 20, FLAGS },
397  { "qfactor","set Q-factor", OFFSET(qfactor),AV_OPT_TYPE_DOUBLE, {.dbl=1.},0.01, 100., FLAGS },
398  { "level", "set input level", OFFSET(level), AV_OPT_TYPE_DOUBLE, {.dbl=1.}, 0., 2., FLAGS },
399  { NULL }
400 };
401 
402 AVFILTER_DEFINE_CLASS_EXT(asuperpass_asuperstop, "asuperpass/asuperstop",
404 
406  .name = "asuperpass",
407  .description = NULL_IF_CONFIG_SMALL("Apply high order Butterworth band-pass filter."),
408  .priv_class = &asuperpass_asuperstop_class,
409  .query_formats = query_formats,
410  .priv_size = sizeof(ASuperCutContext),
411  .uninit = uninit,
414  .process_command = process_command,
417 };
418 
420  .name = "asuperstop",
421  .description = NULL_IF_CONFIG_SMALL("Apply high order Butterworth band-stop filter."),
422  .priv_class = &asuperpass_asuperstop_class,
423  .query_formats = query_formats,
424  .priv_size = sizeof(ASuperCutContext),
425  .uninit = uninit,
428  .process_command = process_command,
431 };
ff_af_asuperpass
const AVFilter ff_af_asuperpass
Definition: af_asupercut.c:405
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:88
asupercut_options
static const AVOption asupercut_options[]
Definition: af_asupercut.c:332
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
td
#define td
Definition: regdef.h:70
FLAGS
#define FLAGS
Definition: af_asupercut.c:330
config_input
static int config_input(AVFilterLink *inlink)
Definition: af_asupercut.c:262
level
uint8_t level
Definition: svq3.c:204
ASuperCutContext
Definition: af_asupercut.c:34
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
opt.h
out
FILE * out
Definition: movenc.c:54
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1019
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:948
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
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:112
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
AVOption
AVOption.
Definition: opt.h:247
b
#define b
Definition: input.c:40
W
@ W
Definition: vf_addroi.c:26
calc_q_factors
static void calc_q_factors(int n, double *q)
Definition: af_asupercut.c:70
ff_set_common_all_samplerates
int ff_set_common_all_samplerates(AVFilterContext *ctx)
Equivalent to ff_set_common_samplerates(ctx, ff_all_samplerates())
Definition: formats.c:687
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:153
ThreadData::out
AVFrame * out
Definition: af_adeclick.c:492
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: af_asupercut.c:52
D
D(D(float, sse)
Definition: rematrix_init.c:29
formats.h
BiquadCoeffs::a1
double a1
Definition: af_aemphasis.c:27
A
#define A(x)
Definition: vp56_arith.h:28
BiquadCoeffs
Definition: af_acrossover.c:48
ASuperCutContext::order
int order
Definition: af_asupercut.c:40
ff_af_asupercut
const AVFilter ff_af_asupercut
Definition: af_asupercut.c:357
BiquadCoeffs::a2
double a2
Definition: af_aemphasis.c:27
BiquadCoeffs::b2
double b2
Definition: af_aemphasis.c:27
FILTER
#define FILTER(name, type)
Definition: af_asupercut.c:219
get_coeffs
static int get_coeffs(AVFilterContext *ctx)
Definition: af_asupercut.c:76
ASuperCutContext::coeffs
BiquadCoeffs coeffs[10]
Definition: af_asupercut.c:45
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:50
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(asupercut)
av_cold
#define av_cold
Definition: attributes.h:90
s
#define s(width, name)
Definition: cbs_vp9.c:257
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Definition: opt.h:226
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
ff_set_common_formats_from_list
int ff_set_common_formats_from_list(AVFilterContext *ctx, const int *fmts)
Equivalent to ff_set_common_formats(ctx, ff_make_format_list(fmts))
Definition: formats.c:703
ctx
AVFormatContext * ctx
Definition: movenc.c:48
OFFSET
#define OFFSET(x)
Definition: af_asupercut.c:329
ASuperCutContext::qfactor
double qfactor
Definition: af_asupercut.c:39
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:152
arg
const char * arg
Definition: jacosubdec.c:67
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
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:537
ff_af_asuperstop
const AVFilter ff_af_asuperstop
Definition: af_asupercut.c:419
BiquadCoeffs::b0
double b0
Definition: af_asupercut.c:31
ff_set_common_all_channel_counts
int ff_set_common_all_channel_counts(AVFilterContext *ctx)
Equivalent to ff_set_common_channel_layouts(ctx, ff_all_channel_counts())
Definition: formats.c:669
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
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
ff_af_asubcut
const AVFilter ff_af_asubcut
Definition: af_asupercut.c:380
asubcut_options
static const AVOption asubcut_options[]
Definition: af_asupercut.c:371
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:473
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:883
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: af_asupercut.c:322
ASuperCutContext::filter_channels
int(* filter_channels)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: af_asupercut.c:49
M_PI
#define M_PI
Definition: mathematics.h:52
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:130
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:369
i
int i
Definition: input.c:406
inputs
static const AVFilterPad inputs[]
Definition: af_asupercut.c:341
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:804
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
ThreadData
Used for passing data between threads.
Definition: dsddec.c:67
AVFILTER_DEFINE_CLASS_EXT
AVFILTER_DEFINE_CLASS_EXT(asuperpass_asuperstop, "asuperpass/asuperstop", asuperpass_asuperstop_options)
asuperpass_asuperstop_options
static const AVOption asuperpass_asuperstop_options[]
Definition: af_asupercut.c:394
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
ASuperCutContext::cutoff
double cutoff
Definition: af_asupercut.c:37
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:56
BiquadCoeffs::b1
double b1
Definition: af_aemphasis.c:27
AVFilter
Filter definition.
Definition: avfilter.h:149
ret
ret
Definition: filter_design.txt:187
B
#define B
Definition: huffyuvdsp.h:32
channel_layout.h
ASuperCutContext::filter_count
int filter_count
Definition: af_asupercut.c:42
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
avfilter.h
process_command
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: af_asupercut.c:310
AV_SAMPLE_FMT_DBLP
@ AV_SAMPLE_FMT_DBLP
double, planar
Definition: samplefmt.h:70
ffmath.h
AVFilterContext
An instance of a filter.
Definition: avfilter.h:346
ASuperCutContext::bypass
int bypass
Definition: af_asupercut.c:43
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:121
audio.h
ThreadData::in
AVFrame * in
Definition: af_adecorrelate.c:171
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:153
ASuperCutContext::level
double level
Definition: af_asupercut.c:38
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: af_asupercut.c:279
d
d
Definition: ffmpeg_filter.c:156
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
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:143
int
int
Definition: ffmpeg_filter.c:156
ASuperCutContext::w
AVFrame * w
Definition: af_asupercut.c:47
outputs
static const AVFilterPad outputs[]
Definition: af_asupercut.c:350