FFmpeg
af_afreqshift.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) Paul B Mahol
3  * Copyright (c) Laurent de Soras, 2005
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 
28 #define MAX_NB_COEFFS 16
29 
30 typedef struct AFreqShift {
31  const AVClass *class;
32 
33  double shift;
34  double level;
35  int nb_coeffs;
37 
38  double cd[MAX_NB_COEFFS * 2];
39  float cf[MAX_NB_COEFFS * 2];
40 
41  int64_t in_samples;
42 
45 
47  int channel,
48  AVFrame *in, AVFrame *out);
49 } AFreqShift;
50 
51 static const enum AVSampleFormat sample_fmts[] = {
53 };
54 
55 #define PFILTER(name, type, sin, cos, cc) \
56 static void pfilter_channel_## name(AVFilterContext *ctx, \
57  int ch, \
58  AVFrame *in, AVFrame *out) \
59 { \
60  AFreqShift *s = ctx->priv; \
61  const int nb_samples = in->nb_samples; \
62  const type *src = (const type *)in->extended_data[ch]; \
63  type *dst = (type *)out->extended_data[ch]; \
64  type *i1 = (type *)s->i1->extended_data[ch]; \
65  type *o1 = (type *)s->o1->extended_data[ch]; \
66  type *i2 = (type *)s->i2->extended_data[ch]; \
67  type *o2 = (type *)s->o2->extended_data[ch]; \
68  const int nb_coeffs = s->nb_coeffs; \
69  const type *c = s->cc; \
70  const type level = s->level; \
71  type shift = s->shift * M_PI; \
72  type cos_theta = cos(shift); \
73  type sin_theta = sin(shift); \
74  \
75  for (int n = 0; n < nb_samples; n++) { \
76  type xn1 = src[n], xn2 = src[n]; \
77  type I, Q; \
78  \
79  for (int j = 0; j < nb_coeffs; j++) { \
80  I = c[j] * (xn1 + o2[j]) - i2[j]; \
81  i2[j] = i1[j]; \
82  i1[j] = xn1; \
83  o2[j] = o1[j]; \
84  o1[j] = I; \
85  xn1 = I; \
86  } \
87  \
88  for (int j = nb_coeffs; j < nb_coeffs*2; j++) { \
89  Q = c[j] * (xn2 + o2[j]) - i2[j]; \
90  i2[j] = i1[j]; \
91  i1[j] = xn2; \
92  o2[j] = o1[j]; \
93  o1[j] = Q; \
94  xn2 = Q; \
95  } \
96  Q = o2[nb_coeffs * 2 - 1]; \
97  \
98  dst[n] = (I * cos_theta - Q * sin_theta) * level; \
99  } \
100 }
101 
102 PFILTER(flt, float, sin, cos, cf)
103 PFILTER(dbl, double, sin, cos, cd)
104 
105 #define FFILTER(name, type, sin, cos, fmod, cc) \
106 static void ffilter_channel_## name(AVFilterContext *ctx, \
107  int ch, \
108  AVFrame *in, AVFrame *out) \
109 { \
110  AFreqShift *s = ctx->priv; \
111  const int nb_samples = in->nb_samples; \
112  const type *src = (const type *)in->extended_data[ch]; \
113  type *dst = (type *)out->extended_data[ch]; \
114  type *i1 = (type *)s->i1->extended_data[ch]; \
115  type *o1 = (type *)s->o1->extended_data[ch]; \
116  type *i2 = (type *)s->i2->extended_data[ch]; \
117  type *o2 = (type *)s->o2->extended_data[ch]; \
118  const int nb_coeffs = s->nb_coeffs; \
119  const type *c = s->cc; \
120  const type level = s->level; \
121  type ts = 1. / in->sample_rate; \
122  type shift = s->shift; \
123  int64_t N = s->in_samples; \
124  \
125  for (int n = 0; n < nb_samples; n++) { \
126  type xn1 = src[n], xn2 = src[n]; \
127  type I, Q, theta; \
128  \
129  for (int j = 0; j < nb_coeffs; j++) { \
130  I = c[j] * (xn1 + o2[j]) - i2[j]; \
131  i2[j] = i1[j]; \
132  i1[j] = xn1; \
133  o2[j] = o1[j]; \
134  o1[j] = I; \
135  xn1 = I; \
136  } \
137  \
138  for (int j = nb_coeffs; j < nb_coeffs*2; j++) { \
139  Q = c[j] * (xn2 + o2[j]) - i2[j]; \
140  i2[j] = i1[j]; \
141  i1[j] = xn2; \
142  o2[j] = o1[j]; \
143  o1[j] = Q; \
144  xn2 = Q; \
145  } \
146  Q = o2[nb_coeffs * 2 - 1]; \
147  \
148  theta = 2. * M_PI * fmod(shift * (N + n) * ts, 1.); \
149  dst[n] = (I * cos(theta) - Q * sin(theta)) * level; \
150  } \
151 }
152 
153 FFILTER(flt, float, sinf, cosf, fmodf, cf)
154 FFILTER(dbl, double, sin, cos, fmod, cd)
155 
156 static void compute_transition_param(double *K, double *Q, double transition)
157 {
158  double kksqrt, e, e2, e4, k, q;
159 
160  k = tan((1. - transition * 2.) * M_PI / 4.);
161  k *= k;
162  kksqrt = pow(1 - k * k, 0.25);
163  e = 0.5 * (1. - kksqrt) / (1. + kksqrt);
164  e2 = e * e;
165  e4 = e2 * e2;
166  q = e * (1. + e4 * (2. + e4 * (15. + 150. * e4)));
167 
168  *Q = q;
169  *K = k;
170 }
171 
172 static double ipowp(double x, int64_t n)
173 {
174  double z = 1.;
175 
176  while (n != 0) {
177  if (n & 1)
178  z *= x;
179  n >>= 1;
180  x *= x;
181  }
182 
183  return z;
184 }
185 
186 static double compute_acc_num(double q, int order, int c)
187 {
188  int64_t i = 0;
189  int j = 1;
190  double acc = 0.;
191  double q_ii1;
192 
193  do {
194  q_ii1 = ipowp(q, i * (i + 1));
195  q_ii1 *= sin((i * 2 + 1) * c * M_PI / order) * j;
196  acc += q_ii1;
197 
198  j = -j;
199  i++;
200  } while (fabs(q_ii1) > 1e-100);
201 
202  return acc;
203 }
204 
205 static double compute_acc_den(double q, int order, int c)
206 {
207  int64_t i = 1;
208  int j = -1;
209  double acc = 0.;
210  double q_i2;
211 
212  do {
213  q_i2 = ipowp(q, i * i);
214  q_i2 *= cos(i * 2 * c * M_PI / order) * j;
215  acc += q_i2;
216 
217  j = -j;
218  i++;
219  } while (fabs(q_i2) > 1e-100);
220 
221  return acc;
222 }
223 
224 static double compute_coef(int index, double k, double q, int order)
225 {
226  const int c = index + 1;
227  const double num = compute_acc_num(q, order, c) * pow(q, 0.25);
228  const double den = compute_acc_den(q, order, c) + 0.5;
229  const double ww = num / den;
230  const double wwsq = ww * ww;
231 
232  const double x = sqrt((1 - wwsq * k) * (1 - wwsq / k)) / (1 + wwsq);
233  const double coef = (1 - x) / (1 + x);
234 
235  return coef;
236 }
237 
238 static void compute_coefs(double *coef_arrd, float *coef_arrf, int nbr_coefs, double transition)
239 {
240  const int order = nbr_coefs * 2 + 1;
241  double k, q;
242 
243  compute_transition_param(&k, &q, transition);
244 
245  for (int n = 0; n < nbr_coefs; n++) {
246  const int idx = (n / 2) + (n & 1) * nbr_coefs / 2;
247 
248  coef_arrd[idx] = compute_coef(n, k, q, order);
249  coef_arrf[idx] = coef_arrd[idx];
250  }
251 }
252 
254 {
255  AVFilterContext *ctx = inlink->dst;
256  AFreqShift *s = ctx->priv;
257 
258  if (s->old_nb_coeffs != s->nb_coeffs)
259  compute_coefs(s->cd, s->cf, s->nb_coeffs * 2, 2. * 20. / inlink->sample_rate);
260  s->old_nb_coeffs = s->nb_coeffs;
261 
266  if (!s->i1 || !s->o1 || !s->i2 || !s->o2)
267  return AVERROR(ENOMEM);
268 
269  if (inlink->format == AV_SAMPLE_FMT_DBLP) {
270  if (!strcmp(ctx->filter->name, "afreqshift"))
271  s->filter_channel = ffilter_channel_dbl;
272  else
273  s->filter_channel = pfilter_channel_dbl;
274  } else {
275  if (!strcmp(ctx->filter->name, "afreqshift"))
276  s->filter_channel = ffilter_channel_flt;
277  else
278  s->filter_channel = pfilter_channel_flt;
279  }
280 
281  return 0;
282 }
283 
284 typedef struct ThreadData {
285  AVFrame *in, *out;
286 } ThreadData;
287 
288 static int filter_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
289 {
290  AFreqShift *s = ctx->priv;
291  ThreadData *td = arg;
292  AVFrame *out = td->out;
293  AVFrame *in = td->in;
294  const int start = (in->ch_layout.nb_channels * jobnr) / nb_jobs;
295  const int end = (in->ch_layout.nb_channels * (jobnr+1)) / nb_jobs;
296 
297  for (int ch = start; ch < end; ch++)
298  s->filter_channel(ctx, ch, in, out);
299 
300  return 0;
301 }
302 
304 {
305  AVFilterContext *ctx = inlink->dst;
306  AVFilterLink *outlink = ctx->outputs[0];
307  AFreqShift *s = ctx->priv;
308  AVFrame *out;
309  ThreadData td;
310 
311  if (s->old_nb_coeffs != s->nb_coeffs)
312  compute_coefs(s->cd, s->cf, s->nb_coeffs * 2, 2. * 20. / inlink->sample_rate);
313  s->old_nb_coeffs = s->nb_coeffs;
314 
315  if (av_frame_is_writable(in)) {
316  out = in;
317  } else {
318  out = ff_get_audio_buffer(outlink, in->nb_samples);
319  if (!out) {
320  av_frame_free(&in);
321  return AVERROR(ENOMEM);
322  }
324  }
325 
326  td.in = in; td.out = out;
328  FFMIN(inlink->ch_layout.nb_channels, ff_filter_get_nb_threads(ctx)));
329 
330  s->in_samples += in->nb_samples;
331 
332  if (out != in)
333  av_frame_free(&in);
334  return ff_filter_frame(outlink, out);
335 }
336 
338 {
339  AFreqShift *s = ctx->priv;
340 
341  av_frame_free(&s->i1);
342  av_frame_free(&s->o1);
343  av_frame_free(&s->i2);
344  av_frame_free(&s->o2);
345 }
346 
347 #define OFFSET(x) offsetof(AFreqShift, x)
348 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
349 
350 static const AVOption afreqshift_options[] = {
351  { "shift", "set frequency shift", OFFSET(shift), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -INT_MAX, INT_MAX, FLAGS },
352  { "level", "set output level", OFFSET(level), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0.0, 1.0, FLAGS },
353  { "order", "set filter order", OFFSET(nb_coeffs),AV_OPT_TYPE_INT, {.i64=8}, 1, MAX_NB_COEFFS, FLAGS },
354  { NULL }
355 };
356 
357 AVFILTER_DEFINE_CLASS(afreqshift);
358 
359 static const AVFilterPad inputs[] = {
360  {
361  .name = "default",
362  .type = AVMEDIA_TYPE_AUDIO,
363  .filter_frame = filter_frame,
364  .config_props = config_input,
365  },
366 };
367 
369  .name = "afreqshift",
370  .description = NULL_IF_CONFIG_SMALL("Apply frequency shifting to input audio."),
371  .priv_size = sizeof(AFreqShift),
372  .priv_class = &afreqshift_class,
373  .uninit = uninit,
377  .process_command = ff_filter_process_command,
380 };
381 
382 static const AVOption aphaseshift_options[] = {
383  { "shift", "set phase shift", OFFSET(shift), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -1.0, 1.0, FLAGS },
384  { "level", "set output level",OFFSET(level), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0.0, 1.0, FLAGS },
385  { "order", "set filter order",OFFSET(nb_coeffs), AV_OPT_TYPE_INT,{.i64=8}, 1, MAX_NB_COEFFS, FLAGS },
386  { NULL }
387 };
388 
389 AVFILTER_DEFINE_CLASS(aphaseshift);
390 
392  .name = "aphaseshift",
393  .description = NULL_IF_CONFIG_SMALL("Apply phase shifting to input audio."),
394  .priv_size = sizeof(AFreqShift),
395  .priv_class = &aphaseshift_class,
396  .uninit = uninit,
400  .process_command = ff_filter_process_command,
403 };
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:97
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
level
uint8_t level
Definition: svq3.c:205
acc
int acc
Definition: yuv2rgb.c:553
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:55
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1015
AFreqShift::old_nb_coeffs
int old_nb_coeffs
Definition: af_afreqshift.c:36
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
filter_channels
static int filter_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: af_afreqshift.c:288
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:160
inputs
static const AVFilterPad inputs[]
Definition: af_afreqshift.c:359
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
AVOption
AVOption.
Definition: opt.h:357
AFreqShift::cd
double cd[MAX_NB_COEFFS *2]
Definition: af_afreqshift.c:38
MAX_NB_COEFFS
#define MAX_NB_COEFFS
Definition: af_afreqshift.c:28
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:170
ThreadData::out
AVFrame * out
Definition: af_adeclick.c:527
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:321
ThreadData::in
AVFrame * in
Definition: af_adecorrelate.c:154
cosf
#define cosf(x)
Definition: libm.h:78
aphaseshift_options
static const AVOption aphaseshift_options[]
Definition: af_afreqshift.c:382
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: af_afreqshift.c:303
ff_af_aphaseshift
const AVFilter ff_af_aphaseshift
Definition: af_afreqshift.c:391
AVFrame::ch_layout
AVChannelLayout ch_layout
Channel layout of the audio data.
Definition: frame.h:775
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:33
av_cold
#define av_cold
Definition: attributes.h:90
compute_acc_den
static double compute_acc_den(double q, int order, int c)
Definition: af_afreqshift.c:205
AFreqShift::cf
float cf[MAX_NB_COEFFS *2]
Definition: af_afreqshift.c:39
PFILTER
#define PFILTER(name, type, sin, cos, cc)
Definition: af_afreqshift.c:55
s
#define s(width, name)
Definition: cbs_vp9.c:198
AFreqShift
Definition: af_afreqshift.c:30
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: af_afreqshift.c:51
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Definition: opt.h:247
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
ctx
AVFormatContext * ctx
Definition: movenc.c:49
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:182
arg
const char * arg
Definition: jacosubdec.c:67
compute_transition_param
static void compute_transition_param(double *K, double *Q, double transition)
Definition: af_afreqshift.c:156
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
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:709
ipowp
static double ipowp(double x, int64_t n)
Definition: af_afreqshift.c:172
OFFSET
#define OFFSET(x)
Definition: af_afreqshift.c:347
AFreqShift::shift
double shift
Definition: af_afreqshift.c:33
ff_audio_default_filterpad
const AVFilterPad ff_audio_default_filterpad[1]
An AVFilterPad array whose only entry has name "default" and is of type AVMEDIA_TYPE_AUDIO.
Definition: audio.c:33
sinf
#define sinf(x)
Definition: libm.h:419
AFreqShift::i2
AVFrame * i2
Definition: af_afreqshift.c:44
AFreqShift::level
double level
Definition: af_afreqshift.c:34
index
int index
Definition: gxfenc.c:90
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
FFILTER
#define FFILTER(name, type, sin, cos, fmod, cc)
Definition: af_afreqshift.c:105
compute_acc_num
static double compute_acc_num(double q, int order, int c)
Definition: af_afreqshift.c:186
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:94
shift
static int shift(int a, int b)
Definition: bonk.c:261
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
FILTER_SAMPLEFMTS_ARRAY
#define FILTER_SAMPLEFMTS_ARRAY(array)
Definition: internal.h:165
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:645
config_input
static int config_input(AVFilterLink *inlink)
Definition: af_afreqshift.c:253
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:887
AFreqShift::nb_coeffs
int nb_coeffs
Definition: af_afreqshift.c:35
M_PI
#define M_PI
Definition: mathematics.h:67
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: af_afreqshift.c:337
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:147
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:454
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AFreqShift::o1
AVFrame * o1
Definition: af_afreqshift.c:43
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:827
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
ThreadData
Used for passing data between threads.
Definition: dsddec.c:71
AFreqShift::in_samples
int64_t in_samples
Definition: af_afreqshift.c:41
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
ff_af_afreqshift
const AVFilter ff_af_afreqshift
Definition: af_afreqshift.c:368
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:39
compute_coefs
static void compute_coefs(double *coef_arrd, float *coef_arrf, int nbr_coefs, double transition)
Definition: af_afreqshift.c:238
AVFilter
Filter definition.
Definition: avfilter.h:166
afreqshift_options
static const AVOption afreqshift_options[]
Definition: af_afreqshift.c:350
AFreqShift::filter_channel
void(* filter_channel)(AVFilterContext *ctx, int channel, AVFrame *in, AVFrame *out)
Definition: af_afreqshift.c:46
AFreqShift::o2
AVFrame * o2
Definition: af_afreqshift.c:44
channel_layout.h
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:245
avfilter.h
AV_SAMPLE_FMT_DBLP
@ AV_SAMPLE_FMT_DBLP
double, planar
Definition: samplefmt.h:67
ffmath.h
AVFilterContext
An instance of a filter.
Definition: avfilter.h:407
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:117
audio.h
FLAGS
#define FLAGS
Definition: af_afreqshift.c:348
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:183
K
#define K
Definition: palette.c:25
Q
#define Q(x)
Definition: filter_template.c:433
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:134
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(afreqshift)
compute_coef
static double compute_coef(int index, double k, double q, int order)
Definition: af_afreqshift.c:224
channel
channel
Definition: ebur128.h:39
AFreqShift::i1
AVFrame * i1
Definition: af_afreqshift.c:43