1b1d83e5964a860404d2a9038896aa28e22d62e8
[ffmpeg.git] / libswresample / resample.c
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     double x, y, w, t, s;
148     double *tab = av_malloc_array(tap_count+1,  sizeof(*tab));
149     double *sin_lut = av_malloc_array(phase_count / 2 + 1, sizeof(*sin_lut));
150     const int center= (tap_count-1)/2;
151
152     if (!tab || !sin_lut)
153         goto fail;
154
155     /* if upsampling, only need to interpolate, no filter */
156     if (factor > 1.0)
157         factor = 1.0;
158
159     av_assert0(phase_count == 1 || phase_count % 2 == 0);
160
161     if (factor == 1.0) {
162         for (ph = 0; ph <= phase_count / 2; ph++)
163             sin_lut[ph] = sin(M_PI * ph / phase_count);
164     }
165     for(ph = 0; ph <= phase_count / 2; 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;}
182             case SWR_FILTER_TYPE_BLACKMAN_NUTTALL:
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;
187             case SWR_FILTER_TYPE_KAISER:
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 (tap_count % 2 == 0 || tap_count == 1) {
207                 for (i = 0; i < tap_count; i++)
208                     ((int16_t*)filter)[(phase_count-ph) * alloc + tap_count-1-i] = ((int16_t*)filter)[ph * alloc + i];
209             }
210             else {
211                 for (i = 1; i <= tap_count; i++)
212                     ((int16_t*)filter)[(phase_count-ph) * alloc + tap_count-i] =
213                         av_clip_int16(lrintf(tab[i] * scale / (norm - tab[0] + tab[tap_count])));
214             }
215             break;
216         case AV_SAMPLE_FMT_S32P:
217             for(i=0;i<tap_count;i++)
218                 ((int32_t*)filter)[ph * alloc + i] = av_clipl_int32(llrint(tab[i] * scale / norm));
219             if (tap_count % 2 == 0 || tap_count == 1) {
220                 for (i = 0; i < tap_count; i++)
221                     ((int32_t*)filter)[(phase_count-ph) * alloc + tap_count-1-i] = ((int32_t*)filter)[ph * alloc + i];
222             }
223             else {
224                 for (i = 1; i <= tap_count; i++)
225                     ((int32_t*)filter)[(phase_count-ph) * alloc + tap_count-i] =
226                         av_clipl_int32(llrint(tab[i] * scale / (norm - tab[0] + tab[tap_count])));
227             }
228             break;
229         case AV_SAMPLE_FMT_FLTP:
230             for(i=0;i<tap_count;i++)
231                 ((float*)filter)[ph * alloc + i] = tab[i] * scale / norm;
232             if (tap_count % 2 == 0 || tap_count == 1) {
233                 for (i = 0; i < tap_count; i++)
234                     ((float*)filter)[(phase_count-ph) * alloc + tap_count-1-i] = ((float*)filter)[ph * alloc + i];
235             }
236             else {
237                 for (i = 1; i <= tap_count; i++)
238                     ((float*)filter)[(phase_count-ph) * alloc + tap_count-i] = tab[i] * scale / (norm - tab[0] + tab[tap_count]);
239             }
240             break;
241         case AV_SAMPLE_FMT_DBLP:
242             for(i=0;i<tap_count;i++)
243                 ((double*)filter)[ph * alloc + i] = tab[i] * scale / norm;
244             if (tap_count % 2 == 0 || tap_count == 1) {
245                 for (i = 0; i < tap_count; i++)
246                     ((double*)filter)[(phase_count-ph) * alloc + tap_count-1-i] = ((double*)filter)[ph * alloc + i];
247             }
248             else {
249                 for (i = 1; i <= tap_count; i++)
250                     ((double*)filter)[(phase_count-ph) * alloc + tap_count-i] = tab[i] * scale / (norm - tab[0] + tab[tap_count]);
251             }
252             break;
253         }
254     }
255 #if 0
256     {
257 #define LEN 1024
258         int j,k;
259         double sine[LEN + tap_count];
260         double filtered[LEN];
261         double maxff=-2, minff=2, maxsf=-2, minsf=2;
262         for(i=0; i<LEN; i++){
263             double ss=0, sf=0, ff=0;
264             for(j=0; j<LEN+tap_count; j++)
265                 sine[j]= cos(i*j*M_PI/LEN);
266             for(j=0; j<LEN; j++){
267                 double sum=0;
268                 ph=0;
269                 for(k=0; k<tap_count; k++)
270                     sum += filter[ph * tap_count + k] * sine[k+j];
271                 filtered[j]= sum / (1<<FILTER_SHIFT);
272                 ss+= sine[j + center] * sine[j + center];
273                 ff+= filtered[j] * filtered[j];
274                 sf+= sine[j + center] * filtered[j];
275             }
276             ss= sqrt(2*ss/LEN);
277             ff= sqrt(2*ff/LEN);
278             sf= 2*sf/LEN;
279             maxff= FFMAX(maxff, ff);
280             minff= FFMIN(minff, ff);
281             maxsf= FFMAX(maxsf, sf);
282             minsf= FFMIN(minsf, sf);
283             if(i%11==0){
284                 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);
285                 minff=minsf= 2;
286                 maxff=maxsf= -2;
287             }
288         }
289     }
290 #endif
291
292 fail:
293     av_free(tab);
294     av_free(sin_lut);
295     return 0;
296 }
297
298 static ResampleContext *resample_init(ResampleContext *c, int out_rate, int in_rate, int filter_size, int phase_shift, int linear,
299                                     double cutoff0, enum AVSampleFormat format, enum SwrFilterType filter_type, double kaiser_beta,
300                                     double precision, int cheby, int exact_rational)
301 {
302     double cutoff = cutoff0? cutoff0 : 0.97;
303     double factor= FFMIN(out_rate * cutoff / in_rate, 1.0);
304     int phase_count= 1<<phase_shift;
305
306     if (exact_rational) {
307         int phase_count_exact, phase_count_exact_den;
308
309         av_reduce(&phase_count_exact, &phase_count_exact_den, out_rate, in_rate, INT_MAX);
310         /* FIXME this is not required, but build_filter needs even phase_count */
311         if (phase_count_exact & 1 && phase_count_exact > 1 && phase_count_exact < INT_MAX/2)
312             phase_count_exact *= 2;
313
314         if (phase_count_exact <= phase_count) {
315             /* FIXME this is not required when soft compensation is disabled */
316             phase_count_exact *= phase_count / phase_count_exact;
317             phase_count = phase_count_exact;
318         }
319     }
320
321     if (!c || c->phase_count != phase_count || c->linear!=linear || c->factor != factor
322            || c->filter_length != FFMAX((int)ceil(filter_size/factor), 1) || c->format != format
323            || c->filter_type != filter_type || c->kaiser_beta != kaiser_beta) {
324         c = av_mallocz(sizeof(*c));
325         if (!c)
326             return NULL;
327
328         c->format= format;
329
330         c->felem_size= av_get_bytes_per_sample(c->format);
331
332         switch(c->format){
333         case AV_SAMPLE_FMT_S16P:
334             c->filter_shift = 15;
335             break;
336         case AV_SAMPLE_FMT_S32P:
337             c->filter_shift = 30;
338             break;
339         case AV_SAMPLE_FMT_FLTP:
340         case AV_SAMPLE_FMT_DBLP:
341             c->filter_shift = 0;
342             break;
343         default:
344             av_log(NULL, AV_LOG_ERROR, "Unsupported sample format\n");
345             av_assert0(0);
346         }
347
348         if (filter_size/factor > INT32_MAX/256) {
349             av_log(NULL, AV_LOG_ERROR, "Filter length too large\n");
350             goto error;
351         }
352
353         c->phase_shift   = phase_shift;
354         c->phase_mask    = phase_count - 1;
355         c->phase_count   = phase_count;
356         c->linear        = linear;
357         c->factor        = factor;
358         c->filter_length = FFMAX((int)ceil(filter_size/factor), 1);
359         c->filter_alloc  = FFALIGN(c->filter_length, 8);
360         c->filter_bank   = av_calloc(c->filter_alloc, (phase_count+1)*c->felem_size);
361         c->filter_type   = filter_type;
362         c->kaiser_beta   = kaiser_beta;
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
385     swri_resample_dsp_init(c);
386
387     return c;
388 error:
389     av_freep(&c->filter_bank);
390     av_free(c);
391     return NULL;
392 }
393
394 static void resample_free(ResampleContext **c){
395     if(!*c)
396         return;
397     av_freep(&(*c)->filter_bank);
398     av_freep(c);
399 }
400
401 static int set_compensation(ResampleContext *c, int sample_delta, int compensation_distance){
402     c->compensation_distance= compensation_distance;
403     if (compensation_distance)
404         c->dst_incr = c->ideal_dst_incr - c->ideal_dst_incr * (int64_t)sample_delta / compensation_distance;
405     else
406         c->dst_incr = c->ideal_dst_incr;
407
408     c->dst_incr_div   = c->dst_incr / c->src_incr;
409     c->dst_incr_mod   = c->dst_incr % c->src_incr;
410
411     return 0;
412 }
413
414 static int swri_resample(ResampleContext *c,
415                          uint8_t *dst, const uint8_t *src, int *consumed,
416                          int src_size, int dst_size, int update_ctx)
417 {
418     if (c->filter_length == 1 && c->phase_count == 1) {
419         int index= c->index;
420         int frac= c->frac;
421         int64_t index2= (1LL<<32)*c->frac/c->src_incr + (1LL<<32)*index;
422         int64_t incr= (1LL<<32) * c->dst_incr / c->src_incr;
423         int new_size = (src_size * (int64_t)c->src_incr - frac + c->dst_incr - 1) / c->dst_incr;
424
425         dst_size= FFMIN(dst_size, new_size);
426         c->dsp.resample_one(dst, src, dst_size, index2, incr);
427
428         index += dst_size * c->dst_incr_div;
429         index += (frac + dst_size * (int64_t)c->dst_incr_mod) / c->src_incr;
430         av_assert2(index >= 0);
431         *consumed= index;
432         if (update_ctx) {
433             c->frac   = (frac + dst_size * (int64_t)c->dst_incr_mod) % c->src_incr;
434             c->index = 0;
435         }
436     } else {
437         int64_t end_index = (1LL + src_size - c->filter_length) * c->phase_count;
438         int64_t delta_frac = (end_index - c->index) * c->src_incr - c->frac;
439         int delta_n = (delta_frac + c->dst_incr - 1) / c->dst_incr;
440
441         dst_size = FFMIN(dst_size, delta_n);
442         if (dst_size > 0) {
443             *consumed = c->dsp.resample(c, dst, src, dst_size, update_ctx);
444         } else {
445             *consumed = 0;
446         }
447     }
448
449     return dst_size;
450 }
451
452 static int multiple_resample(ResampleContext *c, AudioData *dst, int dst_size, AudioData *src, int src_size, int *consumed){
453     int i, ret= -1;
454     int av_unused mm_flags = av_get_cpu_flags();
455     int need_emms = c->format == AV_SAMPLE_FMT_S16P && ARCH_X86_32 &&
456                     (mm_flags & (AV_CPU_FLAG_MMX2 | AV_CPU_FLAG_SSE2)) == AV_CPU_FLAG_MMX2;
457     int64_t max_src_size = (INT64_MAX/2 / c->phase_count) / c->src_incr;
458
459     if (c->compensation_distance)
460         dst_size = FFMIN(dst_size, c->compensation_distance);
461     src_size = FFMIN(src_size, max_src_size);
462
463     for(i=0; i<dst->ch_count; i++){
464         ret= swri_resample(c, dst->ch[i], src->ch[i],
465                            consumed, src_size, dst_size, i+1==dst->ch_count);
466     }
467     if(need_emms)
468         emms_c();
469
470     if (c->compensation_distance) {
471         c->compensation_distance -= ret;
472         if (!c->compensation_distance) {
473             c->dst_incr     = c->ideal_dst_incr;
474             c->dst_incr_div = c->dst_incr / c->src_incr;
475             c->dst_incr_mod = c->dst_incr % c->src_incr;
476         }
477     }
478
479     return ret;
480 }
481
482 static int64_t get_delay(struct SwrContext *s, int64_t base){
483     ResampleContext *c = s->resample;
484     int64_t num = s->in_buffer_count - (c->filter_length-1)/2;
485     num *= c->phase_count;
486     num -= c->index;
487     num *= c->src_incr;
488     num -= c->frac;
489     return av_rescale(num, base, s->in_sample_rate*(int64_t)c->src_incr * c->phase_count);
490 }
491
492 static int64_t get_out_samples(struct SwrContext *s, int in_samples) {
493     ResampleContext *c = s->resample;
494     // The + 2 are added to allow implementations to be slightly inaccurate, they should not be needed currently.
495     // They also make it easier to proof that changes and optimizations do not
496     // break the upper bound.
497     int64_t num = s->in_buffer_count + 2LL + in_samples;
498     num *= c->phase_count;
499     num -= c->index;
500     num = av_rescale_rnd(num, s->out_sample_rate, ((int64_t)s->in_sample_rate) * c->phase_count, AV_ROUND_UP) + 2;
501
502     if (c->compensation_distance) {
503         if (num > INT_MAX)
504             return AVERROR(EINVAL);
505
506         num = FFMAX(num, (num * c->ideal_dst_incr - 1) / c->dst_incr + 1);
507     }
508     return num;
509 }
510
511 static int resample_flush(struct SwrContext *s) {
512     AudioData *a= &s->in_buffer;
513     int i, j, ret;
514     if((ret = swri_realloc_audio(a, s->in_buffer_index + 2*s->in_buffer_count)) < 0)
515         return ret;
516     av_assert0(a->planar);
517     for(i=0; i<a->ch_count; i++){
518         for(j=0; j<s->in_buffer_count; j++){
519             memcpy(a->ch[i] + (s->in_buffer_index+s->in_buffer_count+j  )*a->bps,
520                 a->ch[i] + (s->in_buffer_index+s->in_buffer_count-j-1)*a->bps, a->bps);
521         }
522     }
523     s->in_buffer_count += (s->in_buffer_count+1)/2;
524     return 0;
525 }
526
527 // in fact the whole handle multiple ridiculously small buffers might need more thinking...
528 static int invert_initial_buffer(ResampleContext *c, AudioData *dst, const AudioData *src,
529                                  int in_count, int *out_idx, int *out_sz)
530 {
531     int n, ch, num = FFMIN(in_count + *out_sz, c->filter_length + 1), res;
532
533     if (c->index >= 0)
534         return 0;
535
536     if ((res = swri_realloc_audio(dst, c->filter_length * 2 + 1)) < 0)
537         return res;
538
539     // copy
540     for (n = *out_sz; n < num; n++) {
541         for (ch = 0; ch < src->ch_count; ch++) {
542             memcpy(dst->ch[ch] + ((c->filter_length + n) * c->felem_size),
543                    src->ch[ch] + ((n - *out_sz) * c->felem_size), c->felem_size);
544         }
545     }
546
547     // if not enough data is in, return and wait for more
548     if (num < c->filter_length + 1) {
549         *out_sz = num;
550         *out_idx = c->filter_length;
551         return INT_MAX;
552     }
553
554     // else invert
555     for (n = 1; n <= c->filter_length; n++) {
556         for (ch = 0; ch < src->ch_count; ch++) {
557             memcpy(dst->ch[ch] + ((c->filter_length - n) * c->felem_size),
558                    dst->ch[ch] + ((c->filter_length + n) * c->felem_size),
559                    c->felem_size);
560         }
561     }
562
563     res = num - *out_sz;
564     *out_idx = c->filter_length;
565     while (c->index < 0) {
566         --*out_idx;
567         c->index += c->phase_count;
568     }
569     *out_sz = FFMAX(*out_sz + c->filter_length,
570                     1 + c->filter_length * 2) - *out_idx;
571
572     return FFMAX(res, 0);
573 }
574
575 struct Resampler const swri_resampler={
576   resample_init,
577   resample_free,
578   multiple_resample,
579   resample_flush,
580   set_compensation,
581   get_delay,
582   invert_initial_buffer,
583   get_out_samples,
584 };