FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 "resample.h"
31 
32 static inline double eval_poly(const double *coeff, int size, double x) {
33  double sum = coeff[size-1];
34  int i;
35  for (i = size-2; i >= 0; --i) {
36  sum *= x;
37  sum += coeff[i];
38  }
39  return sum;
40 }
41 
42 /**
43  * 0th order modified bessel function of the first kind.
44  * Algorithm taken from the Boost project, source:
45  * https://searchcode.com/codesearch/view/14918379/
46  * Use, modification and distribution are subject to the
47  * Boost Software License, Version 1.0 (see notice below).
48  * Boost Software License - Version 1.0 - August 17th, 2003
49 Permission is hereby granted, free of charge, to any person or organization
50 obtaining a copy of the software and accompanying documentation covered by
51 this license (the "Software") to use, reproduce, display, distribute,
52 execute, and transmit the Software, and to prepare derivative works of the
53 Software, and to permit third-parties to whom the Software is furnished to
54 do so, all subject to the following:
55 
56 The copyright notices in the Software and this entire statement, including
57 the above license grant, this restriction and the following disclaimer,
58 must be included in all copies of the Software, in whole or in part, and
59 all derivative works of the Software, unless such copies or derivative
60 works are solely in the form of machine-executable object code generated by
61 a source language processor.
62 
63 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
64 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
65 FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
66 SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
67 FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
68 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
69 DEALINGS IN THE SOFTWARE.
70  */
71 
72 static double bessel(double x) {
73 // Modified Bessel function of the first kind of order zero
74 // minimax rational approximations on intervals, see
75 // Blair and Edwards, Chalk River Report AECL-4928, 1974
76  static const double p1[] = {
77  -2.2335582639474375249e+15,
78  -5.5050369673018427753e+14,
79  -3.2940087627407749166e+13,
80  -8.4925101247114157499e+11,
81  -1.1912746104985237192e+10,
82  -1.0313066708737980747e+08,
83  -5.9545626019847898221e+05,
84  -2.4125195876041896775e+03,
85  -7.0935347449210549190e+00,
86  -1.5453977791786851041e-02,
87  -2.5172644670688975051e-05,
88  -3.0517226450451067446e-08,
89  -2.6843448573468483278e-11,
90  -1.5982226675653184646e-14,
91  -5.2487866627945699800e-18,
92  };
93  static const double q1[] = {
94  -2.2335582639474375245e+15,
95  7.8858692566751002988e+12,
96  -1.2207067397808979846e+10,
97  1.0377081058062166144e+07,
98  -4.8527560179962773045e+03,
99  1.0,
100  };
101  static const double p2[] = {
102  -2.2210262233306573296e-04,
103  1.3067392038106924055e-02,
104  -4.4700805721174453923e-01,
105  5.5674518371240761397e+00,
106  -2.3517945679239481621e+01,
107  3.1611322818701131207e+01,
108  -9.6090021968656180000e+00,
109  };
110  static const double q2[] = {
111  -5.5194330231005480228e-04,
112  3.2547697594819615062e-02,
113  -1.1151759188741312645e+00,
114  1.3982595353892851542e+01,
115  -6.0228002066743340583e+01,
116  8.5539563258012929600e+01,
117  -3.1446690275135491500e+01,
118  1.0,
119  };
120  double y, r, factor;
121  if (x == 0)
122  return 1.0;
123  x = fabs(x);
124  if (x <= 15) {
125  y = x * x;
126  return eval_poly(p1, FF_ARRAY_ELEMS(p1), y) / eval_poly(q1, FF_ARRAY_ELEMS(q1), y);
127  }
128  else {
129  y = 1 / x - 1.0 / 15;
130  r = eval_poly(p2, FF_ARRAY_ELEMS(p2), y) / eval_poly(q2, FF_ARRAY_ELEMS(q2), y);
131  factor = exp(x) / sqrt(x);
132  return factor * r;
133  }
134 }
135 
136 /**
137  * builds a polyphase filterbank.
138  * @param factor resampling factor
139  * @param scale wanted sum of coefficients for each filter
140  * @param filter_type filter type
141  * @param kaiser_beta kaiser window beta
142  * @return 0 on success, negative on error
143  */
144 static int build_filter(ResampleContext *c, void *filter, double factor, int tap_count, int alloc, int phase_count, int scale,
145  int filter_type, double kaiser_beta){
146  int ph, i;
147  int ph_nb = phase_count % 2 ? phase_count : phase_count / 2 + 1;
148  double x, y, w, t, s;
149  double *tab = av_malloc_array(tap_count+1, sizeof(*tab));
150  double *sin_lut = av_malloc_array(ph_nb, sizeof(*sin_lut));
151  const int center= (tap_count-1)/2;
152  int ret = AVERROR(ENOMEM);
153 
154  if (!tab || !sin_lut)
155  goto fail;
156 
157  /* if upsampling, only need to interpolate, no filter */
158  if (factor > 1.0)
159  factor = 1.0;
160 
161  if (factor == 1.0) {
162  for (ph = 0; ph < ph_nb; ph++)
163  sin_lut[ph] = sin(M_PI * ph / phase_count);
164  }
165  for(ph = 0; ph < ph_nb; ph++) {
166  double norm = 0;
167  s = sin_lut[ph];
168  for(i=0;i<=tap_count;i++) {
169  x = M_PI * ((double)(i - center) - (double)ph / phase_count) * factor;
170  if (x == 0) y = 1.0;
171  else if (factor == 1.0)
172  y = s / x;
173  else
174  y = sin(x) / x;
175  switch(filter_type){
176  case SWR_FILTER_TYPE_CUBIC:{
177  const float d= -0.5; //first order derivative = -0.5
178  x = fabs(((double)(i - center) - (double)ph / phase_count) * factor);
179  if(x<1.0) y= 1 - 3*x*x + 2*x*x*x + d*( -x*x + x*x*x);
180  else y= d*(-4 + 8*x - 5*x*x + x*x*x);
181  break;}
183  w = 2.0*x / (factor*tap_count);
184  t = -cos(w);
185  y *= 0.3635819 - 0.4891775 * t + 0.1365995 * (2*t*t-1) - 0.0106411 * (4*t*t*t - 3*t);
186  break;
188  w = 2.0*x / (factor*tap_count*M_PI);
189  y *= bessel(kaiser_beta*sqrt(FFMAX(1-w*w, 0)));
190  break;
191  default:
192  av_assert0(0);
193  }
194 
195  tab[i] = y;
196  s = -s;
197  if (i < tap_count)
198  norm += y;
199  }
200 
201  /* normalize so that an uniform color remains the same */
202  switch(c->format){
203  case AV_SAMPLE_FMT_S16P:
204  for(i=0;i<tap_count;i++)
205  ((int16_t*)filter)[ph * alloc + i] = av_clip_int16(lrintf(tab[i] * scale / norm));
206  if (phase_count % 2) break;
207  if (tap_count % 2 == 0 || tap_count == 1) {
208  for (i = 0; i < tap_count; i++)
209  ((int16_t*)filter)[(phase_count-ph) * alloc + tap_count-1-i] = ((int16_t*)filter)[ph * alloc + i];
210  }
211  else {
212  for (i = 1; i <= tap_count; i++)
213  ((int16_t*)filter)[(phase_count-ph) * alloc + tap_count-i] =
214  av_clip_int16(lrintf(tab[i] * scale / (norm - tab[0] + tab[tap_count])));
215  }
216  break;
217  case AV_SAMPLE_FMT_S32P:
218  for(i=0;i<tap_count;i++)
219  ((int32_t*)filter)[ph * alloc + i] = av_clipl_int32(llrint(tab[i] * scale / norm));
220  if (phase_count % 2) break;
221  if (tap_count % 2 == 0 || tap_count == 1) {
222  for (i = 0; i < tap_count; i++)
223  ((int32_t*)filter)[(phase_count-ph) * alloc + tap_count-1-i] = ((int32_t*)filter)[ph * alloc + i];
224  }
225  else {
226  for (i = 1; i <= tap_count; i++)
227  ((int32_t*)filter)[(phase_count-ph) * alloc + tap_count-i] =
228  av_clipl_int32(llrint(tab[i] * scale / (norm - tab[0] + tab[tap_count])));
229  }
230  break;
231  case AV_SAMPLE_FMT_FLTP:
232  for(i=0;i<tap_count;i++)
233  ((float*)filter)[ph * alloc + i] = tab[i] * scale / norm;
234  if (phase_count % 2) break;
235  if (tap_count % 2 == 0 || tap_count == 1) {
236  for (i = 0; i < tap_count; i++)
237  ((float*)filter)[(phase_count-ph) * alloc + tap_count-1-i] = ((float*)filter)[ph * alloc + i];
238  }
239  else {
240  for (i = 1; i <= tap_count; i++)
241  ((float*)filter)[(phase_count-ph) * alloc + tap_count-i] = tab[i] * scale / (norm - tab[0] + tab[tap_count]);
242  }
243  break;
244  case AV_SAMPLE_FMT_DBLP:
245  for(i=0;i<tap_count;i++)
246  ((double*)filter)[ph * alloc + i] = tab[i] * scale / norm;
247  if (phase_count % 2) break;
248  if (tap_count % 2 == 0 || tap_count == 1) {
249  for (i = 0; i < tap_count; i++)
250  ((double*)filter)[(phase_count-ph) * alloc + tap_count-1-i] = ((double*)filter)[ph * alloc + i];
251  }
252  else {
253  for (i = 1; i <= tap_count; i++)
254  ((double*)filter)[(phase_count-ph) * alloc + tap_count-i] = tab[i] * scale / (norm - tab[0] + tab[tap_count]);
255  }
256  break;
257  }
258  }
259 #if 0
260  {
261 #define LEN 1024
262  int j,k;
263  double sine[LEN + tap_count];
264  double filtered[LEN];
265  double maxff=-2, minff=2, maxsf=-2, minsf=2;
266  for(i=0; i<LEN; i++){
267  double ss=0, sf=0, ff=0;
268  for(j=0; j<LEN+tap_count; j++)
269  sine[j]= cos(i*j*M_PI/LEN);
270  for(j=0; j<LEN; j++){
271  double sum=0;
272  ph=0;
273  for(k=0; k<tap_count; k++)
274  sum += filter[ph * tap_count + k] * sine[k+j];
275  filtered[j]= sum / (1<<FILTER_SHIFT);
276  ss+= sine[j + center] * sine[j + center];
277  ff+= filtered[j] * filtered[j];
278  sf+= sine[j + center] * filtered[j];
279  }
280  ss= sqrt(2*ss/LEN);
281  ff= sqrt(2*ff/LEN);
282  sf= 2*sf/LEN;
283  maxff= FFMAX(maxff, ff);
284  minff= FFMIN(minff, ff);
285  maxsf= FFMAX(maxsf, sf);
286  minsf= FFMIN(minsf, sf);
287  if(i%11==0){
288  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);
289  minff=minsf= 2;
290  maxff=maxsf= -2;
291  }
292  }
293  }
294 #endif
295 
296  ret = 0;
297 fail:
298  av_free(tab);
299  av_free(sin_lut);
300  return ret;
301 }
302 
303 static ResampleContext *resample_init(ResampleContext *c, int out_rate, int in_rate, int filter_size, int phase_shift, int linear,
304  double cutoff0, enum AVSampleFormat format, enum SwrFilterType filter_type, double kaiser_beta,
305  double precision, int cheby, int exact_rational)
306 {
307  double cutoff = cutoff0? cutoff0 : 0.97;
308  double factor= FFMIN(out_rate * cutoff / in_rate, 1.0);
309  int phase_count= 1<<phase_shift;
310  int phase_count_compensation = phase_count;
311 
312  if (exact_rational) {
313  int phase_count_exact, phase_count_exact_den;
314 
315  av_reduce(&phase_count_exact, &phase_count_exact_den, out_rate, in_rate, INT_MAX);
316  if (phase_count_exact <= phase_count) {
317  phase_count_compensation = phase_count_exact * (phase_count / phase_count_exact);
318  phase_count = phase_count_exact;
319  }
320  }
321 
322  if (!c || c->phase_count != phase_count || c->linear!=linear || c->factor != factor
323  || c->filter_length != FFMAX((int)ceil(filter_size/factor), 1) || c->format != format
324  || c->filter_type != filter_type || c->kaiser_beta != kaiser_beta) {
325  c = av_mallocz(sizeof(*c));
326  if (!c)
327  return NULL;
328 
329  c->format= format;
330 
332 
333  switch(c->format){
334  case AV_SAMPLE_FMT_S16P:
335  c->filter_shift = 15;
336  break;
337  case AV_SAMPLE_FMT_S32P:
338  c->filter_shift = 30;
339  break;
340  case AV_SAMPLE_FMT_FLTP:
341  case AV_SAMPLE_FMT_DBLP:
342  c->filter_shift = 0;
343  break;
344  default:
345  av_log(NULL, AV_LOG_ERROR, "Unsupported sample format\n");
346  av_assert0(0);
347  }
348 
349  if (filter_size/factor > INT32_MAX/256) {
350  av_log(NULL, AV_LOG_ERROR, "Filter length too large\n");
351  goto error;
352  }
353 
354  c->phase_count = phase_count;
355  c->linear = linear;
356  c->factor = factor;
357  c->filter_length = FFMAX((int)ceil(filter_size/factor), 1);
358  c->filter_alloc = FFALIGN(c->filter_length, 8);
359  c->filter_bank = av_calloc(c->filter_alloc, (phase_count+1)*c->felem_size);
360  c->filter_type = filter_type;
361  c->kaiser_beta = kaiser_beta;
362  c->phase_count_compensation = phase_count_compensation;
363  if (!c->filter_bank)
364  goto error;
365  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))
366  goto error;
367  memcpy(c->filter_bank + (c->filter_alloc*phase_count+1)*c->felem_size, c->filter_bank, (c->filter_alloc-1)*c->felem_size);
368  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);
369  }
370 
371  c->compensation_distance= 0;
372  if(!av_reduce(&c->src_incr, &c->dst_incr, out_rate, in_rate * (int64_t)phase_count, INT32_MAX/2))
373  goto error;
374  while (c->dst_incr < (1<<20) && c->src_incr < (1<<20)) {
375  c->dst_incr *= 2;
376  c->src_incr *= 2;
377  }
378  c->ideal_dst_incr = c->dst_incr;
379  c->dst_incr_div = c->dst_incr / c->src_incr;
380  c->dst_incr_mod = c->dst_incr % c->src_incr;
381 
382  c->index= -phase_count*((c->filter_length-1)/2);
383  c->frac= 0;
384 
386 
387  return c;
388 error:
389  av_freep(&c->filter_bank);
390  av_free(c);
391  return NULL;
392 }
393 
395  if(!*c)
396  return;
397  av_freep(&(*c)->filter_bank);
398  av_freep(c);
399 }
400 
402 {
403  uint8_t *new_filter_bank;
404  int new_src_incr, new_dst_incr;
405  int phase_count = c->phase_count_compensation;
406  int ret;
407 
408  if (phase_count == c->phase_count)
409  return 0;
410 
412 
413  new_filter_bank = av_calloc(c->filter_alloc, (phase_count + 1) * c->felem_size);
414  if (!new_filter_bank)
415  return AVERROR(ENOMEM);
416 
417  ret = build_filter(c, new_filter_bank, c->factor, c->filter_length, c->filter_alloc,
418  phase_count, 1 << c->filter_shift, c->filter_type, c->kaiser_beta);
419  if (ret < 0) {
420  av_freep(&new_filter_bank);
421  return ret;
422  }
423  memcpy(new_filter_bank + (c->filter_alloc*phase_count+1)*c->felem_size, new_filter_bank, (c->filter_alloc-1)*c->felem_size);
424  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);
425 
426  if (!av_reduce(&new_src_incr, &new_dst_incr, c->src_incr,
427  c->dst_incr * (int64_t)(phase_count/c->phase_count), INT32_MAX/2))
428  {
429  av_freep(&new_filter_bank);
430  return AVERROR(EINVAL);
431  }
432 
433  c->src_incr = new_src_incr;
434  c->dst_incr = new_dst_incr;
435  while (c->dst_incr < (1<<20) && c->src_incr < (1<<20)) {
436  c->dst_incr *= 2;
437  c->src_incr *= 2;
438  }
439  c->ideal_dst_incr = c->dst_incr;
440  c->dst_incr_div = c->dst_incr / c->src_incr;
441  c->dst_incr_mod = c->dst_incr % c->src_incr;
442  c->index *= phase_count / c->phase_count;
443  c->phase_count = phase_count;
444  av_freep(&c->filter_bank);
445  c->filter_bank = new_filter_bank;
446  return 0;
447 }
448 
449 static int set_compensation(ResampleContext *c, int sample_delta, int compensation_distance){
450  int ret;
451 
452  if (compensation_distance) {
454  if (ret < 0)
455  return ret;
456  }
457 
459  if (compensation_distance)
460  c->dst_incr = c->ideal_dst_incr - c->ideal_dst_incr * (int64_t)sample_delta / compensation_distance;
461  else
462  c->dst_incr = c->ideal_dst_incr;
463 
464  c->dst_incr_div = c->dst_incr / c->src_incr;
465  c->dst_incr_mod = c->dst_incr % c->src_incr;
466 
467  return 0;
468 }
469 
471  uint8_t *dst, const uint8_t *src, int *consumed,
472  int src_size, int dst_size, int update_ctx)
473 {
474  if (c->filter_length == 1 && c->phase_count == 1) {
475  int index= c->index;
476  int frac= c->frac;
477  int64_t index2= (1LL<<32)*c->frac/c->src_incr + (1LL<<32)*index;
478  int64_t incr= (1LL<<32) * c->dst_incr / c->src_incr;
479  int new_size = (src_size * (int64_t)c->src_incr - frac + c->dst_incr - 1) / c->dst_incr;
480 
481  dst_size= FFMIN(dst_size, new_size);
482  c->dsp.resample_one(dst, src, dst_size, index2, incr);
483 
484  index += dst_size * c->dst_incr_div;
485  index += (frac + dst_size * (int64_t)c->dst_incr_mod) / c->src_incr;
486  av_assert2(index >= 0);
487  *consumed= index;
488  if (update_ctx) {
489  c->frac = (frac + dst_size * (int64_t)c->dst_incr_mod) % c->src_incr;
490  c->index = 0;
491  }
492  } else {
493  int64_t end_index = (1LL + src_size - c->filter_length) * c->phase_count;
494  int64_t delta_frac = (end_index - c->index) * c->src_incr - c->frac;
495  int delta_n = (delta_frac + c->dst_incr - 1) / c->dst_incr;
496 
497  dst_size = FFMIN(dst_size, delta_n);
498  if (dst_size > 0) {
499  *consumed = c->dsp.resample(c, dst, src, dst_size, update_ctx);
500  } else {
501  *consumed = 0;
502  }
503  }
504 
505  return dst_size;
506 }
507 
508 static int multiple_resample(ResampleContext *c, AudioData *dst, int dst_size, AudioData *src, int src_size, int *consumed){
509  int i, ret= -1;
510  int av_unused mm_flags = av_get_cpu_flags();
511  int need_emms = c->format == AV_SAMPLE_FMT_S16P && ARCH_X86_32 &&
513  int64_t max_src_size = (INT64_MAX/2 / c->phase_count) / c->src_incr;
514 
516  dst_size = FFMIN(dst_size, c->compensation_distance);
517  src_size = FFMIN(src_size, max_src_size);
518 
519  for(i=0; i<dst->ch_count; i++){
520  ret= swri_resample(c, dst->ch[i], src->ch[i],
521  consumed, src_size, dst_size, i+1==dst->ch_count);
522  }
523  if(need_emms)
524  emms_c();
525 
526  if (c->compensation_distance) {
527  c->compensation_distance -= ret;
528  if (!c->compensation_distance) {
529  c->dst_incr = c->ideal_dst_incr;
530  c->dst_incr_div = c->dst_incr / c->src_incr;
531  c->dst_incr_mod = c->dst_incr % c->src_incr;
532  }
533  }
534 
535  return ret;
536 }
537 
538 static int64_t get_delay(struct SwrContext *s, int64_t base){
539  ResampleContext *c = s->resample;
540  int64_t num = s->in_buffer_count - (c->filter_length-1)/2;
541  num *= c->phase_count;
542  num -= c->index;
543  num *= c->src_incr;
544  num -= c->frac;
545  return av_rescale(num, base, s->in_sample_rate*(int64_t)c->src_incr * c->phase_count);
546 }
547 
548 static int64_t get_out_samples(struct SwrContext *s, int in_samples) {
549  ResampleContext *c = s->resample;
550  // The + 2 are added to allow implementations to be slightly inaccurate, they should not be needed currently.
551  // They also make it easier to proof that changes and optimizations do not
552  // break the upper bound.
553  int64_t num = s->in_buffer_count + 2LL + in_samples;
554  num *= c->phase_count;
555  num -= c->index;
556  num = av_rescale_rnd(num, s->out_sample_rate, ((int64_t)s->in_sample_rate) * c->phase_count, AV_ROUND_UP) + 2;
557 
558  if (c->compensation_distance) {
559  if (num > INT_MAX)
560  return AVERROR(EINVAL);
561 
562  num = FFMAX(num, (num * c->ideal_dst_incr - 1) / c->dst_incr + 1);
563  }
564  return num;
565 }
566 
567 static int resample_flush(struct SwrContext *s) {
568  AudioData *a= &s->in_buffer;
569  int i, j, ret;
570  if((ret = swri_realloc_audio(a, s->in_buffer_index + 2*s->in_buffer_count)) < 0)
571  return ret;
572  av_assert0(a->planar);
573  for(i=0; i<a->ch_count; i++){
574  for(j=0; j<s->in_buffer_count; j++){
575  memcpy(a->ch[i] + (s->in_buffer_index+s->in_buffer_count+j )*a->bps,
576  a->ch[i] + (s->in_buffer_index+s->in_buffer_count-j-1)*a->bps, a->bps);
577  }
578  }
579  s->in_buffer_count += (s->in_buffer_count+1)/2;
580  return 0;
581 }
582 
583 // in fact the whole handle multiple ridiculously small buffers might need more thinking...
585  int in_count, int *out_idx, int *out_sz)
586 {
587  int n, ch, num = FFMIN(in_count + *out_sz, c->filter_length + 1), res;
588 
589  if (c->index >= 0)
590  return 0;
591 
592  if ((res = swri_realloc_audio(dst, c->filter_length * 2 + 1)) < 0)
593  return res;
594 
595  // copy
596  for (n = *out_sz; n < num; n++) {
597  for (ch = 0; ch < src->ch_count; ch++) {
598  memcpy(dst->ch[ch] + ((c->filter_length + n) * c->felem_size),
599  src->ch[ch] + ((n - *out_sz) * c->felem_size), c->felem_size);
600  }
601  }
602 
603  // if not enough data is in, return and wait for more
604  if (num < c->filter_length + 1) {
605  *out_sz = num;
606  *out_idx = c->filter_length;
607  return INT_MAX;
608  }
609 
610  // else invert
611  for (n = 1; n <= c->filter_length; n++) {
612  for (ch = 0; ch < src->ch_count; ch++) {
613  memcpy(dst->ch[ch] + ((c->filter_length - n) * c->felem_size),
614  dst->ch[ch] + ((c->filter_length + n) * c->felem_size),
615  c->felem_size);
616  }
617  }
618 
619  res = num - *out_sz;
620  *out_idx = c->filter_length;
621  while (c->index < 0) {
622  --*out_idx;
623  c->index += c->phase_count;
624  }
625  *out_sz = FFMAX(*out_sz + c->filter_length,
626  1 + c->filter_length * 2) - *out_idx;
627 
628  return FFMAX(res, 0);
629 }
630 
631 struct Resampler const swri_resampler={
637  get_delay,
640 };
float, planar
Definition: samplefmt.h:69
#define NULL
Definition: coverity.c:32
const char * s
Definition: avisynth_c.h:768
static int multiple_resample(ResampleContext *c, AudioData *dst, int dst_size, AudioData *src, int src_size, int *consumed)
Definition: resample.c:508
double factor
Definition: resample.h:47
static int rebuild_filter_bank_with_compensation(ResampleContext *c)
Definition: resample.c:401
int out_sample_rate
output sample rate
Audio buffer used for intermediate storage between conversion phases.
Definition: audio_data.h:37
static int linear(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:116
int ch_count
number of channels
SwrFilterType
Resampling Filter Types.
Definition: swresample.h:170
#define AV_CPU_FLAG_MMX2
SSE integer functions or AMD MMX ext.
Definition: cpu.h:31
double, planar
Definition: samplefmt.h:70
int in_buffer_index
cached buffer position
AudioData in_buffer
cached audio data (convert and resample purpose)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:252
struct ResampleContext * resample
resampling context
static const uint8_t q1[256]
Definition: twofish.c:96
struct ResampleContext::@243 dsp
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:260
int filter_alloc
Definition: resample.h:34
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
enum AVSampleFormat format
Definition: resample.h:48
uint8_t
Round toward +infinity.
Definition: mathematics.h:83
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
static int swri_resample(ResampleContext *c, uint8_t *dst, const uint8_t *src, int *consumed, int src_size, int dst_size, int update_ctx)
Definition: resample.c:470
static void resample_free(ResampleContext **c)
Definition: resample.c:394
static double bessel(double x)
0th order modified bessel function of the first kind.
Definition: resample.c:72
static void filter(int16_t *output, ptrdiff_t out_stride, int16_t *low, ptrdiff_t low_stride, int16_t *high, ptrdiff_t high_stride, int len, uint8_t clip)
Definition: cfhd.c:80
int swri_realloc_audio(AudioData *a, int count)
Definition: swresample.c:393
int compensation_distance
Definition: resample.h:38
static int set_compensation(ResampleContext *c, int sample_delta, int compensation_distance)
Definition: resample.c:449
enum AVResampleFilterType filter_type
Definition: resample.h:42
int filter_shift
Definition: resample.h:50
struct Resampler const swri_resampler
Definition: resample.c:631
static int invert_initial_buffer(ResampleContext *c, AudioData *dst, const AudioData *src, int in_count, int *out_idx, int *out_sz)
Definition: resample.c:584
#define lrintf(x)
Definition: libm_mips.h:70
int dst_incr_mod
Definition: resample.h:38
ptrdiff_t size
Definition: opengl_enc.c:101
Kaiser windowed sinc.
Definition: swresample.h:173
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
#define FFALIGN(x, a)
Definition: macros.h:48
#define av_log(a,...)
static double eval_poly(const double *coeff, int size, double x)
Definition: resample.c:32
int in_buffer_count
cached buffer length
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
Blackman Nuttall windowed sinc.
Definition: swresample.h:172
static int resample_flush(struct SwrContext *s)
Definition: resample.c:567
#define AVERROR(e)
Definition: error.h:43
The libswresample context.
const char * r
Definition: vf_curves.c:111
unsigned int index
Definition: resample.h:35
int dst_incr_div
Definition: resample.h:37
simple assert() macros that are a bit more flexible than ISO C assert().
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:303
#define FFMAX(a, b)
Definition: common.h:94
#define fail()
Definition: checkasm.h:83
int8_t exp
Definition: eval.c:64
int compensation_distance
Definition: resample2.c:71
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
#define FFMIN(a, b)
Definition: common.h:96
signed 32 bits, planar
Definition: samplefmt.h:68
static int64_t get_delay(struct SwrContext *s, int64_t base)
Definition: resample.c:538
int32_t
int in_sample_rate
input sample rate
int bps
bytes per sample
int n
Definition: avisynth_c.h:684
#define src
Definition: vp9dsp.c:530
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
#define FF_ARRAY_ELEMS(a)
#define FILTER_SHIFT
Definition: resample2.c:35
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
#define ss
#define llrint(x)
Definition: libm.h:394
int filter_length
Definition: resample.h:32
static const char * format
Definition: movenc.c:47
int index
Definition: gxfenc.c:89
void swri_resample_dsp_init(ResampleContext *c)
Definition: resample_dsp.c:46
#define LEN
static const int factor[16]
Definition: vf_pp7.c:75
int av_get_cpu_flags(void)
Return the flags which specify extensions supported by the CPU.
Definition: cpu.c:76
int(* resample)(struct ResampleContext *c, void *dst, const void *src, int n, int update_ctx)
Definition: resample.h:56
static int64_t get_out_samples(struct SwrContext *s, int in_samples)
Definition: resample.c:548
void(* resample_one)(struct ResampleContext *c, void *dst0, int dst_index, const void *src0, unsigned int index, int frac)
Definition: resample.h:45
int ideal_dst_incr
Definition: resample.h:33
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
if(ret< 0)
Definition: vf_mcdeint.c:282
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:144
static double c[64]
int phase_count_compensation
Definition: resample.h:51
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(constuint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(constint16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(constint32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(constint64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(constfloat *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(constdouble *) pi *(INT64_C(1)<< 63)))#defineFMT_PAIR_FUNC(out, in) staticconv_func_type *constfmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};staticvoidcpy1(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, len);}staticvoidcpy2(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 2 *len);}staticvoidcpy4(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 4 *len);}staticvoidcpy8(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, constint *ch_map, intflags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) returnNULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) returnNULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case1:ctx->simd_f=cpy1;break;case2:ctx->simd_f=cpy2;break;case4:ctx->simd_f=cpy4;break;case8:ctx->simd_f=cpy8;break;}}if(HAVE_YASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);returnctx;}voidswri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}intswri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, intlen){intch;intoff=0;constintos=(out->planar?1:out->ch_count)*out->bps;unsignedmisaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){intplanes=in->planar?in->ch_count:1;unsignedm=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){intplanes=out->planar?out->ch_count:1;unsignedm=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){intplanes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
#define av_free(p)
static const double coeff[2][5]
Definition: vf_owdenoise.c:72
uint8_t * filter_bank
Definition: resample.h:31
static const struct twinvq_data tab
#define AV_CPU_FLAG_SSE2
PIV SSE2 functions.
Definition: cpu.h:34
#define av_freep(p)
signed 16 bits, planar
Definition: samplefmt.h:67
int planar
1 if planar audio, 0 otherwise
#define M_PI
Definition: mathematics.h:52
#define av_malloc_array(a, b)
uint8_t * ch[SWR_CH_MAX]
samples buffer per channel
#define av_unused
Definition: attributes.h:126