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 && sample_delta) {
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  /* resample_linear and resample_common should have same behavior
500  * when frac and dst_incr_mod are zero */
501  if (c->linear && (c->frac || c->dst_incr_mod))
502  *consumed = c->dsp.resample_linear(c, dst, src, dst_size, update_ctx);
503  else
504  *consumed = c->dsp.resample_common(c, dst, src, dst_size, update_ctx);
505  } else {
506  *consumed = 0;
507  }
508  }
509 
510  return dst_size;
511 }
512 
513 static int multiple_resample(ResampleContext *c, AudioData *dst, int dst_size, AudioData *src, int src_size, int *consumed){
514  int i, ret= -1;
515  int av_unused mm_flags = av_get_cpu_flags();
516  int need_emms = c->format == AV_SAMPLE_FMT_S16P && ARCH_X86_32 &&
518  int64_t max_src_size = (INT64_MAX/2 / c->phase_count) / c->src_incr;
519 
521  dst_size = FFMIN(dst_size, c->compensation_distance);
522  src_size = FFMIN(src_size, max_src_size);
523 
524  for(i=0; i<dst->ch_count; i++){
525  ret= swri_resample(c, dst->ch[i], src->ch[i],
526  consumed, src_size, dst_size, i+1==dst->ch_count);
527  }
528  if(need_emms)
529  emms_c();
530 
531  if (c->compensation_distance) {
532  c->compensation_distance -= ret;
533  if (!c->compensation_distance) {
534  c->dst_incr = c->ideal_dst_incr;
535  c->dst_incr_div = c->dst_incr / c->src_incr;
536  c->dst_incr_mod = c->dst_incr % c->src_incr;
537  }
538  }
539 
540  return ret;
541 }
542 
543 static int64_t get_delay(struct SwrContext *s, int64_t base){
544  ResampleContext *c = s->resample;
545  int64_t num = s->in_buffer_count - (c->filter_length-1)/2;
546  num *= c->phase_count;
547  num -= c->index;
548  num *= c->src_incr;
549  num -= c->frac;
550  return av_rescale(num, base, s->in_sample_rate*(int64_t)c->src_incr * c->phase_count);
551 }
552 
553 static int64_t get_out_samples(struct SwrContext *s, int in_samples) {
554  ResampleContext *c = s->resample;
555  // The + 2 are added to allow implementations to be slightly inaccurate, they should not be needed currently.
556  // They also make it easier to proof that changes and optimizations do not
557  // break the upper bound.
558  int64_t num = s->in_buffer_count + 2LL + in_samples;
559  num *= c->phase_count;
560  num -= c->index;
561  num = av_rescale_rnd(num, s->out_sample_rate, ((int64_t)s->in_sample_rate) * c->phase_count, AV_ROUND_UP) + 2;
562 
563  if (c->compensation_distance) {
564  if (num > INT_MAX)
565  return AVERROR(EINVAL);
566 
567  num = FFMAX(num, (num * c->ideal_dst_incr - 1) / c->dst_incr + 1);
568  }
569  return num;
570 }
571 
572 static int resample_flush(struct SwrContext *s) {
573  AudioData *a= &s->in_buffer;
574  int i, j, ret;
575  if((ret = swri_realloc_audio(a, s->in_buffer_index + 2*s->in_buffer_count)) < 0)
576  return ret;
577  av_assert0(a->planar);
578  for(i=0; i<a->ch_count; i++){
579  for(j=0; j<s->in_buffer_count; j++){
580  memcpy(a->ch[i] + (s->in_buffer_index+s->in_buffer_count+j )*a->bps,
581  a->ch[i] + (s->in_buffer_index+s->in_buffer_count-j-1)*a->bps, a->bps);
582  }
583  }
584  s->in_buffer_count += (s->in_buffer_count+1)/2;
585  return 0;
586 }
587 
588 // in fact the whole handle multiple ridiculously small buffers might need more thinking...
590  int in_count, int *out_idx, int *out_sz)
591 {
592  int n, ch, num = FFMIN(in_count + *out_sz, c->filter_length + 1), res;
593 
594  if (c->index >= 0)
595  return 0;
596 
597  if ((res = swri_realloc_audio(dst, c->filter_length * 2 + 1)) < 0)
598  return res;
599 
600  // copy
601  for (n = *out_sz; n < num; n++) {
602  for (ch = 0; ch < src->ch_count; ch++) {
603  memcpy(dst->ch[ch] + ((c->filter_length + n) * c->felem_size),
604  src->ch[ch] + ((n - *out_sz) * c->felem_size), c->felem_size);
605  }
606  }
607 
608  // if not enough data is in, return and wait for more
609  if (num < c->filter_length + 1) {
610  *out_sz = num;
611  *out_idx = c->filter_length;
612  return INT_MAX;
613  }
614 
615  // else invert
616  for (n = 1; n <= c->filter_length; n++) {
617  for (ch = 0; ch < src->ch_count; ch++) {
618  memcpy(dst->ch[ch] + ((c->filter_length - n) * c->felem_size),
619  dst->ch[ch] + ((c->filter_length + n) * c->felem_size),
620  c->felem_size);
621  }
622  }
623 
624  res = num - *out_sz;
625  *out_idx = c->filter_length;
626  while (c->index < 0) {
627  --*out_idx;
628  c->index += c->phase_count;
629  }
630  *out_sz = FFMAX(*out_sz + c->filter_length,
631  1 + c->filter_length * 2) - *out_idx;
632 
633  return FFMAX(res, 0);
634 }
635 
636 struct Resampler const swri_resampler={
642  get_delay,
645 };
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:513
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:121
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
#define src
Definition: vp8dsp.c:254
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:636
static int invert_initial_buffer(ResampleContext *c, AudioData *dst, const AudioData *src, int in_count, int *out_idx, int *out_sz)
Definition: resample.c:589
#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:572
#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
int(* resample_linear)(struct ResampleContext *c, void *dst, const void *src, int n, int update_ctx)
Definition: resample.h:58
static void error(const char *err)
#define fail()
Definition: checkasm.h:84
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:543
int32_t
int in_sample_rate
input sample rate
int bps
bytes per sample
int n
Definition: avisynth_c.h:684
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
int(* resample_common)(struct ResampleContext *c, void *dst, const void *src, int n, int update_ctx)
Definition: resample.h:56
#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:88
static int64_t get_out_samples(struct SwrContext *s, int in_samples)
Definition: resample.c:553
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
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 AVCodec * c
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