FFmpeg
asrc_sinc.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2008-2009 Rob Sykes <robs@users.sourceforge.net>
3  * Copyright (c) 2017 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 
22 #include "libavutil/avassert.h"
24 #include "libavutil/opt.h"
25 
26 #include "libavcodec/avfft.h"
27 
28 #include "audio.h"
29 #include "avfilter.h"
30 #include "internal.h"
31 
32 typedef struct SincContext {
33  const AVClass *class;
34 
36  float att, beta, phase, Fc0, Fc1, tbw0, tbw1;
37  int num_taps[2];
38  int round;
39 
40  int n, rdft_len;
41  float *coeffs;
42  int64_t pts;
43 
45 } SincContext;
46 
47 static int request_frame(AVFilterLink *outlink)
48 {
49  AVFilterContext *ctx = outlink->src;
50  SincContext *s = ctx->priv;
51  const float *coeffs = s->coeffs;
52  AVFrame *frame = NULL;
53  int nb_samples;
54 
55  nb_samples = FFMIN(s->nb_samples, s->n - s->pts);
56  if (nb_samples <= 0)
57  return AVERROR_EOF;
58 
59  if (!(frame = ff_get_audio_buffer(outlink, nb_samples)))
60  return AVERROR(ENOMEM);
61 
62  memcpy(frame->data[0], coeffs + s->pts, nb_samples * sizeof(float));
63 
64  frame->pts = s->pts;
65  s->pts += nb_samples;
66 
67  return ff_filter_frame(outlink, frame);
68 }
69 
71 {
72  SincContext *s = ctx->priv;
73  static const int64_t chlayouts[] = { AV_CH_LAYOUT_MONO, -1 };
74  int sample_rates[] = { s->sample_rate, -1 };
75  static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_FLT,
79  int ret;
80 
82  if (!formats)
83  return AVERROR(ENOMEM);
85  if (ret < 0)
86  return ret;
87 
88  layouts = ff_make_format64_list(chlayouts);
89  if (!layouts)
90  return AVERROR(ENOMEM);
92  if (ret < 0)
93  return ret;
94 
96  if (!formats)
97  return AVERROR(ENOMEM);
99 }
100 
101 static float bessel_I_0(float x)
102 {
103  float term = 1, sum = 1, last_sum, x2 = x / 2;
104  int i = 1;
105 
106  do {
107  float y = x2 / i++;
108 
109  last_sum = sum;
110  sum += term *= y * y;
111  } while (sum != last_sum);
112 
113  return sum;
114 }
115 
116 static float *make_lpf(int num_taps, float Fc, float beta, float rho,
117  float scale, int dc_norm)
118 {
119  int i, m = num_taps - 1;
120  float *h = av_calloc(num_taps, sizeof(*h)), sum = 0;
121  float mult = scale / bessel_I_0(beta), mult1 = 1.f / (.5f * m + rho);
122 
123  av_assert0(Fc >= 0 && Fc <= 1);
124 
125  for (i = 0; i <= m / 2; i++) {
126  float z = i - .5f * m, x = z * M_PI, y = z * mult1;
127  h[i] = x ? sinf(Fc * x) / x : Fc;
128  sum += h[i] *= bessel_I_0(beta * sqrtf(1.f - y * y)) * mult;
129  if (m - i != i) {
130  h[m - i] = h[i];
131  sum += h[i];
132  }
133  }
134 
135  for (i = 0; dc_norm && i < num_taps; i++)
136  h[i] *= scale / sum;
137 
138  return h;
139 }
140 
141 static float kaiser_beta(float att, float tr_bw)
142 {
143  if (att >= 60.f) {
144  static const float coefs[][4] = {
145  {-6.784957e-10, 1.02856e-05, 0.1087556, -0.8988365 + .001},
146  {-6.897885e-10, 1.027433e-05, 0.10876, -0.8994658 + .002},
147  {-1.000683e-09, 1.030092e-05, 0.1087677, -0.9007898 + .003},
148  {-3.654474e-10, 1.040631e-05, 0.1087085, -0.8977766 + .006},
149  {8.106988e-09, 6.983091e-06, 0.1091387, -0.9172048 + .015},
150  {9.519571e-09, 7.272678e-06, 0.1090068, -0.9140768 + .025},
151  {-5.626821e-09, 1.342186e-05, 0.1083999, -0.9065452 + .05},
152  {-9.965946e-08, 5.073548e-05, 0.1040967, -0.7672778 + .085},
153  {1.604808e-07, -5.856462e-05, 0.1185998, -1.34824 + .1},
154  {-1.511964e-07, 6.363034e-05, 0.1064627, -0.9876665 + .18},
155  };
156  float realm = logf(tr_bw / .0005f) / logf(2.f);
157  float const *c0 = coefs[av_clip((int)realm, 0, FF_ARRAY_ELEMS(coefs) - 1)];
158  float const *c1 = coefs[av_clip(1 + (int)realm, 0, FF_ARRAY_ELEMS(coefs) - 1)];
159  float b0 = ((c0[0] * att + c0[1]) * att + c0[2]) * att + c0[3];
160  float b1 = ((c1[0] * att + c1[1]) * att + c1[2]) * att + c1[3];
161 
162  return b0 + (b1 - b0) * (realm - (int)realm);
163  }
164  if (att > 50.f)
165  return .1102f * (att - 8.7f);
166  if (att > 20.96f)
167  return .58417f * powf(att - 20.96f, .4f) + .07886f * (att - 20.96f);
168  return 0;
169 }
170 
171 static void kaiser_params(float att, float Fc, float tr_bw, float *beta, int *num_taps)
172 {
173  *beta = *beta < 0.f ? kaiser_beta(att, tr_bw * .5f / Fc): *beta;
174  att = att < 60.f ? (att - 7.95f) / (2.285f * M_PI * 2.f) :
175  ((.0007528358f-1.577737e-05 * *beta) * *beta + 0.6248022f) * *beta + .06186902f;
176  *num_taps = !*num_taps ? ceilf(att/tr_bw + 1) : *num_taps;
177 }
178 
179 static float *lpf(float Fn, float Fc, float tbw, int *num_taps, float att, float *beta, int round)
180 {
181  int n = *num_taps;
182 
183  if ((Fc /= Fn) <= 0.f || Fc >= 1.f) {
184  *num_taps = 0;
185  return NULL;
186  }
187 
188  att = att ? att : 120.f;
189 
190  kaiser_params(att, Fc, (tbw ? tbw / Fn : .05f) * .5f, beta, num_taps);
191 
192  if (!n) {
193  n = *num_taps;
194  *num_taps = av_clip(n, 11, 32767);
195  if (round)
196  *num_taps = 1 + 2 * (int)((int)((*num_taps / 2) * Fc + .5f) / Fc + .5f);
197  }
198 
199  return make_lpf(*num_taps |= 1, Fc, *beta, 0.f, 1.f, 0);
200 }
201 
202 static void invert(float *h, int n)
203 {
204  for (int i = 0; i < n; i++)
205  h[i] = -h[i];
206 
207  h[(n - 1) / 2] += 1;
208 }
209 
210 #define PACK(h, n) h[1] = h[n]
211 #define UNPACK(h, n) h[n] = h[1], h[n + 1] = h[1] = 0;
212 #define SQR(a) ((a) * (a))
213 
214 static float safe_log(float x)
215 {
216  av_assert0(x >= 0);
217  if (x)
218  return logf(x);
219  return -26;
220 }
221 
222 static int fir_to_phase(SincContext *s, float **h, int *len, int *post_len, float phase)
223 {
224  float *pi_wraps, *work, phase1 = (phase > 50.f ? 100.f - phase : phase) / 50.f;
225  int i, work_len, begin, end, imp_peak = 0, peak = 0;
226  float imp_sum = 0, peak_imp_sum = 0;
227  float prev_angle2 = 0, cum_2pi = 0, prev_angle1 = 0, cum_1pi = 0;
228 
229  for (i = *len, work_len = 2 * 2 * 8; i > 1; work_len <<= 1, i >>= 1);
230 
231  /* The first part is for work (+2 for (UN)PACK), the latter for pi_wraps. */
232  work = av_calloc((work_len + 2) + (work_len / 2 + 1), sizeof(float));
233  if (!work)
234  return AVERROR(ENOMEM);
235  pi_wraps = &work[work_len + 2];
236 
237  memcpy(work, *h, *len * sizeof(*work));
238 
239  av_rdft_end(s->rdft);
240  av_rdft_end(s->irdft);
241  s->rdft = s->irdft = NULL;
242  s->rdft = av_rdft_init(av_log2(work_len), DFT_R2C);
243  s->irdft = av_rdft_init(av_log2(work_len), IDFT_C2R);
244  if (!s->rdft || !s->irdft) {
245  av_free(work);
246  return AVERROR(ENOMEM);
247  }
248 
249  av_rdft_calc(s->rdft, work); /* Cepstral: */
250  UNPACK(work, work_len);
251 
252  for (i = 0; i <= work_len; i += 2) {
253  float angle = atan2f(work[i + 1], work[i]);
254  float detect = 2 * M_PI;
255  float delta = angle - prev_angle2;
256  float adjust = detect * ((delta < -detect * .7f) - (delta > detect * .7f));
257 
258  prev_angle2 = angle;
259  cum_2pi += adjust;
260  angle += cum_2pi;
261  detect = M_PI;
262  delta = angle - prev_angle1;
263  adjust = detect * ((delta < -detect * .7f) - (delta > detect * .7f));
264  prev_angle1 = angle;
265  cum_1pi += fabsf(adjust); /* fabs for when 2pi and 1pi have combined */
266  pi_wraps[i >> 1] = cum_1pi;
267 
268  work[i] = safe_log(sqrtf(SQR(work[i]) + SQR(work[i + 1])));
269  work[i + 1] = 0;
270  }
271 
272  PACK(work, work_len);
273  av_rdft_calc(s->irdft, work);
274 
275  for (i = 0; i < work_len; i++)
276  work[i] *= 2.f / work_len;
277 
278  for (i = 1; i < work_len / 2; i++) { /* Window to reject acausal components */
279  work[i] *= 2;
280  work[i + work_len / 2] = 0;
281  }
282  av_rdft_calc(s->rdft, work);
283 
284  for (i = 2; i < work_len; i += 2) /* Interpolate between linear & min phase */
285  work[i + 1] = phase1 * i / work_len * pi_wraps[work_len >> 1] + (1 - phase1) * (work[i + 1] + pi_wraps[i >> 1]) - pi_wraps[i >> 1];
286 
287  work[0] = exp(work[0]);
288  work[1] = exp(work[1]);
289  for (i = 2; i < work_len; i += 2) {
290  float x = expf(work[i]);
291 
292  work[i ] = x * cosf(work[i + 1]);
293  work[i + 1] = x * sinf(work[i + 1]);
294  }
295 
296  av_rdft_calc(s->irdft, work);
297  for (i = 0; i < work_len; i++)
298  work[i] *= 2.f / work_len;
299 
300  /* Find peak pos. */
301  for (i = 0; i <= (int) (pi_wraps[work_len >> 1] / M_PI + .5f); i++) {
302  imp_sum += work[i];
303  if (fabs(imp_sum) > fabs(peak_imp_sum)) {
304  peak_imp_sum = imp_sum;
305  peak = i;
306  }
307  if (work[i] > work[imp_peak]) /* For debug check only */
308  imp_peak = i;
309  }
310 
311  while (peak && fabsf(work[peak - 1]) > fabsf(work[peak]) && (work[peak - 1] * work[peak] > 0)) {
312  peak--;
313  }
314 
315  if (!phase1) {
316  begin = 0;
317  } else if (phase1 == 1) {
318  begin = peak - *len / 2;
319  } else {
320  begin = (.997f - (2 - phase1) * .22f) * *len + .5f;
321  end = (.997f + (0 - phase1) * .22f) * *len + .5f;
322  begin = peak - (begin & ~3);
323  end = peak + 1 + ((end + 3) & ~3);
324  *len = end - begin;
325  *h = av_realloc_f(*h, *len, sizeof(**h));
326  if (!*h) {
327  av_free(work);
328  return AVERROR(ENOMEM);
329  }
330  }
331 
332  for (i = 0; i < *len; i++) {
333  (*h)[i] = work[(begin + (phase > 50.f ? *len - 1 - i : i) + work_len) & (work_len - 1)];
334  }
335  *post_len = phase > 50 ? peak - begin : begin + *len - (peak + 1);
336 
337  av_log(s, AV_LOG_DEBUG, "%d nPI=%g peak-sum@%i=%g (val@%i=%g); len=%i post=%i (%g%%)\n",
338  work_len, pi_wraps[work_len >> 1] / M_PI, peak, peak_imp_sum, imp_peak,
339  work[imp_peak], *len, *post_len, 100.f - 100.f * *post_len / (*len - 1));
340 
341  av_free(work);
342 
343  return 0;
344 }
345 
346 static int config_output(AVFilterLink *outlink)
347 {
348  AVFilterContext *ctx = outlink->src;
349  SincContext *s = ctx->priv;
350  float Fn = s->sample_rate * .5f;
351  float *h[2];
352  int i, n, post_peak, longer;
353 
354  outlink->sample_rate = s->sample_rate;
355  s->pts = 0;
356 
357  if (s->Fc0 >= Fn || s->Fc1 >= Fn) {
359  "filter frequency must be less than %d/2.\n", s->sample_rate);
360  return AVERROR(EINVAL);
361  }
362 
363  h[0] = lpf(Fn, s->Fc0, s->tbw0, &s->num_taps[0], s->att, &s->beta, s->round);
364  h[1] = lpf(Fn, s->Fc1, s->tbw1, &s->num_taps[1], s->att, &s->beta, s->round);
365 
366  if (h[0])
367  invert(h[0], s->num_taps[0]);
368 
369  longer = s->num_taps[1] > s->num_taps[0];
370  n = s->num_taps[longer];
371 
372  if (h[0] && h[1]) {
373  for (i = 0; i < s->num_taps[!longer]; i++)
374  h[longer][i + (n - s->num_taps[!longer]) / 2] += h[!longer][i];
375 
376  if (s->Fc0 < s->Fc1)
377  invert(h[longer], n);
378 
379  av_free(h[!longer]);
380  }
381 
382  if (s->phase != 50.f) {
383  int ret = fir_to_phase(s, &h[longer], &n, &post_peak, s->phase);
384  if (ret < 0)
385  return ret;
386  } else {
387  post_peak = n >> 1;
388  }
389 
390  s->n = 1 << (av_log2(n) + 1);
391  s->rdft_len = 1 << av_log2(n);
392  s->coeffs = av_calloc(s->n, sizeof(*s->coeffs));
393  if (!s->coeffs)
394  return AVERROR(ENOMEM);
395 
396  for (i = 0; i < n; i++)
397  s->coeffs[i] = h[longer][i];
398  av_free(h[longer]);
399 
400  av_rdft_end(s->rdft);
401  av_rdft_end(s->irdft);
402  s->rdft = s->irdft = NULL;
403 
404  return 0;
405 }
406 
408 {
409  SincContext *s = ctx->priv;
410 
411  av_freep(&s->coeffs);
412  av_rdft_end(s->rdft);
413  av_rdft_end(s->irdft);
414  s->rdft = s->irdft = NULL;
415 }
416 
417 static const AVFilterPad sinc_outputs[] = {
418  {
419  .name = "default",
420  .type = AVMEDIA_TYPE_AUDIO,
421  .config_props = config_output,
422  .request_frame = request_frame,
423  },
424  { NULL }
425 };
426 
427 #define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
428 #define OFFSET(x) offsetof(SincContext, x)
429 
430 static const AVOption sinc_options[] = {
431  { "sample_rate", "set sample rate", OFFSET(sample_rate), AV_OPT_TYPE_INT, {.i64=44100}, 1, INT_MAX, AF },
432  { "r", "set sample rate", OFFSET(sample_rate), AV_OPT_TYPE_INT, {.i64=44100}, 1, INT_MAX, AF },
433  { "nb_samples", "set the number of samples per requested frame", OFFSET(nb_samples), AV_OPT_TYPE_INT, {.i64=1024}, 1, INT_MAX, AF },
434  { "n", "set the number of samples per requested frame", OFFSET(nb_samples), AV_OPT_TYPE_INT, {.i64=1024}, 1, INT_MAX, AF },
435  { "hp", "set high-pass filter frequency", OFFSET(Fc0), AV_OPT_TYPE_FLOAT, {.dbl=0}, 0, INT_MAX, AF },
436  { "lp", "set low-pass filter frequency", OFFSET(Fc1), AV_OPT_TYPE_FLOAT, {.dbl=0}, 0, INT_MAX, AF },
437  { "phase", "set filter phase response", OFFSET(phase), AV_OPT_TYPE_FLOAT, {.dbl=50}, 0, 100, AF },
438  { "beta", "set kaiser window beta", OFFSET(beta), AV_OPT_TYPE_FLOAT, {.dbl=-1}, -1, 256, AF },
439  { "att", "set stop-band attenuation", OFFSET(att), AV_OPT_TYPE_FLOAT, {.dbl=120}, 40, 180, AF },
440  { "round", "enable rounding", OFFSET(round), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, AF },
441  { "hptaps", "set number of taps for high-pass filter", OFFSET(num_taps[0]), AV_OPT_TYPE_INT, {.i64=0}, 0, 32768, AF },
442  { "lptaps", "set number of taps for low-pass filter", OFFSET(num_taps[1]), AV_OPT_TYPE_INT, {.i64=0}, 0, 32768, AF },
443  { NULL }
444 };
445 
447 
449  .name = "sinc",
450  .description = NULL_IF_CONFIG_SMALL("Generate a sinc kaiser-windowed low-pass, high-pass, band-pass, or band-reject FIR coefficients."),
451  .priv_size = sizeof(SincContext),
452  .priv_class = &sinc_class,
454  .uninit = uninit,
455  .inputs = NULL,
457 };
formats
formats
Definition: signature.h:48
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:86
AVFilterChannelLayouts
A list of supported channel layouts.
Definition: formats.h:85
av_clip
#define av_clip
Definition: common.h:122
SincContext
Definition: asrc_sinc.c:32
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
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:286
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:978
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:948
layouts
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:434
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:90
atan2f
#define atan2f(y, x)
Definition: libm.h:45
ff_make_format64_list
AVFilterChannelLayouts * ff_make_format64_list(const int64_t *fmts)
Definition: formats.c:295
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
kaiser_beta
static float kaiser_beta(float att, float tr_bw)
Definition: asrc_sinc.c:141
AVOption
AVOption.
Definition: opt.h:247
expf
#define expf(x)
Definition: libm.h:283
PACK
#define PACK(h, n)
Definition: asrc_sinc.c:210
AF
#define AF
Definition: asrc_sinc.c:427
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:149
c1
static const uint64_t c1
Definition: murmur3.c:51
SincContext::sample_rate
int sample_rate
Definition: asrc_sinc.c:35
SincContext::att
float att
Definition: asrc_sinc.c:36
SincContext::nb_samples
int nb_samples
Definition: asrc_sinc.c:35
SincContext::coeffs
float * coeffs
Definition: asrc_sinc.c:41
ceilf
static __device__ float ceilf(float a)
Definition: cuda_runtime.h:175
sample_rate
sample_rate
Definition: ffmpeg_filter.c:156
SincContext::rdft
RDFTContext * rdft
Definition: asrc_sinc.c:44
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
lpf
static float * lpf(float Fn, float Fc, float tbw, int *num_taps, float att, float *beta, int round)
Definition: asrc_sinc.c:179
b1
static double b1(void *priv, double x, double y)
Definition: vf_xfade.c:1665
cosf
#define cosf(x)
Definition: libm.h:78
IDFT_C2R
@ IDFT_C2R
Definition: avfft.h:73
SincContext::tbw1
float tbw1
Definition: asrc_sinc.c:36
SincContext::Fc1
float Fc1
Definition: asrc_sinc.c:36
SincContext::pts
int64_t pts
Definition: asrc_sinc.c:42
make_lpf
static float * make_lpf(int num_taps, float Fc, float beta, float rho, float scale, int dc_norm)
Definition: asrc_sinc.c:116
fabsf
static __device__ float fabsf(float a)
Definition: cuda_runtime.h:181
OFFSET
#define OFFSET(x)
Definition: asrc_sinc.c:428
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:54
mult
static int16_t mult(Float11 *f1, Float11 *f2)
Definition: g726.c:56
avassert.h
SincContext::rdft_len
int rdft_len
Definition: asrc_sinc.c:40
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
inputs
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
Definition: filter_design.txt:243
ff_set_common_formats
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:580
s
#define s(width, name)
Definition: cbs_vp9.c:257
adjust
static int adjust(int x, int size)
Definition: mobiclip.c:515
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
SincContext::tbw0
float tbw0
Definition: asrc_sinc.c:36
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
outputs
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
SincContext::irdft
RDFTContext * irdft
Definition: asrc_sinc.c:44
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
f
#define f(width, name)
Definition: cbs_vp9.c:255
av_rdft_calc
void av_rdft_calc(RDFTContext *s, FFTSample *data)
SincContext::n
int n
Definition: asrc_sinc.c:40
ff_asrc_sinc
const AVFilter ff_asrc_sinc
Definition: asrc_sinc.c:448
SincContext::phase
float phase
Definition: asrc_sinc.c:36
av_realloc_f
#define av_realloc_f(p, o, n)
Definition: tableprint_vlc.h:33
fir_to_phase
static int fir_to_phase(SincContext *s, float **h, int *len, int *post_len, float phase)
Definition: asrc_sinc.c:222
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
sinc_outputs
static const AVFilterPad sinc_outputs[]
Definition: asrc_sinc.c:417
SincContext::round
int round
Definition: asrc_sinc.c:38
work
must be printed separately If there s no standard function for printing the type you the WRITE_1D_FUNC_ARGV macro is a very quick way to create one See libavcodec dv_tablegen c for an example The h file This file should the initialization functions should not do and instead of the variable declarations the generated *_tables h file should be included Since that will be generated in the build the path must be i e not Makefile changes To make the automatic table creation work
Definition: tablegen.txt:66
DFT_R2C
@ DFT_R2C
Definition: avfft.h:72
avfft.h
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: asrc_sinc.c:407
sinf
#define sinf(x)
Definition: libm.h:419
exp
int8_t exp
Definition: eval.c:72
kaiser_params
static void kaiser_params(float att, float Fc, float tr_bw, float *beta, int *num_taps)
Definition: asrc_sinc.c:171
request_frame
static int request_frame(AVFilterLink *outlink)
Definition: asrc_sinc.c:47
SQR
#define SQR(a)
Definition: asrc_sinc.c:212
av_rdft_init
RDFTContext * av_rdft_init(int nbits, enum RDFTransformType trans)
Set up a real FFT.
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:116
powf
#define powf(x, y)
Definition: libm.h:50
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
SincContext::beta
float beta
Definition: asrc_sinc.c:36
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
M_PI
#define M_PI
Definition: mathematics.h:52
sample_rates
sample_rates
Definition: ffmpeg_filter.c:156
internal.h
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:227
i
int i
Definition: input.c:406
round
static av_always_inline av_const double round(double x)
Definition: libm.h:444
invert
static void invert(float *h, int n)
Definition: asrc_sinc.c:202
RDFTContext
Definition: rdft.h:28
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
delta
float delta
Definition: vorbis_enc_data.h:430
len
int len
Definition: vorbis_enc_data.h:426
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:60
AVFilter
Filter definition.
Definition: avfilter.h:145
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
config_output
static int config_output(AVFilterLink *outlink)
Definition: asrc_sinc.c:346
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:251
channel_layout.h
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
avfilter.h
SincContext::Fc0
float Fc0
Definition: asrc_sinc.c:36
AVFilterContext
An instance of a filter.
Definition: avfilter.h:333
sinc_options
static const AVOption sinc_options[]
Definition: asrc_sinc.c:430
audio.h
SincContext::num_taps
int num_taps[2]
Definition: asrc_sinc.c:37
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:241
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
safe_log
static float safe_log(float x)
Definition: asrc_sinc.c:214
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: asrc_sinc.c:70
av_rdft_end
void av_rdft_end(RDFTContext *s)
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
ff_set_common_samplerates
int ff_set_common_samplerates(AVFilterContext *ctx, AVFilterFormats *samplerates)
Definition: formats.c:568
b0
static double b0(void *priv, double x, double y)
Definition: vf_xfade.c:1664
h
h
Definition: vp9dsp_template.c:2038
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(sinc)
int
int
Definition: ffmpeg_filter.c:156
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
AV_SAMPLE_FMT_FLT
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:63
bessel_I_0
static float bessel_I_0(float x)
Definition: asrc_sinc.c:101
UNPACK
#define UNPACK(h, n)
Definition: asrc_sinc.c:211
ff_set_common_channel_layouts
int ff_set_common_channel_layouts(AVFilterContext *ctx, AVFilterChannelLayouts *channel_layouts)
A helper for query_formats() which sets all links to the same list of channel layouts/sample rates.
Definition: formats.c:561