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