gst/speexresample/: Update Speex resampler with latest version from Speex GIT.

Original commit message from CVS:
* gst/speexresample/README:
* gst/speexresample/arch.h:
* gst/speexresample/fixed_arm4.h:
* gst/speexresample/fixed_arm5e.h:
* gst/speexresample/fixed_bfin.h:
* gst/speexresample/fixed_debug.h:
* gst/speexresample/fixed_generic.h:
* gst/speexresample/resample.c: (compute_func), (main), (sinc),
(cubic_coef), (resampler_basic_direct_single),
(resampler_basic_direct_double),
(resampler_basic_interpolate_single),
(resampler_basic_interpolate_double), (update_filter),
(speex_resampler_init_frac), (speex_resampler_process_native),
(speex_resampler_magic), (speex_resampler_process_float),
(speex_resampler_process_int),
(speex_resampler_process_interleaved_float),
(speex_resampler_process_interleaved_int),
(speex_resampler_set_rate_frac), (speex_resampler_skip_zeros),
(speex_resampler_reset_mem):
* gst/speexresample/speex_resampler.h:
Update Speex resampler with latest version from Speex GIT.

1 files changed, 320 insertions, 406 deletions

diff --git a/gst/speexresample/resample.c b/gst/speexresample/resample.c
index 29b95f23..ec127aa1 100644
--- a/gst/speexresample/resample.c
+++ b/gst/speexresample/resample.c
@@ -1,4 +1,5 @@
-/* Copyright (C) 2007 Jean-Marc Valin
+/* Copyright (C) 2007-2008 Jean-Marc Valin
+   Copyright (C) 2008      Thorvald Natvig
       
    File: resample.c
    Arbitrary resampling code
@@ -62,13 +63,17 @@
 
 #ifdef OUTSIDE_SPEEX
 #include <stdlib.h>
+
 #include <glib.h>
 
+#define EXPORT
+
 static inline void *
 speex_alloc (int size)
 {
   return g_malloc0 (size);
 }
+
 static inline void *
 speex_realloc (void *ptr, int size)
 {
@@ -85,7 +90,7 @@ speex_free (void *ptr)
 #include "arch.h"
 #else /* OUTSIDE_SPEEX */
 
-#include "speex/speex_resampler.h"
+#include "../include/speex/speex_resampler.h"
 #include "arch.h"
 #include "os_support.h"
 #endif /* OUTSIDE_SPEEX */
@@ -102,10 +107,6 @@ speex_free (void *ptr)
 #define WORD2INT(x) ((x) < -32767.5f ? -32768 : ((x) > 32766.5f ? 32767 : floor(.5+(x))))
 #endif
 
-/*#define float double*/
-#define FILTER_SIZE 64
-#define OVERSAMPLE 8
-
 #define IMAX(a,b) ((a) > (b) ? (a) : (b))
 #define IMIN(a,b) ((a) < (b) ? (a) : (b))
 
@@ -113,6 +114,17 @@ speex_free (void *ptr)
 #define NULL 0
 #endif
 
+#ifdef _USE_SSE
+#include "resample_sse.h"
+#endif
+
+/* Numer of elements to allocate on the stack */
+#ifdef VAR_ARRAYS
+#define FIXED_STACK_ALLOC 8192
+#else
+#define FIXED_STACK_ALLOC 1024
+#endif
+
 typedef int (*resampler_basic_func) (SpeexResamplerState *, spx_uint32_t,
     const spx_word16_t *, spx_uint32_t *, spx_word16_t *, spx_uint32_t *);
 
@@ -127,6 +139,7 @@ struct SpeexResamplerState_
   spx_uint32_t nb_channels;
   spx_uint32_t filt_len;
   spx_uint32_t mem_alloc_size;
+  spx_uint32_t buffer_size;
   int int_advance;
   int frac_advance;
   float cutoff;
@@ -260,7 +273,6 @@ compute_func (float x, struct FuncDef *func)
   float y, frac;
   double interp[4];
   int ind;
-
   y = x * func->oversample;
   ind = (int) floor (y);
   frac = (y - ind);
@@ -285,7 +297,6 @@ int
 main (int argc, char **argv)
 {
   int i;
-
   for (i = 0; i < 256; i++) {
     printf ("%f\n", compute_func (i / 256., KAISER12));
   }
@@ -300,7 +311,6 @@ sinc (float cutoff, float x, int N, struct FuncDef *window_func)
 {
   /*fprintf (stderr, "%f ", x); */
   float xx = x * cutoff;
-
   if (fabs (x) < 1e-6f)
     return WORD2INT (32768. * cutoff);
   else if (fabs (x) > .5f * N)
@@ -316,7 +326,6 @@ sinc (float cutoff, float x, int N, struct FuncDef *window_func)
 {
   /*fprintf (stderr, "%f ", x); */
   float xx = x * cutoff;
-
   if (fabs (x) < 1e-6)
     return cutoff;
   else if (fabs (x) > .5 * N)
@@ -334,7 +343,6 @@ cubic_coef (spx_word16_t x, spx_word16_t interp[4])
   /* Compute interpolation coefficients. I'm not sure whether this corresponds to cubic interpolation
      but I know it's MMSE-optimal on a sinc */
   spx_word16_t x2, x3;
-
   x2 = MULT16_16_P15 (x, x);
   x3 = MULT16_16_P15 (x, x2);
   interp[0] =
@@ -373,48 +381,46 @@ 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;
+  const int N = st->filt_len;
   int out_sample = 0;
-  spx_word16_t *mem;
   int last_sample = st->last_sample[channel_index];
   spx_uint32_t samp_frac_num = st->samp_frac_num[channel_index];
+  const spx_word16_t *sinc_table = st->sinc_table;
+  const int out_stride = st->out_stride;
+  const int int_advance = st->int_advance;
+  const int frac_advance = st->frac_advance;
+  const spx_uint32_t den_rate = st->den_rate;
+  spx_word32_t sum;
+  int j;
 
-  mem = st->mem + channel_index * st->mem_alloc_size;
   while (!(last_sample >= (spx_int32_t) * in_len
           || out_sample >= (spx_int32_t) * out_len)) {
-    int j;
-    spx_word32_t sum = 0;
-
-    /* We already have all the filter coefficients pre-computed in the table */
-    const spx_word16_t *ptr;
+    const spx_word16_t *sinc = &sinc_table[samp_frac_num * N];
+    const spx_word16_t *iptr = &in[last_sample];
 
-    /* Do the memory part */
-    for (j = 0; last_sample - N + 1 + j < 0; j++) {
-      sum +=
-          MULT16_16 (mem[last_sample + j],
-          st->sinc_table[samp_frac_num * st->filt_len + j]);
-    }
+#ifndef OVERRIDE_INNER_PRODUCT_SINGLE
+    float accum[4] = { 0, 0, 0, 0 };
 
-    /* Do the new part */
-    if (in != NULL) {
-      ptr = in + st->in_stride * (last_sample - N + 1 + j);
-      for (; j < N; j++) {
-        sum +=
-            MULT16_16 (*ptr, st->sinc_table[samp_frac_num * st->filt_len + j]);
-        ptr += st->in_stride;
-      }
+    for (j = 0; j < N; j += 4) {
+      accum[0] += sinc[j] * iptr[j];
+      accum[1] += sinc[j + 1] * iptr[j + 1];
+      accum[2] += sinc[j + 2] * iptr[j + 2];
+      accum[3] += sinc[j + 3] * iptr[j + 3];
     }
+    sum = accum[0] + accum[1] + accum[2] + accum[3];
+#else
+    sum = inner_product_single (sinc, iptr, N);
+#endif
 
-    *out = PSHR32 (sum, 15);
-    out += st->out_stride;
-    out_sample++;
-    last_sample += st->int_advance;
-    samp_frac_num += st->frac_advance;
-    if (samp_frac_num >= st->den_rate) {
-      samp_frac_num -= st->den_rate;
+    out[out_stride * out_sample++] = PSHR32 (sum, 15);
+    last_sample += int_advance;
+    samp_frac_num += frac_advance;
+    if (samp_frac_num >= den_rate) {
+      samp_frac_num -= den_rate;
       last_sample++;
     }
   }
+
   st->last_sample[channel_index] = last_sample;
   st->samp_frac_num[channel_index] = samp_frac_num;
   return out_sample;
@@ -428,49 +434,46 @@ 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;
+  const int N = st->filt_len;
   int out_sample = 0;
-  spx_word16_t *mem;
   int last_sample = st->last_sample[channel_index];
   spx_uint32_t samp_frac_num = st->samp_frac_num[channel_index];
+  const spx_word16_t *sinc_table = st->sinc_table;
+  const int out_stride = st->out_stride;
+  const int int_advance = st->int_advance;
+  const int frac_advance = st->frac_advance;
+  const spx_uint32_t den_rate = st->den_rate;
+  double sum;
+  int j;
 
-  mem = st->mem + channel_index * st->mem_alloc_size;
   while (!(last_sample >= (spx_int32_t) * in_len
           || out_sample >= (spx_int32_t) * out_len)) {
-    int j;
-    double sum = 0;
+    const spx_word16_t *sinc = &sinc_table[samp_frac_num * N];
+    const spx_word16_t *iptr = &in[last_sample];
 
-    /* We already have all the filter coefficients pre-computed in the table */
-    const spx_word16_t *ptr;
+#ifndef OVERRIDE_INNER_PRODUCT_DOUBLE
+    double accum[4] = { 0, 0, 0, 0 };
 
-    /* Do the memory part */
-    for (j = 0; last_sample - N + 1 + j < 0; j++) {
-      sum +=
-          MULT16_16 (mem[last_sample + j],
-          (double) st->sinc_table[samp_frac_num * st->filt_len + j]);
-    }
-
-    /* Do the new part */
-    if (in != NULL) {
-      ptr = in + st->in_stride * (last_sample - N + 1 + j);
-      for (; j < N; j++) {
-        sum +=
-            MULT16_16 (*ptr,
-            (double) st->sinc_table[samp_frac_num * st->filt_len + j]);
-        ptr += st->in_stride;
-      }
+    for (j = 0; j < N; j += 4) {
+      accum[0] += sinc[j] * iptr[j];
+      accum[1] += sinc[j + 1] * iptr[j + 1];
+      accum[2] += sinc[j + 2] * iptr[j + 2];
+      accum[3] += sinc[j + 3] * iptr[j + 3];
     }
+    sum = accum[0] + accum[1] + accum[2] + accum[3];
+#else
+    sum = inner_product_double (sinc, iptr, N);
+#endif
 
-    *out = sum;
-    out += st->out_stride;
-    out_sample++;
-    last_sample += st->int_advance;
-    samp_frac_num += st->frac_advance;
-    if (samp_frac_num >= st->den_rate) {
-      samp_frac_num -= st->den_rate;
+    out[out_stride * out_sample++] = PSHR32 (sum, 15);
+    last_sample += int_advance;
+    samp_frac_num += frac_advance;
+    if (samp_frac_num >= den_rate) {
+      samp_frac_num -= den_rate;
       last_sample++;
     }
   }
+
   st->last_sample[channel_index] = last_sample;
   st->samp_frac_num[channel_index] = samp_frac_num;
   return out_sample;
@@ -482,92 +485,75 @@ 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;
+  const int N = st->filt_len;
   int out_sample = 0;
-  spx_word16_t *mem;
   int last_sample = st->last_sample[channel_index];
   spx_uint32_t samp_frac_num = st->samp_frac_num[channel_index];
+  const int out_stride = st->out_stride;
+  const int int_advance = st->int_advance;
+  const int frac_advance = st->frac_advance;
+  const spx_uint32_t den_rate = st->den_rate;
+  int j;
+  spx_word32_t sum;
 
-  mem = st->mem + channel_index * st->mem_alloc_size;
   while (!(last_sample >= (spx_int32_t) * in_len
           || out_sample >= (spx_int32_t) * out_len)) {
-    int j;
-    spx_word32_t sum = 0;
+    const spx_word16_t *iptr = &in[last_sample];
 
-    /* We need to interpolate the sinc filter */
-    spx_word32_t accum[4] = { 0.f, 0.f, 0.f, 0.f };
-    spx_word16_t interp[4];
-    const spx_word16_t *ptr;
-    int offset;
-    spx_word16_t frac;
-
-    offset = samp_frac_num * st->oversample / st->den_rate;
+    const int offset = samp_frac_num * st->oversample / st->den_rate;
 #ifdef FIXED_POINT
-    frac =
+    const spx_word16_t frac =
         PDIV32 (SHL32 ((samp_frac_num * st->oversample) % st->den_rate, 15),
         st->den_rate);
 #else
-    frac =
+    const spx_word16_t frac =
         ((float) ((samp_frac_num * st->oversample) % st->den_rate)) /
         st->den_rate;
 #endif
-    /* This code is written like this to make it easy to optimise with SIMD.
-       For most DSPs, it would be best to split the loops in two because most DSPs 
-       have only two accumulators */
-    for (j = 0; last_sample - N + 1 + j < 0; j++) {
-      spx_word16_t curr_mem = mem[last_sample + j];
+    spx_word16_t interp[4];
 
+
+#ifndef OVERRIDE_INTERPOLATE_PRODUCT_SINGLE
+    spx_word32_t accum[4] = { 0, 0, 0, 0 };
+
+    for (j = 0; j < N; j++) {
+      const spx_word16_t curr_in = iptr[j];
       accum[0] +=
-          MULT16_16 (curr_mem,
+          MULT16_16 (curr_in,
           st->sinc_table[4 + (j + 1) * st->oversample - offset - 2]);
       accum[1] +=
-          MULT16_16 (curr_mem,
+          MULT16_16 (curr_in,
           st->sinc_table[4 + (j + 1) * st->oversample - offset - 1]);
       accum[2] +=
-          MULT16_16 (curr_mem,
+          MULT16_16 (curr_in,
           st->sinc_table[4 + (j + 1) * st->oversample - offset]);
       accum[3] +=
-          MULT16_16 (curr_mem,
+          MULT16_16 (curr_in,
           st->sinc_table[4 + (j + 1) * st->oversample - offset + 1]);
     }
 
-    if (in != NULL) {
-      ptr = in + st->in_stride * (last_sample - N + 1 + j);
-      /* Do the new part */
-      for (; j < N; j++) {
-        spx_word16_t curr_in = *ptr;
-
-        ptr += st->in_stride;
-        accum[0] +=
-            MULT16_16 (curr_in,
-            st->sinc_table[4 + (j + 1) * st->oversample - offset - 2]);
-        accum[1] +=
-            MULT16_16 (curr_in,
-            st->sinc_table[4 + (j + 1) * st->oversample - offset - 1]);
-        accum[2] +=
-            MULT16_16 (curr_in,
-            st->sinc_table[4 + (j + 1) * st->oversample - offset]);
-        accum[3] +=
-            MULT16_16 (curr_in,
-            st->sinc_table[4 + (j + 1) * st->oversample - offset + 1]);
-      }
-    }
     cubic_coef (frac, interp);
     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]);
+#else
+    cubic_coef (frac, interp);
+    sum =
+        interpolate_product_single (iptr,
+        st->sinc_table + st->oversample + 4 - offset - 2, N, st->oversample,
+        interp);
+#endif
 
-    *out = PSHR32 (sum, 15);
-    out += st->out_stride;
-    out_sample++;
-    last_sample += st->int_advance;
-    samp_frac_num += st->frac_advance;
-    if (samp_frac_num >= st->den_rate) {
-      samp_frac_num -= st->den_rate;
+    out[out_stride * out_sample++] = PSHR32 (sum, 15);
+    last_sample += int_advance;
+    samp_frac_num += frac_advance;
+    if (samp_frac_num >= den_rate) {
+      samp_frac_num -= den_rate;
       last_sample++;
     }
   }
+
   st->last_sample[channel_index] = last_sample;
   st->samp_frac_num[channel_index] = samp_frac_num;
   return out_sample;
@@ -581,81 +567,75 @@ 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;
+  const int N = st->filt_len;
   int out_sample = 0;
-  spx_word16_t *mem;
   int last_sample = st->last_sample[channel_index];
   spx_uint32_t samp_frac_num = st->samp_frac_num[channel_index];
+  const int out_stride = st->out_stride;
+  const int int_advance = st->int_advance;
+  const int frac_advance = st->frac_advance;
+  const spx_uint32_t den_rate = st->den_rate;
+  int j;
+  spx_word32_t sum;
 
-  mem = st->mem + channel_index * st->mem_alloc_size;
   while (!(last_sample >= (spx_int32_t) * in_len
           || out_sample >= (spx_int32_t) * out_len)) {
-    int j;
-    spx_word32_t sum = 0;
-
-    /* We need to interpolate the sinc filter */
-    double accum[4] = { 0.f, 0.f, 0.f, 0.f };
-    float interp[4];
-    const spx_word16_t *ptr;
-    float alpha = ((float) samp_frac_num) / st->den_rate;
-    int offset = samp_frac_num * st->oversample / st->den_rate;
-    float frac = alpha * st->oversample - offset;
-
-    /* This code is written like this to make it easy to optimise with SIMD.
-       For most DSPs, it would be best to split the loops in two because most DSPs 
-       have only two accumulators */
-    for (j = 0; last_sample - N + 1 + j < 0; j++) {
-      double curr_mem = mem[last_sample + j];
+    const spx_word16_t *iptr = &in[last_sample];
 
+    const int offset = samp_frac_num * st->oversample / st->den_rate;
+#ifdef FIXED_POINT
+    const spx_word16_t frac =
+        PDIV32 (SHL32 ((samp_frac_num * st->oversample) % st->den_rate, 15),
+        st->den_rate);
+#else
+    const spx_word16_t frac =
+        ((float) ((samp_frac_num * st->oversample) % st->den_rate)) /
+        st->den_rate;
+#endif
+    spx_word16_t interp[4];
+
+
+#ifndef OVERRIDE_INTERPOLATE_PRODUCT_DOUBLE
+    double accum[4] = { 0, 0, 0, 0 };
+
+    for (j = 0; j < N; j++) {
+      const double curr_in = iptr[j];
       accum[0] +=
-          MULT16_16 (curr_mem,
+          MULT16_16 (curr_in,
           st->sinc_table[4 + (j + 1) * st->oversample - offset - 2]);
       accum[1] +=
-          MULT16_16 (curr_mem,
+          MULT16_16 (curr_in,
           st->sinc_table[4 + (j + 1) * st->oversample - offset - 1]);
       accum[2] +=
-          MULT16_16 (curr_mem,
+          MULT16_16 (curr_in,
           st->sinc_table[4 + (j + 1) * st->oversample - offset]);
       accum[3] +=
-          MULT16_16 (curr_mem,
+          MULT16_16 (curr_in,
           st->sinc_table[4 + (j + 1) * st->oversample - offset + 1]);
     }
-    if (in != NULL) {
-      ptr = in + st->in_stride * (last_sample - N + 1 + j);
-      /* Do the new part */
-      for (; j < N; j++) {
-        double curr_in = *ptr;
-
-        ptr += st->in_stride;
-        accum[0] +=
-            MULT16_16 (curr_in,
-            st->sinc_table[4 + (j + 1) * st->oversample - offset - 2]);
-        accum[1] +=
-            MULT16_16 (curr_in,
-            st->sinc_table[4 + (j + 1) * st->oversample - offset - 1]);
-        accum[2] +=
-            MULT16_16 (curr_in,
-            st->sinc_table[4 + (j + 1) * st->oversample - offset]);
-        accum[3] +=
-            MULT16_16 (curr_in,
-            st->sinc_table[4 + (j + 1) * st->oversample - offset + 1]);
-      }
-    }
+
+    cubic_coef (frac, interp);
+    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]);
+#else
     cubic_coef (frac, interp);
     sum =
-        interp[0] * accum[0] + interp[1] * accum[1] + interp[2] * accum[2] +
-        interp[3] * accum[3];
-
-    *out = PSHR32 (sum, 15);
-    out += st->out_stride;
-    out_sample++;
-    last_sample += st->int_advance;
-    samp_frac_num += st->frac_advance;
-    if (samp_frac_num >= st->den_rate) {
-      samp_frac_num -= st->den_rate;
+        interpolate_product_double (iptr,
+        st->sinc_table + st->oversample + 4 - offset - 2, N, st->oversample,
+        interp);
+#endif
+
+    out[out_stride * out_sample++] = PSHR32 (sum, 15);
+    last_sample += int_advance;
+    samp_frac_num += frac_advance;
+    if (samp_frac_num >= den_rate) {
+      samp_frac_num -= den_rate;
       last_sample++;
     }
   }
+
   st->last_sample[channel_index] = last_sample;
   st->samp_frac_num[channel_index] = samp_frac_num;
   return out_sample;
@@ -698,7 +678,6 @@ 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 *
@@ -711,7 +690,6 @@ update_filter (SpeexResamplerState * st)
     }
     for (i = 0; i < st->den_rate; i++) {
       spx_int32_t j;
-
       for (j = 0; j < st->filt_len; j++) {
         st->sinc_table[i * st->filt_len + j] =
             sinc (st->cutoff,
@@ -731,7 +709,6 @@ update_filter (SpeexResamplerState * st)
     /*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 +
@@ -765,41 +742,36 @@ update_filter (SpeexResamplerState * st)
      due to handling of lots of corner cases. */
   if (!st->mem) {
     spx_uint32_t i;
-
+    st->mem_alloc_size = st->filt_len - 1 + st->buffer_size;
     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++)
+        (spx_word16_t *) speex_alloc (st->nb_channels * st->mem_alloc_size *
+        sizeof (spx_word16_t));
+    for (i = 0; i < st->nb_channels * st->mem_alloc_size; i++)
       st->mem[i] = 0;
-    st->mem_alloc_size = st->filt_len - 1;
     /*speex_warning("init filter"); */
   } else if (!st->started) {
     spx_uint32_t i;
-
+    st->mem_alloc_size = st->filt_len - 1 + st->buffer_size;
     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->nb_channels * st->mem_alloc_size * sizeof (spx_word16_t));
+    for (i = 0; i < st->nb_channels * st->mem_alloc_size; i++)
       st->mem[i] = 0;
-    st->mem_alloc_size = st->filt_len - 1;
     /*speex_warning("reinit filter"); */
   } else if (st->filt_len > old_length) {
     spx_int32_t i;
-
     /* Increase the filter length */
     /*speex_warning("increase filter size"); */
     int old_alloc_size = st->mem_alloc_size;
-
-    if (st->filt_len - 1 > st->mem_alloc_size) {
+    if ((st->filt_len - 1 + st->buffer_size) > st->mem_alloc_size) {
+      st->mem_alloc_size = st->filt_len - 1 + st->buffer_size;
       st->mem =
           (spx_word16_t *) speex_realloc (st->mem,
-          st->nb_channels * (st->filt_len - 1) * sizeof (spx_word16_t));
-      st->mem_alloc_size = st->filt_len - 1;
+          st->nb_channels * st->mem_alloc_size * sizeof (spx_word16_t));
     }
     for (i = st->nb_channels - 1; i >= 0; i--) {
       spx_int32_t j;
       spx_uint32_t olen = old_length;
-
       /*if (st->magic_samples[i]) */
       {
         /* Try and remove the magic samples as if nothing had happened */
@@ -834,13 +806,11 @@ update_filter (SpeexResamplerState * st)
     }
   } else if (st->filt_len < old_length) {
     spx_uint32_t i;
-
     /* Reduce filter length, this a bit tricky. We need to store some of the memory as "magic"
        samples so they can be used directly as input the next time(s) */
     for (i = 0; i < st->nb_channels; i++) {
       spx_uint32_t j;
       spx_uint32_t old_magic = st->magic_samples[i];
-
       st->magic_samples[i] = (old_length - st->filt_len) / 2;
       /* We must copy some of the memory that's no longer used */
       /* Copy data going backward */
@@ -853,7 +823,7 @@ update_filter (SpeexResamplerState * st)
 
 }
 
-SpeexResamplerState *
+EXPORT SpeexResamplerState *
 speex_resampler_init (spx_uint32_t nb_channels, spx_uint32_t in_rate,
     spx_uint32_t out_rate, int quality, int *err)
 {
@@ -861,14 +831,13 @@ speex_resampler_init (spx_uint32_t nb_channels, spx_uint32_t in_rate,
       out_rate, quality, err);
 }
 
-SpeexResamplerState *
+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)
 {
   spx_uint32_t i;
   SpeexResamplerState *st;
-
   if (quality > 10 || quality < 0) {
     if (err)
       *err = RESAMPLER_ERR_INVALID_ARG;
@@ -893,6 +862,12 @@ speex_resampler_init_frac (spx_uint32_t nb_channels, spx_uint32_t ratio_num,
   st->in_stride = 1;
   st->out_stride = 1;
 
+#ifdef FIXED_POINT
+  st->buffer_size = 160;
+#else
+  st->buffer_size = 160;
+#endif
+
   /* Per channel data */
   st->last_sample = (spx_int32_t *) speex_alloc (nb_channels * sizeof (int));
   st->magic_samples = (spx_uint32_t *) speex_alloc (nb_channels * sizeof (int));
@@ -916,7 +891,7 @@ speex_resampler_init_frac (spx_uint32_t nb_channels, spx_uint32_t ratio_num,
   return st;
 }
 
-void
+EXPORT void
 speex_resampler_destroy (SpeexResamplerState * st)
 {
   speex_free (st->mem);
@@ -927,249 +902,193 @@ speex_resampler_destroy (SpeexResamplerState * st)
   speex_free (st);
 }
 
-
-
 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)
+    spx_uint32_t channel_index, spx_uint32_t * in_len, spx_word16_t * out,
+    spx_uint32_t * out_len)
 {
   int j = 0;
-  int N = st->filt_len;
+  const int N = st->filt_len;
   int out_sample = 0;
-  spx_word16_t *mem;
-  spx_uint32_t tmp_out_len = 0;
+  spx_word16_t *mem = st->mem + channel_index * st->mem_alloc_size;
+  spx_uint32_t ilen;
 
-  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 istride_save;
-    spx_uint32_t tmp_in_len;
-    spx_uint32_t tmp_magic;
-
-    istride_save = st->in_stride;
-    tmp_in_len = st->magic_samples[channel_index];
-    tmp_out_len = *out_len;
-    /* magic_samples needs to be set to zero to avoid infinite recursion */
-    tmp_magic = st->magic_samples[channel_index];
-    st->magic_samples[channel_index] = 0;
-    st->in_stride = 1;
-    speex_resampler_process_native (st, channel_index, mem + N - 1, &tmp_in_len,
-        out, &tmp_out_len);
-    st->in_stride = istride_save;
-    /*speex_warning_int("extra samples:", tmp_out_len); */
-    /* If we couldn't process all "magic" input samples, save the rest for next time */
-    if (tmp_in_len < tmp_magic) {
-      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];
-    }
-    out += tmp_out_len * st->out_stride;
-    *out_len -= tmp_out_len;
-  }
-
   /* Call the right resampler through the function ptr */
-  out_sample = st->resampler_ptr (st, channel_index, in, in_len, out, out_len);
+  out_sample = st->resampler_ptr (st, channel_index, mem, in_len, out, out_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;
+  *out_len = out_sample;
   st->last_sample[channel_index] -= *in_len;
 
-  for (j = 0; j < N - 1 - (spx_int32_t) * in_len; j++)
-    mem[j] = mem[j + *in_len];
-  if (in != NULL) {
-    for (; j < N - 1; j++)
-      mem[j] = in[st->in_stride * (j + *in_len - N + 1)];
-  } else {
-    for (; j < N - 1; j++)
-      mem[j] = 0;
-  }
+  ilen = *in_len;
+
+  for (j = 0; j < N - 1; ++j)
+    mem[j] = mem[j + ilen];
+
   return RESAMPLER_ERR_SUCCESS;
 }
 
-#define FIXED_STACK_ALLOC 1024
-
-#ifdef FIXED_POINT
-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)
+static int
+speex_resampler_magic (SpeexResamplerState * st, spx_uint32_t channel_index,
+    spx_word16_t ** out, spx_uint32_t out_len)
 {
-  spx_uint32_t i;
-  int istride_save, ostride_save;
+  spx_uint32_t tmp_in_len = st->magic_samples[channel_index];
+  spx_word16_t *mem = st->mem + channel_index * st->mem_alloc_size;
+  const int N = st->filt_len;
 
-#ifdef VAR_ARRAYS
-  spx_word16_t x[*in_len];
-  spx_word16_t y[*out_len];
+  speex_resampler_process_native (st, channel_index, &tmp_in_len, *out,
+      &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;
-  if (in != NULL) {
-    for (i = 0; i < *in_len; i++)
-      x[i] = WORD2INT (in[i * st->in_stride]);
-    st->in_stride = st->out_stride = 1;
-    speex_resampler_process_native (st, channel_index, x, in_len, y, out_len);
-  } else {
-    st->in_stride = st->out_stride = 1;
-    speex_resampler_process_native (st, channel_index, NULL, in_len, y,
-        out_len);
-  }
-  st->in_stride = istride_save;
-  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;
+  st->magic_samples[channel_index] -= tmp_in_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;
-    if (in != NULL) {
-      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);
-    } else {
-      st->in_stride = st->out_stride = 1;
-      speex_resampler_process_native (st, channel_index, NULL, &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;
+  /* If we couldn't process all "magic" input samples, save the rest for next time */
+  if (st->magic_samples[channel_index]) {
+    spx_uint32_t i;
+    for (i = 0; i < st->magic_samples[channel_index]; i++)
+      mem[N - 1 + i] = mem[N - 1 + i + tmp_in_len];
   }
-  *in_len -= ilen;
-  *out_len -= olen;
-#endif
-  return RESAMPLER_ERR_SUCCESS;
+  *out += out_len * st->out_stride;
+  return out_len;
 }
 
-int
+#ifdef FIXED_POINT
+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)
-{
-  return speex_resampler_process_native (st, channel_index, in, in_len, out,
-      out_len);
-}
 #else
-int
+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)
+#endif
 {
-  return speex_resampler_process_native (st, channel_index, in, in_len, out,
-      out_len);
+  int j;
+  spx_uint32_t ilen = *in_len;
+  spx_uint32_t olen = *out_len;
+  spx_word16_t *x = st->mem + channel_index * st->mem_alloc_size;
+  const int filt_offs = st->filt_len - 1;
+  const spx_uint32_t xlen = st->mem_alloc_size - filt_offs;
+  const int istride = st->in_stride;
+
+  if (st->magic_samples[channel_index])
+    olen -= speex_resampler_magic (st, channel_index, &out, olen);
+  if (!st->magic_samples[channel_index]) {
+    while (ilen && olen) {
+      spx_uint32_t ichunk = (ilen > xlen) ? xlen : ilen;
+      spx_uint32_t ochunk = olen;
+
+      if (in) {
+        for (j = 0; j < ichunk; ++j)
+          x[j + filt_offs] = in[j * istride];
+      } else {
+        for (j = 0; j < ichunk; ++j)
+          x[j + filt_offs] = 0;
+      }
+      speex_resampler_process_native (st, channel_index, &ichunk, out, &ochunk);
+      ilen -= ichunk;
+      olen -= ochunk;
+      out += ochunk * st->out_stride;
+      if (in)
+        in += ichunk * istride;
+    }
+  }
+  *in_len -= ilen;
+  *out_len -= olen;
+  return RESAMPLER_ERR_SUCCESS;
 }
 
-int
+#ifdef FIXED_POINT
+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)
+#else
+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)
+#endif
 {
-  spx_uint32_t i;
-  int istride_save, ostride_save;
-
+  int j;
+  const int istride_save = st->in_stride;
+  const int ostride_save = st->out_stride;
+  spx_uint32_t ilen = *in_len;
+  spx_uint32_t olen = *out_len;
+  spx_word16_t *x = st->mem + channel_index * st->mem_alloc_size;
+  const spx_uint32_t xlen = st->mem_alloc_size - (st->filt_len - 1);
 #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;
-  if (in != NULL) {
-    for (i = 0; i < *in_len; i++)
-      x[i] = in[i * st->in_stride];
-    st->in_stride = st->out_stride = 1;
-    speex_resampler_process_native (st, channel_index, x, in_len, y, out_len);
-  } else {
-    st->in_stride = st->out_stride = 1;
-    speex_resampler_process_native (st, channel_index, NULL, in_len, y,
-        out_len);
-  }
-  st->in_stride = istride_save;
-  st->out_stride = ostride_save;
-  for (i = 0; i < *out_len; i++)
-    out[i * st->out_stride] = WORD2INT (y[i]);
+  const unsigned int ylen =
+      (olen < FIXED_STACK_ALLOC) ? olen : FIXED_STACK_ALLOC;
+  VARDECL (spx_word16_t * ystack);
+  ALLOC (ystack, ylen, spx_word16_t);
 #else
-  spx_word16_t x[FIXED_STACK_ALLOC];
-  spx_word16_t y[FIXED_STACK_ALLOC];
-  spx_uint32_t ilen = *in_len, olen = *out_len;
+  const unsigned int ylen = FIXED_STACK_ALLOC;
+  spx_word16_t ystack[FIXED_STACK_ALLOC];
+#endif
+
+  st->out_stride = 1;
 
-  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;
-    if (in != NULL) {
-      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);
+    spx_word16_t *y = ystack;
+    spx_uint32_t ichunk = (ilen > xlen) ? xlen : ilen;
+    spx_uint32_t ochunk = (olen > ylen) ? ylen : olen;
+    spx_uint32_t omagic = 0;
+
+    if (st->magic_samples[channel_index]) {
+      omagic = speex_resampler_magic (st, channel_index, &y, ochunk);
+      ochunk -= omagic;
+      olen -= omagic;
+    }
+    if (!st->magic_samples[channel_index]) {
+      if (in) {
+        for (j = 0; j < ichunk; ++j)
+#ifdef FIXED_POINT
+          x[j + st->filt_len - 1] = WORD2INT (in[j * istride_save]);
+#else
+          x[j + st->filt_len - 1] = in[j * istride_save];
+#endif
+      } else {
+        for (j = 0; j < ichunk; ++j)
+          x[j + st->filt_len - 1] = 0;
+      }
+
+      speex_resampler_process_native (st, channel_index, &ichunk, y, &ochunk);
     } else {
-      st->in_stride = st->out_stride = 1;
-      speex_resampler_process_native (st, channel_index, NULL, &ichunk, y,
-          &ochunk);
+      ichunk = 0;
+      ochunk = 0;
     }
-    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;
+
+    for (j = 0; j < ochunk + omagic; ++j)
+#ifdef FIXED_POINT
+      out[j * ostride_save] = ystack[j];
+#else
+      out[j * ostride_save] = WORD2INT (ystack[j]);
+#endif
+
     ilen -= ichunk;
     olen -= ochunk;
+    out += (ochunk + omagic) * ostride_save;
+    if (in)
+      in += ichunk * istride_save;
   }
+  st->out_stride = ostride_save;
   *in_len -= ilen;
   *out_len -= olen;
-#endif
+
   return RESAMPLER_ERR_SUCCESS;
 }
-#endif
 
-int
+EXPORT int
 speex_resampler_process_interleaved_float (SpeexResamplerState * st,
     const float *in, spx_uint32_t * in_len, float *out, spx_uint32_t * out_len)
 {
   spx_uint32_t i;
   int istride_save, ostride_save;
   spx_uint32_t bak_len = *out_len;
-
   istride_save = st->in_stride;
   ostride_save = st->out_stride;
   st->in_stride = st->out_stride = st->nb_channels;
@@ -1185,8 +1104,7 @@ speex_resampler_process_interleaved_float (SpeexResamplerState * st,
   return RESAMPLER_ERR_SUCCESS;
 }
 
-
-int
+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)
@@ -1194,7 +1112,6 @@ speex_resampler_process_interleaved_int (SpeexResamplerState * st,
   spx_uint32_t i;
   int istride_save, ostride_save;
   spx_uint32_t bak_len = *out_len;
-
   istride_save = st->in_stride;
   ostride_save = st->out_stride;
   st->in_stride = st->out_stride = st->nb_channels;
@@ -1210,7 +1127,7 @@ speex_resampler_process_interleaved_int (SpeexResamplerState * st,
   return RESAMPLER_ERR_SUCCESS;
 }
 
-int
+EXPORT int
 speex_resampler_set_rate (SpeexResamplerState * st, spx_uint32_t in_rate,
     spx_uint32_t out_rate)
 {
@@ -1218,7 +1135,7 @@ speex_resampler_set_rate (SpeexResamplerState * st, spx_uint32_t in_rate,
       out_rate);
 }
 
-void
+EXPORT void
 speex_resampler_get_rate (SpeexResamplerState * st, spx_uint32_t * in_rate,
     spx_uint32_t * out_rate)
 {
@@ -1226,14 +1143,13 @@ speex_resampler_get_rate (SpeexResamplerState * st, spx_uint32_t * in_rate,
   *out_rate = st->out_rate;
 }
 
-int
+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)
 {
   spx_uint32_t fact;
   spx_uint32_t old_den;
   spx_uint32_t i;
-
   if (st->in_rate == in_rate && st->out_rate == out_rate
       && st->num_rate == ratio_num && st->den_rate == ratio_den)
     return RESAMPLER_ERR_SUCCESS;
@@ -1265,7 +1181,7 @@ speex_resampler_set_rate_frac (SpeexResamplerState * st, spx_uint32_t ratio_num,
   return RESAMPLER_ERR_SUCCESS;
 }
 
-void
+EXPORT void
 speex_resampler_get_ratio (SpeexResamplerState * st, spx_uint32_t * ratio_num,
     spx_uint32_t * ratio_den)
 {
@@ -1273,7 +1189,7 @@ speex_resampler_get_ratio (SpeexResamplerState * st, spx_uint32_t * ratio_num,
   *ratio_den = st->den_rate;
 }
 
-int
+EXPORT int
 speex_resampler_set_quality (SpeexResamplerState * st, int quality)
 {
   if (quality > 10 || quality < 0)
@@ -1286,73 +1202,71 @@ speex_resampler_set_quality (SpeexResamplerState * st, int quality)
   return RESAMPLER_ERR_SUCCESS;
 }
 
-void
+EXPORT void
 speex_resampler_get_quality (SpeexResamplerState * st, int *quality)
 {
   *quality = st->quality;
 }
 
-void
+EXPORT void
 speex_resampler_set_input_stride (SpeexResamplerState * st, spx_uint32_t stride)
 {
   st->in_stride = stride;
 }
 
-void
+EXPORT void
 speex_resampler_get_input_stride (SpeexResamplerState * st,
     spx_uint32_t * stride)
 {
   *stride = st->in_stride;
 }
 
-void
+EXPORT void
 speex_resampler_set_output_stride (SpeexResamplerState * st,
     spx_uint32_t stride)
 {
   st->out_stride = stride;
 }
 
-void
+EXPORT void
 speex_resampler_get_output_stride (SpeexResamplerState * st,
     spx_uint32_t * stride)
 {
   *stride = st->out_stride;
 }
 
-int
+EXPORT int
 speex_resampler_get_input_latency (SpeexResamplerState * st)
 {
   return st->filt_len / 2;
 }
 
-int
+EXPORT int
 speex_resampler_get_output_latency (SpeexResamplerState * st)
 {
   return ((st->filt_len / 2) * st->den_rate +
       (st->num_rate >> 1)) / st->num_rate;
 }
 
-int
+EXPORT int
 speex_resampler_skip_zeros (SpeexResamplerState * st)
 {
   spx_uint32_t i;
-
   for (i = 0; i < st->nb_channels; i++)
     st->last_sample[i] = st->filt_len / 2;
   return RESAMPLER_ERR_SUCCESS;
 }
 
-int
+EXPORT int
 speex_resampler_reset_mem (SpeexResamplerState * st)
 {
   spx_uint32_t i;
-
   for (i = 0; i < st->nb_channels * (st->filt_len - 1); i++)
     st->mem[i] = 0;
   return RESAMPLER_ERR_SUCCESS;
 }
 
-const char *
+EXPORT const char *
 speex_resampler_strerror (int err)
 {
   switch (err) {