FFmpeg
resample.c
Go to the documentation of this file.
1 /*
2  * audio resampling
3  * Copyright (c) 2004-2012 Michael Niedermayer <michaelni@gmx.at>
4  * bessel function: Copyright (c) 2006 Xiaogang Zhang
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * audio resampling
26  * @author Michael Niedermayer <michaelni@gmx.at>
27  */
28 
29 #include "libavutil/avassert.h"
30 #include "libavutil/mem.h"
31 #include "resample.h"
32 
33 /**
34  * builds a polyphase filterbank.
35  * @param factor resampling factor
36  * @param scale wanted sum of coefficients for each filter
37  * @param filter_type filter type
38  * @param kaiser_beta kaiser window beta
39  * @return 0 on success, negative on error
40  */
41 static int build_filter(ResampleContext *c, void *filter, double factor, int tap_count, int alloc, int phase_count, int scale,
42  int filter_type, double kaiser_beta){
43  int ph, i;
44  int ph_nb = phase_count % 2 ? phase_count : phase_count / 2 + 1;
45  double x, y, w, t, s;
46  double *tab = av_malloc_array(tap_count+1, sizeof(*tab));
47  double *sin_lut = av_malloc_array(ph_nb, sizeof(*sin_lut));
48  const int center= (tap_count-1)/2;
49  double norm = 0;
50  int ret = AVERROR(ENOMEM);
51 
52  if (!tab || !sin_lut)
53  goto fail;
54 
55  av_assert0(tap_count == 1 || tap_count % 2 == 0);
56 
57  /* if upsampling, only need to interpolate, no filter */
58  if (factor > 1.0)
59  factor = 1.0;
60 
61  if (factor == 1.0) {
62  for (ph = 0; ph < ph_nb; ph++)
63  sin_lut[ph] = sin(M_PI * ph / phase_count) * (center & 1 ? 1 : -1);
64  }
65  for(ph = 0; ph < ph_nb; ph++) {
66  s = sin_lut[ph];
67  for(i=0;i<tap_count;i++) {
68  x = M_PI * ((double)(i - center) - (double)ph / phase_count) * factor;
69  if (x == 0) y = 1.0;
70  else if (factor == 1.0)
71  y = s / x;
72  else
73  y = sin(x) / x;
74  switch(filter_type){
76  const float d= -0.5; //first order derivative = -0.5
77  x = fabs(((double)(i - center) - (double)ph / phase_count) * factor);
78  if(x<1.0) y= 1 - 3*x*x + 2*x*x*x + d*( -x*x + x*x*x);
79  else y= d*(-4 + 8*x - 5*x*x + x*x*x);
80  break;}
82  w = 2.0*x / (factor*tap_count);
83  t = -cos(w);
84  y *= 0.3635819 - 0.4891775 * t + 0.1365995 * (2*t*t-1) - 0.0106411 * (4*t*t*t - 3*t);
85  break;
87  w = 2.0*x / (factor*tap_count*M_PI);
88  y *= av_bessel_i0(kaiser_beta*sqrt(FFMAX(1-w*w, 0)));
89  break;
90  default:
91  av_assert0(0);
92  }
93 
94  tab[i] = y;
95  s = -s;
96  if (!ph)
97  norm += y;
98  }
99 
100  /* normalize so that an uniform color remains the same */
101  switch(c->format){
102  case AV_SAMPLE_FMT_S16P:
103  for(i=0;i<tap_count;i++)
104  ((int16_t*)filter)[ph * alloc + i] = av_clip_int16(lrintf(tab[i] * scale / norm));
105  if (phase_count % 2) break;
106  for (i = 0; i < tap_count; i++)
107  ((int16_t*)filter)[(phase_count-ph) * alloc + tap_count-1-i] = ((int16_t*)filter)[ph * alloc + i];
108  break;
109  case AV_SAMPLE_FMT_S32P:
110  for(i=0;i<tap_count;i++)
111  ((int32_t*)filter)[ph * alloc + i] = av_clipl_int32(llrint(tab[i] * scale / norm));
112  if (phase_count % 2) break;
113  for (i = 0; i < tap_count; i++)
114  ((int32_t*)filter)[(phase_count-ph) * alloc + tap_count-1-i] = ((int32_t*)filter)[ph * alloc + i];
115  break;
116  case AV_SAMPLE_FMT_FLTP:
117  for(i=0;i<tap_count;i++)
118  ((float*)filter)[ph * alloc + i] = tab[i] * scale / norm;
119  if (phase_count % 2) break;
120  for (i = 0; i < tap_count; i++)
121  ((float*)filter)[(phase_count-ph) * alloc + tap_count-1-i] = ((float*)filter)[ph * alloc + i];
122  break;
123  case AV_SAMPLE_FMT_DBLP:
124  for(i=0;i<tap_count;i++)
125  ((double*)filter)[ph * alloc + i] = tab[i] * scale / norm;
126  if (phase_count % 2) break;
127  for (i = 0; i < tap_count; i++)
128  ((double*)filter)[(phase_count-ph) * alloc + tap_count-1-i] = ((double*)filter)[ph * alloc + i];
129  break;
130  }
131  }
132 #if 0
133  {
134 #define LEN 1024
135  int j,k;
136  double sine[LEN + tap_count];
137  double filtered[LEN];
138  double maxff=-2, minff=2, maxsf=-2, minsf=2;
139  for(i=0; i<LEN; i++){
140  double ss=0, sf=0, ff=0;
141  for(j=0; j<LEN+tap_count; j++)
142  sine[j]= cos(i*j*M_PI/LEN);
143  for(j=0; j<LEN; j++){
144  double sum=0;
145  ph=0;
146  for(k=0; k<tap_count; k++)
147  sum += filter[ph * tap_count + k] * sine[k+j];
148  filtered[j]= sum / (1<<FILTER_SHIFT);
149  ss+= sine[j + center] * sine[j + center];
150  ff+= filtered[j] * filtered[j];
151  sf+= sine[j + center] * filtered[j];
152  }
153  ss= sqrt(2*ss/LEN);
154  ff= sqrt(2*ff/LEN);
155  sf= 2*sf/LEN;
156  maxff= FFMAX(maxff, ff);
157  minff= FFMIN(minff, ff);
158  maxsf= FFMAX(maxsf, sf);
159  minsf= FFMIN(minsf, sf);
160  if(i%11==0){
161  av_log(NULL, AV_LOG_ERROR, "i:%4d ss:%f ff:%13.6e-%13.6e sf:%13.6e-%13.6e\n", i, ss, maxff, minff, maxsf, minsf);
162  minff=minsf= 2;
163  maxff=maxsf= -2;
164  }
165  }
166  }
167 #endif
168 
169  ret = 0;
170 fail:
171  av_free(tab);
172  av_free(sin_lut);
173  return ret;
174 }
175 
176 static void resample_free(ResampleContext **cc){
177  ResampleContext *c = *cc;
178  if(!c)
179  return;
180  av_freep(&c->filter_bank);
181  av_freep(cc);
182 }
183 
184 static ResampleContext *resample_init(ResampleContext *c, int out_rate, int in_rate, int filter_size, int phase_shift, int linear,
185  double cutoff0, enum AVSampleFormat format, enum SwrFilterType filter_type, double kaiser_beta,
186  double precision, int cheby, int exact_rational)
187 {
188  double cutoff = cutoff0? cutoff0 : 0.97;
189  double factor= FFMIN(out_rate * cutoff / in_rate, 1.0);
190  int phase_count= 1<<phase_shift;
191  int phase_count_compensation = phase_count;
192  int filter_length = FFMAX((int)ceil(filter_size/factor), 1);
193 
194  if (filter_length > 1)
195  filter_length = FFALIGN(filter_length, 2);
196 
197  if (exact_rational) {
198  int phase_count_exact, phase_count_exact_den;
199 
200  av_reduce(&phase_count_exact, &phase_count_exact_den, out_rate, in_rate, INT_MAX);
201  if (phase_count_exact <= phase_count) {
202  phase_count_compensation = phase_count_exact * (phase_count / phase_count_exact);
203  phase_count = phase_count_exact;
204  }
205  }
206 
207  if (!c || c->phase_count != phase_count || c->linear!=linear || c->factor != factor
208  || c->filter_length != filter_length || c->format != format
209  || c->filter_type != filter_type || c->kaiser_beta != kaiser_beta) {
210  resample_free(&c);
211  c = av_mallocz(sizeof(*c));
212  if (!c)
213  return NULL;
214 
215  c->format= format;
216 
217  c->felem_size= av_get_bytes_per_sample(c->format);
218 
219  switch(c->format){
220  case AV_SAMPLE_FMT_S16P:
221  c->filter_shift = 15;
222  break;
223  case AV_SAMPLE_FMT_S32P:
224  c->filter_shift = 30;
225  break;
226  case AV_SAMPLE_FMT_FLTP:
227  case AV_SAMPLE_FMT_DBLP:
228  c->filter_shift = 0;
229  break;
230  default:
231  av_log(NULL, AV_LOG_ERROR, "Unsupported sample format\n");
232  av_assert0(0);
233  }
234 
235  if (filter_size/factor > INT32_MAX/256) {
236  av_log(NULL, AV_LOG_ERROR, "Filter length too large\n");
237  goto error;
238  }
239 
240  c->phase_count = phase_count;
241  c->linear = linear;
242  c->factor = factor;
243  c->filter_length = filter_length;
244  c->filter_alloc = FFALIGN(c->filter_length, 8);
245  c->filter_bank = av_calloc(c->filter_alloc, (phase_count+1)*c->felem_size);
246  c->filter_type = filter_type;
247  c->kaiser_beta = kaiser_beta;
248  c->phase_count_compensation = phase_count_compensation;
249  if (!c->filter_bank)
250  goto error;
251  if (build_filter(c, (void*)c->filter_bank, factor, c->filter_length, c->filter_alloc, phase_count, 1<<c->filter_shift, filter_type, kaiser_beta))
252  goto error;
253  memcpy(c->filter_bank + (c->filter_alloc*phase_count+1)*c->felem_size, c->filter_bank, (c->filter_alloc-1)*c->felem_size);
254  memcpy(c->filter_bank + (c->filter_alloc*phase_count )*c->felem_size, c->filter_bank + (c->filter_alloc - 1)*c->felem_size, c->felem_size);
255  }
256 
257  c->compensation_distance= 0;
258  if(!av_reduce(&c->src_incr, &c->dst_incr, out_rate, in_rate * (int64_t)phase_count, INT32_MAX/2))
259  goto error;
260  while (c->dst_incr < (1<<20) && c->src_incr < (1<<20)) {
261  c->dst_incr *= 2;
262  c->src_incr *= 2;
263  }
264  c->ideal_dst_incr = c->dst_incr;
265  c->dst_incr_div = c->dst_incr / c->src_incr;
266  c->dst_incr_mod = c->dst_incr % c->src_incr;
267 
268  c->index= -phase_count*((c->filter_length-1)/2);
269  c->frac= 0;
270 
272 
273  return c;
274 error:
275  av_freep(&c->filter_bank);
276  av_free(c);
277  return NULL;
278 }
279 
281 {
282  uint8_t *new_filter_bank;
283  int new_src_incr, new_dst_incr;
284  int phase_count = c->phase_count_compensation;
285  int ret;
286 
287  if (phase_count == c->phase_count)
288  return 0;
289 
290  av_assert0(!c->frac && !c->dst_incr_mod);
291 
292  new_filter_bank = av_calloc(c->filter_alloc, (phase_count + 1) * c->felem_size);
293  if (!new_filter_bank)
294  return AVERROR(ENOMEM);
295 
296  ret = build_filter(c, new_filter_bank, c->factor, c->filter_length, c->filter_alloc,
297  phase_count, 1 << c->filter_shift, c->filter_type, c->kaiser_beta);
298  if (ret < 0) {
299  av_freep(&new_filter_bank);
300  return ret;
301  }
302  memcpy(new_filter_bank + (c->filter_alloc*phase_count+1)*c->felem_size, new_filter_bank, (c->filter_alloc-1)*c->felem_size);
303  memcpy(new_filter_bank + (c->filter_alloc*phase_count )*c->felem_size, new_filter_bank + (c->filter_alloc - 1)*c->felem_size, c->felem_size);
304 
305  if (!av_reduce(&new_src_incr, &new_dst_incr, c->src_incr,
306  c->dst_incr * (int64_t)(phase_count/c->phase_count), INT32_MAX/2))
307  {
308  av_freep(&new_filter_bank);
309  return AVERROR(EINVAL);
310  }
311 
312  c->src_incr = new_src_incr;
313  c->dst_incr = new_dst_incr;
314  while (c->dst_incr < (1<<20) && c->src_incr < (1<<20)) {
315  c->dst_incr *= 2;
316  c->src_incr *= 2;
317  }
318  c->ideal_dst_incr = c->dst_incr;
319  c->dst_incr_div = c->dst_incr / c->src_incr;
320  c->dst_incr_mod = c->dst_incr % c->src_incr;
321  c->index *= phase_count / c->phase_count;
322  c->phase_count = phase_count;
323  av_freep(&c->filter_bank);
324  c->filter_bank = new_filter_bank;
325  return 0;
326 }
327 
328 static int set_compensation(ResampleContext *c, int sample_delta, int compensation_distance){
329  int ret;
330 
331  if (compensation_distance && sample_delta) {
333  if (ret < 0)
334  return ret;
335  }
336 
337  c->compensation_distance= compensation_distance;
338  if (compensation_distance)
339  c->dst_incr = c->ideal_dst_incr - c->ideal_dst_incr * (int64_t)sample_delta / compensation_distance;
340  else
341  c->dst_incr = c->ideal_dst_incr;
342 
343  c->dst_incr_div = c->dst_incr / c->src_incr;
344  c->dst_incr_mod = c->dst_incr % c->src_incr;
345 
346  return 0;
347 }
348 
349 static int multiple_resample(ResampleContext *c, AudioData *dst, int dst_size, AudioData *src, int src_size, int *consumed){
350  int i;
351  int64_t max_src_size = (INT64_MAX/2 / c->phase_count) / c->src_incr;
352 
353  if (c->compensation_distance)
354  dst_size = FFMIN(dst_size, c->compensation_distance);
355  src_size = FFMIN(src_size, max_src_size);
356 
357  *consumed = 0;
358 
359  if (c->filter_length == 1 && c->phase_count == 1) {
360  int64_t index2= (1LL<<32)*c->frac/c->src_incr + (1LL<<32)*c->index + 1;
361  int64_t incr= (1LL<<32) * c->dst_incr / c->src_incr + 1;
362  int new_size = (src_size * (int64_t)c->src_incr - c->frac + c->dst_incr - 1) / c->dst_incr;
363 
364  dst_size = FFMAX(FFMIN(dst_size, new_size), 0);
365  if (dst_size > 0) {
366  for (i = 0; i < dst->ch_count; i++) {
367  c->dsp.resample_one(dst->ch[i], src->ch[i], dst_size, index2, incr);
368  if (i+1 == dst->ch_count) {
369  c->index += dst_size * c->dst_incr_div;
370  c->index += (c->frac + dst_size * (int64_t)c->dst_incr_mod) / c->src_incr;
371  av_assert2(c->index >= 0);
372  *consumed = c->index;
373  c->frac = (c->frac + dst_size * (int64_t)c->dst_incr_mod) % c->src_incr;
374  c->index = 0;
375  }
376  }
377  }
378  } else {
379  int64_t end_index = (1LL + src_size - c->filter_length) * c->phase_count;
380  int64_t delta_frac = (end_index - c->index) * c->src_incr - c->frac;
381  int delta_n = (delta_frac + c->dst_incr - 1) / c->dst_incr;
382  int (*resample_func)(struct ResampleContext *c, void *dst,
383  const void *src, int n, int update_ctx);
384 
385  dst_size = FFMAX(FFMIN(dst_size, delta_n), 0);
386  if (dst_size > 0) {
387  /* resample_linear and resample_common should have same behavior
388  * when frac and dst_incr_mod are zero */
389  resample_func = (c->linear && (c->frac || c->dst_incr_mod)) ?
390  c->dsp.resample_linear : c->dsp.resample_common;
391  for (i = 0; i < dst->ch_count; i++)
392  *consumed = resample_func(c, dst->ch[i], src->ch[i], dst_size, i+1 == dst->ch_count);
393  }
394  }
395 
396  if (c->compensation_distance) {
397  c->compensation_distance -= dst_size;
398  if (!c->compensation_distance) {
399  c->dst_incr = c->ideal_dst_incr;
400  c->dst_incr_div = c->dst_incr / c->src_incr;
401  c->dst_incr_mod = c->dst_incr % c->src_incr;
402  }
403  }
404 
405  return dst_size;
406 }
407 
408 static int64_t get_delay(struct SwrContext *s, int64_t base){
409  ResampleContext *c = s->resample;
410  int64_t num = s->in_buffer_count - (c->filter_length-1)/2;
411  num *= c->phase_count;
412  num -= c->index;
413  num *= c->src_incr;
414  num -= c->frac;
415  return av_rescale(num, base, s->in_sample_rate*(int64_t)c->src_incr * c->phase_count);
416 }
417 
418 static int64_t get_out_samples(struct SwrContext *s, int in_samples) {
419  ResampleContext *c = s->resample;
420  // The + 2 are added to allow implementations to be slightly inaccurate, they should not be needed currently.
421  // They also make it easier to proof that changes and optimizations do not
422  // break the upper bound.
423  int64_t num = s->in_buffer_count + 2LL + in_samples;
424  num *= c->phase_count;
425  num -= c->index;
426  num = av_rescale_rnd(num, s->out_sample_rate, ((int64_t)s->in_sample_rate) * c->phase_count, AV_ROUND_UP) + 2;
427 
428  if (c->compensation_distance) {
429  if (num > INT_MAX)
430  return AVERROR(EINVAL);
431 
432  num = FFMAX(num, (num * c->ideal_dst_incr - 1) / c->dst_incr + 1);
433  }
434  return num;
435 }
436 
437 static int resample_flush(struct SwrContext *s) {
438  ResampleContext *c = s->resample;
439  AudioData *a= &s->in_buffer;
440  int i, j, ret;
441  int reflection = (FFMIN(s->in_buffer_count, c->filter_length) + 1) / 2;
442 
443  if((ret = swri_realloc_audio(a, s->in_buffer_index + s->in_buffer_count + reflection)) < 0)
444  return ret;
445  av_assert0(a->planar);
446  for(i=0; i<a->ch_count; i++){
447  for(j=0; j<reflection; j++){
448  memcpy(a->ch[i] + (s->in_buffer_index+s->in_buffer_count+j )*a->bps,
449  a->ch[i] + (s->in_buffer_index+s->in_buffer_count-j-1)*a->bps, a->bps);
450  }
451  }
452  s->in_buffer_count += reflection;
453  return 0;
454 }
455 
456 // in fact the whole handle multiple ridiculously small buffers might need more thinking...
458  int in_count, int *out_idx, int *out_sz)
459 {
460  int n, ch, num = FFMIN(in_count + *out_sz, c->filter_length + 1), res;
461 
462  if (c->index >= 0)
463  return 0;
464 
465  if ((res = swri_realloc_audio(dst, c->filter_length * 2 + 1)) < 0)
466  return res;
467 
468  // copy
469  for (n = *out_sz; n < num; n++) {
470  for (ch = 0; ch < src->ch_count; ch++) {
471  memcpy(dst->ch[ch] + ((c->filter_length + n) * c->felem_size),
472  src->ch[ch] + ((n - *out_sz) * c->felem_size), c->felem_size);
473  }
474  }
475 
476  // if not enough data is in, return and wait for more
477  if (num < c->filter_length + 1) {
478  *out_sz = num;
479  *out_idx = c->filter_length;
480  return INT_MAX;
481  }
482 
483  // else invert
484  for (n = 1; n <= c->filter_length; n++) {
485  for (ch = 0; ch < src->ch_count; ch++) {
486  memcpy(dst->ch[ch] + ((c->filter_length - n) * c->felem_size),
487  dst->ch[ch] + ((c->filter_length + n) * c->felem_size),
488  c->felem_size);
489  }
490  }
491 
492  res = num - *out_sz;
493  *out_idx = c->filter_length;
494  while (c->index < 0) {
495  --*out_idx;
496  c->index += c->phase_count;
497  }
498  *out_sz = FFMAX(*out_sz + c->filter_length,
499  1 + c->filter_length * 2) - *out_idx;
500 
501  return FFMAX(res, 0);
502 }
503 
504 struct Resampler const swri_resampler={
510  get_delay,
513 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
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
resample_free
static void resample_free(ResampleContext **cc)
Definition: resample.c:176
av_bessel_i0
double av_bessel_i0(double x)
0th order modified bessel function of the first kind.
Definition: mathematics.c:257
ph
static int FUNC() ph(CodedBitstreamContext *ctx, RWContext *rw, H266RawPH *current)
Definition: cbs_h266_syntax_template.c:3005
w
uint8_t w
Definition: llviddspenc.c:38
kaiser_beta
static float kaiser_beta(float att, float tr_bw)
Definition: asrc_sinc.c:124
AV_SAMPLE_FMT_S32P
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
Definition: samplefmt.h:65
linear
static int linear(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:135
LEN
#define LEN
base
uint8_t base
Definition: vp3data.h:128
filter
void(* filter)(uint8_t *src, int stride, int qscale)
Definition: h263dsp.c:29
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AudioData
Definition: swresample_internal.h:45
SWR_FILTER_TYPE_BLACKMAN_NUTTALL
@ SWR_FILTER_TYPE_BLACKMAN_NUTTALL
Blackman Nuttall windowed sinc.
Definition: swresample.h:175
ResampleContext::filter_length
int filter_length
Definition: resample.h:33
fail
#define fail()
Definition: checkasm.h:184
swri_realloc_audio
int swri_realloc_audio(AudioData *a, int count)
Definition: swresample.c:402
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:10345
AV_ROUND_UP
@ AV_ROUND_UP
Round toward +infinity.
Definition: mathematics.h:134
SWR_FILTER_TYPE_KAISER
@ SWR_FILTER_TYPE_KAISER
Kaiser windowed sinc.
Definition: swresample.h:176
ss
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:202
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
avassert.h
ceil
static __device__ float ceil(float a)
Definition: cuda_runtime.h:176
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
s
#define s(width, name)
Definition: cbs_vp9.c:198
ResampleContext
Definition: resample.h:30
format
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 format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
SwrContext
The libswresample context.
Definition: swresample_internal.h:95
AudioData::ch
uint8_t * ch[SWR_CH_MAX]
samples buffer per channel
Definition: swresample_internal.h:46
if
if(ret)
Definition: filter_design.txt:179
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
av_clip_int16
#define av_clip_int16
Definition: common.h:114
NULL
#define NULL
Definition: coverity.c:32
SwrFilterType
SwrFilterType
Resampling Filter Types.
Definition: swresample.h:173
get_delay
static int64_t get_delay(struct SwrContext *s, int64_t base)
Definition: resample.c:408
double
double
Definition: af_crystalizer.c:131
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
AudioData::ch_count
int ch_count
number of channels
Definition: swresample_internal.h:48
av_rescale_rnd
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)
Rescale a 64-bit integer with specified rounding.
Definition: mathematics.c:58
av_clipl_int32
#define av_clipl_int32
Definition: common.h:117
SWR_FILTER_TYPE_CUBIC
@ SWR_FILTER_TYPE_CUBIC
Cubic.
Definition: swresample.h:174
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
rebuild_filter_bank_with_compensation
static int rebuild_filter_bank_with_compensation(ResampleContext *c)
Definition: resample.c:280
Resampler
Definition: swresample_internal.h:81
M_PI
#define M_PI
Definition: mathematics.h:67
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:64
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:67
lrintf
#define lrintf(x)
Definition: libm_mips.h:72
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
av_get_bytes_per_sample
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:108
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
invert_initial_buffer
static int invert_initial_buffer(ResampleContext *c, AudioData *dst, const AudioData *src, int in_count, int *out_idx, int *out_sz)
Definition: resample.c:457
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
resample.h
ret
ret
Definition: filter_design.txt:187
get_out_samples
static int64_t get_out_samples(struct SwrContext *s, int in_samples)
Definition: resample.c:418
set_compensation
static int set_compensation(ResampleContext *c, int sample_delta, int compensation_distance)
Definition: resample.c:328
AV_SAMPLE_FMT_DBLP
@ AV_SAMPLE_FMT_DBLP
double, planar
Definition: samplefmt.h:67
factor
static const int factor[16]
Definition: vf_pp7.c:79
swri_resample_dsp_init
void swri_resample_dsp_init(ResampleContext *c)
Definition: resample_dsp.c:46
build_filter
static int build_filter(ResampleContext *c, void *filter, double factor, int tap_count, int alloc, int phase_count, int scale, int filter_type, double kaiser_beta)
builds a polyphase filterbank.
Definition: resample.c:41
resample_flush
static int resample_flush(struct SwrContext *s)
Definition: resample.c:437
mem.h
multiple_resample
static int multiple_resample(ResampleContext *c, AudioData *dst, int dst_size, AudioData *src, int src_size, int *consumed)
Definition: resample.c:349
llrint
#define llrint(x)
Definition: libm.h:394
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:291
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
d
d
Definition: ffmpeg_filter.c:424
int32_t
int32_t
Definition: audioconvert.c:56
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
resample_init
static ResampleContext * resample_init(ResampleContext *c, int out_rate, int in_rate, int filter_size, int phase_shift, int linear, double cutoff0, enum AVSampleFormat format, enum SwrFilterType filter_type, double kaiser_beta, double precision, int cheby, int exact_rational)
Definition: resample.c:184
int
int
Definition: ffmpeg_filter.c:424
swri_resampler
struct Resampler const swri_resampler
Definition: resample.c:504