Adding error codes.
[speexdsp.git] / libspeex / resample.c
index 419a108..7f42c5c 100644 (file)
@@ -60,10 +60,12 @@ void *speex_alloc (int size) {return calloc(size,1);}
 void *speex_realloc (void *ptr, int size) {return realloc(ptr, size);}
 void speex_free (void *ptr) {free(ptr);}
 #include "speex_resampler.h"
-#else
+#include "arch.h"
+#else /* OUTSIDE_SPEEX */
+               
 #include "speex/speex_resampler.h"
 #include "misc.h"
-#endif
+#endif /* OUTSIDE_SPEEX */
 
 #include <math.h>
 
@@ -83,34 +85,37 @@ void speex_free (void *ptr) {free(ptr);}
 
 #define IMAX(a,b) ((a) > (b) ? (a) : (b))
 
+#ifndef NULL
+#define NULL 0
+#endif
 
-typedef int (*resampler_basic_func)(SpeexResamplerState *, int , const spx_word16_t *, int *, spx_word16_t *, int *);
+typedef int (*resampler_basic_func)(SpeexResamplerState *, spx_uint32_t , const spx_word16_t *, spx_uint32_t *, spx_word16_t *, spx_uint32_t *);
 
 struct SpeexResamplerState_ {
-   int    in_rate;
-   int    out_rate;
-   int    num_rate;
-   int    den_rate;
+   spx_uint32_t in_rate;
+   spx_uint32_t out_rate;
+   spx_uint32_t num_rate;
+   spx_uint32_t den_rate;
    
    int    quality;
-   int    nb_channels;
-   int    filt_len;
-   int    mem_alloc_size;
-   int    int_advance;
-   int    frac_advance;
+   spx_uint32_t nb_channels;
+   spx_uint32_t filt_len;
+   spx_uint32_t mem_alloc_size;
+   int          int_advance;
+   int          frac_advance;
    float  cutoff;
-   int    oversample;
-   int    initialised;
-   int    started;
+   spx_uint32_t oversample;
+   int          initialised;
+   int          started;
    
    /* These are per-channel */
-   int    *last_sample;
-   int    *samp_frac_num;
-   int    *magic_samples;
+   spx_int32_t  *last_sample;
+   spx_uint32_t *samp_frac_num;
+   spx_uint32_t *magic_samples;
    
    spx_word16_t *mem;
    spx_word16_t *sinc_table;
-   int    sinc_table_length;
+   spx_uint32_t sinc_table_length;
    resampler_basic_func resampler_ptr;
          
    int    in_stride;
@@ -163,14 +168,6 @@ static double kaiser6_table[36] = {
    0.19505503, 0.16360756, 0.13508755, 0.10953262, 0.08693120, 0.06722600,
    0.05031820, 0.03607231, 0.02432151, 0.01487334, 0.00752000, 0.00000000};
 
-static double kaiser4_table[36] = {
-   0.99831452, 1.00000000, 0.99831452, 0.99327105, 0.98490841, 0.97329088,
-   0.95850750, 0.94067123, 0.91991776, 0.89640418, 0.87030740, 0.84182235,
-   0.81116010, 0.77854570, 0.74421601, 0.70841739, 0.67140328, 0.63343178,
-   0.59476318, 0.55565754, 0.51637222, 0.47715958, 0.43826468, 0.39992313,
-   0.36235905, 0.32578323, 0.29039137, 0.25636266, 0.22385840, 0.19302093,
-   0.16397278, 0.13681602, 0.11163187, 0.08848053, 0.06740000, 0.00000000};
-
 struct FuncDef {
    double *table;
    int oversample;
@@ -186,8 +183,6 @@ static struct FuncDef _KAISER8 = {kaiser8_table, 32};
 #define KAISER8 (&_KAISER8)
 static struct FuncDef _KAISER6 = {kaiser6_table, 32};
 #define KAISER6 (&_KAISER6)
-static struct FuncDef _KAISER4 = {kaiser4_table, 32};
-#define KAISER4 (&_KAISER4)
 
 struct QualityMapping {
    int base_length;
@@ -207,9 +202,9 @@ struct QualityMapping {
       by the sinusoids/noise just below the Nyquist rate (guaranteed only for
       up-sampling).
 */
-const struct QualityMapping quality_map[11] = {
-   {  8,  4, 0.830f, 0.860f, KAISER4 }, /* Q0 */  /* 63.5% cutoff ( ~20 dB stop) 4  */
-   { 16,  4, 0.850f, 0.880f, KAISER4 }, /* Q1 */  /* 75.3% cutoff ( ~40 dB stop) 4  */ 
+static const struct QualityMapping quality_map[11] = {
+   {  8,  4, 0.830f, 0.860f, KAISER6 }, /* Q0 */
+   { 16,  4, 0.850f, 0.880f, KAISER6 }, /* Q1 */
    { 32,  4, 0.882f, 0.910f, KAISER6 }, /* Q2 */  /* 82.3% cutoff ( ~60 dB stop) 6  */
    { 48,  8, 0.895f, 0.917f, KAISER8 }, /* Q3 */  /* 84.9% cutoff ( ~80 dB stop) 8  */
    { 64,  8, 0.921f, 0.940f, KAISER8 }, /* Q4 */  /* 88.7% cutoff ( ~80 dB stop) 8  */
@@ -312,15 +307,15 @@ static void cubic_coef(spx_word16_t frac, spx_word16_t interp[4])
 }
 #endif
 
-static int resampler_basic_direct_single(SpeexResamplerState *st, int channel_index, const spx_word16_t *in, int *in_len, spx_word16_t *out, int *out_len)
+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)
 {
    int N = st->filt_len;
    int out_sample = 0;
    spx_word16_t *mem;
    int last_sample = st->last_sample[channel_index];
-   int samp_frac_num = st->samp_frac_num[channel_index];
+   spx_uint32_t samp_frac_num = st->samp_frac_num[channel_index];
    mem = st->mem + channel_index * st->mem_alloc_size;
-   while (!(last_sample >= *in_len || out_sample >= *out_len))
+   while (!(last_sample >= (spx_int32_t)*in_len || out_sample >= (spx_int32_t)*out_len))
    {
       int j;
       spx_word32_t sum=0;
@@ -360,15 +355,15 @@ static int resampler_basic_direct_single(SpeexResamplerState *st, int channel_in
 #ifdef FIXED_POINT
 #else
 /* This is the same as the previous function, except with a double-precision accumulator */
-static int resampler_basic_direct_double(SpeexResamplerState *st, int channel_index, const spx_word16_t *in, int *in_len, spx_word16_t *out, int *out_len)
+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)
 {
    int N = st->filt_len;
    int out_sample = 0;
    spx_word16_t *mem;
    int last_sample = st->last_sample[channel_index];
-   int samp_frac_num = st->samp_frac_num[channel_index];
+   spx_uint32_t samp_frac_num = st->samp_frac_num[channel_index];
    mem = st->mem + channel_index * st->mem_alloc_size;
-   while (!(last_sample >= *in_len || out_sample >= *out_len))
+   while (!(last_sample >= (spx_int32_t)*in_len || out_sample >= (spx_int32_t)*out_len))
    {
       int j;
       double sum=0;
@@ -406,15 +401,15 @@ static int resampler_basic_direct_double(SpeexResamplerState *st, int channel_in
 }
 #endif
 
-static int resampler_basic_interpolate_single(SpeexResamplerState *st, int channel_index, const spx_word16_t *in, int *in_len, spx_word16_t *out, int *out_len)
+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)
 {
    int N = st->filt_len;
    int out_sample = 0;
    spx_word16_t *mem;
    int last_sample = st->last_sample[channel_index];
-   int samp_frac_num = st->samp_frac_num[channel_index];
+   spx_uint32_t samp_frac_num = st->samp_frac_num[channel_index];
    mem = st->mem + channel_index * st->mem_alloc_size;
-   while (!(last_sample >= *in_len || out_sample >= *out_len))
+   while (!(last_sample >= (spx_int32_t)*in_len || out_sample >= (spx_int32_t)*out_len))
    {
       int j;
       spx_word32_t sum=0;
@@ -475,15 +470,15 @@ static int resampler_basic_interpolate_single(SpeexResamplerState *st, int chann
 #ifdef FIXED_POINT
 #else
 /* This is the same as the previous function, except with a double-precision accumulator */
-static int resampler_basic_interpolate_double(SpeexResamplerState *st, int channel_index, const spx_word16_t *in, int *in_len, spx_word16_t *out, int *out_len)
+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)
 {
    int N = st->filt_len;
    int out_sample = 0;
    spx_word16_t *mem;
    int last_sample = st->last_sample[channel_index];
-   int samp_frac_num = st->samp_frac_num[channel_index];
+   spx_uint32_t samp_frac_num = st->samp_frac_num[channel_index];
    mem = st->mem + channel_index * st->mem_alloc_size;
-   while (!(last_sample >= *in_len || out_sample >= *out_len))
+   while (!(last_sample >= (spx_int32_t)*in_len || out_sample >= (spx_int32_t)*out_len))
    {
       int j;
       spx_word32_t sum=0;
@@ -539,8 +534,7 @@ static int resampler_basic_interpolate_double(SpeexResamplerState *st, int chann
 
 static void update_filter(SpeexResamplerState *st)
 {
-   int i;
-   int old_length;
+   spx_uint32_t old_length;
    
    old_length = st->filt_len;
    st->oversample = quality_map[st->quality].oversample;
@@ -562,6 +556,7 @@ static void update_filter(SpeexResamplerState *st)
    /* Choose the resampling type that requires the least amount of memory */
    if (st->den_rate <= st->oversample)
    {
+      spx_uint32_t i;
       if (!st->sinc_table)
          st->sinc_table = (spx_word16_t *)speex_alloc(st->filt_len*st->den_rate*sizeof(spx_word16_t));
       else if (st->sinc_table_length < st->filt_len*st->den_rate)
@@ -571,7 +566,7 @@ static void update_filter(SpeexResamplerState *st)
       }
       for (i=0;i<st->den_rate;i++)
       {
-         int j;
+         spx_uint32_t j;
          for (j=0;j<st->filt_len;j++)
          {
             st->sinc_table[i*st->filt_len+j] = sinc(st->cutoff,((j-st->filt_len/2+1)-((float)i)/st->den_rate), st->filt_len, quality_map[st->quality].window_func);
@@ -587,6 +582,7 @@ static void update_filter(SpeexResamplerState *st)
 #endif
       /*fprintf (stderr, "resampler uses direct sinc table and normalised cutoff %f\n", cutoff);*/
    } else {
+      spx_int32_t i;
       if (!st->sinc_table)
          st->sinc_table = (spx_word16_t *)speex_alloc((st->filt_len*st->oversample+8)*sizeof(spx_word16_t));
       else if (st->sinc_table_length < st->filt_len*st->oversample+8)
@@ -594,7 +590,7 @@ static void update_filter(SpeexResamplerState *st)
          st->sinc_table = (spx_word16_t *)speex_realloc(st->sinc_table,(st->filt_len*st->oversample+8)*sizeof(spx_word16_t));
          st->sinc_table_length = st->filt_len*st->oversample+8;
       }
-      for (i=-4;i<st->oversample*st->filt_len+4;i++)
+      for (i=-4;i<(spx_int32_t)(st->oversample*st->filt_len+4);i++)
          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);
 #ifdef FIXED_POINT
       st->resampler_ptr = resampler_basic_interpolate_single;
@@ -611,6 +607,7 @@ static void update_filter(SpeexResamplerState *st)
 
    if (!st->mem)
    {
+      spx_uint32_t i;
       st->mem = (spx_word16_t*)speex_alloc(st->nb_channels*(st->filt_len-1) * sizeof(spx_word16_t));
       for (i=0;i<st->nb_channels*(st->filt_len-1);i++)
          st->mem[i] = 0;
@@ -618,6 +615,7 @@ static void update_filter(SpeexResamplerState *st)
       /*speex_warning("init filter");*/
    } else if (!st->started)
    {
+      spx_uint32_t i;
       st->mem = (spx_word16_t*)speex_realloc(st->mem, st->nb_channels*(st->filt_len-1) * sizeof(spx_word16_t));
       for (i=0;i<st->nb_channels*(st->filt_len-1);i++)
          st->mem[i] = 0;
@@ -625,6 +623,7 @@ static void update_filter(SpeexResamplerState *st)
       /*speex_warning("reinit filter");*/
    } else if (st->filt_len > old_length)
    {
+      spx_uint32_t i;
       /* Increase the filter length */
       /*speex_warning("increase filter size");*/
       int old_alloc_size = st->mem_alloc_size;
@@ -635,7 +634,7 @@ static void update_filter(SpeexResamplerState *st)
       }
       for (i=0;i<st->nb_channels;i++)
       {
-         int j;
+         spx_uint32_t j;
          /* Copy data going backward */
          for (j=0;j<old_length-1;j++)
             st->mem[i*st->mem_alloc_size+(st->filt_len-2-j)] = st->mem[i*old_alloc_size+(old_length-2-j)];
@@ -647,13 +646,14 @@ static void update_filter(SpeexResamplerState *st)
       }
    } else if (st->filt_len < old_length)
    {
+      spx_uint32_t i;
       /* Reduce filter length, this a bit tricky */
       /*speex_warning("decrease filter size (unimplemented)");*/
       /* Adjust last_sample (which will likely end up negative) */
       /*st->last_sample += (st->filt_len - old_length)/2;*/
       for (i=0;i<st->nb_channels;i++)
       {
-         int j;
+         spx_uint32_t j;
          st->magic_samples[i] = (old_length - st->filt_len)/2;
          /* Copy data going backward */
          for (j=0;j<st->filt_len-1+st->magic_samples[i];j++)
@@ -663,15 +663,22 @@ static void update_filter(SpeexResamplerState *st)
 
 }
 
-SpeexResamplerState *speex_resampler_init(int nb_channels, int in_rate, int out_rate, int quality)
+SpeexResamplerState *speex_resampler_init(spx_uint32_t nb_channels, spx_uint32_t in_rate, spx_uint32_t out_rate, int quality, int *err)
 {
-   return speex_resampler_init_frac(nb_channels, in_rate, out_rate, in_rate, out_rate, quality);
+   return speex_resampler_init_frac(nb_channels, in_rate, out_rate, in_rate, out_rate, quality, err);
 }
 
-SpeexResamplerState *speex_resampler_init_frac(int nb_channels, int ratio_num, int ratio_den, int in_rate, int out_rate, int quality)
+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)
 {
-   int i;
-   SpeexResamplerState *st = (SpeexResamplerState *)speex_alloc(sizeof(SpeexResamplerState));
+   spx_uint32_t i;
+   SpeexResamplerState *st;
+   if (quality > 10 || quality < 0)
+   {
+      if (err)
+         *err = RESAMPLER_ERR_INVALID_ARG;
+      return NULL;
+   }
+   st = (SpeexResamplerState *)speex_alloc(sizeof(SpeexResamplerState));
    st->initialised = 0;
    st->started = 0;
    st->in_rate = 0;
@@ -691,9 +698,9 @@ SpeexResamplerState *speex_resampler_init_frac(int nb_channels, int ratio_num, i
    st->out_stride = 1;
    
    /* Per channel data */
-   st->last_sample = (int*)speex_alloc(nb_channels*sizeof(int));
-   st->magic_samples = (int*)speex_alloc(nb_channels*sizeof(int));
-   st->samp_frac_num = (int*)speex_alloc(nb_channels*sizeof(int));
+   st->last_sample = (spx_int32_t*)speex_alloc(nb_channels*sizeof(int));
+   st->magic_samples = (spx_uint32_t*)speex_alloc(nb_channels*sizeof(int));
+   st->samp_frac_num = (spx_uint32_t*)speex_alloc(nb_channels*sizeof(int));
    for (i=0;i<nb_channels;i++)
    {
       st->last_sample[i] = 0;
@@ -708,6 +715,9 @@ SpeexResamplerState *speex_resampler_init_frac(int nb_channels, int ratio_num, i
    update_filter(st);
    
    st->initialised = 1;
+   if (err)
+      *err = RESAMPLER_ERR_SUCCESS;
+
    return st;
 }
 
@@ -723,21 +733,21 @@ void speex_resampler_destroy(SpeexResamplerState *st)
 
 
 
-static void speex_resampler_process_native(SpeexResamplerState *st, int channel_index, const spx_word16_t *in, int *in_len, spx_word16_t *out, int *out_len)
+static int speex_resampler_process_native(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)
 {
    int j=0;
    int N = st->filt_len;
    int out_sample = 0;
    spx_word16_t *mem;
-   int tmp_out_len = 0;
+   spx_uint32_t tmp_out_len = 0;
    mem = st->mem + channel_index * st->mem_alloc_size;
    st->started = 1;
    
    /* Handle the case where we have samples left from a reduction in filter length */
    if (st->magic_samples[channel_index])
    {
-      int tmp_in_len;
-      int tmp_magic;
+      spx_uint32_t tmp_in_len;
+      spx_uint32_t tmp_magic;
       tmp_in_len = st->magic_samples[channel_index];
       tmp_out_len = *out_len;
       /* FIXME: Need to handle the case where the out array is too small */
@@ -749,7 +759,7 @@ static void speex_resampler_process_native(SpeexResamplerState *st, int channel_
       /* If we couldn't process all "magic" input samples, save the rest for next time */
       if (tmp_in_len < tmp_magic)
       {
-         int i;
+         spx_uint32_t i;
          st->magic_samples[channel_index] = tmp_magic-tmp_in_len;
          for (i=0;i<st->magic_samples[channel_index];i++)
             mem[N-1+i]=mem[N-1+i+tmp_in_len];
@@ -760,25 +770,33 @@ static void speex_resampler_process_native(SpeexResamplerState *st, int channel_
    /* Call the right resampler through the function ptr */
    out_sample = st->resampler_ptr(st, channel_index, in, in_len, out, out_len);
    
-   if (st->last_sample[channel_index] < *in_len)
+   if (st->last_sample[channel_index] < (spx_int32_t)*in_len)
       *in_len = st->last_sample[channel_index];
    *out_len = out_sample+tmp_out_len;
    st->last_sample[channel_index] -= *in_len;
    
-   for (j=0;j<N-1-*in_len;j++)
+   for (j=0;j<N-1-(spx_int32_t)*in_len;j++)
       mem[j] = mem[j+*in_len];
    for (;j<N-1;j++)
       mem[j] = in[st->in_stride*(j+*in_len-N+1)];
    
+   return RESAMPLER_ERR_SUCCESS;
 }
 
+#define FIXED_STACK_ALLOC 1024
+
 #ifdef FIXED_POINT
-void speex_resampler_process_float(SpeexResamplerState *st, int channel_index, const float *in, int *in_len, float *out, int *out_len)
+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)
 {
-   int i;
+   spx_uint32_t i;
    int istride_save, ostride_save;
+#ifdef VAR_ARRAYS
    spx_word16_t x[*in_len];
    spx_word16_t y[*out_len];
+   /*VARDECL(spx_word16_t *x);
+   VARDECL(spx_word16_t *y);
+   ALLOC(x, *in_len, spx_word16_t);
+   ALLOC(y, *out_len, spx_word16_t);*/
    istride_save = st->in_stride;
    ostride_save = st->out_stride;
    for (i=0;i<*in_len;i++)
@@ -789,22 +807,59 @@ void speex_resampler_process_float(SpeexResamplerState *st, int channel_index, c
    st->out_stride = ostride_save;
    for (i=0;i<*out_len;i++)
       out[i*st->out_stride] = y[i];
+#else
+   spx_word16_t x[FIXED_STACK_ALLOC];
+   spx_word16_t y[FIXED_STACK_ALLOC];
+   spx_uint32_t ilen=*in_len, olen=*out_len;
+   istride_save = st->in_stride;
+   ostride_save = st->out_stride;
+   while (ilen && olen)
+   {
+      spx_uint32_t ichunk, ochunk;
+      ichunk = ilen;
+      ochunk = olen;
+      if (ichunk>FIXED_STACK_ALLOC)
+         ichunk=FIXED_STACK_ALLOC;
+      if (ochunk>FIXED_STACK_ALLOC)
+         ochunk=FIXED_STACK_ALLOC;
+      for (i=0;i<ichunk;i++)
+         x[i] = WORD2INT(in[i*st->in_stride]);
+      st->in_stride = st->out_stride = 1;
+      speex_resampler_process_native(st, channel_index, x, &ichunk, y, &ochunk);
+      st->in_stride = istride_save;
+      st->out_stride = ostride_save;
+      for (i=0;i<ochunk;i++)
+         out[i*st->out_stride] = y[i];
+      out += ochunk;
+      in += ichunk;
+      ilen -= ichunk;
+      olen -= ochunk;
+   }
+   *in_len -= ilen;
+   *out_len -= olen;   
+#endif
+   return RESAMPLER_ERR_SUCCESS;
 }
-void speex_resampler_process_int(SpeexResamplerState *st, int channel_index, const spx_int16_t *in, int *in_len, spx_int16_t *out, int *out_len)
+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)
 {
-   speex_resampler_process_native(st, channel_index, in, in_len, out, out_len);
+   return speex_resampler_process_native(st, channel_index, in, in_len, out, out_len);
 }
 #else
-void speex_resampler_process_float(SpeexResamplerState *st, int channel_index, const float *in, int *in_len, float *out, int *out_len)
+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)
 {
-   speex_resampler_process_native(st, channel_index, in, in_len, out, out_len);
+   return speex_resampler_process_native(st, channel_index, in, in_len, out, out_len);
 }
-void speex_resampler_process_int(SpeexResamplerState *st, int channel_index, const spx_int16_t *in, int *in_len, spx_int16_t *out, int *out_len)
+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)
 {
-   int i;
+   spx_uint32_t i;
    int istride_save, ostride_save;
+#ifdef VAR_ARRAYS
    spx_word16_t x[*in_len];
    spx_word16_t y[*out_len];
+   /*VARDECL(spx_word16_t *x);
+   VARDECL(spx_word16_t *y);
+   ALLOC(x, *in_len, spx_word16_t);
+   ALLOC(y, *out_len, spx_word16_t);*/
    istride_save = st->in_stride;
    ostride_save = st->out_stride;
    for (i=0;i<*in_len;i++)
@@ -815,12 +870,44 @@ void speex_resampler_process_int(SpeexResamplerState *st, int channel_index, con
    st->out_stride = ostride_save;
    for (i=0;i<*out_len;i++)
       out[i*st->out_stride] = WORD2INT(y[i]);
+#else
+   spx_word16_t x[FIXED_STACK_ALLOC];
+   spx_word16_t y[FIXED_STACK_ALLOC];
+   spx_uint32_t ilen=*in_len, olen=*out_len;
+   istride_save = st->in_stride;
+   ostride_save = st->out_stride;
+   while (ilen && olen)
+   {
+      spx_uint32_t ichunk, ochunk;
+      ichunk = ilen;
+      ochunk = olen;
+      if (ichunk>FIXED_STACK_ALLOC)
+         ichunk=FIXED_STACK_ALLOC;
+      if (ochunk>FIXED_STACK_ALLOC)
+         ochunk=FIXED_STACK_ALLOC;
+      for (i=0;i<ichunk;i++)
+         x[i] = in[i*st->in_stride];
+      st->in_stride = st->out_stride = 1;
+      speex_resampler_process_native(st, channel_index, x, &ichunk, y, &ochunk);
+      st->in_stride = istride_save;
+      st->out_stride = ostride_save;
+      for (i=0;i<ochunk;i++)
+         out[i*st->out_stride] = WORD2INT(y[i]);
+      out += ochunk;
+      in += ichunk;
+      ilen -= ichunk;
+      olen -= ochunk;
+   }
+   *in_len -= ilen;
+   *out_len -= olen;   
+#endif
+   return RESAMPLER_ERR_SUCCESS;
 }
 #endif
 
-void speex_resampler_process_interleaved_float(SpeexResamplerState *st, const float *in, int *in_len, float *out, int *out_len)
+int speex_resampler_process_interleaved_float(SpeexResamplerState *st, const float *in, spx_uint32_t *in_len, float *out, spx_uint32_t *out_len)
 {
-   int i;
+   spx_uint32_t i;
    int istride_save, ostride_save;
    istride_save = st->in_stride;
    ostride_save = st->out_stride;
@@ -831,11 +918,12 @@ void speex_resampler_process_interleaved_float(SpeexResamplerState *st, const fl
    }
    st->in_stride = istride_save;
    st->out_stride = ostride_save;
+   return RESAMPLER_ERR_SUCCESS;
 }
 
-void speex_resampler_process_interleaved_int(SpeexResamplerState *st, const spx_int16_t *in, int *in_len, spx_int16_t *out, int *out_len)
+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)
 {
-   int i;
+   spx_uint32_t i;
    int istride_save, ostride_save;
    istride_save = st->in_stride;
    ostride_save = st->out_stride;
@@ -846,24 +934,25 @@ void speex_resampler_process_interleaved_int(SpeexResamplerState *st, const spx_
    }
    st->in_stride = istride_save;
    st->out_stride = ostride_save;
+   return RESAMPLER_ERR_SUCCESS;
 }
 
-void speex_resampler_set_rate(SpeexResamplerState *st, int in_rate, int out_rate)
+int speex_resampler_set_rate(SpeexResamplerState *st, spx_uint32_t in_rate, spx_uint32_t out_rate)
 {
-   speex_resampler_set_rate_frac(st, in_rate, out_rate, in_rate, out_rate);
+   return speex_resampler_set_rate_frac(st, in_rate, out_rate, in_rate, out_rate);
 }
 
-void speex_resampler_get_rate(SpeexResamplerState *st, int *in_rate, int *out_rate)
+void speex_resampler_get_rate(SpeexResamplerState *st, spx_uint32_t *in_rate, spx_uint32_t *out_rate)
 {
    *in_rate = st->in_rate;
    *out_rate = st->out_rate;
 }
 
-void speex_resampler_set_rate_frac(SpeexResamplerState *st, int ratio_num, int ratio_den, int in_rate, int out_rate)
+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)
 {
    int fact;
    if (st->in_rate == in_rate && st->out_rate == out_rate && st->num_rate == ratio_num && st->den_rate == ratio_den)
-      return;
+      return RESAMPLER_ERR_SUCCESS;
    
    st->in_rate = in_rate;
    st->out_rate = out_rate;
@@ -881,25 +970,25 @@ void speex_resampler_set_rate_frac(SpeexResamplerState *st, int ratio_num, int r
       
    if (st->initialised)
       update_filter(st);
+   return RESAMPLER_ERR_SUCCESS;
 }
 
-void speex_resampler_get_ratio(SpeexResamplerState *st, int *ratio_num, int *ratio_den)
+void speex_resampler_get_ratio(SpeexResamplerState *st, spx_uint32_t *ratio_num, spx_uint32_t *ratio_den)
 {
    *ratio_num = st->num_rate;
    *ratio_den = st->den_rate;
 }
 
-void speex_resampler_set_quality(SpeexResamplerState *st, int quality)
+int speex_resampler_set_quality(SpeexResamplerState *st, int quality)
 {
-   if (quality < 0)
-      quality = 0;
-   if (quality > 10)
-      quality = 10;
+   if (quality > 10 || quality < 0)
+      return RESAMPLER_ERR_INVALID_ARG;
    if (st->quality == quality)
-      return;
+      return RESAMPLER_ERR_SUCCESS;
    st->quality = quality;
    if (st->initialised)
       update_filter(st);
+   return RESAMPLER_ERR_SUCCESS;
 }
 
 void speex_resampler_get_quality(SpeexResamplerState *st, int *quality)
@@ -907,37 +996,39 @@ void speex_resampler_get_quality(SpeexResamplerState *st, int *quality)
    *quality = st->quality;
 }
 
-void speex_resampler_set_input_stride(SpeexResamplerState *st, int stride)
+void speex_resampler_set_input_stride(SpeexResamplerState *st, spx_uint32_t stride)
 {
    st->in_stride = stride;
 }
 
-void speex_resampler_get_input_stride(SpeexResamplerState *st, int *stride)
+void speex_resampler_get_input_stride(SpeexResamplerState *st, spx_uint32_t *stride)
 {
    *stride = st->in_stride;
 }
 
-void speex_resampler_set_output_stride(SpeexResamplerState *st, int stride)
+void speex_resampler_set_output_stride(SpeexResamplerState *st, spx_uint32_t stride)
 {
    st->out_stride = stride;
 }
 
-void speex_resampler_get_output_stride(SpeexResamplerState *st, int *stride)
+void speex_resampler_get_output_stride(SpeexResamplerState *st, spx_uint32_t *stride)
 {
    *stride = st->out_stride;
 }
 
-void speex_resampler_skip_zeros(SpeexResamplerState *st)
+int speex_resampler_skip_zeros(SpeexResamplerState *st)
 {
-   int i;
+   spx_uint32_t i;
    for (i=0;i<st->nb_channels;i++)
       st->last_sample[i] = st->filt_len/2;
+   return RESAMPLER_ERR_SUCCESS;
 }
 
-void speex_resampler_reset_mem(SpeexResamplerState *st)
+int speex_resampler_reset_mem(SpeexResamplerState *st)
 {
-   int i;
+   spx_uint32_t i;
    for (i=0;i<st->nb_channels*(st->filt_len-1);i++)
       st->mem[i] = 0;
+   return RESAMPLER_ERR_SUCCESS;
 }