third_party/speex/libspeex/resample.c

   1 /* Copyright (C) 2007-2008 Jean-Marc Valin
   2    Copyright (C) 2008      Thorvald Natvig
   3
   4    File: resample.c
   5    Arbitrary resampling code
   6
   7    Redistribution and use in source and binary forms, with or without
   8    modification, are permitted provided that the following conditions are
   9    met:
  10
  11    1. Redistributions of source code must retain the above copyright notice,
  12    this list of conditions and the following disclaimer.
  13
  14    2. Redistributions in binary form must reproduce the above copyright
  15    notice, this list of conditions and the following disclaimer in the
  16    documentation and/or other materials provided with the distribution.
  17
  18    3. The name of the author may not be used to endorse or promote products
  19    derived from this software without specific prior written permission.
  20
  21    THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  22    IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  23    OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  24    DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  25    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  26    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  27    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28    HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  29    STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  30    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  31    POSSIBILITY OF SUCH DAMAGE.
  32 */
  33
  34 /*
  35    The design goals of this code are:
  36       - Very fast algorithm
  37       - SIMD-friendly algorithm
  38       - Low memory requirement
  39       - Good *perceptual* quality (and not best SNR)
  40
  41    Warning: This resampler is relatively new. Although I think I got rid of
  42    all the major bugs and I don't expect the API to change anymore, there
  43    may be something I've missed. So use with caution.
  44
  45    This algorithm is based on this original resampling algorithm:
  46    Smith, Julius O. Digital Audio Resampling Home Page
  47    Center for Computer Research in Music and Acoustics (CCRMA),
  48    Stanford University, 2007.
  49    Web published at http://www-ccrma.stanford.edu/~jos/resample/.
  50
  51    There is one main difference, though. This resampler uses cubic
  52    interpolation instead of linear interpolation in the above paper. This
  53    makes the table much smaller and makes it possible to compute that table
  54    on a per-stream basis. In turn, being able to tweak the table for each
  55    stream makes it possible to both reduce complexity on simple ratios
  56    (e.g. 2/3), and get rid of the rounding operations in the inner loop.
  57    The latter both reduces CPU time and makes the algorithm more SIMD-friendly.
  58 */
  59
  60 #ifdef HAVE_CONFIG_H
  61 #include "config.h"
  62 #endif
  63
  64 #ifdef OUTSIDE_SPEEX
  65 #include <stdlib.h>
  66 static void *speex_alloc (int size) {return calloc(size,1);}
  67 static void *speex_realloc (void *ptr, int size) {return realloc(ptr, size);}
  68 static void speex_free (void *ptr) {free(ptr);}
  69 #include "speex_resampler.h"
  70 #include "arch.h"
  71 #else /* OUTSIDE_SPEEX */
  72
  73 #include "speex/speex_resampler.h"
  74 #include "arch.h"
  75 #include "os_support.h"
  76 #endif /* OUTSIDE_SPEEX */
  77
  78 #include "stack_alloc.h"
  79 #include <math.h>
  80
  81 #ifndef M_PI
  82 #define M_PI 3.14159263
  83 #endif
  84
  85 #ifdef FIXED_POINT
  86 #define WORD2INT(x) ((x) < -32767 ? -32768 : ((x) > 32766 ? 32767 : (x)))
  87 #else
  88 #define WORD2INT(x) ((x) < -32767.5f ? -32768 : ((x) > 32766.5f ? 32767 : floor(.5+(x))))
  89 #endif
  90
  91 #define IMAX(a,b) ((a) > (b) ? (a) : (b))
  92 #define IMIN(a,b) ((a) < (b) ? (a) : (b))
  93
  94 #ifndef NULL
  95 #define NULL 0
  96 #endif
  97
  98 #ifdef _USE_SSE
  99 #include "resample_sse.h"
 100 #endif
 101
 102 /* Numer of elements to allocate on the stack */
 103 #ifdef VAR_ARRAYS
 104 #define FIXED_STACK_ALLOC 8192
 105 #else
 106 #define FIXED_STACK_ALLOC 1024
 107 #endif
 108
 109 typedef int (*resampler_basic_func)(SpeexResamplerState *, spx_uint32_t , const spx_word16_t *, spx_uint32_t *, spx_word16_t *, spx_uint32_t *);
 110
 111 struct SpeexResamplerState_ {
 112    spx_uint32_t in_rate;
 113    spx_uint32_t out_rate;
 114    spx_uint32_t num_rate;
 115    spx_uint32_t den_rate;
 116
 117    int    quality;
 118    spx_uint32_t nb_channels;
 119    spx_uint32_t filt_len;
 120    spx_uint32_t mem_alloc_size;
 121    spx_uint32_t buffer_size;
 122    int          int_advance;
 123    int          frac_advance;
 124    float  cutoff;
 125    spx_uint32_t oversample;
 126    int          initialised;
 127    int          started;
 128
 129    /* These are per-channel */
 130    spx_int32_t  *last_sample;
 131    spx_uint32_t *samp_frac_num;
 132    spx_uint32_t *magic_samples;
 133
 134    spx_word16_t *mem;
 135    spx_word16_t *sinc_table;
 136    spx_uint32_t sinc_table_length;
 137    resampler_basic_func resampler_ptr;
 138
 139    int    in_stride;
 140    int    out_stride;
 141 } ;
 142
 143 static double kaiser12_table[68] = {
 144    0.99859849, 1.00000000, 0.99859849, 0.99440475, 0.98745105, 0.97779076,
 145    0.96549770, 0.95066529, 0.93340547, 0.91384741, 0.89213598, 0.86843014,
 146    0.84290116, 0.81573067, 0.78710866, 0.75723148, 0.72629970, 0.69451601,
 147    0.66208321, 0.62920216, 0.59606986, 0.56287762, 0.52980938, 0.49704014,
 148    0.46473455, 0.43304576, 0.40211431, 0.37206735, 0.34301800, 0.31506490,
 149    0.28829195, 0.26276832, 0.23854851, 0.21567274, 0.19416736, 0.17404546,
 150    0.15530766, 0.13794294, 0.12192957, 0.10723616, 0.09382272, 0.08164178,
 151    0.07063950, 0.06075685, 0.05193064, 0.04409466, 0.03718069, 0.03111947,
 152    0.02584161, 0.02127838, 0.01736250, 0.01402878, 0.01121463, 0.00886058,
 153    0.00691064, 0.00531256, 0.00401805, 0.00298291, 0.00216702, 0.00153438,
 154    0.00105297, 0.00069463, 0.00043489, 0.00025272, 0.00013031, 0.0000527734,
 155    0.00001000, 0.00000000};
 156 /*
 157 static double kaiser12_table[36] = {
 158    0.99440475, 1.00000000, 0.99440475, 0.97779076, 0.95066529, 0.91384741,
 159    0.86843014, 0.81573067, 0.75723148, 0.69451601, 0.62920216, 0.56287762,
 160    0.49704014, 0.43304576, 0.37206735, 0.31506490, 0.26276832, 0.21567274,
 161    0.17404546, 0.13794294, 0.10723616, 0.08164178, 0.06075685, 0.04409466,
 162    0.03111947, 0.02127838, 0.01402878, 0.00886058, 0.00531256, 0.00298291,
 163    0.00153438, 0.00069463, 0.00025272, 0.0000527734, 0.00000500, 0.00000000};
 164 */
 165 static double kaiser10_table[36] = {
 166    0.99537781, 1.00000000, 0.99537781, 0.98162644, 0.95908712, 0.92831446,
 167    0.89005583, 0.84522401, 0.79486424, 0.74011713, 0.68217934, 0.62226347,
 168    0.56155915, 0.50119680, 0.44221549, 0.38553619, 0.33194107, 0.28205962,
 169    0.23636152, 0.19515633, 0.15859932, 0.12670280, 0.09935205, 0.07632451,
 170    0.05731132, 0.04193980, 0.02979584, 0.02044510, 0.01345224, 0.00839739,
 171    0.00488951, 0.00257636, 0.00115101, 0.00035515, 0.00000000, 0.00000000};
 172
 173 static double kaiser8_table[36] = {
 174    0.99635258, 1.00000000, 0.99635258, 0.98548012, 0.96759014, 0.94302200,
 175    0.91223751, 0.87580811, 0.83439927, 0.78875245, 0.73966538, 0.68797126,
 176    0.63451750, 0.58014482, 0.52566725, 0.47185369, 0.41941150, 0.36897272,
 177    0.32108304, 0.27619388, 0.23465776, 0.19672670, 0.16255380, 0.13219758,
 178    0.10562887, 0.08273982, 0.06335451, 0.04724088, 0.03412321, 0.02369490,
 179    0.01563093, 0.00959968, 0.00527363, 0.00233883, 0.00050000, 0.00000000};
 180
 181 static double kaiser6_table[36] = {
 182    0.99733006, 1.00000000, 0.99733006, 0.98935595, 0.97618418, 0.95799003,
 183    0.93501423, 0.90755855, 0.87598009, 0.84068475, 0.80211977, 0.76076565,
 184    0.71712752, 0.67172623, 0.62508937, 0.57774224, 0.53019925, 0.48295561,
 185    0.43647969, 0.39120616, 0.34752997, 0.30580127, 0.26632152, 0.22934058,
 186    0.19505503, 0.16360756, 0.13508755, 0.10953262, 0.08693120, 0.06722600,
 187    0.05031820, 0.03607231, 0.02432151, 0.01487334, 0.00752000, 0.00000000};
 188
 189 struct FuncDef {
 190    double *table;
 191    int oversample;
 192 };
 193
 194 static struct FuncDef _KAISER12 = {kaiser12_table, 64};
 195 #define KAISER12 (&_KAISER12)
 196 /*static struct FuncDef _KAISER12 = {kaiser12_table, 32};
 197 #define KAISER12 (&_KAISER12)*/
 198 static struct FuncDef _KAISER10 = {kaiser10_table, 32};
 199 #define KAISER10 (&_KAISER10)
 200 static struct FuncDef _KAISER8 = {kaiser8_table, 32};
 201 #define KAISER8 (&_KAISER8)
 202 static struct FuncDef _KAISER6 = {kaiser6_table, 32};
 203 #define KAISER6 (&_KAISER6)
 204
 205 struct QualityMapping {
 206    int base_length;
 207    int oversample;
 208    float downsample_bandwidth;
 209    float upsample_bandwidth;
 210    struct FuncDef *window_func;
 211 };
 212
 213
 214 /* This table maps conversion quality to internal parameters. There are two
 215    reasons that explain why the up-sampling bandwidth is larger than the
 216    down-sampling bandwidth:
 217    1) When up-sampling, we can assume that the spectrum is already attenuated
 218       close to the Nyquist rate (from an A/D or a previous resampling filter)
 219    2) Any aliasing that occurs very close to the Nyquist rate will be masked
 220       by the sinusoids/noise just below the Nyquist rate (guaranteed only for
 221       up-sampling).
 222 */
 223 static const struct QualityMapping quality_map[11] = {
 224    {  8,  4, 0.830f, 0.860f, KAISER6 }, /* Q0 */
 225    { 16,  4, 0.850f, 0.880f, KAISER6 }, /* Q1 */
 226    { 32,  4, 0.882f, 0.910f, KAISER6 }, /* Q2 */  /* 82.3% cutoff ( ~60 dB stop) 6  */
 227    { 48,  8, 0.895f, 0.917f, KAISER8 }, /* Q3 */  /* 84.9% cutoff ( ~80 dB stop) 8  */
 228    { 64,  8, 0.921f, 0.940f, KAISER8 }, /* Q4 */  /* 88.7% cutoff ( ~80 dB stop) 8  */
 229    { 80, 16, 0.922f, 0.940f, KAISER10}, /* Q5 */  /* 89.1% cutoff (~100 dB stop) 10 */
 230    { 96, 16, 0.940f, 0.945f, KAISER10}, /* Q6 */  /* 91.5% cutoff (~100 dB stop) 10 */
 231    {128, 16, 0.950f, 0.950f, KAISER10}, /* Q7 */  /* 93.1% cutoff (~100 dB stop) 10 */
 232    {160, 16, 0.960f, 0.960f, KAISER10}, /* Q8 */  /* 94.5% cutoff (~100 dB stop) 10 */
 233    {192, 32, 0.968f, 0.968f, KAISER12}, /* Q9 */  /* 95.5% cutoff (~100 dB stop) 10 */
 234    {256, 32, 0.975f, 0.975f, KAISER12}, /* Q10 */ /* 96.6% cutoff (~100 dB stop) 10 */
 235 };
 236 /*8,24,40,56,80,104,128,160,200,256,320*/
 237 static double compute_func(float x, struct FuncDef *func)
 238 {
 239    float y, frac;
 240    double interp[4];
 241    int ind;
 242    y = x*func->oversample;
 243    ind = (int)floor(y);
 244    frac = (y-ind);
 245    /* CSE with handle the repeated powers */
 246    interp[3] =  -0.1666666667*frac + 0.1666666667*(frac*frac*frac);
 247    interp[2] = frac + 0.5*(frac*frac) - 0.5*(frac*frac*frac);
 248    /*interp[2] = 1.f - 0.5f*frac - frac*frac + 0.5f*frac*frac*frac;*/
 249    interp[0] = -0.3333333333*frac + 0.5*(frac*frac) - 0.1666666667*(frac*frac*frac);
 250    /* Just to make sure we don't have rounding problems */
 251    interp[1] = 1.f-interp[3]-interp[2]-interp[0];
 252
 253    /*sum = frac*accum[1] + (1-frac)*accum[2];*/
 254    return interp[0]*func->table[ind] + interp[1]*func->table[ind+1] + interp[2]*func->table[ind+2] + interp[3]*func->table[ind+3];
 255 }
 256
 257 #if 0
 258 #include <stdio.h>
 259 int main(int argc, char **argv)
 260 {
 261    int i;
 262    for (i=0;i<256;i++)
 263    {
 264       printf ("%f\n", compute_func(i/256., KAISER12));
 265    }
 266    return 0;
 267 }
 268 #endif
 269
 270 #ifdef FIXED_POINT
 271 /* The slow way of computing a sinc for the table. Should improve that some day */
 272 static spx_word16_t sinc(float cutoff, float x, int N, struct FuncDef *window_func)
 273 {
 274    /*fprintf (stderr, "%f ", x);*/
 275    float xx = x * cutoff;
 276    if (fabs(x)<1e-6f)
 277       return WORD2INT(32768.*cutoff);
 278    else if (fabs(x) > .5f*N)
 279       return 0;
 280    /*FIXME: Can it really be any slower than this? */
 281    return WORD2INT(32768.*cutoff*sin(M_PI*xx)/(M_PI*xx) * compute_func(fabs(2.*x/N), window_func));
 282 }
 283 #else
 284 /* The slow way of computing a sinc for the table. Should improve that some day */
 285 static spx_word16_t sinc(float cutoff, float x, int N, struct FuncDef *window_func)
 286 {
 287    /*fprintf (stderr, "%f ", x);*/
 288    float xx = x * cutoff;
 289    if (fabs(x)<1e-6)
 290       return cutoff;
 291    else if (fabs(x) > .5*N)
 292       return 0;
 293    /*FIXME: Can it really be any slower than this? */
 294    return cutoff*sin(M_PI*xx)/(M_PI*xx) * compute_func(fabs(2.*x/N), window_func);
 295 }
 296 #endif
 297
 298 #ifdef FIXED_POINT
 299 static void cubic_coef(spx_word16_t x, spx_word16_t interp[4])
 300 {
 301    /* Compute interpolation coefficients. I'm not sure whether this corresponds to cubic interpolation
 302    but I know it's MMSE-optimal on a sinc */
 303    spx_word16_t x2, x3;
 304    x2 = MULT16_16_P15(x, x);
 305    x3 = MULT16_16_P15(x, x2);
 306    interp[0] = PSHR32(MULT16_16(QCONST16(-0.16667f, 15),x) + MULT16_16(QCONST16(0.16667f, 15),x3),15);
 307    interp[1] = EXTRACT16(EXTEND32(x) + SHR32(SUB32(EXTEND32(x2),EXTEND32(x3)),1));
 308    interp[3] = PSHR32(MULT16_16(QCONST16(-0.33333f, 15),x) + MULT16_16(QCONST16(.5f,15),x2) - MULT16_16(QCONST16(0.16667f, 15),x3),15);
 309    /* Just to make sure we don't have rounding problems */
 310    interp[2] = Q15_ONE-interp[0]-interp[1]-interp[3];
 311    if (interp[2]<32767)
 312       interp[2]+=1;
 313 }
 314 #else
 315 static void cubic_coef(spx_word16_t frac, spx_word16_t interp[4])
 316 {
 317    /* Compute interpolation coefficients. I'm not sure whether this corresponds to cubic interpolation
 318    but I know it's MMSE-optimal on a sinc */
 319    interp[0] =  -0.16667f*frac + 0.16667f*frac*frac*frac;
 320    interp[1] = frac + 0.5f*frac*frac - 0.5f*frac*frac*frac;
 321    /*interp[2] = 1.f - 0.5f*frac - frac*frac + 0.5f*frac*frac*frac;*/
 322    interp[3] = -0.33333f*frac + 0.5f*frac*frac - 0.16667f*frac*frac*frac;
 323    /* Just to make sure we don't have rounding problems */
 324    interp[2] = 1.-interp[0]-interp[1]-interp[3];
 325 }
 326 #endif
 327
 328 static int resampler_basic_direct_single(SpeexResamplerState *st, spx_uint32_t channel_index, const spx_word16_t *in, spx_uint32_t *in_len, spx_word16_t *out, spx_uint32_t *out_len)
 329 {
 330    const int N = st->filt_len;
 331    int out_sample = 0;
 332    int last_sample = st->last_sample[channel_index];
 333    spx_uint32_t samp_frac_num = st->samp_frac_num[channel_index];
 334    const spx_word16_t *sinc_table = st->sinc_table;
 335    const int out_stride = st->out_stride;
 336    const int int_advance = st->int_advance;
 337    const int frac_advance = st->frac_advance;
 338    const spx_uint32_t den_rate = st->den_rate;
 339    spx_word32_t sum;
 340    int j;
 341
 342    while (!(last_sample >= (spx_int32_t)*in_len || out_sample >= (spx_int32_t)*out_len))
 343    {
 344       const spx_word16_t *sinc = & sinc_table[samp_frac_num*N];
 345       const spx_word16_t *iptr = & in[last_sample];
 346
 347 #ifndef OVERRIDE_INNER_PRODUCT_SINGLE
 348       float accum[4] = {0,0,0,0};
 349
 350       for(j=0;j<N;j+=4) {
 351         accum[0] += sinc[j]*iptr[j];
 352         accum[1] += sinc[j+1]*iptr[j+1];
 353         accum[2] += sinc[j+2]*iptr[j+2];
 354         accum[3] += sinc[j+3]*iptr[j+3];
 355       }
 356       sum = accum[0] + accum[1] + accum[2] + accum[3];
 357 #else
 358       sum = inner_product_single(sinc, iptr, N);
 359 #endif
 360
 361       out[out_stride * out_sample++] = PSHR32(sum, 15);
 362       last_sample += int_advance;
 363       samp_frac_num += frac_advance;
 364       if (samp_frac_num >= den_rate)
 365       {
 366          samp_frac_num -= den_rate;
 367          last_sample++;
 368       }
 369    }
 370
 371    st->last_sample[channel_index] = last_sample;
 372    st->samp_frac_num[channel_index] = samp_frac_num;
 373    return out_sample;
 374 }
 375
 376 #ifdef FIXED_POINT
 377 #else
 378 /* This is the same as the previous function, except with a double-precision accumulator */
 379 static int resampler_basic_direct_double(SpeexResamplerState *st, spx_uint32_t channel_index, const spx_word16_t *in, spx_uint32_t *in_len, spx_word16_t *out, spx_uint32_t *out_len)
 380 {
 381    const int N = st->filt_len;
 382    int out_sample = 0;
 383    int last_sample = st->last_sample[channel_index];
 384    spx_uint32_t samp_frac_num = st->samp_frac_num[channel_index];
 385    const spx_word16_t *sinc_table = st->sinc_table;
 386    const int out_stride = st->out_stride;
 387    const int int_advance = st->int_advance;
 388    const int frac_advance = st->frac_advance;
 389    const spx_uint32_t den_rate = st->den_rate;
 390    double sum;
 391    int j;
 392
 393    while (!(last_sample >= (spx_int32_t)*in_len || out_sample >= (spx_int32_t)*out_len))
 394    {
 395       const spx_word16_t *sinc = & sinc_table[samp_frac_num*N];
 396       const spx_word16_t *iptr = & in[last_sample];
 397
 398 #ifndef OVERRIDE_INNER_PRODUCT_DOUBLE
 399       double accum[4] = {0,0,0,0};
 400
 401       for(j=0;j<N;j+=4) {
 402         accum[0] += sinc[j]*iptr[j];
 403         accum[1] += sinc[j+1]*iptr[j+1];
 404         accum[2] += sinc[j+2]*iptr[j+2];
 405         accum[3] += sinc[j+3]*iptr[j+3];
 406       }
 407       sum = accum[0] + accum[1] + accum[2] + accum[3];
 408 #else
 409       sum = inner_product_double(sinc, iptr, N);
 410 #endif
 411
 412       out[out_stride * out_sample++] = PSHR32(sum, 15);
 413       last_sample += int_advance;
 414       samp_frac_num += frac_advance;
 415       if (samp_frac_num >= den_rate)
 416       {
 417          samp_frac_num -= den_rate;
 418          last_sample++;
 419       }
 420    }
 421
 422    st->last_sample[channel_index] = last_sample;
 423    st->samp_frac_num[channel_index] = samp_frac_num;
 424    return out_sample;
 425 }
 426 #endif
 427
 428 static int resampler_basic_interpolate_single(SpeexResamplerState *st, spx_uint32_t channel_index, const spx_word16_t *in, spx_uint32_t *in_len, spx_word16_t *out, spx_uint32_t *out_len)
 429 {
 430    const int N = st->filt_len;
 431    int out_sample = 0;
 432    int last_sample = st->last_sample[channel_index];
 433    spx_uint32_t samp_frac_num = st->samp_frac_num[channel_index];
 434    const int out_stride = st->out_stride;
 435    const int int_advance = st->int_advance;
 436    const int frac_advance = st->frac_advance;
 437    const spx_uint32_t den_rate = st->den_rate;
 438    int j;
 439    spx_word32_t sum;
 440
 441    while (!(last_sample >= (spx_int32_t)*in_len || out_sample >= (spx_int32_t)*out_len))
 442    {
 443       const spx_word16_t *iptr = & in[last_sample];
 444
 445       const int offset = samp_frac_num*st->oversample/st->den_rate;
 446 #ifdef FIXED_POINT
 447       const spx_word16_t frac = PDIV32(SHL32((samp_frac_num*st->oversample) % st->den_rate,15),st->den_rate);
 448 #else
 449       const spx_word16_t frac = ((float)((samp_frac_num*st->oversample) % st->den_rate))/st->den_rate;
 450 #endif
 451       spx_word16_t interp[4];
 452
 453
 454 #ifndef OVERRIDE_INTERPOLATE_PRODUCT_SINGLE
 455       spx_word32_t accum[4] = {0,0,0,0};
 456
 457       for(j=0;j<N;j++) {
 458         const spx_word16_t curr_in=iptr[j];
 459         accum[0] += MULT16_16(curr_in,st->sinc_table[4+(j+1)*st->oversample-offset-2]);
 460         accum[1] += MULT16_16(curr_in,st->sinc_table[4+(j+1)*st->oversample-offset-1]);
 461         accum[2] += MULT16_16(curr_in,st->sinc_table[4+(j+1)*st->oversample-offset]);
 462         accum[3] += MULT16_16(curr_in,st->sinc_table[4+(j+1)*st->oversample-offset+1]);
 463       }
 464
 465       cubic_coef(frac, interp);
 466       sum = MULT16_32_Q15(interp[0],accum[0]) + MULT16_32_Q15(interp[1],accum[1]) + MULT16_32_Q15(interp[2],accum[2]) + MULT16_32_Q15(interp[3],accum[3]);
 467 #else
 468       cubic_coef(frac, interp);
 469       sum = interpolate_product_single(iptr, st->sinc_table + st->oversample + 4 - offset - 2, N, st->oversample, interp);
 470 #endif
 471
 472       out[out_stride * out_sample++] = PSHR32(sum,15);
 473       last_sample += int_advance;
 474       samp_frac_num += frac_advance;
 475       if (samp_frac_num >= den_rate)
 476       {
 477          samp_frac_num -= den_rate;
 478          last_sample++;
 479       }
 480    }
 481
 482    st->last_sample[channel_index] = last_sample;
 483    st->samp_frac_num[channel_index] = samp_frac_num;
 484    return out_sample;
 485 }
 486
 487 #ifdef FIXED_POINT
 488 #else
 489 /* This is the same as the previous function, except with a double-precision accumulator */
 490 static int resampler_basic_interpolate_double(SpeexResamplerState *st, spx_uint32_t channel_index, const spx_word16_t *in, spx_uint32_t *in_len, spx_word16_t *out, spx_uint32_t *out_len)
 491 {
 492    const int N = st->filt_len;
 493    int out_sample = 0;
 494    int last_sample = st->last_sample[channel_index];
 495    spx_uint32_t samp_frac_num = st->samp_frac_num[channel_index];
 496    const int out_stride = st->out_stride;
 497    const int int_advance = st->int_advance;
 498    const int frac_advance = st->frac_advance;
 499    const spx_uint32_t den_rate = st->den_rate;
 500    int j;
 501    spx_word32_t sum;
 502
 503    while (!(last_sample >= (spx_int32_t)*in_len || out_sample >= (spx_int32_t)*out_len))
 504    {
 505       const spx_word16_t *iptr = & in[last_sample];
 506
 507       const int offset = samp_frac_num*st->oversample/st->den_rate;
 508 #ifdef FIXED_POINT
 509       const spx_word16_t frac = PDIV32(SHL32((samp_frac_num*st->oversample) % st->den_rate,15),st->den_rate);
 510 #else
 511       const spx_word16_t frac = ((float)((samp_frac_num*st->oversample) % st->den_rate))/st->den_rate;
 512 #endif
 513       spx_word16_t interp[4];
 514
 515
 516 #ifndef OVERRIDE_INTERPOLATE_PRODUCT_DOUBLE
 517       double accum[4] = {0,0,0,0};
 518
 519       for(j=0;j<N;j++) {
 520         const double curr_in=iptr[j];
 521         accum[0] += MULT16_16(curr_in,st->sinc_table[4+(j+1)*st->oversample-offset-2]);
 522         accum[1] += MULT16_16(curr_in,st->sinc_table[4+(j+1)*st->oversample-offset-1]);
 523         accum[2] += MULT16_16(curr_in,st->sinc_table[4+(j+1)*st->oversample-offset]);
 524         accum[3] += MULT16_16(curr_in,st->sinc_table[4+(j+1)*st->oversample-offset+1]);
 525       }
 526
 527       cubic_coef(frac, interp);
 528       sum = MULT16_32_Q15(interp[0],accum[0]) + MULT16_32_Q15(interp[1],accum[1]) + MULT16_32_Q15(interp[2],accum[2]) + MULT16_32_Q15(interp[3],accum[3]);
 529 #else
 530       cubic_coef(frac, interp);
 531       sum = interpolate_product_double(iptr, st->sinc_table + st->oversample + 4 - offset - 2, N, st->oversample, interp);
 532 #endif
 533
 534       out[out_stride * out_sample++] = PSHR32(sum,15);
 535       last_sample += int_advance;
 536       samp_frac_num += frac_advance;
 537       if (samp_frac_num >= den_rate)
 538       {
 539          samp_frac_num -= den_rate;
 540          last_sample++;
 541       }
 542    }
 543
 544    st->last_sample[channel_index] = last_sample;
 545    st->samp_frac_num[channel_index] = samp_frac_num;
 546    return out_sample;
 547 }
 548 #endif
 549
 550 static void update_filter(SpeexResamplerState *st)
 551 {
 552    spx_uint32_t old_length;
 553
 554    old_length = st->filt_len;
 555    st->oversample = quality_map[st->quality].oversample;
 556    st->filt_len = quality_map[st->quality].base_length;
 557
 558    if (st->num_rate > st->den_rate)
 559    {
 560       /* down-sampling */
 561       st->cutoff = quality_map[st->quality].downsample_bandwidth * st->den_rate / st->num_rate;
 562       /* FIXME: divide the numerator and denominator by a certain amount if they're too large */
 563       st->filt_len = st->filt_len*st->num_rate / st->den_rate;
 564       /* Round down to make sure we have a multiple of 4 */
 565       st->filt_len &= (~0x3);
 566       if (2*st->den_rate < st->num_rate)
 567          st->oversample >>= 1;
 568       if (4*st->den_rate < st->num_rate)
 569          st->oversample >>= 1;
 570       if (8*st->den_rate < st->num_rate)
 571          st->oversample >>= 1;
 572       if (16*st->den_rate < st->num_rate)
 573          st->oversample >>= 1;
 574       if (st->oversample < 1)
 575          st->oversample = 1;
 576    } else {
 577       /* up-sampling */
 578       st->cutoff = quality_map[st->quality].upsample_bandwidth;
 579    }
 580
 581    /* Choose the resampling type that requires the least amount of memory */
 582    if (st->den_rate <= st->oversample)
 583    {
 584       spx_uint32_t i;
 585       if (!st->sinc_table)
 586          st->sinc_table = (spx_word16_t *)speex_alloc(st->filt_len*st->den_rate*sizeof(spx_word16_t));
 587       else if (st->sinc_table_length < st->filt_len*st->den_rate)
 588       {
 589          st->sinc_table = (spx_word16_t *)speex_realloc(st->sinc_table,st->filt_len*st->den_rate*sizeof(spx_word16_t));
 590          st->sinc_table_length = st->filt_len*st->den_rate;
 591       }
 592       for (i=0;i<st->den_rate;i++)
 593       {
 594          spx_int32_t j;
 595          for (j=0;j<st->filt_len;j++)
 596          {
 597             st->sinc_table[i*st->filt_len+j] = sinc(st->cutoff,((j-(spx_int32_t)st->filt_len/2+1)-((float)i)/st->den_rate), st->filt_len, quality_map[st->quality].window_func);
 598          }
 599       }
 600 #ifdef FIXED_POINT
 601       st->resampler_ptr = resampler_basic_direct_single;
 602 #else
 603       if (st->quality>8)
 604          st->resampler_ptr = resampler_basic_direct_double;
 605       else
 606          st->resampler_ptr = resampler_basic_direct_single;
 607 #endif
 608       /*fprintf (stderr, "resampler uses direct sinc table and normalised cutoff %f\n", cutoff);*/
 609    } else {
 610       spx_int32_t i;
 611       if (!st->sinc_table)
 612          st->sinc_table = (spx_word16_t *)speex_alloc((st->filt_len*st->oversample+8)*sizeof(spx_word16_t));
 613       else if (st->sinc_table_length < st->filt_len*st->oversample+8)
 614       {
 615          st->sinc_table = (spx_word16_t *)speex_realloc(st->sinc_table,(st->filt_len*st->oversample+8)*sizeof(spx_word16_t));
 616          st->sinc_table_length = st->filt_len*st->oversample+8;
 617       }
 618       for (i=-4;i<(spx_int32_t)(st->oversample*st->filt_len+4);i++)
 619          st->sinc_table[i+4] = sinc(st->cutoff,(i/(float)st->oversample - st->filt_len/2), st->filt_len, quality_map[st->quality].window_func);
 620 #ifdef FIXED_POINT
 621       st->resampler_ptr = resampler_basic_interpolate_single;
 622 #else
 623       if (st->quality>8)
 624          st->resampler_ptr = resampler_basic_interpolate_double;
 625       else
 626          st->resampler_ptr = resampler_basic_interpolate_single;
 627 #endif
 628       /*fprintf (stderr, "resampler uses interpolated sinc table and normalised cutoff %f\n", cutoff);*/
 629    }
 630    st->int_advance = st->num_rate/st->den_rate;
 631    st->frac_advance = st->num_rate%st->den_rate;
 632
 633
 634    /* Here's the place where we update the filter memory to take into account
 635       the change in filter length. It's probably the messiest part of the code
 636       due to handling of lots of corner cases. */
 637    if (!st->mem)
 638    {
 639       spx_uint32_t i;
 640       st->mem_alloc_size = st->filt_len-1 + st->buffer_size;
 641       st->mem = (spx_word16_t*)speex_alloc(st->nb_channels*st->mem_alloc_size * sizeof(spx_word16_t));
 642       for (i=0;i<st->nb_channels*st->mem_alloc_size;i++)
 643          st->mem[i] = 0;
 644       /*speex_warning("init filter");*/
 645    } else if (!st->started)
 646    {
 647       spx_uint32_t i;
 648       st->mem_alloc_size = st->filt_len-1 + st->buffer_size;
 649       st->mem = (spx_word16_t*)speex_realloc(st->mem, st->nb_channels*st->mem_alloc_size * sizeof(spx_word16_t));
 650       for (i=0;i<st->nb_channels*st->mem_alloc_size;i++)
 651          st->mem[i] = 0;
 652       /*speex_warning("reinit filter");*/
 653    } else if (st->filt_len > old_length)
 654    {
 655       spx_int32_t i;
 656       /* Increase the filter length */
 657       /*speex_warning("increase filter size");*/
 658       int old_alloc_size = st->mem_alloc_size;
 659       if ((st->filt_len-1 + st->buffer_size) > st->mem_alloc_size)
 660       {
 661          st->mem_alloc_size = st->filt_len-1 + st->buffer_size;
 662          st->mem = (spx_word16_t*)speex_realloc(st->mem, st->nb_channels*st->mem_alloc_size * sizeof(spx_word16_t));
 663       }
 664       for (i=st->nb_channels-1;i>=0;i--)
 665       {
 666          spx_int32_t j;
 667          spx_uint32_t olen = old_length;
 668          /*if (st->magic_samples[i])*/
 669          {
 670             /* Try and remove the magic samples as if nothing had happened */
 671
 672             /* FIXME: This is wrong but for now we need it to avoid going over the array bounds */
 673             olen = old_length + 2*st->magic_samples[i];
 674             for (j=old_length-2+st->magic_samples[i];j>=0;j--)
 675                st->mem[i*st->mem_alloc_size+j+st->magic_samples[i]] = st->mem[i*old_alloc_size+j];
 676             for (j=0;j<st->magic_samples[i];j++)
 677                st->mem[i*st->mem_alloc_size+j] = 0;
 678             st->magic_samples[i] = 0;
 679          }
 680          if (st->filt_len > olen)
 681          {
 682             /* If the new filter length is still bigger than the "augmented" length */
 683             /* Copy data going backward */
 684             for (j=0;j<olen-1;j++)
 685                st->mem[i*st->mem_alloc_size+(st->filt_len-2-j)] = st->mem[i*st->mem_alloc_size+(olen-2-j)];
 686             /* Then put zeros for lack of anything better */
 687             for (;j<st->filt_len-1;j++)
 688                st->mem[i*st->mem_alloc_size+(st->filt_len-2-j)] = 0;
 689             /* Adjust last_sample */
 690             st->last_sample[i] += (st->filt_len - olen)/2;
 691          } else {
 692             /* Put back some of the magic! */
 693             st->magic_samples[i] = (olen - st->filt_len)/2;
 694             for (j=0;j<st->filt_len-1+st->magic_samples[i];j++)
 695                st->mem[i*st->mem_alloc_size+j] = st->mem[i*st->mem_alloc_size+j+st->magic_samples[i]];
 696          }
 697       }
 698    } else if (st->filt_len < old_length)
 699    {
 700       spx_uint32_t i;
 701       /* Reduce filter length, this a bit tricky. We need to store some of the memory as "magic"
 702          samples so they can be used directly as input the next time(s) */
 703       for (i=0;i<st->nb_channels;i++)
 704       {
 705          spx_uint32_t j;
 706          spx_uint32_t old_magic = st->magic_samples[i];
 707          st->magic_samples[i] = (old_length - st->filt_len)/2;
 708          /* We must copy some of the memory that's no longer used */
 709          /* Copy data going backward */
 710          for (j=0;j<st->filt_len-1+st->magic_samples[i]+old_magic;j++)
 711             st->mem[i*st->mem_alloc_size+j] = st->mem[i*st->mem_alloc_size+j+st->magic_samples[i]];
 712          st->magic_samples[i] += old_magic;
 713       }
 714    }
 715
 716 }
 717
 718 EXPORT SpeexResamplerState *speex_resampler_init(spx_uint32_t nb_channels, spx_uint32_t in_rate, spx_uint32_t out_rate, int quality, int *err)
 719 {
 720    return speex_resampler_init_frac(nb_channels, in_rate, out_rate, in_rate, out_rate, quality, err);
 721 }
 722
 723 EXPORT SpeexResamplerState *speex_resampler_init_frac(spx_uint32_t nb_channels, spx_uint32_t ratio_num, spx_uint32_t ratio_den, spx_uint32_t in_rate, spx_uint32_t out_rate, int quality, int *err)
 724 {
 725    spx_uint32_t i;
 726    SpeexResamplerState *st;
 727    if (quality > 10 || quality < 0)
 728    {
 729       if (err)
 730          *err = RESAMPLER_ERR_INVALID_ARG;
 731       return NULL;
 732    }
 733    st = (SpeexResamplerState *)speex_alloc(sizeof(SpeexResamplerState));
 734    st->initialised = 0;
 735    st->started = 0;
 736    st->in_rate = 0;
 737    st->out_rate = 0;
 738    st->num_rate = 0;
 739    st->den_rate = 0;
 740    st->quality = -1;
 741    st->sinc_table_length = 0;
 742    st->mem_alloc_size = 0;
 743    st->filt_len = 0;
 744    st->mem = 0;
 745    st->resampler_ptr = 0;
 746
 747    st->cutoff = 1.f;
 748    st->nb_channels = nb_channels;
 749    st->in_stride = 1;
 750    st->out_stride = 1;
 751
 752 #ifdef FIXED_POINT
 753    st->buffer_size = 160;
 754 #else
 755    st->buffer_size = 160;
 756 #endif
 757
 758    /* Per channel data */
 759    st->last_sample = (spx_int32_t*)speex_alloc(nb_channels*sizeof(int));
 760    st->magic_samples = (spx_uint32_t*)speex_alloc(nb_channels*sizeof(int));
 761    st->samp_frac_num = (spx_uint32_t*)speex_alloc(nb_channels*sizeof(int));
 762    for (i=0;i<nb_channels;i++)
 763    {
 764       st->last_sample[i] = 0;
 765       st->magic_samples[i] = 0;
 766       st->samp_frac_num[i] = 0;
 767    }
 768
 769    speex_resampler_set_quality(st, quality);
 770    speex_resampler_set_rate_frac(st, ratio_num, ratio_den, in_rate, out_rate);
 771
 772
 773    update_filter(st);
 774
 775    st->initialised = 1;
 776    if (err)
 777       *err = RESAMPLER_ERR_SUCCESS;
 778
 779    return st;
 780 }
 781
 782 EXPORT void speex_resampler_destroy(SpeexResamplerState *st)
 783 {
 784    speex_free(st->mem);
 785    speex_free(st->sinc_table);
 786    speex_free(st->last_sample);
 787    speex_free(st->magic_samples);
 788    speex_free(st->samp_frac_num);
 789    speex_free(st);
 790 }
 791
 792 static int speex_resampler_process_native(SpeexResamplerState *st, spx_uint32_t channel_index, spx_uint32_t *in_len, spx_word16_t *out, spx_uint32_t *out_len)
 793 {
 794    int j=0;
 795    const int N = st->filt_len;
 796    int out_sample = 0;
 797    spx_word16_t *mem = st->mem + channel_index * st->mem_alloc_size;
 798    spx_uint32_t ilen;
 799
 800    st->started = 1;
 801
 802    /* Call the right resampler through the function ptr */
 803    out_sample = st->resampler_ptr(st, channel_index, mem, in_len, out, out_len);
 804
 805    if (st->last_sample[channel_index] < (spx_int32_t)*in_len)
 806       *in_len = st->last_sample[channel_index];
 807    *out_len = out_sample;
 808    st->last_sample[channel_index] -= *in_len;
 809
 810    ilen = *in_len;
 811
 812    for(j=0;j<N-1;++j)
 813      mem[j] = mem[j+ilen];
 814
 815    return RESAMPLER_ERR_SUCCESS;
 816 }
 817
 818 static int speex_resampler_magic(SpeexResamplerState *st, spx_uint32_t channel_index, spx_word16_t **out, spx_uint32_t out_len) {
 819    spx_uint32_t tmp_in_len = st->magic_samples[channel_index];
 820    spx_word16_t *mem = st->mem + channel_index * st->mem_alloc_size;
 821    const int N = st->filt_len;
 822
 823    speex_resampler_process_native(st, channel_index, &tmp_in_len, *out, &out_len);
 824
 825    st->magic_samples[channel_index] -= tmp_in_len;
 826
 827    /* If we couldn't process all "magic" input samples, save the rest for next time */
 828    if (st->magic_samples[channel_index])
 829    {
 830       spx_uint32_t i;
 831       for (i=0;i<st->magic_samples[channel_index];i++)
 832          mem[N-1+i]=mem[N-1+i+tmp_in_len];
 833    }
 834    *out += out_len*st->out_stride;
 835    return out_len;
 836 }
 837
 838 #ifdef FIXED_POINT
 839 EXPORT int speex_resampler_process_int(SpeexResamplerState *st, spx_uint32_t channel_index, const spx_int16_t *in, spx_uint32_t *in_len, spx_int16_t *out, spx_uint32_t *out_len)
 840 #else
 841 EXPORT int speex_resampler_process_float(SpeexResamplerState *st, spx_uint32_t channel_index, const float *in, spx_uint32_t *in_len, float *out, spx_uint32_t *out_len)
 842 #endif
 843 {
 844    int j;
 845    spx_uint32_t ilen = *in_len;
 846    spx_uint32_t olen = *out_len;
 847    spx_word16_t *x = st->mem + channel_index * st->mem_alloc_size;
 848    const int filt_offs = st->filt_len - 1;
 849    const spx_uint32_t xlen = st->mem_alloc_size - filt_offs;
 850    const int istride = st->in_stride;
 851
 852    if (st->magic_samples[channel_index])
 853       olen -= speex_resampler_magic(st, channel_index, &out, olen);
 854    if (! st->magic_samples[channel_index]) {
 855       while (ilen && olen) {
 856         spx_uint32_t ichunk = (ilen > xlen) ? xlen : ilen;
 857         spx_uint32_t ochunk = olen;
 858
 859         if (in) {
 860            for(j=0;j<ichunk;++j)
 861               x[j+filt_offs]=in[j*istride];
 862         } else {
 863           for(j=0;j<ichunk;++j)
 864             x[j+filt_offs]=0;
 865         }
 866         speex_resampler_process_native(st, channel_index, &ichunk, out, &ochunk);
 867         ilen -= ichunk;
 868         olen -= ochunk;
 869         out += ochunk * st->out_stride;
 870         if (in)
 871            in += ichunk * istride;
 872       }
 873    }
 874    *in_len -= ilen;
 875    *out_len -= olen;
 876    return RESAMPLER_ERR_SUCCESS;
 877 }
 878
 879 #ifdef FIXED_POINT
 880 EXPORT int speex_resampler_process_float(SpeexResamplerState *st, spx_uint32_t channel_index, const float *in, spx_uint32_t *in_len, float *out, spx_uint32_t *out_len)
 881 #else
 882 EXPORT int speex_resampler_process_int(SpeexResamplerState *st, spx_uint32_t channel_index, const spx_int16_t *in, spx_uint32_t *in_len, spx_int16_t *out, spx_uint32_t *out_len)
 883 #endif
 884 {
 885    int j;
 886    const int istride_save = st->in_stride;
 887    const int ostride_save = st->out_stride;
 888    spx_uint32_t ilen = *in_len;
 889    spx_uint32_t olen = *out_len;
 890    spx_word16_t *x = st->mem + channel_index * st->mem_alloc_size;
 891    const spx_uint32_t xlen = st->mem_alloc_size - (st->filt_len - 1);
 892 #ifdef VAR_ARRAYS
 893    const unsigned int ylen = (olen < FIXED_STACK_ALLOC) ? olen : FIXED_STACK_ALLOC;
 894    VARDECL(spx_word16_t *ystack);
 895    ALLOC(ystack, ylen, spx_word16_t);
 896 #else
 897    const unsigned int ylen = FIXED_STACK_ALLOC;
 898    spx_word16_t ystack[FIXED_STACK_ALLOC];
 899 #endif
 900
 901    st->out_stride = 1;
 902
 903    while (ilen && olen) {
 904      spx_word16_t *y = ystack;
 905      spx_uint32_t ichunk = (ilen > xlen) ? xlen : ilen;
 906      spx_uint32_t ochunk = (olen > ylen) ? ylen : olen;
 907      spx_uint32_t omagic = 0;
 908
 909      if (st->magic_samples[channel_index]) {
 910        omagic = speex_resampler_magic(st, channel_index, &y, ochunk);
 911        ochunk -= omagic;
 912        olen -= omagic;
 913      }
 914      if (! st->magic_samples[channel_index]) {
 915        if (in) {
 916          for(j=0;j<ichunk;++j)
 917 #ifdef FIXED_POINT
 918            x[j+st->filt_len-1]=WORD2INT(in[j*istride_save]);
 919 #else
 920            x[j+st->filt_len-1]=in[j*istride_save];
 921 #endif
 922        } else {
 923          for(j=0;j<ichunk;++j)
 924            x[j+st->filt_len-1]=0;
 925        }
 926
 927        speex_resampler_process_native(st, channel_index, &ichunk, y, &ochunk);
 928      } else {
 929        ichunk = 0;
 930        ochunk = 0;
 931      }
 932
 933      for (j=0;j<ochunk+omagic;++j)
 934 #ifdef FIXED_POINT
 935         out[j*ostride_save] = ystack[j];
 936 #else
 937         out[j*ostride_save] = WORD2INT(ystack[j]);
 938 #endif
 939
 940      ilen -= ichunk;
 941      olen -= ochunk;
 942      out += (ochunk+omagic) * ostride_save;
 943      if (in)
 944        in += ichunk * istride_save;
 945    }
 946    st->out_stride = ostride_save;
 947    *in_len -= ilen;
 948    *out_len -= olen;
 949
 950    return RESAMPLER_ERR_SUCCESS;
 951 }
 952
 953 EXPORT int speex_resampler_process_interleaved_float(SpeexResamplerState *st, const float *in, spx_uint32_t *in_len, float *out, spx_uint32_t *out_len)
 954 {
 955    spx_uint32_t i;
 956    int istride_save, ostride_save;
 957    spx_uint32_t bak_len = *out_len;
 958    istride_save = st->in_stride;
 959    ostride_save = st->out_stride;
 960    st->in_stride = st->out_stride = st->nb_channels;
 961    for (i=0;i<st->nb_channels;i++)
 962    {
 963       *out_len = bak_len;
 964       if (in != NULL)
 965          speex_resampler_process_float(st, i, in+i, in_len, out+i, out_len);
 966       else
 967          speex_resampler_process_float(st, i, NULL, in_len, out+i, out_len);
 968    }
 969    st->in_stride = istride_save;
 970    st->out_stride = ostride_save;
 971    return RESAMPLER_ERR_SUCCESS;
 972 }
 973
 974 EXPORT int speex_resampler_process_interleaved_int(SpeexResamplerState *st, const spx_int16_t *in, spx_uint32_t *in_len, spx_int16_t *out, spx_uint32_t *out_len)
 975 {
 976    spx_uint32_t i;
 977    int istride_save, ostride_save;
 978    spx_uint32_t bak_len = *out_len;
 979    istride_save = st->in_stride;
 980    ostride_save = st->out_stride;
 981    st->in_stride = st->out_stride = st->nb_channels;
 982    for (i=0;i<st->nb_channels;i++)
 983    {
 984       *out_len = bak_len;
 985       if (in != NULL)
 986          speex_resampler_process_int(st, i, in+i, in_len, out+i, out_len);
 987       else
 988          speex_resampler_process_int(st, i, NULL, in_len, out+i, out_len);
 989    }
 990    st->in_stride = istride_save;
 991    st->out_stride = ostride_save;
 992    return RESAMPLER_ERR_SUCCESS;
 993 }
 994
 995 EXPORT int speex_resampler_set_rate(SpeexResamplerState *st, spx_uint32_t in_rate, spx_uint32_t out_rate)
 996 {
 997    return speex_resampler_set_rate_frac(st, in_rate, out_rate, in_rate, out_rate);
 998 }
 999
1000 EXPORT void speex_resampler_get_rate(SpeexResamplerState *st, spx_uint32_t *in_rate, spx_uint32_t *out_rate)
1001 {
1002    *in_rate = st->in_rate;
1003    *out_rate = st->out_rate;
1004 }
1005
1006 EXPORT int speex_resampler_set_rate_frac(SpeexResamplerState *st, spx_uint32_t ratio_num, spx_uint32_t ratio_den, spx_uint32_t in_rate, spx_uint32_t out_rate)
1007 {
1008    spx_uint32_t fact;
1009    spx_uint32_t old_den;
1010    spx_uint32_t i;
1011    if (st->in_rate == in_rate && st->out_rate == out_rate && st->num_rate == ratio_num && st->den_rate == ratio_den)
1012       return RESAMPLER_ERR_SUCCESS;
1013
1014    old_den = st->den_rate;
1015    st->in_rate = in_rate;
1016    st->out_rate = out_rate;
1017    st->num_rate = ratio_num;
1018    st->den_rate = ratio_den;
1019    /* FIXME: This is terribly inefficient, but who cares (at least for now)? */
1020    for (fact=2;fact<=IMIN(st->num_rate, st->den_rate);fact++)
1021    {
1022       while ((st->num_rate % fact == 0) && (st->den_rate % fact == 0))
1023       {
1024          st->num_rate /= fact;
1025          st->den_rate /= fact;
1026       }
1027    }
1028
1029    if (old_den > 0)
1030    {
1031       for (i=0;i<st->nb_channels;i++)
1032       {
1033          st->samp_frac_num[i]=st->samp_frac_num[i]*st->den_rate/old_den;
1034          /* Safety net */
1035          if (st->samp_frac_num[i] >= st->den_rate)
1036             st->samp_frac_num[i] = st->den_rate-1;
1037       }
1038    }
1039
1040    if (st->initialised)
1041       update_filter(st);
1042    return RESAMPLER_ERR_SUCCESS;
1043 }
1044
1045 EXPORT void speex_resampler_get_ratio(SpeexResamplerState *st, spx_uint32_t *ratio_num, spx_uint32_t *ratio_den)
1046 {
1047    *ratio_num = st->num_rate;
1048    *ratio_den = st->den_rate;
1049 }
1050
1051 EXPORT int speex_resampler_set_quality(SpeexResamplerState *st, int quality)
1052 {
1053    if (quality > 10 || quality < 0)
1054       return RESAMPLER_ERR_INVALID_ARG;
1055    if (st->quality == quality)
1056       return RESAMPLER_ERR_SUCCESS;
1057    st->quality = quality;
1058    if (st->initialised)
1059       update_filter(st);
1060    return RESAMPLER_ERR_SUCCESS;
1061 }
1062
1063 EXPORT void speex_resampler_get_quality(SpeexResamplerState *st, int *quality)
1064 {
1065    *quality = st->quality;
1066 }
1067
1068 EXPORT void speex_resampler_set_input_stride(SpeexResamplerState *st, spx_uint32_t stride)
1069 {
1070    st->in_stride = stride;
1071 }
1072
1073 EXPORT void speex_resampler_get_input_stride(SpeexResamplerState *st, spx_uint32_t *stride)
1074 {
1075    *stride = st->in_stride;
1076 }
1077
1078 EXPORT void speex_resampler_set_output_stride(SpeexResamplerState *st, spx_uint32_t stride)
1079 {
1080    st->out_stride = stride;
1081 }
1082
1083 EXPORT void speex_resampler_get_output_stride(SpeexResamplerState *st, spx_uint32_t *stride)
1084 {
1085    *stride = st->out_stride;
1086 }
1087
1088 EXPORT int speex_resampler_get_input_latency(SpeexResamplerState *st)
1089 {
1090   return st->filt_len / 2;
1091 }
1092
1093 EXPORT int speex_resampler_get_output_latency(SpeexResamplerState *st)
1094 {
1095   return ((st->filt_len / 2) * st->den_rate + (st->num_rate >> 1)) / st->num_rate;
1096 }
1097
1098 EXPORT int speex_resampler_skip_zeros(SpeexResamplerState *st)
1099 {
1100    spx_uint32_t i;
1101    for (i=0;i<st->nb_channels;i++)
1102       st->last_sample[i] = st->filt_len/2;
1103    return RESAMPLER_ERR_SUCCESS;
1104 }
1105
1106 EXPORT int speex_resampler_reset_mem(SpeexResamplerState *st)
1107 {
1108    spx_uint32_t i;
1109    for (i=0;i<st->nb_channels*(st->filt_len-1);i++)
1110       st->mem[i] = 0;
1111    return RESAMPLER_ERR_SUCCESS;
1112 }
1113
1114 EXPORT const char *speex_resampler_strerror(int err)
1115 {
1116    switch (err)
1117    {
1118       case RESAMPLER_ERR_SUCCESS:
1119          return "Success.";
1120       case RESAMPLER_ERR_ALLOC_FAILED:
1121          return "Memory allocation failed.";
1122       case RESAMPLER_ERR_BAD_STATE:
1123          return "Bad resampler state.";
1124       case RESAMPLER_ERR_INVALID_ARG:
1125          return "Invalid argument.";
1126       case RESAMPLER_ERR_PTR_OVERLAP:
1127          return "Input and output buffers overlap.";
1128       default:
1129          return "Unknown error. Bad error code or strange version mismatch.";
1130    }
1131 }