Convert default resampler from libresample to libsoxr.

2025-12-16 09:31:14 +01:00 · 2012-10-09 02:57:19 +00:00
parent de3bf9610a
commit 79faef4192
104 changed files with 13914 additions and 8 deletions
--- a/lib-src/libsoxr/src/CMakeLists.txt
+++ b/lib-src/libsoxr/src/CMakeLists.txt
@@ -0,0 +1,64 @@
+# SoX Resampler Library       Copyright (c) 2007-12 robs@users.sourceforge.net
+# Licence for this file: LGPL v2.1                  See LICENCE for details.
+
+add_definitions (${PROJECT_DEFS} -DSOXR_LIB)
+
+set (RDFT32 fft4g32)
+if (WITH_AVFFT AND AVCODEC_FOUND)
+  set (RDFT32S avfft32s)
+elseif (WITH_PFFFT)
+  set (RDFT32S pffft32s)
+elseif (WITH_SIMD)
+  set (RDFT32S fft4g32s)
+endif ()
+
+if (WITH_DOUBLE_PRECISION)
+  set (DP_SOURCES rate64)
+endif ()
+
+if (WITH_SINGLE_PRECISION)
+  set (SP_SOURCES rate32 ${RDFT32})
+endif ()
+
+if (HAVE_SIMD)
+  set (SIMD_SOURCES rate32s ${RDFT32S} simd)
+  foreach (source ${SIMD_SOURCES})
+    set_property(SOURCE ${source} PROPERTY COMPILE_FLAGS ${SIMD_C_FLAGS})
+  endforeach ()
+endif ()
+
+add_library(${PROJECT_NAME} ${LIB_TYPE} ${PROJECT_NAME} data-io dbesi0 filter fft4g64
+  ${SP_SOURCES} ${DP_SOURCES} ${SIMD_SOURCES})
+set_target_properties (${PROJECT_NAME} PROPERTIES SOVERSION "${VERSION}")
+list (APPEND TARGET_HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}.h")
+
+
+if (WITH_LSR_IF)
+  set (LSR samplerate)
+  set (LSR ${PROJECT_NAME}-lsr)
+  add_library(${LSR} ${LIB_TYPE} lsr)
+  target_link_libraries (${LSR} ${PROJECT_NAME})
+  set_target_properties (${LSR} PROPERTIES SOVERSION ${VERSION})
+  list (APPEND TARGET_HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/${LSR}.h")
+endif ()
+
+install (TARGETS ${PROJECT_NAME} ${LSR} DESTINATION lib)
+install (FILES ${TARGET_HEADERS} DESTINATION include)
+
+
+
+# Packaging
+
+get_property(LIB1 TARGET ${PROJECT_NAME} PROPERTY LOCATION)
+if (BUILD_SHARED_LIBS)
+  set (LIB1 ${LIB1}.${VERSION})
+endif ()
+if (WITH_LSR_IF)
+  get_property(LIB2 TARGET ${LSR} PROPERTY LOCATION)
+  if (BUILD_SHARED_LIBS)
+    set (LIB2 ${LIB2}.${VERSION})
+  endif ()
+endif ()
+set (TARGET_LIBS ${LIB1} ${LIB2})
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libsoxr.src ${CMAKE_CURRENT_BINARY_DIR}/libsoxr.src)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libsoxr-dev.src ${CMAKE_CURRENT_BINARY_DIR}/libsoxr-dev.src)
--- a/lib-src/libsoxr/src/aliases.h
+++ b/lib-src/libsoxr/src/aliases.h
@@ -0,0 +1,30 @@
+#if defined SOXR_LIB
+
+#define lsx_bessel_I_0        _soxr_bessel_I_0
+#define lsx_cdft              _soxr_cdft
+#define lsx_cdft_f            _soxr_cdft_f
+#define lsx_clear_fft_cache   _soxr_clear_fft_cache
+#define lsx_clear_fft_cache_f _soxr_clear_fft_cache_f
+#define lsx_ddct              _soxr_ddct
+#define lsx_ddct_f            _soxr_ddct_f
+#define lsx_ddst              _soxr_ddst
+#define lsx_ddst_f            _soxr_ddst_f
+#define lsx_design_lpf        _soxr_design_lpf
+#define lsx_dfct              _soxr_dfct
+#define lsx_dfct_f            _soxr_dfct_f
+#define lsx_dfst              _soxr_dfst
+#define lsx_dfst_f            _soxr_dfst_f
+#define lsx_fir_to_phase      _soxr_fir_to_phase
+#define lsx_init_fft_cache    _soxr_init_fft_cache
+#define lsx_init_fft_cache_f  _soxr_init_fft_cache_f
+#define lsx_kaiser_beta       _soxr_kaiser_beta
+#define lsx_kaiser_params     _soxr_kaiser_params
+#define lsx_make_lpf          _soxr_make_lpf
+#define lsx_rdft              _soxr_rdft
+#define lsx_rdft_f            _soxr_rdft_f
+#define lsx_safe_cdft         _soxr_safe_cdft
+#define lsx_safe_cdft_f       _soxr_safe_cdft_f
+#define lsx_safe_rdft         _soxr_safe_rdft
+#define lsx_safe_rdft_f       _soxr_safe_rdft_f
+
+#endif
--- a/lib-src/libsoxr/src/avfft32.c
+++ b/lib-src/libsoxr/src/avfft32.c
@@ -0,0 +1,27 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+#include <math.h>
+#include <libavcodec/avfft.h>
+#include "filter.h"
+
+static void * forward_setup(int len) {return av_rdft_init((int)(log(len)/log(2)+.5),DFT_R2C);}
+static void * backward_setup(int len) {return av_rdft_init((int)(log(len)/log(2)+.5),IDFT_C2R);}
+static void rdft(int length, void * setup, float * h) {av_rdft_calc(setup, h); (void)length;}
+static int multiplier(void) {return 2;}
+static void nothing(void) {}
+
+typedef void (* fn_t)(void);
+fn_t _soxr_rdft32_cb[] = {
+  (fn_t)forward_setup,
+  (fn_t)backward_setup,
+  (fn_t)av_rdft_end,
+  (fn_t)rdft,
+  (fn_t)rdft,
+  (fn_t)rdft,
+  (fn_t)rdft,
+  (fn_t)_soxr_ordered_convolve_f,
+  (fn_t)_soxr_ordered_partial_convolve_f,
+  (fn_t)multiplier,
+  (fn_t)nothing,
+};
--- a/lib-src/libsoxr/src/avfft32s.c
+++ b/lib-src/libsoxr/src/avfft32s.c
@@ -0,0 +1,27 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+#include <math.h>
+#include <libavcodec/avfft.h>
+#include "simd.h"
+
+static void * forward_setup(int len) {return av_rdft_init((int)(log(len)/log(2)+.5),DFT_R2C);}
+static void * backward_setup(int len) {return av_rdft_init((int)(log(len)/log(2)+.5),IDFT_C2R);}
+static void rdft(int length, void * setup, float * h) {av_rdft_calc(setup, h); (void)length;}
+static int multiplier(void) {return 2;}
+static void nothing(void) {}
+
+typedef void (* fn_t)(void);
+fn_t _soxr_rdft32s_cb[] = {
+  (fn_t)forward_setup,
+  (fn_t)backward_setup,
+  (fn_t)av_rdft_end,
+  (fn_t)rdft,
+  (fn_t)rdft,
+  (fn_t)rdft,
+  (fn_t)rdft,
+  (fn_t)_soxr_ordered_convolve_simd,
+  (fn_t)_soxr_ordered_partial_convolve_simd,
+  (fn_t)multiplier,
+  (fn_t)nothing,
+};
--- a/lib-src/libsoxr/src/ccrw2.h
+++ b/lib-src/libsoxr/src/ccrw2.h
@@ -0,0 +1,73 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+/* Concurrent Control with "Readers" and "Writers", P.J. Courtois et al, 1971 */
+
+#if !defined ccrw2_included
+#define ccrw2_included
+
+#include "internal.h"
+
+#if defined _OPENMP
+
+#include <omp.h>
+
+typedef struct {
+  int readcount, writecount; /* initial value = 0 */
+  omp_lock_t mutex_1, mutex_2, mutex_3, w, r; /* initial value = 1 */
+} ccrw2_t; /* Problem #2: `writers-preference' */
+
+#define ccrw2_become_reader(p) do {\
+  omp_set_lock(&p.mutex_3);\
+    omp_set_lock(&p.r);\
+      omp_set_lock(&p.mutex_1);\
+        if (++p.readcount == 1) omp_set_lock(&p.w);\
+      omp_unset_lock(&p.mutex_1);\
+    omp_unset_lock(&p.r);\
+  omp_unset_lock(&p.mutex_3);\
+} while (0)
+#define ccrw2_cease_reading(p) do {\
+  omp_set_lock(&p.mutex_1);\
+    if (!--p.readcount) omp_unset_lock(&p.w);\
+  omp_unset_lock(&p.mutex_1);\
+} while (0)
+#define ccrw2_become_writer(p) do {\
+  omp_set_lock(&p.mutex_2);\
+    if (++p.writecount == 1) omp_set_lock(&p.r);\
+  omp_unset_lock(&p.mutex_2);\
+  omp_set_lock(&p.w);\
+} while (0)
+#define ccrw2_cease_writing(p) do {\
+  omp_unset_lock(&p.w);\
+  omp_set_lock(&p.mutex_2);\
+    if (!--p.writecount) omp_unset_lock(&p.r);\
+  omp_unset_lock(&p.mutex_2);\
+} while (0)
+#define ccrw2_init(p) do {\
+  omp_init_lock(&p.mutex_1);\
+  omp_init_lock(&p.mutex_2);\
+  omp_init_lock(&p.mutex_3);\
+  omp_init_lock(&p.w);\
+  omp_init_lock(&p.r);\
+} while (0)
+#define ccrw2_clear(p) do {\
+  omp_destroy_lock(&p.r);\
+  omp_destroy_lock(&p.w);\
+  omp_destroy_lock(&p.mutex_3);\
+  omp_destroy_lock(&p.mutex_2);\
+  omp_destroy_lock(&p.mutex_1);\
+} while (0)
+
+#else
+
+typedef int ccrw2_t;
+#define ccrw2_become_reader(x) (void)(x)
+#define ccrw2_cease_reading(x) (void)(x)
+#define ccrw2_become_writer(x) (void)(x)
+#define ccrw2_cease_writing(x) (void)(x)
+#define ccrw2_init(x) (void)(x)
+#define ccrw2_clear(x) (void)(x)
+
+#endif /* _OPENMP */
+
+#endif
--- a/lib-src/libsoxr/src/data-io.c
+++ b/lib-src/libsoxr/src/data-io.c
@@ -0,0 +1,248 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+#include <limits.h>
+#include <math.h>
+#include <string.h>
+
+#include "data-io.h"
+#include "internal.h"
+
+
+
+#define DEINTERLEAVE_FROM(T,flag) do { \
+  unsigned i; \
+  size_t j; \
+  T const * src = *src0; \
+  if (ch > 1) \
+    for (j = 0; j < n; ++j) for (i = 0; i < ch; ++i) dest[i][j] = (DEINTERLEAVE_TO)*src++; \
+  else if (flag) memcpy(dest[0], src, n * sizeof(T)), src = &src[n]; \
+  else for (j = 0; j < n; dest[0][j++] = (DEINTERLEAVE_TO)*src++); \
+  *src0 = src; \
+} while (0)
+
+
+
+#if HAVE_DOUBLE_PRECISION
+void _soxr_deinterleave(double * * dest, /* Round/clipping not needed here */
+    soxr_datatype_t data_type, void const * * src0, size_t n, unsigned ch)
+{
+#define DEINTERLEAVE_TO double
+  switch (data_type & 3) {
+    case SOXR_FLOAT32: DEINTERLEAVE_FROM(float, 0); break;
+    case SOXR_FLOAT64: DEINTERLEAVE_FROM(double, 1); break;
+    case SOXR_INT32:   DEINTERLEAVE_FROM(int32_t, 0); break;
+    case SOXR_INT16:   DEINTERLEAVE_FROM(int16_t, 0); break;
+    default: break;
+  }
+}
+#endif
+
+
+
+#if HAVE_SINGLE_PRECISION
+void _soxr_deinterleave_f(float * * dest, /* Round/clipping not needed here */
+    soxr_datatype_t data_type, void const * * src0, size_t n, unsigned ch)
+{
+#undef DEINTERLEAVE_TO
+#define DEINTERLEAVE_TO float
+  switch (data_type & 3) {
+    case SOXR_FLOAT32: DEINTERLEAVE_FROM(float, 1); break;
+    case SOXR_FLOAT64: DEINTERLEAVE_FROM(double, 0); break;
+    case SOXR_INT32:   DEINTERLEAVE_FROM(int32_t, 0); break;
+    case SOXR_INT16:   DEINTERLEAVE_FROM(int16_t, 0); break;
+    default: break;
+  }
+}
+#endif
+
+
+
+#include "rint.h"
+
+#if HAVE_FENV_H
+  #include <fenv.h>
+#elif defined _MSC_VER
+  #define FE_INVALID    1
+  #define FE_DIVBYZERO  4
+  #define FE_OVERFLOW   8
+  #define FE_UNDERFLOW  16
+  #define FE_INEXACT    32
+  #define FE_ALL_EXCEPT (FE_INEXACT|FE_DIVBYZERO|FE_UNDERFLOW|FE_OVERFLOW|FE_INVALID)
+  static __inline int fetestexcept(int excepts)
+  {
+    short status_word;
+    __asm fnstsw status_word
+    return status_word & excepts & FE_ALL_EXCEPT;
+  }
+
+  static __inline int feclearexcept(int excepts)
+  {
+    int16_t status[14];
+    __asm fnstenv status
+    status[2] &= ~(excepts & FE_ALL_EXCEPT);
+    __asm fldenv status
+    return 0;
+  }
+#endif
+
+
+
+#if defined FE_INVALID && defined FPU_RINT32 && defined __STDC_VERSION__
+  #if __STDC_VERSION__ >= 199901L
+    #pragma STDC FENV_ACCESS ON
+  #endif
+#endif
+
+#if HAVE_DOUBLE_PRECISION
+#define FLOATX double
+
+#define LSX_RINT_CLIP_2 lsx_rint32_clip_2
+#define LSX_RINT_CLIP lsx_rint32_clip
+#define RINT_CLIP rint32_clip
+#define RINT rint32
+#if defined FPU_RINT32
+  #define FPU_RINT
+#endif
+#define RINT_T int32_t
+#define RINT_MAX 2147483647L
+#include "rint-clip.h"
+
+#define LSX_RINT_CLIP_2 lsx_rint16_clip_2
+#define LSX_RINT_CLIP lsx_rint16_clip
+#define RINT_CLIP rint16_clip
+#define RINT rint16
+#if defined FPU_RINT16
+  #define FPU_RINT
+#endif
+#define RINT_T int16_t
+#define RINT_MAX 32767
+#include "rint-clip.h"
+
+#define LSX_RINT_CLIP_2 lsx_rint16_clip_2_dither
+#define LSX_RINT_CLIP lsx_rint16_clip_dither
+#define RINT_CLIP rint16_clip_dither
+#define RINT rint16
+#if defined FPU_RINT16
+  #define FPU_RINT
+#endif
+#define RINT_T int16_t
+#define RINT_MAX 32767
+#define DITHER
+#include "rint-clip.h"
+
+#undef FLOATX
+#endif
+
+
+
+#if HAVE_SINGLE_PRECISION
+#define FLOATX float
+
+#define LSX_RINT_CLIP_2 lsx_rint32_clip_2_f
+#define LSX_RINT_CLIP lsx_rint32_clip_f
+#define RINT_CLIP rint32_clip_f
+#define RINT rint32
+#if defined FPU_RINT32
+  #define FPU_RINT
+#endif
+#define RINT_T int32_t
+#define RINT_MAX 2147483647L
+#include "rint-clip.h"
+
+#define LSX_RINT_CLIP_2 lsx_rint16_clip_2_f
+#define LSX_RINT_CLIP lsx_rint16_clip_f
+#define RINT_CLIP rint16_clip_f
+#define RINT rint16
+#if defined FPU_RINT16
+  #define FPU_RINT
+#endif
+#define RINT_T int16_t
+#define RINT_MAX 32767
+#include "rint-clip.h"
+
+#define LSX_RINT_CLIP_2 lsx_rint16_clip_2_dither_f
+#define LSX_RINT_CLIP lsx_rint16_clip_dither_f
+#define RINT_CLIP rint16_clip_dither_f
+#define RINT rint16
+#if defined FPU_RINT16
+  #define FPU_RINT
+#endif
+#define RINT_T int16_t
+#define RINT_MAX 32767
+#define DITHER
+#include "rint-clip.h"
+
+#undef FLOATX
+#endif
+
+#if defined FE_INVALID && defined FPU_RINT32 && defined __STDC_VERSION__
+  #if __STDC_VERSION__ >= 199901L
+    #pragma STDC FENV_ACCESS OFF
+  #endif
+#endif
+
+
+
+#define INTERLEAVE_TO(T) do { \
+  unsigned i; \
+  size_t j; \
+  T * dest = *dest0; \
+  if (ch == 1) \
+    for (j = 0; j < n; *dest++ = (T)src[0][j++]); \
+  else for (j = 0; j < n; ++j) for (i = 0; i < ch; ++i) *dest++ = (T)src[i][j]; \
+  *dest0 = dest; \
+  return 0; \
+} while (0)
+
+#if HAVE_DOUBLE_PRECISION
+size_t /* clips */ _soxr_interleave(soxr_datatype_t data_type, void * * dest0,
+  double const * const * src, size_t n, unsigned ch, unsigned long * seed)
+{
+  switch (data_type & 3) {
+    case SOXR_FLOAT32: INTERLEAVE_TO(float);
+    case SOXR_FLOAT64: INTERLEAVE_TO(double);
+
+    case SOXR_INT32: if (ch == 1)
+        return lsx_rint32_clip(dest0, src[0], n);
+      return lsx_rint32_clip_2(dest0, src, ch, n);
+
+    case SOXR_INT16: if (seed) {
+      if (ch == 1)
+        return lsx_rint16_clip_dither(dest0, src[0], n, seed);
+      return lsx_rint16_clip_2_dither(dest0, src, ch, n, seed);
+    }
+    if (ch == 1)
+        return lsx_rint16_clip(dest0, src[0], n);
+      return lsx_rint16_clip_2(dest0, src, ch, n);
+    default: break;
+  }
+  return 0;
+}
+#endif
+
+#if HAVE_SINGLE_PRECISION
+size_t /* clips */ _soxr_interleave_f(soxr_datatype_t data_type, void * * dest0,
+  float const * const * src, size_t n, unsigned ch, unsigned long * seed)
+{
+  switch (data_type & 3) {
+    case SOXR_FLOAT32: INTERLEAVE_TO(float);
+    case SOXR_FLOAT64: INTERLEAVE_TO(double);
+
+    case SOXR_INT32: if (ch == 1)
+        return lsx_rint32_clip_f(dest0, src[0], n);
+      return lsx_rint32_clip_2_f(dest0, src, ch, n);
+
+    case SOXR_INT16: if (seed) {
+      if (ch == 1)
+        return lsx_rint16_clip_dither_f(dest0, src[0], n, seed);
+      return lsx_rint16_clip_2_dither_f(dest0, src, ch, n, seed);
+    }
+    if (ch == 1)
+        return lsx_rint16_clip_f(dest0, src[0], n);
+      return lsx_rint16_clip_2_f(dest0, src, ch, n);
+    default: break;
+  }
+  return 0;
+}
+#endif
--- a/lib-src/libsoxr/src/data-io.h
+++ b/lib-src/libsoxr/src/data-io.h
@@ -0,0 +1,39 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+#if !defined soxr_data_io_included
+#define soxr_data_io_included
+
+#include "soxr.h"
+
+void _soxr_deinterleave(
+    double * * dest,
+    soxr_datatype_t data_type,
+    void const * * src0,
+    size_t n,
+    unsigned ch);
+
+void _soxr_deinterleave_f(
+    float * * dest,
+    soxr_datatype_t data_type,
+    void const * * src0,
+    size_t n,
+    unsigned ch);
+
+size_t /* clips */ _soxr_interleave(
+    soxr_datatype_t data_type,
+    void * * dest,
+    double const * const * src,
+    size_t n,
+    unsigned ch,
+    unsigned long * seed);
+
+size_t /* clips */ _soxr_interleave_f(
+    soxr_datatype_t data_type,
+    void * * dest,
+    float const * const * src,
+    size_t n,
+    unsigned ch,
+    unsigned long * seed);
+
+#endif
--- a/lib-src/libsoxr/src/dbesi0.c
+++ b/lib-src/libsoxr/src/dbesi0.c
@@ -0,0 +1,149 @@
+/*  Copyright(C) 1996 Takuya OOURA
+
+You may use, copy, modify this code for any purpose and
+without fee.
+
+Package home:  http://www.kurims.kyoto-u.ac.jp/~ooura/bessel.html
+*/
+
+#include "filter.h"
+#define dbesi0 lsx_bessel_I_0
+
+/* Bessel I_0(x) function in double precision */
+
+#include <math.h>
+
+double dbesi0(double x)
+{
+    int k;
+    double w, t, y;
+    static double a[65] = {
+        8.5246820682016865877e-11, 2.5966600546497407288e-9,
+        7.9689994568640180274e-8, 1.9906710409667748239e-6,
+        4.0312469446528002532e-5, 6.4499871606224265421e-4,
+        0.0079012345761930579108, 0.071111111109207045212,
+        0.444444444444724909, 1.7777777777777532045,
+        4.0000000000000011182, 3.99999999999999998,
+        1.0000000000000000001,
+        1.1520919130377195927e-10, 2.2287613013610985225e-9,
+        8.1903951930694585113e-8, 1.9821560631611544984e-6,
+        4.0335461940910133184e-5, 6.4495330974432203401e-4,
+        0.0079013012611467520626, 0.071111038160875566622,
+        0.44444450319062699316, 1.7777777439146450067,
+        4.0000000132337935071, 3.9999999968569015366,
+        1.0000000003426703174,
+        1.5476870780515238488e-10, 1.2685004214732975355e-9,
+        9.2776861851114223267e-8, 1.9063070109379044378e-6,
+        4.0698004389917945832e-5, 6.4370447244298070713e-4,
+        0.0079044749458444976958, 0.071105052411749363882,
+        0.44445280640924755082, 1.7777694934432109713,
+        4.0000055808824003386, 3.9999977081165740932,
+        1.0000004333949319118,
+        2.0675200625006793075e-10, -6.1689554705125681442e-10,
+        1.2436765915401571654e-7, 1.5830429403520613423e-6,
+        4.2947227560776583326e-5, 6.3249861665073441312e-4,
+        0.0079454472840953930811, 0.070994327785661860575,
+        0.44467219586283000332, 1.7774588182255374745,
+        4.0003038986252717972, 3.9998233869142057195,
+        1.0000472932961288324,
+        2.7475684794982708655e-10, -3.8991472076521332023e-9,
+        1.9730170483976049388e-7, 5.9651531561967674521e-7,
+        5.1992971474748995357e-5, 5.7327338675433770752e-4,
+        0.0082293143836530412024, 0.069990934858728039037,
+        0.44726764292723985087, 1.7726685170014087784,
+        4.0062907863712704432, 3.9952750700487845355,
+        1.0016354346654179322
+    };
+    static double b[70] = {
+        6.7852367144945531383e-8, 4.6266061382821826854e-7,
+        6.9703135812354071774e-6, 7.6637663462953234134e-5,
+        7.9113515222612691636e-4, 0.0073401204731103808981,
+        0.060677114958668837046, 0.43994941411651569622,
+        2.7420017097661750609, 14.289661921740860534,
+        59.820609640320710779, 188.78998681199150629,
+        399.8731367825601118, 427.56411572180478514,
+        1.8042097874891098754e-7, 1.2277164312044637357e-6,
+        1.8484393221474274861e-5, 2.0293995900091309208e-4,
+        0.0020918539850246207459, 0.019375315654033949297,
+        0.15985869016767185908, 1.1565260527420641724,
+        7.1896341224206072113, 37.354773811947484532,
+        155.80993164266268457, 489.5211371158540918,
+        1030.9147225169564806, 1093.5883545113746958,
+        4.8017305613187493564e-7, 3.261317843912380074e-6,
+        4.9073137508166159639e-5, 5.3806506676487583755e-4,
+        0.0055387918291051866561, 0.051223717488786549025,
+        0.42190298621367914765, 3.0463625987357355872,
+        18.895299447327733204, 97.915189029455461554,
+        407.13940115493494659, 1274.3088990480582632,
+        2670.9883037012547506, 2815.7166284662544712,
+        1.2789926338424623394e-6, 8.6718263067604918916e-6,
+        1.3041508821299929489e-4, 0.001428224737372747892,
+        0.014684070635768789378, 0.13561403190404185755,
+        1.1152592585977393953, 8.0387088559465389038,
+        49.761318895895479206, 257.2684232313529138,
+        1066.8543146269566231, 3328.3874581009636362,
+        6948.8586598121634874, 7288.4893398212481055,
+        3.409350368197032893e-6, 2.3079025203103376076e-5,
+        3.4691373283901830239e-4, 0.003794994977222908545,
+        0.038974209677945602145, 0.3594948380414878371,
+        2.9522878893539528226, 21.246564609514287056,
+        131.28727387146173141, 677.38107093296675421,
+        2802.3724744545046518, 8718.5731420798254081,
+        18141.348781638832286, 18948.925349296308859
+    };
+    static double c[45] = {
+        2.5568678676452702768e-15, 3.0393953792305924324e-14,
+        6.3343751991094840009e-13, 1.5041298011833009649e-11,
+        4.4569436918556541414e-10, 1.746393051427167951e-8,
+        1.0059224011079852317e-6, 1.0729838945088577089e-4,
+        0.05150322693642527738,
+        5.2527963991711562216e-15, 7.202118481421005641e-15,
+        7.2561421229904797156e-13, 1.482312146673104251e-11,
+        4.4602670450376245434e-10, 1.7463600061788679671e-8,
+        1.005922609132234756e-6, 1.0729838937545111487e-4,
+        0.051503226936437300716,
+        1.3365917359358069908e-14, -1.2932643065888544835e-13,
+        1.7450199447905602915e-12, 1.0419051209056979788e-11,
+        4.58047881980598326e-10, 1.7442405450073548966e-8,
+        1.0059461453281292278e-6, 1.0729837434500161228e-4,
+        0.051503226940658446941,
+        5.3771611477352308649e-14, -1.1396193006413731702e-12,
+        1.2858641335221653409e-11, -5.9802086004570057703e-11,
+        7.3666894305929510222e-10, 1.6731837150730356448e-8,
+        1.0070831435812128922e-6, 1.0729733111203704813e-4,
+        0.051503227360726294675,
+        3.7819492084858931093e-14, -4.8600496888588034879e-13,
+        1.6898350504817224909e-12, 4.5884624327524255865e-11,
+        1.2521615963377513729e-10, 1.8959658437754727957e-8,
+        1.0020716710561353622e-6, 1.073037119856927559e-4,
+        0.05150322383300230775
+    };
+
+    w = fabs(x);
+    if (w < 8.5) {
+        t = w * w * 0.0625;
+        k = 13 * ((int) t);
+        y = (((((((((((a[k] * t + a[k + 1]) * t +
+            a[k + 2]) * t + a[k + 3]) * t + a[k + 4]) * t +
+            a[k + 5]) * t + a[k + 6]) * t + a[k + 7]) * t +
+            a[k + 8]) * t + a[k + 9]) * t + a[k + 10]) * t +
+            a[k + 11]) * t + a[k + 12];
+    } else if (w < 12.5) {
+        k = (int) w;
+        t = w - k;
+        k = 14 * (k - 8);
+        y = ((((((((((((b[k] * t + b[k + 1]) * t +
+            b[k + 2]) * t + b[k + 3]) * t + b[k + 4]) * t +
+            b[k + 5]) * t + b[k + 6]) * t + b[k + 7]) * t +
+            b[k + 8]) * t + b[k + 9]) * t + b[k + 10]) * t +
+            b[k + 11]) * t + b[k + 12]) * t + b[k + 13];
+    } else {
+        t = 60 / w;
+        k = 9 * ((int) t);
+        y = ((((((((c[k] * t + c[k + 1]) * t +
+            c[k + 2]) * t + c[k + 3]) * t + c[k + 4]) * t +
+            c[k + 5]) * t + c[k + 6]) * t + c[k + 7]) * t +
+            c[k + 8]) * sqrt(t) * exp(w);
+    }
+    return y;
+}
--- a/lib-src/libsoxr/src/fft4g.c
+++ b/lib-src/libsoxr/src/fft4g.c
--- a/lib-src/libsoxr/src/fft4g.h
+++ b/lib-src/libsoxr/src/fft4g.h
@@ -0,0 +1,23 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+void lsx_cdft(int, int, double *, int *, double *);
+void lsx_rdft(int, int, double *, int *, double *);
+void lsx_ddct(int, int, double *, int *, double *);
+void lsx_ddst(int, int, double *, int *, double *);
+void lsx_dfct(int, double *, double *, int *, double *);
+void lsx_dfst(int, double *, double *, int *, double *);
+
+void lsx_cdft_f(int, int, float *, int *, float *);
+void lsx_rdft_f(int, int, float *, int *, float *);
+void lsx_ddct_f(int, int, float *, int *, float *);
+void lsx_ddst_f(int, int, float *, int *, float *);
+void lsx_dfct_f(int, float *, float *, int *, float *);
+void lsx_dfst_f(int, float *, float *, int *, float *);
+
+#define dft_br_len(l) (2ul + (1ul << (int)(log(l / 2 + .5) / log(2.)) / 2))
+#define dft_sc_len(l) ((unsigned long)l / 2)
+
+/* Over-allocate h by 2 to use these macros */
+#define LSX_PACK(h, n)   h[1] = h[n]
+#define LSX_UNPACK(h, n) h[n] = h[1], h[n + 1] = h[1] = 0;
--- a/lib-src/libsoxr/src/fft4g32.c
+++ b/lib-src/libsoxr/src/fft4g32.c
@@ -0,0 +1,27 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+#include "filter.h"
+#define FFT4G_FLOAT
+#include "fft4g.c"
+
+static void * null(void) {return 0;}
+static void forward (int length, void * setup, double * H) {lsx_safe_rdft_f(length,  1, H); (void)setup;}
+static void backward(int length, void * setup, double * H) {lsx_safe_rdft_f(length, -1, H); (void)setup;}
+static int multiplier(void) {return 2;}
+static void nothing(void) {}
+
+typedef void (* fn_t)(void);
+fn_t _soxr_rdft32_cb[] = {
+  (fn_t)null,
+  (fn_t)null,
+  (fn_t)nothing,
+  (fn_t)forward,
+  (fn_t)forward,
+  (fn_t)backward,
+  (fn_t)backward,
+  (fn_t)_soxr_ordered_convolve_f,
+  (fn_t)_soxr_ordered_partial_convolve_f,
+  (fn_t)multiplier,
+  (fn_t)nothing,
+};
--- a/lib-src/libsoxr/src/fft4g32s.c
+++ b/lib-src/libsoxr/src/fft4g32s.c
@@ -0,0 +1,26 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+#include "filter.h"
+#include "simd.h"
+
+static void * null(void) {return 0;}
+static void nothing(void) {}
+static void forward (int length, void * setup, float * H) {lsx_safe_rdft_f(length,  1, H); (void)setup;}
+static void backward(int length, void * setup, float * H) {lsx_safe_rdft_f(length, -1, H); (void)setup;}
+static int multiplier(void) {return 2;}
+
+typedef void (* fn_t)(void);
+fn_t _soxr_rdft32s_cb[] = {
+  (fn_t)null,
+  (fn_t)null,
+  (fn_t)nothing,
+  (fn_t)forward,
+  (fn_t)forward,
+  (fn_t)backward,
+  (fn_t)backward,
+  (fn_t)_soxr_ordered_convolve_simd,
+  (fn_t)_soxr_ordered_partial_convolve_simd,
+  (fn_t)multiplier,
+  (fn_t)nothing,
+};
--- a/lib-src/libsoxr/src/fft4g64.c
+++ b/lib-src/libsoxr/src/fft4g64.c
@@ -0,0 +1,29 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+#include "filter.h"
+#include "fft4g.c"
+#include "soxr-config.h"
+
+#if HAVE_DOUBLE_PRECISION
+static void * null(void) {return 0;}
+static void nothing(void) {}
+static void forward (int length, void * setup, double * H) {lsx_safe_rdft(length,  1, H); (void)setup;}
+static void backward(int length, void * setup, double * H) {lsx_safe_rdft(length, -1, H); (void)setup;}
+static int multiplier(void) {return 2;}
+
+typedef void (* fn_t)(void);
+fn_t _soxr_rdft64_cb[] = {
+  (fn_t)null,
+  (fn_t)null,
+  (fn_t)nothing,
+  (fn_t)forward,
+  (fn_t)forward,
+  (fn_t)backward,
+  (fn_t)backward,
+  (fn_t)_soxr_ordered_convolve,
+  (fn_t)_soxr_ordered_partial_convolve,
+  (fn_t)multiplier,
+  (fn_t)nothing,
+};
+#endif
--- a/lib-src/libsoxr/src/fft4g_cache.h
+++ b/lib-src/libsoxr/src/fft4g_cache.h
@@ -0,0 +1,90 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+static int * LSX_FFT_BR;
+static DFT_FLOAT * LSX_FFT_SC;
+static int FFT_LEN = -1;
+static ccrw2_t FFT_CACHE_CCRW;
+
+void LSX_INIT_FFT_CACHE(void)
+{
+  if (FFT_LEN >= 0)
+    return;
+  assert(LSX_FFT_BR == NULL);
+  assert(LSX_FFT_SC == NULL);
+  assert(FFT_LEN == -1);
+  ccrw2_init(FFT_CACHE_CCRW);
+  FFT_LEN = 0;
+}
+
+void LSX_CLEAR_FFT_CACHE(void)
+{
+  assert(FFT_LEN >= 0);
+  ccrw2_clear(FFT_CACHE_CCRW);
+  free(LSX_FFT_BR);
+  free(LSX_FFT_SC);
+  LSX_FFT_SC = NULL;
+  LSX_FFT_BR = NULL;
+  FFT_LEN = -1;
+}
+
+static bool UPDATE_FFT_CACHE(int len)
+{
+  LSX_INIT_FFT_CACHE();
+  assert(lsx_is_power_of_2(len));
+  assert(FFT_LEN >= 0);
+  ccrw2_become_reader(FFT_CACHE_CCRW);
+  if (len > FFT_LEN) {
+    ccrw2_cease_reading(FFT_CACHE_CCRW);
+    ccrw2_become_writer(FFT_CACHE_CCRW);
+    if (len > FFT_LEN) {
+      int old_n = FFT_LEN;
+      FFT_LEN = len;
+      LSX_FFT_BR = realloc(LSX_FFT_BR, dft_br_len(FFT_LEN) * sizeof(*LSX_FFT_BR));
+      LSX_FFT_SC = realloc(LSX_FFT_SC, dft_sc_len(FFT_LEN) * sizeof(*LSX_FFT_SC));
+      if (!old_n) {
+        LSX_FFT_BR[0] = 0;
+        atexit(LSX_CLEAR_FFT_CACHE);
+      }
+      return true;
+    }
+    ccrw2_cease_writing(FFT_CACHE_CCRW);
+    ccrw2_become_reader(FFT_CACHE_CCRW);
+  }
+  return false;
+}
+
+static void DONE_WITH_FFT_CACHE(bool is_writer)
+{
+  if (is_writer)
+    ccrw2_cease_writing(FFT_CACHE_CCRW);
+  else ccrw2_cease_reading(FFT_CACHE_CCRW);
+}
+
+void LSX_SAFE_RDFT(int len, int type, DFT_FLOAT * d)
+{
+  bool is_writer = UPDATE_FFT_CACHE(len);
+  LSX_RDFT(len, type, d, LSX_FFT_BR, LSX_FFT_SC);
+  DONE_WITH_FFT_CACHE(is_writer);
+}
+
+void LSX_SAFE_CDFT(int len, int type, DFT_FLOAT * d)
+{
+  bool is_writer = UPDATE_FFT_CACHE(len);
+  LSX_CDFT(len, type, d, LSX_FFT_BR, LSX_FFT_SC);
+  DONE_WITH_FFT_CACHE(is_writer);
+}
+
+#undef UPDATE_FFT_CACHE
+#undef LSX_SAFE_RDFT
+#undef LSX_SAFE_CDFT
+#undef LSX_RDFT
+#undef LSX_INIT_FFT_CACHE
+#undef LSX_FFT_SC
+#undef LSX_FFT_BR
+#undef LSX_CLEAR_FFT_CACHE
+#undef LSX_CDFT
+#undef FFT_LEN
+#undef FFT_CACHE_CCRW
+#undef DONE_WITH_FFT_CACHE
+#undef DFT_FLOAT
--- a/lib-src/libsoxr/src/fifo.h
+++ b/lib-src/libsoxr/src/fifo.h
@@ -0,0 +1,125 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+#ifndef fifo_included
+#define fifo_included
+
+#include <string.h>
+
+#if !defined FIFO_SIZE_T
+#define FIFO_SIZE_T size_t
+#endif
+
+#if !defined FIFO_REALLOC
+#include <stdlib.h>
+  #define FIFO_REALLOC(a,b,c) realloc(a,b)
+  #undef FIFO_FREE
+  #define FIFO_FREE free
+  #undef FIFO_MALLOC
+  #define FIFO_MALLOC malloc
+#endif
+
+typedef struct {
+  char * data;
+  size_t allocation;   /* Number of bytes allocated for data. */
+  size_t item_size;    /* Size of each item in data */
+  size_t begin;        /* Offset of the first byte to read. */
+  size_t end;          /* 1 + Offset of the last byte byte to read. */
+} fifo_t;
+
+#define FIFO_MIN 0x4000
+
+#if !defined UNUSED
+  #define UNUSED
+#endif
+
+UNUSED static void fifo_clear(fifo_t * f)
+{
+  f->end = f->begin = 0;
+}
+
+UNUSED static void * fifo_reserve(fifo_t * f, FIFO_SIZE_T n0)
+{
+  size_t n = (size_t)n0;
+  n *= f->item_size;
+
+  if (f->begin == f->end)
+    fifo_clear(f);
+
+  while (1) {
+    if (f->end + n <= f->allocation) {
+      void *p = f->data + f->end;
+
+      f->end += n;
+      return p;
+    }
+    if (f->begin > FIFO_MIN) {
+      memmove(f->data, f->data + f->begin, f->end - f->begin);
+      f->end -= f->begin;
+      f->begin = 0;
+      continue;
+    }
+    f->data = FIFO_REALLOC(f->data, f->allocation + n, f->allocation);
+    f->allocation += n;
+    if (!f->data)
+      return 0;
+  }
+}
+
+UNUSED static void * fifo_write(fifo_t * f, FIFO_SIZE_T n0, void const * data)
+{
+  size_t n = (size_t)n0;
+  void * s = fifo_reserve(f, n0);
+  if (data)
+    memcpy(s, data, n * f->item_size);
+  return s;
+}
+
+UNUSED static void fifo_trim_to(fifo_t * f, FIFO_SIZE_T n0)
+{
+  size_t n = (size_t)n0;
+  n *= f->item_size;
+  f->end = f->begin + n;
+}
+
+UNUSED static void fifo_trim_by(fifo_t * f, FIFO_SIZE_T n0)
+{
+  size_t n = (size_t)n0;
+  n *= f->item_size;
+  f->end -= n;
+}
+
+UNUSED static FIFO_SIZE_T fifo_occupancy(fifo_t * f)
+{
+  return (FIFO_SIZE_T)((f->end - f->begin) / f->item_size);
+}
+
+UNUSED static void * fifo_read(fifo_t * f, FIFO_SIZE_T n0, void * data)
+{
+  size_t n = (size_t)n0;
+  char * ret = f->data + f->begin;
+  n *= f->item_size;
+  if (n > (f->end - f->begin))
+    return NULL;
+  if (data)
+    memcpy(data, ret, (size_t)n);
+  f->begin += n;
+  return ret;
+}
+
+#define fifo_read_ptr(f) fifo_read(f, (FIFO_SIZE_T)0, NULL)
+
+UNUSED static void fifo_delete(fifo_t * f)
+{
+  FIFO_FREE(f->data);
+}
+
+UNUSED static int fifo_create(fifo_t * f, FIFO_SIZE_T item_size)
+{
+  f->item_size = (size_t)item_size;
+  f->allocation = FIFO_MIN;
+  fifo_clear(f);
+  return !(f->data = FIFO_MALLOC(f->allocation));
+}
+
+#endif
--- a/lib-src/libsoxr/src/filter.c
+++ b/lib-src/libsoxr/src/filter.c
@@ -0,0 +1,245 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+#include "filter.h"
+
+#include <math.h>
+#if !defined M_PI
+#define M_PI    3.14159265358979323846
+#endif
+#include <assert.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "fft4g.h"
+#include "ccrw2.h"
+
+#if 1 || HAVE_DOUBLE_PRECISION /* Always need this, for lsx_fir_to_phase. */
+#define DFT_FLOAT double
+#define DONE_WITH_FFT_CACHE done_with_fft_cache
+#define FFT_CACHE_CCRW fft_cache_ccrw
+#define FFT_LEN fft_len
+#define LSX_CDFT lsx_cdft
+#define LSX_CLEAR_FFT_CACHE lsx_clear_fft_cache
+#define LSX_FFT_BR lsx_fft_br
+#define LSX_FFT_SC lsx_fft_sc
+#define LSX_INIT_FFT_CACHE lsx_init_fft_cache
+#define LSX_RDFT lsx_rdft
+#define LSX_SAFE_CDFT lsx_safe_cdft
+#define LSX_SAFE_RDFT lsx_safe_rdft
+#define UPDATE_FFT_CACHE update_fft_cache
+#include "fft4g_cache.h"
+#endif
+
+#if HAVE_SINGLE_PRECISION && !HAVE_AVFFT
+#define DFT_FLOAT float
+#define DONE_WITH_FFT_CACHE done_with_fft_cache_f
+#define FFT_CACHE_CCRW fft_cache_ccrw_f
+#define FFT_LEN fft_len_f
+#define LSX_CDFT lsx_cdft_f
+#define LSX_CLEAR_FFT_CACHE lsx_clear_fft_cache_f
+#define LSX_FFT_BR lsx_fft_br_f
+#define LSX_FFT_SC lsx_fft_sc_f
+#define LSX_INIT_FFT_CACHE lsx_init_fft_cache_f
+#define LSX_RDFT lsx_rdft_f
+#define LSX_SAFE_CDFT lsx_safe_cdft_f
+#define LSX_SAFE_RDFT lsx_safe_rdft_f
+#define UPDATE_FFT_CACHE update_fft_cache_f
+#include "fft4g_cache.h"
+#endif
+
+#if HAVE_DOUBLE_PRECISION
+#define DFT_FLOAT double
+#define ORDERED_CONVOLVE _soxr_ordered_convolve
+#define ORDERED_PARTIAL_CONVOLVE _soxr_ordered_partial_convolve
+#include "rdft.h"
+#endif
+
+#if HAVE_SINGLE_PRECISION
+#define DFT_FLOAT float
+#define ORDERED_CONVOLVE _soxr_ordered_convolve_f
+#define ORDERED_PARTIAL_CONVOLVE _soxr_ordered_partial_convolve_f
+#include "rdft.h"
+#endif
+
+double lsx_kaiser_beta(double att, double tr_bw)
+{
+  if (att >= 60) {
+    static const double coefs[][4] = {
+      {-6.784957e-10,1.02856e-05,0.1087556,-0.8988365+.001},
+      {-6.897885e-10,1.027433e-05,0.10876,-0.8994658+.002},
+      {-1.000683e-09,1.030092e-05,0.1087677,-0.9007898+.003},
+      {-3.654474e-10,1.040631e-05,0.1087085,-0.8977766+.006},
+      {8.106988e-09,6.983091e-06,0.1091387,-0.9172048+.015},
+      {9.519571e-09,7.272678e-06,0.1090068,-0.9140768+.025},
+      {-5.626821e-09,1.342186e-05,0.1083999,-0.9065452+.05},
+      {-9.965946e-08,5.073548e-05,0.1040967,-0.7672778+.085},
+      {1.604808e-07,-5.856462e-05,0.1185998,-1.34824+.1},
+      {-1.511964e-07,6.363034e-05,0.1064627,-0.9876665+.18},
+    };
+    double realm = log(tr_bw/.0005)/log(2.);
+    double const * c0 = coefs[range_limit(  (int)realm, 0, (int)array_length(coefs)-1)];
+    double const * c1 = coefs[range_limit(1+(int)realm, 0, (int)array_length(coefs)-1)];
+    double b0 = ((c0[0]*att + c0[1])*att + c0[2])*att + c0[3];
+    double b1 = ((c1[0]*att + c1[1])*att + c1[2])*att + c1[3];
+    return b0 + (b1 - b0) * (realm - (int)realm);
+  }
+  if (att > 50   ) return .1102 * (att - 8.7);
+  if (att > 20.96) return .58417 * pow(att -20.96, .4) + .07886 * (att - 20.96);
+  return 0;
+}
+
+double * lsx_make_lpf(
+    int num_taps, double Fc, double beta, double rho, double scale)
+{
+  int i, m = num_taps - 1;
+  double * h = malloc((size_t)num_taps * sizeof(*h));
+  double mult = scale / lsx_bessel_I_0(beta), mult1 = 1 / (.5 * m + rho);
+  assert(Fc >= 0 && Fc <= 1);
+  lsx_debug("make_lpf(n=%i Fc=%.7g β=%g ρ=%g scale=%g)",
+      num_taps, Fc, beta, rho, scale);
+
+  if (h) for (i = 0; i <= m / 2; ++i) {
+    double z = i - .5 * m, x = z * M_PI, y = z * mult1;
+    h[i] = x? sin(Fc * x) / x : Fc;
+    h[i] *= lsx_bessel_I_0(beta * sqrt(1 - y * y)) * mult;
+    if (m - i != i)
+      h[m - i] = h[i];
+  }
+  return h;
+}
+
+void lsx_kaiser_params(double att, double Fc, double tr_bw, double * beta, int * num_taps)
+{
+  *beta = *beta < 0? lsx_kaiser_beta(att, tr_bw * .5 / Fc): *beta;
+  att = att < 60? (att - 7.95) / (2.285 * M_PI * 2) :
+    ((.0007528358-1.577737e-05**beta)**beta+.6248022)**beta+.06186902;
+  *num_taps = !*num_taps? (int)ceil(att/tr_bw + 1) : *num_taps;
+}
+
+double * lsx_design_lpf(
+    double Fp,      /* End of pass-band */
+    double Fs,      /* Start of stop-band */
+    double Fn,      /* Nyquist freq; e.g. 0.5, 1, PI */
+    double att,     /* Stop-band attenuation in dB */
+    int * num_taps, /* 0: value will be estimated */
+    int k,          /* >0: number of phases; <0: num_taps ≡ 1 (mod -k) */
+    double beta)    /* <0: value will be estimated */
+{
+  int n = *num_taps, phases = max(k, 1), modulo = max(-k, 1);
+  double tr_bw, Fc, rho = phases == 1? .5 : att < 120? .63 : .75;
+
+  Fp /= fabs(Fn), Fs /= fabs(Fn);        /* Normalise to Fn = 1 */
+  tr_bw = .5 * (Fs - Fp); /* Transition band-width: 6dB to stop points */
+  tr_bw /= phases, Fs /= phases;
+  tr_bw = min(tr_bw, .5 * Fs);
+  Fc = Fs - tr_bw;
+  assert(Fc - tr_bw >= 0);
+  lsx_kaiser_params(att, Fc, tr_bw, &beta, num_taps);
+  if (!n)
+    *num_taps = phases > 1? *num_taps / phases * phases + phases - 1 :
+      (*num_taps + modulo - 2) / modulo * modulo + 1;
+  return Fn < 0? 0 : lsx_make_lpf(*num_taps, Fc, beta, rho, (double)phases);
+}
+
+static double safe_log(double x)
+{
+  assert(x >= 0);
+  if (x)
+    return log(x);
+  lsx_debug("log(0)");
+  return -26;
+}
+
+void lsx_fir_to_phase(double * * h, int * len, int * post_len, double phase)
+{
+  double * pi_wraps, * work, phase1 = (phase > 50 ? 100 - phase : phase) / 50;
+  int i, work_len, begin, end, imp_peak = 0, peak = 0;
+  double imp_sum = 0, peak_imp_sum = 0;
+  double prev_angle2 = 0, cum_2pi = 0, prev_angle1 = 0, cum_1pi = 0;
+
+  for (i = *len, work_len = 2 * 2 * 8; i > 1; work_len <<= 1, i >>= 1);
+
+  work = calloc((size_t)work_len + 2, sizeof(*work)); /* +2: (UN)PACK */
+  pi_wraps = malloc((((size_t)work_len + 2) / 2) * sizeof(*pi_wraps));
+
+  memcpy(work, *h, (size_t)*len * sizeof(*work));
+  lsx_safe_rdft(work_len, 1, work); /* Cepstral: */
+  LSX_UNPACK(work, work_len);
+
+  for (i = 0; i <= work_len; i += 2) {
+    double angle = atan2(work[i + 1], work[i]);
+    double detect = 2 * M_PI;
+    double delta = angle - prev_angle2;
+    double adjust = detect * ((delta < -detect * .7) - (delta > detect * .7));
+    prev_angle2 = angle;
+    cum_2pi += adjust;
+    angle += cum_2pi;
+    detect = M_PI;
+    delta = angle - prev_angle1;
+    adjust = detect * ((delta < -detect * .7) - (delta > detect * .7));
+    prev_angle1 = angle;
+    cum_1pi += fabs(adjust); /* fabs for when 2pi and 1pi have combined */
+    pi_wraps[i >> 1] = cum_1pi;
+
+    work[i] = safe_log(sqrt(sqr(work[i]) + sqr(work[i + 1])));
+    work[i + 1] = 0;
+  }
+  LSX_PACK(work, work_len);
+  lsx_safe_rdft(work_len, -1, work);
+  for (i = 0; i < work_len; ++i) work[i] *= 2. / work_len;
+
+  for (i = 1; i < work_len / 2; ++i) { /* Window to reject acausal components */
+    work[i] *= 2;
+    work[i + work_len / 2] = 0;
+  }
+  lsx_safe_rdft(work_len, 1, work);
+
+  for (i = 2; i < work_len; i += 2) /* Interpolate between linear & min phase */
+    work[i + 1] = phase1 * i / work_len * pi_wraps[work_len >> 1] +
+        (1 - phase1) * (work[i + 1] + pi_wraps[i >> 1]) - pi_wraps[i >> 1];
+
+  work[0] = exp(work[0]), work[1] = exp(work[1]);
+  for (i = 2; i < work_len; i += 2) {
+    double x = exp(work[i]);
+    work[i    ] = x * cos(work[i + 1]);
+    work[i + 1] = x * sin(work[i + 1]);
+  }
+
+  lsx_safe_rdft(work_len, -1, work);
+  for (i = 0; i < work_len; ++i) work[i] *= 2. / work_len;
+
+  /* Find peak pos. */
+  for (i = 0; i <= (int)(pi_wraps[work_len >> 1] / M_PI + .5); ++i) {
+    imp_sum += work[i];
+    if (fabs(imp_sum) > fabs(peak_imp_sum)) {
+      peak_imp_sum = imp_sum;
+      peak = i;
+    }
+    if (work[i] > work[imp_peak]) /* For debug check only */
+      imp_peak = i;
+  }
+  while (peak && fabs(work[peak-1]) > fabs(work[peak]) && work[peak-1] * work[peak] > 0)
+    --peak;
+
+  if (!phase1)
+    begin = 0;
+  else if (phase1 == 1)
+    begin = peak - *len / 2;
+  else {
+    begin = (int)((.997 - (2 - phase1) * .22) * *len + .5);
+    end   = (int)((.997 + (0 - phase1) * .22) * *len + .5);
+    begin = peak - (begin & ~3);
+    end   = peak + 1 + ((end + 3) & ~3);
+    *len = end - begin;
+    *h = realloc(*h, (size_t)*len * sizeof(**h));
+  }
+  for (i = 0; i < *len; ++i) (*h)[i] =
+    work[(begin + (phase > 50 ? *len - 1 - i : i) + work_len) & (work_len - 1)];
+  *post_len = phase > 50 ? peak - begin : begin + *len - (peak + 1);
+
+  lsx_debug("nPI=%g peak-sum@%i=%g (val@%i=%g); len=%i post=%i (%g%%)",
+      pi_wraps[work_len >> 1] / M_PI, peak, peak_imp_sum, imp_peak,
+      work[imp_peak], *len, *post_len, 100 - 100. * *post_len / (*len - 1));
+  free(pi_wraps), free(work);
+}
--- a/lib-src/libsoxr/src/filter.h
+++ b/lib-src/libsoxr/src/filter.h
@@ -0,0 +1,40 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+#if !defined soxr_filter_included
+#define soxr_filter_included
+
+#include "aliases.h"
+
+double lsx_bessel_I_0(double x);
+int lsx_set_dft_length(int num_taps, int min, int large);
+void lsx_init_fft_cache(void);
+void lsx_clear_fft_cache(void);
+void lsx_init_fft_cache_f(void);
+void lsx_clear_fft_cache_f(void);
+#define lsx_is_power_of_2(x) !(x < 2 || (x & (x - 1)))
+void lsx_safe_rdft(int len, int type, double * d);
+void lsx_safe_cdft(int len, int type, double * d);
+void lsx_safe_rdft_f(int len, int type, float * d);
+void lsx_safe_cdft_f(int len, int type, float * d);
+void _soxr_ordered_convolve(int n, void * not_used, double * a, const double * b);
+void _soxr_ordered_convolve_f(int n, void * not_used, float * a, const float * b);
+void _soxr_ordered_partial_convolve(int n, double * a, const double * b);
+void _soxr_ordered_partial_convolve_f(int n, float * a, const float * b);
+
+double lsx_kaiser_beta(double att, double tr_bw);
+double * lsx_make_lpf(int num_taps, double Fc, double beta, double rho,
+    double scale);
+void lsx_kaiser_params(double att, double Fc, double tr_bw, double * beta, int * num_taps);
+double * lsx_design_lpf(
+    double Fp,      /* End of pass-band */
+    double Fs,      /* Start of stop-band */
+    double Fn,      /* Nyquist freq; e.g. 0.5, 1, PI; < 0: dummy run */
+    double att,     /* Stop-band attenuation in dB */
+    int * num_taps, /* 0: value will be estimated */
+    int k,          /* >0: number of phases; <0: num_taps ≡ 1 (mod -k) */
+    double beta);   /* <0: value will be estimated */
+void lsx_fir_to_phase(double * * h, int * len,
+    int * post_len, double phase0);
+
+#endif
--- a/lib-src/libsoxr/src/filters.h
+++ b/lib-src/libsoxr/src/filters.h
@@ -0,0 +1,151 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+#include "half_coefs.h"
+
+#define FUNCTION h8
+#define CONVOLVE _ _ _ _ _ _ _ _
+#define h8_l 8
+#define COEFS half_fir_coefs_8
+#include "half-fir.h"
+
+#define FUNCTION h9
+#define CONVOLVE _ _ _ _ _ _ _ _ _
+#define h9_l 9
+#define COEFS half_fir_coefs_9
+#include "half-fir.h"
+
+#define FUNCTION h10
+#define CONVOLVE _ _ _ _ _ _ _ _ _ _
+#define h10_l 10
+#define COEFS half_fir_coefs_10
+#include "half-fir.h"
+
+#define FUNCTION h11
+#define CONVOLVE _ _ _ _ _ _ _ _ _ _ _
+#define h11_l 11
+#define COEFS half_fir_coefs_11
+#include "half-fir.h"
+
+#define FUNCTION h12
+#define CONVOLVE _ _ _ _ _ _ _ _ _ _ _ _
+#define h12_l 12
+#define COEFS half_fir_coefs_12
+#include "half-fir.h"
+
+#define FUNCTION h13
+#define CONVOLVE _ _ _ _ _ _ _ _ _ _ _ _ _
+#define h13_l 13
+#define COEFS half_fir_coefs_13
+#include "half-fir.h"
+
+static struct {int num_coefs; stage_fn_t fn; float att;} const half_firs[] = {
+  { 8, h8 , 136.51f},
+  { 9, h9 , 152.32f},
+  {10, h10, 168.07f},
+  {11, h11, 183.78f},
+  {12, h12, 199.44f},
+  {13, h13, 212.75f},
+};
+
+#define HI_PREC_CLOCK
+
+#define VAR_LENGTH p->n
+#define VAR_CONVOLVE while (j < FIR_LENGTH) _
+#define VAR_POLY_PHASE_BITS p->phase_bits
+
+#define FUNCTION vpoly0
+#define FIR_LENGTH VAR_LENGTH
+#define CONVOLVE VAR_CONVOLVE
+#include "poly-fir0.h"
+
+#define FUNCTION vpoly1
+#define COEF_INTERP 1
+#define PHASE_BITS VAR_POLY_PHASE_BITS
+#define FIR_LENGTH VAR_LENGTH
+#define CONVOLVE VAR_CONVOLVE
+#include "poly-fir.h"
+
+#define FUNCTION vpoly2
+#define COEF_INTERP 2
+#define PHASE_BITS VAR_POLY_PHASE_BITS
+#define FIR_LENGTH VAR_LENGTH
+#define CONVOLVE VAR_CONVOLVE
+#include "poly-fir.h"
+
+#define FUNCTION vpoly3
+#define COEF_INTERP 3
+#define PHASE_BITS VAR_POLY_PHASE_BITS
+#define FIR_LENGTH VAR_LENGTH
+#define CONVOLVE VAR_CONVOLVE
+#include "poly-fir.h"
+
+#undef HI_PREC_CLOCK
+
+#define U100_l 42
+#if RATE_SIMD_POLY
+  #define U100_l_EXTRA _ _
+  #define u100_l_EXTRA _
+  #define U100_l_EXTRA_LENGTH 2
+  #define u100_l_EXTRA_LENGTH 1
+#else
+  #define U100_l_EXTRA
+  #define u100_l_EXTRA
+  #define U100_l_EXTRA_LENGTH 0
+  #define u100_l_EXTRA_LENGTH 0
+#endif
+#define poly_fir_convolve_U100 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ U100_l_EXTRA
+#define FUNCTION U100_0
+#define FIR_LENGTH (U100_l + U100_l_EXTRA_LENGTH)
+#define CONVOLVE poly_fir_convolve_U100
+#include "poly-fir0.h"
+
+#define u100_l 11
+#define poly_fir_convolve_u100 _ _ _ _ _ _ _ _ _ _ _ u100_l_EXTRA
+#define FUNCTION u100_0
+#define FIR_LENGTH (u100_l + u100_l_EXTRA_LENGTH)
+#define CONVOLVE poly_fir_convolve_u100
+#include "poly-fir0.h"
+
+#define FUNCTION u100_1
+#define COEF_INTERP 1
+#define PHASE_BITS 8
+#define FIR_LENGTH (u100_l + u100_l_EXTRA_LENGTH)
+#define CONVOLVE poly_fir_convolve_u100
+#include "poly-fir.h"
+#define u100_1_b 8
+
+#define FUNCTION u100_2
+#define COEF_INTERP 2
+#define PHASE_BITS 6
+#define FIR_LENGTH (u100_l + u100_l_EXTRA_LENGTH)
+#define CONVOLVE poly_fir_convolve_u100
+#include "poly-fir.h"
+#define u100_2_b 6
+
+typedef struct {float scalar; stage_fn_t fn;} poly_fir1_t;
+typedef struct {float beta; poly_fir1_t interp[3];} poly_fir_t;
+
+static poly_fir_t const poly_firs[] = {
+  {-1, {{0, vpoly0}, { 7.2f, vpoly1}, {5.0f, vpoly2}}},
+  {-1, {{0, vpoly0}, { 9.4f, vpoly1}, {6.7f, vpoly2}}},
+  {-1, {{0, vpoly0}, {12.4f, vpoly1}, {7.8f, vpoly2}}},
+  {-1, {{0, vpoly0}, {13.6f, vpoly1}, {9.3f, vpoly2}}},
+  {-1, {{0, vpoly0}, {10.5f, vpoly2}, {8.4f, vpoly3}}},
+  {-1, {{0, vpoly0}, {11.85f,vpoly2}, {9.0f, vpoly3}}},
+
+  {-1, {{0, vpoly0}, { 8.0f, vpoly1}, {5.3f, vpoly2}}},
+  {-1, {{0, vpoly0}, { 8.6f, vpoly1}, {5.7f, vpoly2}}},
+  {-1, {{0, vpoly0}, {10.6f, vpoly1}, {6.75f,vpoly2}}},
+  {-1, {{0, vpoly0}, {12.6f, vpoly1}, {8.6f, vpoly2}}},
+  {-1, {{0, vpoly0}, { 9.6f, vpoly2}, {7.6f, vpoly3}}},
+  {-1, {{0, vpoly0}, {11.4f, vpoly2}, {8.65f,vpoly3}}},
+
+  {10.62f, {{U100_l, U100_0}, {0, 0}, {0, 0}}},
+  {11.28f, {{u100_l, u100_0}, {u100_1_b, u100_1}, {u100_2_b, u100_2}}},
+  {-1, {{0, vpoly0}, {   9, vpoly1}, {  6, vpoly2}}},
+  {-1, {{0, vpoly0}, {  11, vpoly1}, {  7, vpoly2}}},
+  {-1, {{0, vpoly0}, {  13, vpoly1}, {  8, vpoly2}}},
+  {-1, {{0, vpoly0}, {  10, vpoly2}, {  8, vpoly3}}},
+  {-1, {{0, vpoly0}, {  12, vpoly2}, {  9, vpoly3}}},
+};
--- a/lib-src/libsoxr/src/half-fir.h
+++ b/lib-src/libsoxr/src/half-fir.h
@@ -0,0 +1,25 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+/* Down-sample by a factor of 2 using a FIR with odd length (LEN).*/
+/* Input must be preceded and followed by LEN >> 1 samples. */
+
+#define _ sum += (input[-(2*j +1)] + input[(2*j +1)]) * COEFS[j], ++j;
+static void FUNCTION(stage_t * p, fifo_t * output_fifo)
+{
+  sample_t const * input = stage_read_p(p);
+  int i, num_out = (stage_occupancy(p) + 1) / 2;
+  sample_t * output = fifo_reserve(output_fifo, num_out);
+
+  for (i = 0; i < num_out; ++i, input += 2) {
+    int j = 0;
+    sample_t sum = input[0] * .5f;
+    CONVOLVE
+    output[i] = sum;
+  }
+  fifo_read(&p->fifo, 2 * num_out, NULL);
+}
+#undef _
+#undef COEFS
+#undef CONVOLVE
+#undef FUNCTION
--- a/lib-src/libsoxr/src/half_coefs.h
+++ b/lib-src/libsoxr/src/half_coefs.h
@@ -0,0 +1,57 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+#if defined __GNUC__
+  #pragma GCC system_header
+#elif defined __SUNPRO_C
+  #pragma disable_warn
+#elif defined _MSC_VER
+  #pragma warning(push, 1)
+#endif
+
+static const sample_t half_fir_coefs_8[] = {
+  0.3115465451887802, -0.08734497241282892, 0.03681452335604365,
+  -0.01518925831569441, 0.005454118437408876, -0.001564400922162005,
+  0.0003181701445034203, -3.48001341225749e-5,
+};
+
+static const sample_t half_fir_coefs_9[] = {
+  0.3122703613711853, -0.08922155288172305, 0.03913974805854332,
+  -0.01725059723447163, 0.006858970092378141, -0.002304518467568703,
+  0.0006096426006051062, -0.0001132393923815236, 1.119795386287666e-5,
+};
+
+static const sample_t half_fir_coefs_10[] = {
+  0.3128545521327376, -0.09075671986104322, 0.04109637155154835,
+  -0.01906629512749895, 0.008184039342054333, -0.0030766775017262,
+  0.0009639607022414314, -0.0002358552746579827, 4.025184282444155e-5,
+  -3.629779111541012e-6,
+};
+
+static const sample_t half_fir_coefs_11[] = {
+  0.3133358837508807, -0.09203588680609488, 0.04276515428384758,
+  -0.02067356614745591, 0.00942253142371517, -0.003856330993895144,
+  0.001363470684892284, -0.0003987400965541919, 9.058629923971627e-5,
+  -1.428553070915318e-5, 1.183455238783835e-6,
+};
+
+static const sample_t half_fir_coefs_12[] = {
+  0.3137392991811407, -0.0931182192961332, 0.0442050575271454,
+  -0.02210391200618091, 0.01057473015666001, -0.00462766983973885,
+  0.001793630226239453, -0.0005961819959665878, 0.0001631475979359577,
+  -3.45557865639653e-5, 5.06188341942088e-6, -3.877010943315563e-7,
+};
+
+static const sample_t half_fir_coefs_13[] = {
+  0.3140822554324578, -0.0940458550886253, 0.04545990399121566,
+  -0.02338339450796002, 0.01164429409071052, -0.005380686021429845,
+  0.002242915773871009, -0.000822047600000082, 0.0002572510962395222,
+  -6.607320708956279e-5, 1.309926399120154e-5, -1.790719575255006e-6,
+  1.27504961098836e-7,
+};
+
+#if defined __SUNPRO_C
+  #pragma enable_warn
+#elif defined _MSC_VER
+  #pragma warning(pop)
+#endif
--- a/lib-src/libsoxr/src/internal.h
+++ b/lib-src/libsoxr/src/internal.h
@@ -0,0 +1,41 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+#if !defined soxr_internal_included
+#define soxr_internal_included
+
+#include "soxr-config.h"
+
+#undef min
+#undef max
+#define min(a, b) ((a) <= (b) ? (a) : (b))
+#define max(a, b) ((a) >= (b) ? (a) : (b))
+
+#define range_limit(x, lower, upper) (min(max(x, lower), upper))
+#define linear_to_dB(x) (log10(x) * 20)
+#define array_length(a) (sizeof(a)/sizeof(a[0]))
+#define sqr(a) ((a) * (a))
+
+#if defined NDEBUG
+  #ifdef __GNUC__
+    void lsx_dummy(char const *, ...);
+  #else
+    static __inline void lsx_dummy(char const * x, ...) {}
+  #endif
+  #define lsx_debug if(0) lsx_dummy
+#else
+  #include <stdarg.h>
+  #include <stdio.h>
+  #ifdef __GNUC__
+    __attribute__ ((unused))
+  #endif
+  static void lsx_debug(char const * fmt, ...)
+  {
+    va_list args;
+    va_start(args, fmt);
+    vfprintf(stderr, fmt, args);
+    fputc('\n', stderr);
+    va_end(args);
+  }
+#endif
+#endif
--- a/lib-src/libsoxr/src/libsoxr-dev.src
+++ b/lib-src/libsoxr/src/libsoxr-dev.src
@@ -0,0 +1 @@
+set(TARGET_HEADERS "@TARGET_HEADERS@")
--- a/lib-src/libsoxr/src/libsoxr.src
+++ b/lib-src/libsoxr/src/libsoxr.src
@@ -0,0 +1,2 @@
+set(TARGET_LIBS "@TARGET_LIBS@")
+
--- a/lib-src/libsoxr/src/lsr.c
+++ b/lib-src/libsoxr/src/lsr.c
@@ -0,0 +1,116 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+/* Wrapper mostly compatible with `libsamplerate'. */
+
+#include <assert.h>
+#include <stdlib.h>
+#include "soxr.h"
+
+/* Runtime casts: */
+typedef struct io_t {
+  float *in,*out; long ilen,olen,idone,odone; int eoi; double oi_ratio;} io_t;
+#define SRC_DATA io_t
+typedef struct  soxr_t SRC_STATE;
+#define src_callback_t soxr_input_fn_t
+#define SRC_ERROR soxr_error_t
+#define SRC_SRCTYPE unsigned
+
+#include "soxr-lsr.h"
+#include "rint.h"
+
+
+soxr_error_t src_simple(io_t * p, unsigned id, int channels)
+{
+  size_t idone, odone;
+  soxr_error_t error;
+  soxr_quality_spec_t q_spec = soxr_quality_spec(SOXR_LSR0Q + id, 0);
+  char const * e = getenv("SOXR_LSR_NUM_THREADS");
+  soxr_runtime_spec_t r_spec = soxr_runtime_spec(!(e && atoi(e) != 1));
+  assert (channels > 0);
+  assert (p->ilen >= 0);
+  assert (p->olen >= 0);
+  error = soxr_oneshot(1, p->oi_ratio, (unsigned)channels,
+      p->in, (size_t)p->ilen, &idone, p->out, (size_t)p->olen, &odone,
+      0, &q_spec, &r_spec);
+  p->idone = (long)idone, p->odone = (long)odone;
+  return error;
+}
+
+soxr_t src_callback_new(soxr_input_fn_t fn, unsigned id, int channels, SRC_ERROR * error0, void * p)
+{
+  soxr_quality_spec_t q_spec = soxr_quality_spec(SOXR_LSR0Q + id, 0);
+  char const * e = getenv("SOXR_LSR_NUM_THREADS");
+  soxr_runtime_spec_t r_spec = soxr_runtime_spec(!(e && atoi(e) != 1));
+  soxr_error_t error;
+  soxr_t soxr = 0;
+  assert (channels > 0);
+  /* To minimise latency e.g. for real-time playback:
+  if (id == 2)
+    r_spec.log2_large_dft_size = r_spec.log2_min_dft_size = 8;
+    */
+  soxr = soxr_create(0, 0, (unsigned)channels, &error, 0, &q_spec, &r_spec);
+  if (soxr)
+    error = soxr_set_input_fn(soxr, fn, p);
+  *(int *)error0 = (int)(long)error;
+  return soxr;
+}
+
+soxr_error_t src_process(soxr_t p, io_t * io)
+{
+  if (!p || !io) return "null pointer";
+  soxr_set_error(p, soxr_set_oi_ratio(p, io->oi_ratio));
+
+  { size_t idone , odone;
+  if (io->eoi)
+    io->ilen = -io->ilen; /* hack */
+  soxr_process(p,
+      io->in, (size_t)io->ilen, &idone, io->out, (size_t)io->olen, &odone);
+  io->idone = (long)idone, io->odone = (long)odone;
+  return soxr_error(p); }
+}
+
+long src_callback_read(soxr_t p, double oi_ratio, long olen, float * obuf)
+{
+  if (!p || olen < 0) return -1;
+  soxr_set_error(p, soxr_set_oi_ratio(p, oi_ratio));
+  return (long)soxr_output(p, obuf, (size_t)olen);
+}
+
+void src_float_to_short_array(float const * src, short * dest, int len)
+{
+  double d, N = 1. + SHRT_MAX;
+  assert (src && dest);
+  while (len--) d = src[len] * N, dest[len] = (short)(d > N - 1? (short)(N - 1) : d < -N? (short)-N : rint16(d));
+}
+
+void src_short_to_float_array(short const * src, float * dest, int len)
+{
+  assert (src && dest);
+  while (len--) dest[len] = (float)(src[len] * (1 / (1. + SHRT_MAX)));
+}
+
+void src_float_to_int_array(float const * src, int * dest, int len)
+{
+  double d, N = 32768. * 65536.; /* N.B. int32, not int! (Also next fn.) */
+  assert (src && dest);
+  while (len--) d = src[len] * N, dest[len] = d >= N - 1? (int)(N - 1) : d < -N? (int)(-N) : rint32(d);
+}
+
+void src_int_to_float_array(int const * src, float * dest, int len)
+{
+  assert (src && dest);
+  while (len--) dest[len] = (float)(src[len] * (1 / (32768. * 65536.)));
+}
+
+static char const * const names[] = {"LSR best sinc", "LSR medium sinc", "LSR fastest sinc", "LSR ZOH", "LSR linear", "SoX VHQ"};
+char const * src_get_name(unsigned n)         {return n < 5u + !getenv("SOXR_LSR_STRICT")? names[n] : 0;}
+char const * src_get_description(unsigned id) {return src_get_name(id);}
+char const * src_get_version(void)            {return soxr_version();}
+char const * src_strerror(soxr_error_t error) {return error == (soxr_error_t)1? "Placeholder." : soxr_strerror(error);}
+int src_is_valid_ratio(double oi_ratio)       {return getenv("SOXR_LSR_STRICT")? oi_ratio >= 1./256 && oi_ratio <= 256 : oi_ratio > 0;}
+soxr_error_t src_error(soxr_t p)              {return soxr_error(p);}
+soxr_error_t src_reset(soxr_t p)              {return soxr_clear(p);}
+soxr_t src_delete(soxr_t p)                   {soxr_delete(p); return 0;}
+soxr_error_t src_set_ratio(soxr_t p, double oi_ratio) {return soxr_set_oi_ratio(p, oi_ratio);}
+soxr_t src_new(unsigned id, int channels, SRC_ERROR * error) {return src_callback_new(0, id, channels, error, 0);}
--- a/lib-src/libsoxr/src/pffft.c
+++ b/lib-src/libsoxr/src/pffft.c
--- a/lib-src/libsoxr/src/pffft.h
+++ b/lib-src/libsoxr/src/pffft.h
@@ -0,0 +1,177 @@
+/* Copyright (c) 2011  Julien Pommier ( pommier@modartt.com )
+
+   Based on original fortran 77 code from FFTPACKv4 from NETLIB,
+   authored by Dr Paul Swarztrauber of NCAR, in 1985.
+
+   As confirmed by the NCAR fftpack software curators, the following
+   FFTPACKv5 license applies to FFTPACKv4 sources. My changes are
+   released under the same terms.
+
+   FFTPACK license:
+
+   http://www.cisl.ucar.edu/css/software/fftpack5/ftpk.html
+
+   Copyright (c) 2004 the University Corporation for Atmospheric
+   Research ("UCAR"). All rights reserved. Developed by NCAR's
+   Computational and Information Systems Laboratory, UCAR,
+   www.cisl.ucar.edu.
+
+   Redistribution and use of the Software in source and binary forms,
+   with or without modification, is permitted provided that the
+   following conditions are met:
+
+   - Neither the names of NCAR's Computational and Information Systems
+   Laboratory, the University Corporation for Atmospheric Research,
+   nor the names of its sponsors or contributors may be used to
+   endorse or promote products derived from this Software without
+   specific prior written permission.
+
+   - Redistributions of source code must retain the above copyright
+   notices, this list of conditions, and the disclaimer below.
+
+   - Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions, and the disclaimer below in the
+   documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+   NONINFRINGEMENT. IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT
+   HOLDERS BE LIABLE FOR ANY CLAIM, INDIRECT, INCIDENTAL, SPECIAL,
+   EXEMPLARY, OR CONSEQUENTIAL DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+   ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
+   SOFTWARE.
+*/
+
+/*
+   PFFFT : a Pretty Fast FFT.
+
+   This is basically an adaptation of the single precision fftpack
+   (v4) as found on netlib taking advantage of SIMD instruction found
+   on cpus such as intel x86 (SSE1), powerpc (Altivec), and arm (NEON).
+
+   For architectures where no SIMD instruction is available, the code
+   falls back to a scalar version.
+
+   Restrictions:
+
+   - 1D transforms only, with 32-bit single precision.
+
+   - supports only transforms for inputs of length N of the form
+   N=(2^a)*(3^b), a >= 5 and b >=0 (32, 48, 64, 96, 128, 144 etc
+   are all acceptable lengths). Performance is best for 128<=N<=8192.
+
+   - all (float*) pointers in the functions below are expected to
+   have an "simd-compatible" alignment, that is 16 bytes on x86 and
+   powerpc CPUs.
+
+   You can allocate such buffers with the functions
+   pffft_aligned_malloc / pffft_aligned_free (or with stuff like
+   posix_memalign..)
+
+*/
+
+#ifndef PFFFT_H
+#define PFFFT_H
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+  /* opaque struct holding internal stuff (precomputed twiddle factors)
+     this struct can be shared by many threads as it contains only
+     read-only data.
+  */
+  typedef struct PFFFT_Setup PFFFT_Setup;
+
+  /* direction of the transform */
+  typedef enum { PFFFT_FORWARD, PFFFT_BACKWARD } pffft_direction_t;
+
+  /* type of transform */
+  typedef enum { PFFFT_REAL, PFFFT_COMPLEX } pffft_transform_t;
+
+  /*
+    prepare for performing transforms of size N -- the returned
+    PFFFT_Setup structure is read-only so it can safely be shared by
+    multiple concurrent threads.
+  */
+  static PFFFT_Setup *pffft_new_setup(int N, pffft_transform_t transform);
+  static void pffft_destroy_setup(PFFFT_Setup *);
+  /*
+     Perform a Fourier transform , The z-domain data is stored in the
+     most efficient order for transforming it back, or using it for
+     convolution. If you need to have its content sorted in the
+     "usual" way, that is as an array of interleaved complex numbers,
+     either use pffft_transform_ordered , or call pffft_zreorder after
+     the forward fft, and before the backward fft.
+
+     Transforms are not scaled: PFFFT_BACKWARD(PFFFT_FORWARD(x)) = N*x.
+     Typically you will want to scale the backward transform by 1/N.
+
+     The 'work' pointer should point to an area of N (2*N for complex
+     fft) floats, properly aligned. [del]If 'work' is NULL, then stack will
+     be used instead (this is probably the beest strategy for small
+     FFTs, say for N < 16384).[/del]
+
+     input and output may alias.
+  */
+  static void pffft_transform(PFFFT_Setup *setup, const float *input, float *output, float *work, pffft_direction_t direction);
+
+  /*
+     Similar to pffft_transform, but makes sure that the output is
+     ordered as expected (interleaved complex numbers).  This is
+     similar to calling pffft_transform and then pffft_zreorder.
+
+     input and output may alias.
+  */
+  static void pffft_transform_ordered(PFFFT_Setup *setup, const float *input, float *output, float *work, pffft_direction_t direction);
+
+  /*
+     call pffft_zreorder(.., PFFFT_FORWARD) after pffft_transform(...,
+     PFFFT_FORWARD) if you want to have the frequency components in
+     the correct "canonical" order, as interleaved complex numbers.
+
+     (for real transforms, both 0-frequency and half frequency
+     components, which are real, are assembled in the first entry as
+     F(0)+i*F(n/2+1). Note that the original fftpack did place
+     F(n/2+1) at the end of the arrays).
+
+     input and output should not alias.
+  */
+  static void pffft_zreorder(PFFFT_Setup *setup, const float *input, float *output, pffft_direction_t direction);
+
+  /*
+     Perform a multiplication of the frequency components of dft_a and
+     dft_b and accumulate them into dft_ab. The arrays should have
+     been obtained with pffft_transform(.., PFFFT_FORWARD) and should
+     *not* have been reordered with pffft_zreorder (otherwise just
+     perform the operation yourself as the dft coefs are stored as
+     interleaved complex numbers).
+
+     the operation performed is: dft_ab += (dft_a * fdt_b)*scaling
+
+     The dft_a, dft_b and dft_ab pointers may alias.
+  void pffft_zconvolve_accumulate(PFFFT_Setup *setup, const float *dft_a, const float *dft_b, float *dft_ab, float scaling);
+  */
+
+  /*
+     the operation performed is: dft_ab = (dft_a * fdt_b)
+
+     The dft_a, dft_b and dft_ab pointers may alias.
+  */
+  static void pffft_zconvolve(PFFFT_Setup *setup, const float *dft_a, const float *dft_b, float *dft_ab);
+
+  /* return 4 or 1 wether support SSE/Altivec instructions was enable when building pffft.c */
+  int pffft_simd_size(void);
+
+  static void pffft_reorder_back(int length, void * setup, float * data, float * work);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/lib-src/libsoxr/src/pffft32.c
+++ b/lib-src/libsoxr/src/pffft32.c
@@ -0,0 +1,30 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+#define PFFFT_SIMD_DISABLE
+#include "pffft.c"
+#include "filter.h"
+
+static void * setup(int len) {return pffft_new_setup(len, PFFFT_REAL);}
+static void delete_setup(void * setup) {pffft_destroy_setup(setup);}
+static void forward  (int length, void * setup, float * h, float * scratch) {pffft_transform        (setup, h, h, scratch, PFFFT_FORWARD); (void)length;}
+static void oforward (int length, void * setup, float * h, float * scratch) {pffft_transform_ordered(setup, h, h, scratch, PFFFT_FORWARD); (void)length;}
+static void backward (int length, void * setup, float * H, float * scratch) {pffft_transform        (setup, H, H, scratch, PFFFT_BACKWARD);(void)length;}
+static void obackward(int length, void * setup, float * H, float * scratch) {pffft_transform_ordered(setup, H, H, scratch, PFFFT_BACKWARD);(void)length;}
+static void convolve(int length, void * setup, float * H, float const * with) { pffft_zconvolve(setup, H, with, H);  (void)length;}
+static int multiplier(void) {return 1;}
+
+typedef void (* fn_t)(void);
+fn_t _soxr_rdft32_cb[] = {
+  (fn_t)setup,
+  (fn_t)setup,
+  (fn_t)delete_setup,
+  (fn_t)forward,
+  (fn_t)oforward,
+  (fn_t)backward,
+  (fn_t)obackward,
+  (fn_t)convolve,
+  (fn_t)_soxr_ordered_partial_convolve_f,
+  (fn_t)multiplier,
+  (fn_t)pffft_reorder_back,
+};
--- a/lib-src/libsoxr/src/pffft32s.c
+++ b/lib-src/libsoxr/src/pffft32s.c
@@ -0,0 +1,27 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+#include "pffft.c"
+
+static void * setup(int len) {return pffft_new_setup(len, PFFFT_REAL);}
+static void forward  (int length, void * setup, float * h, float * scratch) {pffft_transform        (setup, h, h, scratch, PFFFT_FORWARD); (void)length;}
+static void oforward (int length, void * setup, float * h, float * scratch) {pffft_transform_ordered(setup, h, h, scratch, PFFFT_FORWARD); (void)length;}
+static void backward (int length, void * setup, float * H, float * scratch) {pffft_transform        (setup, H, H, scratch, PFFFT_BACKWARD);(void)length;}
+static void obackward(int length, void * setup, float * H, float * scratch) {pffft_transform_ordered(setup, H, H, scratch, PFFFT_BACKWARD);(void)length;}
+static void convolve(int length, void * setup, float * H, float const * with) { pffft_zconvolve(setup, H, with, H);                  (void)length;}
+static int multiplier(void) {return 1;}
+
+typedef void (* fn_t)(void);
+fn_t _soxr_rdft32s_cb[] = {
+  (fn_t)setup,
+  (fn_t)setup,
+  (fn_t)pffft_destroy_setup,
+  (fn_t)forward,
+  (fn_t)oforward,
+  (fn_t)backward,
+  (fn_t)obackward,
+  (fn_t)convolve,
+  (fn_t)_soxr_ordered_partial_convolve_simd,
+  (fn_t)multiplier,
+  (fn_t)pffft_reorder_back,
+};
--- a/lib-src/libsoxr/src/poly-fir.h
+++ b/lib-src/libsoxr/src/poly-fir.h
@@ -0,0 +1,98 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+/* Resample using an interpolated poly-phase FIR with length LEN.*/
+/* Input must be followed by LEN-1 samples. */
+
+#define a (coef(p->shared->poly_fir_coefs, COEF_INTERP, FIR_LENGTH, phase, 0,j))
+#define b (coef(p->shared->poly_fir_coefs, COEF_INTERP, FIR_LENGTH, phase, 1,j))
+#define c (coef(p->shared->poly_fir_coefs, COEF_INTERP, FIR_LENGTH, phase, 2,j))
+#define d (coef(p->shared->poly_fir_coefs, COEF_INTERP, FIR_LENGTH, phase, 3,j))
+#if COEF_INTERP == 0
+  #define _ sum += a *in[j], ++j;
+#elif COEF_INTERP == 1
+  #define _ sum += (b *x + a)*in[j], ++j;
+#elif COEF_INTERP == 2
+  #define _ sum += ((c *x + b)*x + a)*in[j], ++j;
+#elif COEF_INTERP == 3
+  #define _ sum += (((d*x + c)*x + b)*x + a)*in[j], ++j;
+#else
+  #error COEF_INTERP
+#endif
+
+static void FUNCTION(stage_t * p, fifo_t * output_fifo)
+{
+  sample_t const * input = stage_read_p(p);
+  int i, num_in = stage_occupancy(p), max_num_out = 1 + (int)(num_in*p->out_in_ratio);
+  sample_t * output = fifo_reserve(output_fifo, max_num_out);
+
+#if defined HI_PREC_CLOCK
+#if FLOAT_HI_PREC_CLOCK
+  if (p->use_hi_prec_clock) {
+    float_step_t at = p->at.flt;
+    for (i = 0; (int)at < num_in; ++i, at += p->step.flt) {
+      sample_t const * in = input + (int)at;
+      float_step_t frac = at - (int)at;
+      int phase = (int)(frac * (1 << PHASE_BITS));
+#if COEF_INTERP > 0
+      sample_t x = (sample_t)(frac * (1 << PHASE_BITS) - phase);
+#endif
+      sample_t sum = 0;
+      int j = 0;
+      CONVOLVE
+      output[i] = sum;
+    }
+    fifo_read(&p->fifo, (int)at, NULL);
+    p->at.flt = at - (int)at;
+  } else
+#else
+  if (p->use_hi_prec_clock) {
+    for (i = 0; p->at.integer < num_in; ++i,
+        p->at.fix.ls.all += p->step.fix.ls.all,
+        p->at.whole += p->step.whole + (p->at.fix.ls.all < p->step.fix.ls.all)) {
+      sample_t const * in = input + p->at.integer;
+      uint32_t frac = p->at.fraction;
+      int phase = (int)(frac >> (32 - PHASE_BITS)); /* high-order bits */
+#if COEF_INTERP > 0              /* low-order bits, scaled to [0,1) */
+      sample_t x = (sample_t)((frac << PHASE_BITS) * (1 / MULT32));
+#endif
+      sample_t sum = 0;
+      int j = 0;
+      CONVOLVE
+      output[i] = sum;
+    }
+    fifo_read(&p->fifo, p->at.integer, NULL);
+    p->at.integer = 0;
+  } else
+#endif
+#endif
+  {
+    for (i = 0; p->at.integer < num_in; ++i, p->at.whole += p->step.whole) {
+      sample_t const * in = input + p->at.integer;
+      uint32_t frac = p->at.fraction;
+      int phase = (int)(frac >> (32 - PHASE_BITS)); /* high-order bits */
+#if COEF_INTERP > 0              /* low-order bits, scaled to [0,1) */
+      sample_t x = (sample_t)((frac << PHASE_BITS) * (1 / MULT32));
+#endif
+      sample_t sum = 0;
+      int j = 0;
+      CONVOLVE
+      output[i] = sum;
+    }
+    fifo_read(&p->fifo, p->at.integer, NULL);
+    p->at.integer = 0;
+  }
+  assert(max_num_out - i >= 0);
+  fifo_trim_by(output_fifo, max_num_out - i);
+}
+
+#undef _
+#undef a
+#undef b
+#undef c
+#undef d
+#undef COEF_INTERP
+#undef CONVOLVE
+#undef FIR_LENGTH
+#undef FUNCTION
+#undef PHASE_BITS
--- a/lib-src/libsoxr/src/poly-fir0.h
+++ b/lib-src/libsoxr/src/poly-fir0.h
@@ -0,0 +1,34 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+/* Resample using a non-interpolated poly-phase FIR with length LEN.*/
+/* Input must be followed by LEN-1 samples. */
+
+#define _ sum += (coef(p->shared->poly_fir_coefs, 0, FIR_LENGTH, divided.rem, 0, j)) *at[j], ++j;
+
+static void FUNCTION(stage_t * p, fifo_t * output_fifo)
+{
+  sample_t const * input = stage_read_p(p);
+  int i, num_in = stage_occupancy(p), max_num_out = 1 + (int)(num_in*p->out_in_ratio);
+  sample_t * output = fifo_reserve(output_fifo, max_num_out);
+  div_t divided2;
+
+  for (i = 0; p->at.integer < num_in * p->L; ++i, p->at.integer += p->step.integer) {
+    div_t divided = div(p->at.integer, p->L);
+    sample_t const * at = input + divided.quot;
+    sample_t sum = 0;
+    int j = 0;
+    CONVOLVE
+    output[i] = sum;
+  }
+  assert(max_num_out - i >= 0);
+  fifo_trim_by(output_fifo, max_num_out - i);
+  divided2 = div(p->at.integer, p->L);
+  fifo_read(&p->fifo, divided2.quot, NULL);
+  p->at.integer = divided2.rem;
+}
+
+#undef _
+#undef CONVOLVE
+#undef FIR_LENGTH
+#undef FUNCTION
--- a/lib-src/libsoxr/src/rate.h
+++ b/lib-src/libsoxr/src/rate.h
@@ -0,0 +1,732 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+#include <math.h>
+#include <assert.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "filter.h"
+#include "internal.h"
+
+extern struct {
+  void * (* forward_setup)(int);
+  void * (* backward_setup)(int);
+  void (* delete_setup)(void *);
+  void (* forward)(int, void *, sample_t *, sample_t *);
+  void (* oforward)(int, void *, sample_t *, sample_t *);
+  void (* backward)(int, void *, sample_t *, sample_t *);
+  void (* obackward)(int, void *, sample_t *, sample_t *);
+  void (* convolve)(int, void *, sample_t *, sample_t const *);
+  void (* convolve_portion)(int, sample_t *, sample_t const *);
+  int (* multiplier)(void);
+  void (* reorder_back)(int, void *, sample_t *, sample_t *);
+} RDFT_CB;
+
+#define rdft_forward_setup (*RDFT_CB.forward_setup)
+#define rdft_backward_setup (*RDFT_CB.backward_setup)
+#define rdft_delete_setup (*RDFT_CB.delete_setup)
+#define rdft_forward (*RDFT_CB.forward)
+#define rdft_oforward (*RDFT_CB.oforward)
+#define rdft_backward (*RDFT_CB.backward)
+#define rdft_obackward (*RDFT_CB.obackward)
+#define rdft_convolve (*RDFT_CB.convolve)
+#define rdft_convolve_portion (*RDFT_CB.convolve_portion)
+#define rdft_multiplier (*RDFT_CB.multiplier)
+#define rdft_reorder_back (*RDFT_CB.reorder_back)
+
+#if RATE_SIMD /* Align for SIMD: */
+  #include "simd.h"
+#if 0 /* Not using this yet. */
+  #define RATE_SIMD_POLY 1
+  #define num_coefs4 ((num_coefs + 3) & ~3)
+  #define coefs4_check(i) ((i) < num_coefs)
+#else
+  #define RATE_SIMD_POLY 0
+  #define num_coefs4 num_coefs
+  #define coefs4_check(i) 1
+#endif
+
+  #define aligned_free    _soxr_simd_aligned_free
+  #define aligned_malloc  _soxr_simd_aligned_malloc
+  #define aligned_calloc  _soxr_simd_aligned_calloc
+#if 0
+  #define FIFO_REALLOC    aligned_realloc
+  #define FIFO_MALLOC     aligned_malloc
+  #define FIFO_FREE       aligned_free
+
+  static void * aligned_realloc(void * q, size_t nb_bytes, size_t copy_bytes) {
+    void * p = aligned_malloc(nb_bytes);
+    if (p) memcpy(p, q, copy_bytes);
+    aligned_free(q);
+    return p;
+  }
+#endif
+#else
+  #define RATE_SIMD_POLY 0
+  #define num_coefs4 num_coefs
+  #define coefs4_check(i) 1
+
+  #define aligned_free    free
+  #define aligned_malloc  malloc
+  #define aligned_calloc  calloc
+#endif
+
+#define  FIFO_SIZE_T int
+#include "fifo.h"
+
+typedef union { /* Int64 in parts */
+  #if WORDS_BIGENDIAN
+  struct {int32_t ms; uint32_t ls;} parts;
+  #else
+  struct {uint32_t ls; int32_t ms;} parts;
+  #endif
+  int64_t all;
+} int64p_t;
+
+typedef union { /* Uint64 in parts */
+  #if WORDS_BIGENDIAN
+  struct {uint32_t ms, ls;} parts;
+  #else
+  struct {uint32_t ls, ms;} parts;
+  #endif
+  uint64_t all;
+} uint64p_t;
+
+#define FLOAT_HI_PREC_CLOCK 0    /* Non-float hi-prec has ~96 bits. */
+#define float_step_t long double /* __float128 is also a (slow) option */
+
+#define coef(coef_p, interp_order, fir_len, phase_num, coef_interp_num, fir_coef_num) coef_p[(fir_len) * ((interp_order) + 1) * (phase_num) + ((interp_order) + 1) * (fir_coef_num) + (interp_order - coef_interp_num)]
+
+#define raw_coef_t double
+
+static sample_t * prepare_coefs(raw_coef_t const * coefs, int num_coefs,
+    int num_phases, int interp_order, double multiplier)
+{
+  int i, j, length = num_coefs4 * num_phases;
+  sample_t * result = malloc((size_t)(length * (interp_order + 1)) * sizeof(*result));
+  double fm1 = coefs[0], f1 = 0, f2 = 0;
+
+  for (i = num_coefs4 - 1; i >= 0; --i)
+    for (j = num_phases - 1; j >= 0; --j) {
+      double f0 = fm1, b = 0, c = 0, d = 0; /* = 0 to kill compiler warning */
+      int pos = i * num_phases + j - 1;
+      fm1 = coefs4_check(i) && pos > 0 ? coefs[pos - 1] * multiplier : 0;
+      switch (interp_order) {
+        case 1: b = f1 - f0; break;
+        case 2: b = f1 - (.5 * (f2+f0) - f1) - f0; c = .5 * (f2+f0) - f1; break;
+        case 3: c=.5*(f1+fm1)-f0;d=(1/6.)*(f2-f1+fm1-f0-4*c);b=f1-f0-d-c; break;
+        default: if (interp_order) assert(0);
+      }
+      #define coef_coef(x) \
+        coef(result, interp_order, num_coefs4, j, x, num_coefs4 - 1 - i)
+      coef_coef(0) = (sample_t)f0;
+      if (interp_order > 0) coef_coef(1) = (sample_t)b;
+      if (interp_order > 1) coef_coef(2) = (sample_t)c;
+      if (interp_order > 2) coef_coef(3) = (sample_t)d;
+      #undef coef_coef
+      f2 = f1, f1 = f0;
+    }
+  return result;
+}
+
+typedef struct {
+  int        dft_length, num_taps, post_peak;
+  void       * dft_forward_setup, * dft_backward_setup;
+  sample_t   * coefs;
+} dft_filter_t;
+
+typedef struct { /* So generated filter coefs may be shared between channels */
+  sample_t   * poly_fir_coefs;
+  dft_filter_t dft_filter[2];
+} rate_shared_t;
+
+typedef enum {
+  irrational_stage = 1,
+  cubic_stage,
+  dft_stage,
+  half_stage,
+  rational_stage
+} stage_type_t;
+
+struct stage;
+typedef void (* stage_fn_t)(struct stage * input, fifo_t * output);
+#define MULT32 (65536. * 65536.)
+
+typedef union { /* Fixed point arithmetic */
+  struct {uint64p_t ls; int64p_t ms;} fix;
+  float_step_t flt;
+} step_t;
+
+typedef struct stage {
+  /* Common to all stage types: */
+  stage_type_t type;
+  stage_fn_t fn;
+  fifo_t     fifo;
+  int        pre;       /* Number of past samples to store */
+  int        pre_post;  /* pre + number of future samples to store */
+  int        preload;   /* Number of zero samples to pre-load the fifo */
+  double     out_in_ratio; /* For buffer management. */
+
+  /* For a stage with variable (run-time generated) filter coefs: */
+  rate_shared_t * shared;
+  unsigned   dft_filter_num; /* Which, if any, of the 2 DFT filters to use */
+  sample_t   * dft_scratch, * dft_out;
+
+  /* For a stage with variable L/M: */
+  step_t     at, step;
+  bool       use_hi_prec_clock;
+  int        L, remM;
+  int        n, phase_bits, block_len;
+  double     mult, phase0;
+} stage_t;
+
+#define stage_occupancy(s) max(0, fifo_occupancy(&(s)->fifo) - (s)->pre_post)
+#define stage_read_p(s) ((sample_t *)fifo_read_ptr(&(s)->fifo) + (s)->pre)
+
+static void cubic_stage_fn(stage_t * p, fifo_t * output_fifo)
+{
+  int i, num_in = stage_occupancy(p), max_num_out = 1 + (int)(num_in*p->out_in_ratio);
+  sample_t const * input = stage_read_p(p);
+  sample_t * output = fifo_reserve(output_fifo, max_num_out);
+
+#define integer  fix.ms.parts.ms
+#define fraction fix.ms.parts.ls
+#define whole    fix.ms.all
+  for (i = 0; p->at.integer < num_in; ++i, p->at.whole += p->step.whole) {
+    sample_t const * s = input + p->at.integer;
+    double x = p->at.fraction * (1 / MULT32);
+    double b = .5*(s[1]+s[-1])-*s, a = (1/6.)*(s[2]-s[1]+s[-1]-*s-4*b);
+    double c = s[1]-*s-a-b;
+    output[i] = (sample_t)(p->mult * (((a*x + b)*x + c)*x + *s));
+  }
+  assert(max_num_out - i >= 0);
+  fifo_trim_by(output_fifo, max_num_out - i);
+  fifo_read(&p->fifo, p->at.integer, NULL);
+  p->at.integer = 0;
+}
+
+#if RATE_SIMD
+  #define dft_out p->dft_out
+#else
+  #define dft_out output
+#endif
+
+static void dft_stage_fn(stage_t * p, fifo_t * output_fifo)
+{
+  sample_t * output;
+  int i, j, num_in = max(0, fifo_occupancy(&p->fifo));
+  rate_shared_t const * s = p->shared;
+  dft_filter_t const * f = &s->dft_filter[p->dft_filter_num];
+  int const overlap = f->num_taps - 1;
+
+  while (p->at.integer + p->L * num_in >= f->dft_length) {
+    div_t divd = div(f->dft_length - overlap - p->at.integer + p->L - 1, p->L);
+    sample_t const * input = fifo_read_ptr(&p->fifo);
+    fifo_read(&p->fifo, divd.quot, NULL);
+    num_in -= divd.quot;
+
+    output = fifo_reserve(output_fifo, f->dft_length);
+
+    if (lsx_is_power_of_2(p->L)) { /* F-domain */
+      int portion = f->dft_length / p->L;
+      memcpy(dft_out, input, (unsigned)portion * sizeof(*dft_out));
+      rdft_oforward(portion, f->dft_forward_setup, dft_out, p->dft_scratch);
+      for (i = portion + 2; i < (portion << 1); i += 2) /* Mirror image. */
+        dft_out[i] = dft_out[(portion << 1) - i],
+        dft_out[i+1] = -dft_out[(portion << 1) - i + 1];
+      dft_out[portion] = dft_out[1];
+      dft_out[portion + 1] = 0;
+      dft_out[1] = dft_out[0];
+
+      for (portion <<= 1; i < f->dft_length; i += portion, portion <<= 1) {
+        memcpy(dft_out + i, dft_out, (size_t)portion * sizeof(*dft_out));
+        dft_out[i + 1] = 0;
+      }
+      if (p->step.integer > 0)
+        rdft_reorder_back(f->dft_length, f->dft_backward_setup, dft_out, p->dft_scratch);
+    } else {
+      if (p->L == 1)
+        memcpy(dft_out, input, (size_t)f->dft_length * sizeof(*dft_out));
+      else {
+        memset(dft_out, 0, (size_t)f->dft_length * sizeof(*dft_out));
+        for (j = 0, i = p->at.integer; i < f->dft_length; ++j, i += p->L)
+          dft_out[i] = input[j];
+        p->at.integer = p->L - 1 - divd.rem;
+      }
+      if (p->step.integer > 0)
+        rdft_forward(f->dft_length, f->dft_forward_setup, dft_out, p->dft_scratch);
+      else
+        rdft_oforward(f->dft_length, f->dft_forward_setup, dft_out, p->dft_scratch);
+    }
+
+    if (p->step.integer > 0) {
+      rdft_convolve(f->dft_length, f->dft_backward_setup, dft_out, f->coefs);
+      rdft_backward(f->dft_length, f->dft_backward_setup, dft_out, p->dft_scratch);
+#if RATE_SIMD
+      if (p->step.integer == 1)
+        memcpy(output, dft_out, (size_t)f->dft_length * sizeof(sample_t));
+#endif
+      if (p->step.integer != 1) {
+        for (j = 0, i = p->remM; i < f->dft_length - overlap; ++j,
+            i += p->step.integer)
+          output[j] = dft_out[i];
+        p->remM = i - (f->dft_length - overlap);
+        fifo_trim_by(output_fifo, f->dft_length - j);
+      }
+      else fifo_trim_by(output_fifo, overlap);
+    }
+    else { /* F-domain */
+      int m = -p->step.integer;
+      rdft_convolve_portion(f->dft_length >> m, dft_out, f->coefs);
+      rdft_obackward(f->dft_length >> m, f->dft_backward_setup, dft_out, p->dft_scratch);
+#if RATE_SIMD
+      memcpy(output, dft_out, (size_t)(f->dft_length >> m) * sizeof(sample_t));
+#endif
+      fifo_trim_by(output_fifo, (((1 << m) - 1) * f->dft_length + overlap) >>m);
+    }
+  }
+}
+
+#undef dft_out
+
+/* Set to 4 x nearest power of 2 */
+/* or half of that if danger of causing too many cache misses. */
+static int set_dft_length(int num_taps, int min, int large)
+{
+  double d = log((double)num_taps) / log(2.);
+  return 1 << range_limit((int)(d + 2.77), min, max((int)(d + 1.77), large));
+}
+
+static void dft_stage_init(
+    unsigned instance, double Fp, double Fs, double Fn, double att,
+    double phase, stage_t * p, int L, int M, double * multiplier,
+    int min_dft_size, int large_dft_size)
+{
+  dft_filter_t * f = &p->shared->dft_filter[instance];
+  int num_taps = 0, dft_length = f->dft_length, i;
+
+  if (!dft_length) {
+    int k = phase == 50 && lsx_is_power_of_2(L) && Fn == L? L << 1 : 4;
+    double * h = lsx_design_lpf(Fp, Fs, Fn, att, &num_taps, -k, -1.);
+
+    if (phase != 50)
+      lsx_fir_to_phase(&h, &num_taps, &f->post_peak, phase);
+    else f->post_peak = num_taps / 2;
+
+    dft_length = set_dft_length(num_taps, min_dft_size, large_dft_size);
+    f->coefs = aligned_calloc((size_t)dft_length, sizeof(*f->coefs));
+    for (i = 0; i < num_taps; ++i)
+      f->coefs[(i + dft_length - num_taps + 1) & (dft_length - 1)]
+        = (sample_t)(h[i] * ((1. / dft_length) * rdft_multiplier() * L * *multiplier));
+    free(h);
+  }
+
+#if RATE_SIMD
+  p->dft_out = aligned_malloc(sizeof(sample_t) * (size_t)dft_length);
+#endif
+#if 1 /* In fact, currently, only pffft needs this. */
+  p->dft_scratch = aligned_malloc(2 * sizeof(sample_t) * (size_t)dft_length);
+#endif
+
+  if (!f->dft_length) {
+    void * coef_setup = rdft_forward_setup(dft_length);
+    int Lp = lsx_is_power_of_2(L)? L : 1;
+    int Mp = lsx_is_power_of_2(M)? M : 1;
+    f->dft_forward_setup = rdft_forward_setup(dft_length / Lp);
+    f->dft_backward_setup = rdft_backward_setup(dft_length / Mp);
+    if (Mp == 1)
+      rdft_forward(dft_length, coef_setup, f->coefs, p->dft_scratch);
+    else
+      rdft_oforward(dft_length, coef_setup, f->coefs, p->dft_scratch);
+    rdft_delete_setup(coef_setup);
+    f->num_taps = num_taps;
+    f->dft_length = dft_length;
+    lsx_debug("fir_len=%i dft_length=%i Fp=%g Fs=%g Fn=%g att=%g %i/%i",
+        num_taps, dft_length, Fp, Fs, Fn, att, L, M);
+  }
+  *multiplier = 1;
+  p->out_in_ratio = (double)L / M;
+  p->type = dft_stage;
+  p->fn = dft_stage_fn;
+  p->preload = f->post_peak / L;
+  p->at.integer    = f->post_peak % L;
+  p->L = L;
+  p->step.integer = abs(3-M) == 1 && Fs == 1 && 1? -M/2 : M;
+  p->dft_filter_num = instance;
+  p->block_len = f->dft_length - (f->num_taps - 1);
+  p->phase0 = p->at.integer / p->L;
+}
+
+#include "filters.h"
+
+typedef struct {
+  double     factor;
+  uint64_t   samples_in, samples_out;
+  int        num_stages;
+  stage_t    * stages;
+} rate_t;
+
+#define pre_stage       p->stages[shift]
+#define arb_stage       p->stages[shift + have_pre_stage]
+#define post_stage      p->stages[shift + have_pre_stage + have_arb_stage]
+#define have_pre_stage  (preM  * preL  != 1)
+#define have_arb_stage  (arbM  * arbL  != 1)
+#define have_post_stage (postM * postL != 1)
+
+#define TO_3dB(a)       ((1.6e-6*a-7.5e-4)*a+.646)
+#define LOW_Q_BW0_PC    (67 + 5 / 8.)
+
+typedef enum {
+  rolloff_none, rolloff_small /* <= 0.01 dB */, rolloff_medium /* <= 0.35 dB */
+} rolloff_t;
+
+
+static char const * rate_init(
+  /* Private work areas (to be supplied by the client):                       */
+  rate_t * p,                /* Per audio channel.                            */
+  rate_shared_t * shared,    /* Between channels (undergoing same rate change)*/
+
+  /* Public parameters:                                             Typically */
+  double factor,             /* Input rate divided by output rate.            */
+  double bits,               /* Required bit-accuracy (pass + stop)  16|20|28 */
+  double phase,              /* Linear/minimum etc. filter phase.       50    */
+  double bw_pc,              /* Pass-band % (0dB pt.) to preserve.   91.3|98.4*/
+  double anti_aliasing_pc,   /* % bandwidth without aliasing            100   */
+  rolloff_t rolloff,    /* Pass-band roll-off                    small   */
+  bool maintain_3dB_pt,      /*                                        true   */
+  double multiplier,         /* Linear gain to apply during conversion.   1   */
+
+  /* Primarily for test/development purposes:                                 */
+  bool use_hi_prec_clock,    /* Increase irrational ratio accuracy.   false   */
+  int interpolator,          /* Force a particular coef interpolator.   -1    */
+  size_t max_coefs_size,     /* k bytes of coefs to try to keep below.  400   */
+  bool noSmallIntOpt,        /* Disable small integer optimisations.  false   */
+  int log2_min_dft_size,
+  int log2_large_dft_size)
+{
+  double att = (bits + 1) * linear_to_dB(2.), attArb = att;    /* pass + stop */
+  double tbw0 = 1 - bw_pc / 100, Fs_a = 2 - anti_aliasing_pc / 100;
+  double arbM = factor, tbw_tighten = 1;
+  int n = 0, i, preL = 1, preM = 1, shift = 0, arbL = 1, postL = 1, postM = 1;
+  bool upsample = false, rational = false, iOpt = !noSmallIntOpt;
+  int mode = rolloff > rolloff_small? factor > 1 || bw_pc > LOW_Q_BW0_PC:
+    (int)ceil(2 + (bits - 17) / 4);
+  stage_t * s;
+
+  assert(factor > 0);
+  assert(!bits || (15 <= bits && bits <= 33));
+  assert(0 <= phase && phase <= 100);
+  assert(53 <= bw_pc && bw_pc <= 100);
+  assert(85 <= anti_aliasing_pc && anti_aliasing_pc <= 100);
+
+  p->factor = factor;
+  if (bits) while (!n++) {                               /* Determine stages: */
+    int try, L, M, x, maxL = interpolator > 0? 1 : mode? 2048 :
+      (int)ceil(DBL max_coefs_size * 1000. / (U100_l * sizeof(sample_t)));
+    double d, epsilon = 0, frac;
+    upsample = arbM < 1;
+    for (i = (int)(arbM * .5), shift = 0; i >>= 1; arbM *= .5, ++shift);
+    preM = 1 - (arbM > 2);
+    postM = 1 + (arbM > 1 && arbM < 2), arbM /= postM;
+    preL = 1 + (upsample && mode), arbM *= preL;
+    if ((frac = arbM - (int)arbM))
+      epsilon = fabs((uint32_t)(frac * MULT32 + .5) / (frac * MULT32) - 1);
+    for (i = 1, rational = !frac; i <= maxL && !rational; ++i) {
+      d = frac * i, try = (int)(d + .5);
+      if ((rational = fabs(try / d - 1) <= epsilon)) {    /* No long doubles! */
+        if (try == i)
+          arbM = ceil(arbM), shift += arbM > 2, arbM /= 1 + (arbM > 2);
+        else arbM = i * (int)arbM + try, arbL = i;
+      }
+    }
+    L = preL * arbL, M = (int)(arbM * postM), x = (L|M)&1, L >>= !x, M >>= !x;
+    if (iOpt && postL == 1 && (d = preL * arbL / arbM) > 4 && d != 5) {
+      for (postL = 4, i = (int)(d / 16); (i >>= 1) && postL < 256; postL <<= 1);
+      arbM = arbM * postL / arbL / preL, arbL = 1, n = 0;
+    } else if (rational && (max(L, M) < 3 + 2 * iOpt || L * M < 6 * iOpt))
+      preL = L, preM = M, arbM = arbL = postM = 1;
+    if (!mode && (!rational || !n))
+      ++mode, n = 0;
+  }
+
+  p->num_stages = shift + have_pre_stage + have_arb_stage + have_post_stage;
+  if (!p->num_stages && multiplier != 1) {
+    arbL = 0;
+    ++p->num_stages;
+  }
+  p->stages = calloc((size_t)p->num_stages + 1, sizeof(*p->stages));
+  for (i = 0; i < p->num_stages; ++i)
+    p->stages[i].shared = shared;
+
+  if ((n = p->num_stages) > 1) {                              /* Att. budget: */
+    if (have_arb_stage)
+      att += linear_to_dB(2.), attArb = att, --n;
+    att += linear_to_dB((double)n);
+  }
+
+  for (n = 0; (size_t)n + 1 < array_length(half_firs) && att > half_firs[n].att; ++n);
+  for (i = 0, s = p->stages; i < shift; ++i, ++s) {
+    s->type = half_stage;
+    s->fn = half_firs[n].fn;
+    s->pre_post = 4 * half_firs[n].num_coefs;
+    s->preload = s->pre = s->pre_post >> 1;
+  }
+
+  if (have_pre_stage) {
+    if (maintain_3dB_pt && have_post_stage) {    /* Trans. bands overlapping. */
+      double tbw3 = tbw0 * TO_3dB(att);                /* FFS: consider Fs_a. */
+      double x = ((2.1429e-4 - 5.2083e-7 * att) * att - .015863) * att + 3.95;
+      x = att * pow((tbw0 - tbw3) / (postM / (factor * postL) - 1 + tbw0), x);
+      if (x > .035) {
+        tbw_tighten = ((4.3074e-3 - 3.9121e-4 * x) * x - .040009) * x + 1.0014;
+        lsx_debug("x=%g tbw_tighten=%g", x, tbw_tighten);
+      }
+    }
+    dft_stage_init(0, 1 - tbw0 * tbw_tighten, Fs_a, preM? max(preL, preM) :
+        arbM / arbL, att, phase, &pre_stage, preL, max(preM, 1), &multiplier,
+        log2_min_dft_size, log2_large_dft_size);
+  }
+
+  if (!bits && have_arb_stage) {                /* Quick and dirty arb stage: */
+    arb_stage.type = cubic_stage;
+    arb_stage.fn = cubic_stage_fn;
+    arb_stage.mult = multiplier, multiplier = 1;
+    arb_stage.step.whole = (int64_t)(arbM * MULT32 + .5);
+    arb_stage.pre_post = max(3, arb_stage.step.integer);
+    arb_stage.preload = arb_stage.pre = 1;
+    arb_stage.out_in_ratio = MULT32 / (double)arb_stage.step.whole;
+  }
+  else if (have_arb_stage) {                     /* Higher quality arb stage: */
+    poly_fir_t const * f = &poly_firs[6*(upsample + !!preM) + mode - !upsample];
+    int order, num_coefs = (int)f->interp[0].scalar, phase_bits, phases;
+    size_t coefs_size;
+    double x = .5, at, Fp, Fs, Fn, mult = upsample? 1 : arbL / arbM;
+    poly_fir1_t const * f1;
+
+    Fn = !upsample && preM? x = arbM / arbL : 1;
+    Fp = !preM? mult : mode? .5 : 1;
+    Fs = 2 - Fp;           /* Ignore Fs_a; it would have little benefit here. */
+    Fp *= 1 - tbw0;
+    if (rolloff > rolloff_small && mode)
+      Fp = !preM? mult * .5 - .125 : mult * .05 + .1;
+    else if (rolloff == rolloff_small)
+      Fp = Fs - (Fs - .148 * x - Fp * .852) * (.00813 * bits + .973);
+
+    i = (interpolator < 0? !rational : max(interpolator, !rational)) - 1;
+    do {
+      f1 = &f->interp[++i];
+      assert(f1->fn);
+      if (i)
+        arbM /= arbL, arbL = 1, rational = false;
+      phase_bits = (int)ceil(f1->scalar + log(mult)/log(2.));
+      phases = !rational? (1 << phase_bits) : arbL;
+      if (!f->interp[0].scalar) {
+        int phases0 = max(phases, 19), n0 = 0;
+        lsx_design_lpf(Fp, Fs, -Fn, attArb, &n0, phases0, f->beta);
+        num_coefs = n0 / phases0 + 1, num_coefs += num_coefs & !preM;
+      }
+      if ((num_coefs & 1) && rational && (arbL & 1))
+        phases <<= 1, arbL <<= 1, arbM *= 2;
+      at = arbL * (arb_stage.phase0 = .5 * (num_coefs & 1));
+      order = i + (i && mode > 4);
+      coefs_size = (size_t)(num_coefs4 * phases * (order + 1)) * sizeof(sample_t);
+    } while (interpolator < 0 && i < 2 && f->interp[i+1].fn &&
+        coefs_size / 1000 > max_coefs_size);
+
+    if (!arb_stage.shared->poly_fir_coefs) {
+      int num_taps = num_coefs * phases - 1;
+      raw_coef_t * coefs = lsx_design_lpf(
+          Fp, Fs, Fn, attArb, &num_taps, phases, f->beta);
+      arb_stage.shared->poly_fir_coefs = prepare_coefs(
+          coefs, num_coefs, phases, order, multiplier);
+      lsx_debug("fir_len=%i phases=%i coef_interp=%i size=%.3gk",
+          num_coefs, phases, order, DBL coefs_size / 1000.);
+      free(coefs);
+    }
+    multiplier = 1;
+    arb_stage.type = rational? rational_stage : irrational_stage;
+    arb_stage.fn = f1->fn;
+    arb_stage.pre_post = num_coefs4 - 1;
+    arb_stage.preload = ((num_coefs - 1) >> 1) + (num_coefs4 - num_coefs);
+    arb_stage.n = num_coefs4;
+    arb_stage.phase_bits = phase_bits;
+    arb_stage.L = arbL;
+    arb_stage.use_hi_prec_clock = mode > 1 && use_hi_prec_clock && !rational;
+#if FLOAT_HI_PREC_CLOCK
+    if (arb_stage.use_hi_prec_clock) {
+      arb_stage.at.flt = at;
+      arb_stage.step.flt = arbM;
+      arb_stage.out_in_ratio = (double)(arbL / arb_stage.step.flt);
+    } else
+#endif
+    {
+      arb_stage.at.whole = (int64_t)(at * MULT32 + .5);
+#if !FLOAT_HI_PREC_CLOCK
+      if (arb_stage.use_hi_prec_clock) {
+        arb_stage.at.fix.ls.parts.ms = 0x80000000ul;
+        arbM *= MULT32;
+        arb_stage.step.whole = (int64_t)arbM;
+        arbM -= (double)arb_stage.step.whole;
+        arbM *= MULT32 * MULT32;
+        arb_stage.step.fix.ls.all = (uint64_t)arbM;
+      } else
+#endif
+        arb_stage.step.whole = (int64_t)(arbM * MULT32 + .5);
+      arb_stage.out_in_ratio = MULT32 * arbL / (double)arb_stage.step.whole;
+    }
+  }
+
+  if (have_post_stage)
+    dft_stage_init(1, 1 - (1 - (1 - tbw0) *
+        (upsample? factor * postL / postM : 1)) * tbw_tighten, Fs_a,
+        (double)max(postL, postM), att, phase, &post_stage, postL, postM,
+        &multiplier, log2_min_dft_size, log2_large_dft_size);
+
+
+  lsx_debug("%g: »%i⋅%i/%i⋅%i/%g⋅%i/%i",
+      1/factor, shift, preL, preM, arbL, arbM, postL, postM);
+  for (i = 0, s = p->stages; i < p->num_stages; ++i, ++s) {
+    fifo_create(&s->fifo, (int)sizeof(sample_t));
+    memset(fifo_reserve(&s->fifo, s->preload), 0, sizeof(sample_t) * (size_t)s->preload);
+    lsx_debug("%5i|%-5i preload=%i remL=%i o/i=%g",
+        s->pre, s->pre_post - s->pre, s->preload, s->at.integer, s->out_in_ratio);
+  }
+  fifo_create(&s->fifo, (int)sizeof(sample_t));
+  return 0;
+}
+
+static void rate_process(rate_t * p)
+{
+  stage_t * stage = p->stages;
+  int i;
+  for (i = 0; i < p->num_stages; ++i, ++stage)
+    stage->fn(stage, &(stage+1)->fifo);
+}
+
+static sample_t * rate_input(rate_t * p, sample_t const * samples, size_t n)
+{
+  fifo_t * fifo = &p->stages[0].fifo;
+  p->samples_in += n;
+  return fifo_write(fifo, (int)n, samples);
+}
+
+static sample_t const * rate_output(rate_t * p, sample_t * samples, size_t * n)
+{
+  fifo_t * fifo = &p->stages[p->num_stages].fifo;
+  p->samples_out += *n = min(*n, (size_t)fifo_occupancy(fifo));
+  return fifo_read(fifo, (int)*n, samples);
+}
+
+static void rate_flush(rate_t * p)
+{
+  fifo_t * fifo = &p->stages[p->num_stages].fifo;
+#if defined _MSC_VER && _MSC_VER == 1200
+  uint64_t samples_out = (uint64_t)(int64_t)((double)(int64_t)p->samples_in / p->factor + .5);
+#else
+  uint64_t samples_out = (uint64_t)((double)p->samples_in / p->factor + .5);
+#endif
+  size_t remaining = (size_t)(samples_out - p->samples_out), idone;
+  sample_t * buff = calloc(1024, sizeof(*buff));
+
+  if ((int)remaining > 0) {
+    while ((size_t)fifo_occupancy(fifo) < remaining) {
+      idone = 1024;
+      rate_input(p, buff, idone);
+      rate_process(p);
+    }
+    fifo_trim_to(fifo, (int)remaining);
+    p->samples_in = 0;
+  }
+  free(buff);
+}
+
+static void rate_close(rate_t * p)
+{
+  rate_shared_t * shared = p->stages[0].shared;
+  int i;
+
+  for (i = 0; i <= p->num_stages; ++i) {
+    stage_t * s = &p->stages[i];
+    aligned_free(s->dft_scratch);
+    aligned_free(s->dft_out);
+    fifo_delete(&s->fifo);
+  }
+  if (shared) {
+    for (i = 0; i < 2; ++i) {
+      dft_filter_t * f= &shared->dft_filter[i];
+      aligned_free(f->coefs);
+      rdft_delete_setup(f->dft_forward_setup);
+      rdft_delete_setup(f->dft_backward_setup);
+    }
+    free(shared->poly_fir_coefs);
+    memset(shared, 0, sizeof(*shared));
+  }
+  free(p->stages);
+}
+
+#if defined SOXR_LIB
+static double rate_delay(rate_t * p)
+{
+#if defined _MSC_VER && _MSC_VER == 1200
+  double samples_out = (double)(int64_t)p->samples_in / p->factor;
+  return samples_out - (double)(int64_t)p->samples_out;
+#else
+  double samples_out = (double)p->samples_in / p->factor;
+  return samples_out - (double)p->samples_out;
+#endif
+}
+
+static void rate_sizes(size_t * shared, size_t * channel)
+{
+  *shared = sizeof(rate_shared_t);
+  *channel = sizeof(rate_t);
+}
+
+#include "soxr.h"
+
+static char const * rate_create(
+    void * channel,
+    void * shared,
+    double oi_ratio,
+    soxr_quality_spec_t * q_spec,
+    soxr_runtime_spec_t * r_spec,
+    double scale)
+{
+  return rate_init(
+      channel, shared,
+      1 / oi_ratio,
+      q_spec->bits,
+      q_spec->phase,
+      q_spec->bw_pc,
+      q_spec->anti_aliasing_pc,
+      "\1\2\0"[q_spec->flags & 3],
+      !!(q_spec->flags & SOXR_MAINTAIN_3DB_PT),
+      scale,
+      !!(q_spec->flags & SOXR_HI_PREC_CLOCK),
+      (int)(r_spec->flags & 3) - 1,
+      r_spec->coef_size_kbytes,
+      !!(r_spec->flags & SOXR_NOSMALLINTOPT),
+      (int)r_spec->log2_min_dft_size,
+      (int)r_spec->log2_large_dft_size);
+}
+
+static char const * id(void)
+{
+  return RATE_ID;
+}
+
+typedef void (* fn_t)(void);
+fn_t RATE_CB[] = {
+  (fn_t)rate_input,
+  (fn_t)rate_process,
+  (fn_t)rate_output,
+  (fn_t)rate_flush,
+  (fn_t)rate_close,
+  (fn_t)rate_delay,
+  (fn_t)rate_sizes,
+  (fn_t)rate_create,
+  0,
+  (fn_t)id,
+};
+#endif
--- a/lib-src/libsoxr/src/rate32.c
+++ b/lib-src/libsoxr/src/rate32.c
@@ -0,0 +1,9 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+#define sample_t   float
+#define RATE_SIMD  0
+#define RDFT_CB    _soxr_rdft32_cb
+#define RATE_CB    _soxr_rate32_cb
+#define RATE_ID    "single-precision"
+#include "rate.h"
--- a/lib-src/libsoxr/src/rate32s.c
+++ b/lib-src/libsoxr/src/rate32s.c
@@ -0,0 +1,9 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+#define sample_t   float
+#define RATE_SIMD  1
+#define RDFT_CB    _soxr_rdft32s_cb
+#define RATE_CB    _soxr_rate32s_cb
+#define RATE_ID    "single-precision-SIMD"
+#include "rate.h"
--- a/lib-src/libsoxr/src/rate64.c
+++ b/lib-src/libsoxr/src/rate64.c
@@ -0,0 +1,9 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+#define sample_t   double
+#define RATE_SIMD  0
+#define RDFT_CB    _soxr_rdft64_cb
+#define RATE_CB    _soxr_rate64_cb
+#define RATE_ID    "double-precision"
+#include "rate.h"
--- a/lib-src/libsoxr/src/rdft.h
+++ b/lib-src/libsoxr/src/rdft.h
@@ -0,0 +1,31 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+void ORDERED_CONVOLVE(int n, void * not_used, DFT_FLOAT * a, const DFT_FLOAT * b)
+{
+  int i;
+  a[0] *= b[0];
+  a[1] *= b[1];
+  for (i = 2; i < n; i += 2) {
+    DFT_FLOAT tmp = a[i];
+    a[i  ] = b[i  ] * tmp - b[i+1] * a[i+1];
+    a[i+1] = b[i+1] * tmp + b[i  ] * a[i+1];
+  }
+  (void)not_used;
+}
+
+void ORDERED_PARTIAL_CONVOLVE(int n, DFT_FLOAT * a, const DFT_FLOAT * b)
+{
+  int i;
+  a[0] *= b[0];
+  for (i = 2; i < n; i += 2) {
+    DFT_FLOAT tmp = a[i];
+    a[i  ] = b[i  ] * tmp - b[i+1] * a[i+1];
+    a[i+1] = b[i+1] * tmp + b[i  ] * a[i+1];
+  }
+  a[1] = b[i] * a[i] - b[i+1] * a[i+1];
+}
+
+#undef ORDERED_CONVOLVE
+#undef ORDERED_PARTIAL_CONVOLVE
+#undef DFT_FLOAT
--- a/lib-src/libsoxr/src/rint-clip.h
+++ b/lib-src/libsoxr/src/rint-clip.h
@@ -0,0 +1,153 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+#if defined DITHER
+
+#define DITHERING (1./32)*(int)(((ran1>>=3)&31)-((ran2>>=3)&31))
+#define DITHER_RAND (seed = 1664525UL * seed + 1013904223UL) >> 3
+#define DITHER_VARS unsigned long ran1 = DITHER_RAND, ran2 = DITHER_RAND
+#define SEED_ARG , unsigned long * seed0
+#define SAVE_SEED *seed0 = seed
+#define COPY_SEED unsigned long seed = *seed0;
+#define COPY_SEED1 unsigned long seed1 = seed
+#define PASS_SEED1 , &seed1
+#define PASS_SEED0 , seed0
+
+#else
+
+#define DITHERING 0
+#define DITHER_VARS
+#define SEED_ARG
+#define SAVE_SEED
+#define COPY_SEED
+#define COPY_SEED1
+#define PASS_SEED1
+#define PASS_SEED0
+
+#endif
+
+
+
+#if defined FE_INVALID && defined FPU_RINT
+static void RINT_CLIP(RINT_T * const dest, FLOATX const * const src,
+    unsigned stride, size_t i, size_t const n, size_t * const clips SEED_ARG)
+{
+  COPY_SEED
+  DITHER_VARS;
+  for (; i < n; ++i) {
+    double d = src[i] + DITHERING;
+    dest[stride * i] = RINT(d);
+    if (fetestexcept(FE_INVALID)) {
+      feclearexcept(FE_INVALID);
+      dest[stride * i] = d > 0? RINT_MAX : -RINT_MAX - 1;
+      ++*clips;
+    }
+  }
+  SAVE_SEED;
+}
+#endif
+
+
+
+static size_t LSX_RINT_CLIP(void * * const dest0, FLOATX const * const src,
+    size_t const n SEED_ARG)
+{
+  size_t i, clips = 0;
+  RINT_T * dest = *dest0;
+  COPY_SEED
+#if defined FE_INVALID && defined FPU_RINT
+#define _ dest[i] = RINT(src[i] + DITHERING), ++i,
+  feclearexcept(FE_INVALID);
+  for (i = 0; i < (n & ~7u);) {
+    COPY_SEED1;
+    DITHER_VARS;
+    _ _ _ _ _ _ _ _ 0;
+    if (fetestexcept(FE_INVALID)) {
+      feclearexcept(FE_INVALID);
+      RINT_CLIP(dest, src, 1, i - 8, i, &clips PASS_SEED1);
+    }
+  }
+  RINT_CLIP(dest, src, 1, i, n, &clips PASS_SEED0);
+#else
+#define _ d = src[i] + DITHERING, dest[i++] = (RINT_T)(d > N - 1? ++clips, (RINT_T)(N - 1) : d < -N? ++clips, (RINT_T)(-N) : RINT(d)),
+  const double N = 1. + RINT_MAX;
+  double d;
+  for (i = 0; i < (n & ~7u);) {
+    DITHER_VARS;
+    _ _ _ _ _ _ _ _ 0;
+  }
+  {
+    DITHER_VARS;
+    for (; i < n; _ 0);
+  }
+#endif
+  SAVE_SEED;
+  *dest0 = dest + n;
+  return clips;
+}
+#undef _
+
+
+
+static size_t LSX_RINT_CLIP_2(void * * dest0, FLOATX const * const * srcs,
+    unsigned const stride, size_t const n SEED_ARG)
+{
+  unsigned j;
+  size_t i, clips = 0;
+  RINT_T * dest = *dest0;
+  COPY_SEED
+#if defined FE_INVALID && defined FPU_RINT
+#define _ dest[stride * i] = RINT(src[i] + DITHERING), ++i,
+  feclearexcept(FE_INVALID);
+  for (j = 0; j < stride; ++j, ++dest) {
+    FLOATX const * const src = srcs[j];
+    for (i = 0; i < (n & ~7u);) {
+      COPY_SEED1;
+      DITHER_VARS;
+      _ _ _ _ _ _ _ _ 0;
+      if (fetestexcept(FE_INVALID)) {
+        feclearexcept(FE_INVALID);
+        RINT_CLIP(dest, src, stride, i - 8, i, &clips PASS_SEED1);
+      }
+    }
+    RINT_CLIP(dest, src, stride, i, n, &clips PASS_SEED0);
+  }
+#else
+#define _ d = src[i] + DITHERING, dest[stride * i++] = (RINT_T)(d > N - 1? ++clips, (RINT_T)(N - 1) : d < -N? ++clips, (RINT_T)(-N) : RINT(d)),
+  const double N = 1. + RINT_MAX;
+  double d;
+  for (j = 0; j < stride; ++j, ++dest) {
+    FLOATX const * const src = srcs[j];
+    for (i = 0; i < (n & ~7u);) {
+      DITHER_VARS;
+      _ _ _ _ _ _ _ _ 0;
+    }
+    {
+      DITHER_VARS;
+      for (; i < n; _ 0);
+    }
+  }
+#endif
+  SAVE_SEED;
+  *dest0 = dest + stride * (n - 1);
+  return clips;
+}
+#undef _
+
+#undef PASS_SEED0
+#undef PASS_SEED1
+#undef COPY_SEED1
+#undef COPY_SEED
+#undef SAVE_SEED
+#undef SEED_ARG
+#undef DITHER_VARS
+#undef DITHERING
+#undef DITHER
+
+#undef RINT_MAX
+#undef RINT_T
+#undef FPU_RINT
+#undef RINT
+#undef RINT_CLIP
+#undef LSX_RINT_CLIP
+#undef LSX_RINT_CLIP_2
--- a/lib-src/libsoxr/src/rint.h
+++ b/lib-src/libsoxr/src/rint.h
@@ -0,0 +1,68 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+#if !defined soxr_rint_included
+#define soxr_rint_included
+
+#include "soxr-config.h"
+
+
+
+#if HAVE_LRINT && LONG_MAX == 2147483647L
+  #include <math.h>
+  #define FPU_RINT32
+  #define rint32 lrint
+#elif defined __GNUC__ && (defined __i386__ || defined __x86_64__)
+  #define FPU_RINT32
+  static __inline int32_t rint32(double input) {
+    int32_t result;
+    __asm__ __volatile__("fistpl %0": "=m"(result): "t"(input): "st");
+    return result;
+  }
+#elif defined __GNUC__ && defined __arm__
+  #define FPU_RINT32
+  static __inline int32_t rint32(double input) {
+    register int32_t result;
+    __asm__ __volatile__ ("ftosid %0, %P1": "=w"(result): "w"(input));
+    return result;
+  }
+#elif defined _MSC_VER && defined _M_IX86
+  #define FPU_RINT32
+  static __inline int32_t rint32(double input) {
+    int32_t result;
+    _asm {
+      fld input
+      fistp result
+    }
+    return result;
+  }
+#else
+  #define rint32(x) (int32_t)((x) < 0? x - .5 : x + .5)
+#endif
+
+
+
+#if defined __GNUC__ && (defined __i386__ || defined __x86_64__)
+  #define FPU_RINT16
+  static __inline int16_t rint16(double input) {
+    int16_t result;
+    __asm__ __volatile__("fistps %0": "=m"(result): "t"(input): "st");
+    return result;
+  }
+#elif defined _MSC_VER && defined _M_IX86
+  #define FPU_RINT16
+  static __inline int16_t rint16(double input) {
+    int16_t result;
+    _asm {
+      fld input
+      fistp result
+    }
+    return result;
+  }
+#else
+  #define rint16(x) (int16_t)floor((x)+.5) /* Is this faster than in rint32? */
+#endif
+
+
+
+#endif
--- a/lib-src/libsoxr/src/samplerate.h
+++ b/lib-src/libsoxr/src/samplerate.h
@@ -0,0 +1 @@
+soxr-lsr.h
--- a/lib-src/libsoxr/src/simd-dev.h
+++ b/lib-src/libsoxr/src/simd-dev.h
@@ -0,0 +1,5 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+#define PFFT_MACROS_ONLY
+#include "pffft.c"
--- a/lib-src/libsoxr/src/simd.c
+++ b/lib-src/libsoxr/src/simd.c
@@ -0,0 +1,84 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+#include <assert.h>
+#include <string.h>
+#include <stdlib.h>
+#include "simd.h"
+#include "simd-dev.h"
+
+#define SIMD_ALIGNMENT (sizeof(float) * 4)
+
+void * _soxr_simd_aligned_malloc(size_t size)
+{
+  char * p1 = 0, * p = malloc(size + SIMD_ALIGNMENT);
+  if (p) {
+    p1 = (char *)((size_t)(p + SIMD_ALIGNMENT) & ~(SIMD_ALIGNMENT - 1));
+    *((void * *)p1 - 1) = p;
+  }
+  return p1;
+}
+
+
+
+void * _soxr_simd_aligned_calloc(size_t nmemb, size_t size)
+{
+  void * p = _soxr_simd_aligned_malloc(nmemb * size);
+  if (p)
+    memset(p, 0, nmemb * size);
+  return p;
+}
+
+
+
+void _soxr_simd_aligned_free(void * p1)
+{
+  if (p1)
+    free(*((void * *)p1 - 1));
+}
+
+
+
+void _soxr_ordered_convolve_simd(int n, void * not_used, float * a, const float * b)
+{
+  int i;
+  float ab0, ab1;
+  v4sf       * /*RESTRICT*/ va = (v4sf       *)a;
+  v4sf const *   RESTRICT   vb = (v4sf const *)b;
+  assert(VALIGNED(a) && VALIGNED(b));
+  ab0 = a[0] * b[0], ab1 = a[1] * b[1];
+  for (i = 0; i < n / 4; i += 2) {
+    v4sf a1r = va[i+0], a1i = va[i+1];
+    v4sf b1r = vb[i+0], b1i = vb[i+1];
+    UNINTERLEAVE2(a1r, a1i, a1r, a1i);
+    UNINTERLEAVE2(b1r, b1i, b1r, b1i);
+    VCPLXMUL(a1r, a1i, b1r, b1i);
+    INTERLEAVE2(a1r, a1i, a1r, a1i);
+    va[i+0] = a1r, va[i+1] = a1i;
+  }
+  a[0] = ab0, a[1] = ab1;
+  (void)not_used;
+}
+
+
+
+void _soxr_ordered_partial_convolve_simd(int n, float * a, const float * b)
+{
+  int i;
+  float ab0;
+  v4sf       * /*RESTRICT*/ va = (v4sf       *)a;
+  v4sf const *   RESTRICT   vb = (v4sf const *)b;
+  assert(VALIGNED(a) && VALIGNED(b));
+  ab0 = a[0] * b[0];
+  for (i = 0; i < n / 4; i += 2) {
+    v4sf a1r = va[i+0], a1i = va[i+1];
+    v4sf b1r = vb[i+0], b1i = vb[i+1];
+    UNINTERLEAVE2(a1r, a1i, a1r, a1i);
+    UNINTERLEAVE2(b1r, b1i, b1r, b1i);
+    VCPLXMUL(a1r, a1i, b1r, b1i);
+    INTERLEAVE2(a1r, a1i, a1r, a1i);
+    va[i+0] = a1r, va[i+1] = a1i;
+  }
+  a[0] = ab0;
+  a[1] = b[n] * a[n] - b[n+1] * a[n+1];
+}
--- a/lib-src/libsoxr/src/simd.h
+++ b/lib-src/libsoxr/src/simd.h
@@ -0,0 +1,16 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+#if !defined simd_included
+#define simd_included
+
+#include <stddef.h>
+
+void * _soxr_simd_aligned_malloc(size_t);
+void * _soxr_simd_aligned_calloc(size_t, size_t);
+void _soxr_simd_aligned_free(void *);
+
+void _soxr_ordered_convolve_simd(int n, void * not_used, float * a, const float * b);
+void _soxr_ordered_partial_convolve_simd(int n, float * a, const float * b);
+
+#endif
--- a/lib-src/libsoxr/src/soxr-lsr.h
+++ b/lib-src/libsoxr/src/soxr-lsr.h
@@ -0,0 +1,78 @@
+/* SoX Resampler Library       Copyright (c) 2007-12 robs@users.sourceforge.net
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+/* Wrapper mostly compatible with `libsamplerate'.
+ * (Libsoxr's native API can be found in soxr.h).  */
+
+#if !defined SAMPLERATE_H
+#define SAMPLERATE_H
+#if defined __cplusplus
+  extern "C" {
+#endif
+
+#if defined SOXR_DLL
+  #if defined soxr_lsr_EXPORTS
+    #define _ __declspec(dllexport)
+  #else
+    #define _ __declspec(dllimport)
+  #endif
+#else
+  #define _
+#endif
+
+typedef float   SRC_SAMPLE;
+#if !defined SOXR_LIB
+enum SRC_SRCTYPE{SRC_SINC_BEST_QUALITY,SRC_SINC_MEDIUM_QUALITY,SRC_SINC_FASTEST,
+                    SRC_ZERO_ORDER_HOLD, SRC_LINEAR};
+typedef int     SRC_SRCTYPE;
+typedef int     SRC_ERROR;
+typedef long    (* src_callback_t)(void *, SRC_SAMPLE * *);
+typedef struct  SRC_STATE SRC_STATE;
+typedef struct  SRC_DATA {
+  SRC_SAMPLE    * data_in, * data_out;
+  long          input_frames, output_frames;
+  long          input_frames_used, output_frames_gen;
+  int           end_of_input;
+  double        src_ratio;
+} SRC_DATA;
+#endif
+_ SRC_STATE *   src_new(SRC_SRCTYPE, int num_channels, SRC_ERROR *);
+_ SRC_ERROR     src_process  (SRC_STATE *, SRC_DATA *);
+_ SRC_ERROR     src_set_ratio(SRC_STATE *, double);
+_ SRC_ERROR     src_reset    (SRC_STATE *);
+_ SRC_ERROR     src_error    (SRC_STATE *);
+_ SRC_STATE *   src_delete   (SRC_STATE *);
+_ SRC_STATE *   src_callback_new(
+                    src_callback_t, SRC_SRCTYPE, int, SRC_ERROR *, void *);
+_ long          src_callback_read(
+                    SRC_STATE *, double src_ratio, long, SRC_SAMPLE *);
+_ SRC_ERROR     src_simple(SRC_DATA *, SRC_SRCTYPE, int);
+_ char const *  src_get_name(SRC_SRCTYPE);
+_ char const *  src_get_description(SRC_SRCTYPE);
+_ char const *  src_get_version(void);
+_ char const *  src_strerror(SRC_ERROR);
+_ int           src_is_valid_ratio(double);
+_ void          src_short_to_float_array(short const *, float *, int);
+_ void          src_float_to_short_array(float const *, short *, int);
+_ void          src_int_to_float_array(int const *, float *, int);
+_ void          src_float_to_int_array(float const *, int *, int);
+
+#undef _
+#if defined __cplusplus
+  }
+#endif
+#endif
--- a/lib-src/libsoxr/src/soxr.c
+++ b/lib-src/libsoxr/src/soxr.c
@@ -0,0 +1,639 @@
+/* SoX Resampler Library      Copyright (c) 2007-12 robs@users.sourceforge.net
+ * Licence for this file: LGPL v2.1                  See LICENCE for details. */
+
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include "soxr.h"
+#include "data-io.h"
+#include "internal.h"
+
+
+
+char const * soxr_version(void)
+{
+  return "libsoxr-" SOXR_VERSION;
+}
+
+
+
+typedef void sample_t; /* float or double */
+
+typedef struct {
+  sample_t * (*  input)(void *, sample_t * samples, size_t   n);
+  void (* process)(void *);
+  sample_t const * (* output)(void *, sample_t * samples, size_t * n);
+  void (* flush)(void *);
+  void (* close)(void *);
+  double (* delay)(void *);
+  void (* sizes)(size_t * shared, size_t * channel);
+  char const * (* create)(void * channel, void * shared, double oi_ratio,
+      soxr_quality_spec_t * q_spec, soxr_runtime_spec_t * r_spec, double scale);
+  void (* set_oi_ratio)(void *, double oi_ratio);
+  char const * (* id)(void);
+} control_block_t;
+
+#define resampler_input (*p->control_block.input)
+#define resampler_process (*p->control_block.process)
+#define resampler_output (*p->control_block.output)
+#define resampler_flush (*p->control_block.flush)
+#define resampler_close (*p->control_block.close)
+#define resampler_delay (*p->control_block.delay)
+#define resampler_sizes (*p->control_block.sizes)
+#define resampler_create (*p->control_block.create)
+#define resampler_set_oi_ratio (*p->control_block.set_oi_ratio)
+#define resampler_id (*p->control_block.id)
+
+
+
+typedef void * resampler_t; /* For one channel. */
+typedef void * resampler_shared_t; /* Between channels. */
+typedef void (* deinterleave_t)(sample_t * * dest,
+    soxr_datatype_t data_type, void const * * src0, size_t n, unsigned ch);
+typedef size_t (* interleave_t)(soxr_datatype_t data_type, void * * dest,
+    sample_t const * const * src, size_t, unsigned, unsigned long *);
+
+struct soxr_t {
+  unsigned num_channels;
+  double oi_ratio;
+  soxr_error_t error;
+  soxr_quality_spec_t q_spec;
+  soxr_io_spec_t io_spec;
+  soxr_runtime_spec_t runtime_spec;
+
+  void * input_fn_state;
+  soxr_input_fn_t input_fn;
+
+  resampler_shared_t shared;
+  resampler_t * resamplers;
+  control_block_t control_block;
+  deinterleave_t deinterleave;
+  interleave_t interleave;
+
+  void * * channel_ptrs;
+  size_t clips;
+  unsigned long seed;
+  int flushing;
+};
+
+
+
+/* TODO: these should not be here. */
+#define TO_3dB(a)       ((1.6e-6*a-7.5e-4)*a+.646)
+#define LOW_Q_BW0_PC    (67 + 5 / 8.)
+
+soxr_quality_spec_t soxr_quality_spec(unsigned long recipe, unsigned long flags)
+{
+  soxr_quality_spec_t spec, * p = &spec;
+  unsigned quality = recipe & 0xf;
+  double rej;
+  memset(p, 0, sizeof(*p));
+  if (quality > 13) {
+    p->e = "invalid quality type";
+    return spec;
+  }
+  if (quality == 13)
+    quality = 6;
+  else if (quality > 10)
+    quality = 0;
+  p->phase = "\62\31\144"[(recipe & 0x30)>>8];
+  p->anti_aliasing_pc = 100;
+  p->bits = !quality? 0: quality < 3? 16 : quality < 8? 4 + quality * 4 : 55 - quality * 4;
+  rej = p->bits * linear_to_dB(2.);
+  p->flags = flags;
+  if (quality < 8) {
+    p->bw_pc = quality == 1? LOW_Q_BW0_PC : 100 - 5 / TO_3dB(rej);
+    if (quality <= 2)
+      p->flags &= ~SOXR_ROLLOFF_NONE, p->flags |= SOXR_ROLLOFF_MEDIUM;
+  }
+  else {
+    static float const bw[] = {93.1f, 83.2f, 66.3f};
+    p->bw_pc = bw[quality - 8];
+    if (quality - 8 == 2)
+      p->flags &= ~SOXR_ROLLOFF_NONE, p->flags |= SOXR_ROLLOFF_MEDIUM;
+  }
+  if (recipe & SOXR_STEEP_FILTER)
+    p->bw_pc = 100 - 1 / TO_3dB(rej);
+  return spec;
+}
+
+
+
+char const * soxr_engine(soxr_t p)
+{
+  return resampler_id();
+}
+
+
+
+size_t * soxr_num_clips(soxr_t p)
+{
+  return &p->clips;
+}
+
+
+
+soxr_error_t soxr_error(soxr_t p)
+{
+  return p->error;
+}
+
+
+
+soxr_runtime_spec_t soxr_runtime_spec(unsigned num_threads)
+{
+  soxr_runtime_spec_t spec, * p = &spec;
+  memset(p, 0, sizeof(*p));
+  p->log2_min_dft_size = 10;
+  p->log2_large_dft_size = 17;
+  p->coef_size_kbytes = 400;
+  p->num_threads = num_threads;
+  return spec;
+}
+
+
+
+soxr_io_spec_t soxr_io_spec(
+  soxr_datatype_t itype,
+  soxr_datatype_t otype)
+{
+  soxr_io_spec_t spec, * p = &spec;
+  memset(p, 0, sizeof(*p));
+  if ((itype | otype) >= SOXR_SPLIT * 2)
+    p->e = "invalid io datatype(s)";
+  else {
+    p->itype = itype;
+    p->otype = otype;
+    p->scale = 1;
+  }
+  return spec;
+}
+
+
+
+#if HAVE_SIMD
+static bool cpu_has_simd(void)
+{
+#if defined __x86_64__ || defined _M_X64
+  return true;
+#elif defined __GNUC__ && defined i386
+  uint32_t eax, ebx, ecx, edx;
+  __asm__ __volatile__ (
+      "pushl %%ebx   \n\t"
+      "cpuid         \n\t"
+      "movl %%ebx, %1\n\t"
+      "popl %%ebx    \n\t"
+      : "=a"(eax), "=r"(ebx), "=c"(ecx), "=d"(edx)
+      : "a"(1)
+      : "cc" );
+  return !!(edx & 0x06000000);
+#elif defined _MSC_VER && defined _M_IX86
+  uint32_t d;
+  __asm {
+    xor     eax, eax
+    inc     eax
+    push    ebx
+    cpuid
+    pop     ebx
+    mov     d, edx
+  }
+  return !!(d & 0x06000000);
+#endif
+  return false;
+}
+#endif
+
+extern control_block_t _soxr_rate32s_cb, _soxr_rate32_cb, _soxr_rate64_cb;
+
+
+
+soxr_t soxr_create(
+  double input_rate, double output_rate,
+  unsigned num_channels,
+  soxr_error_t * error0,
+  soxr_io_spec_t const * io_spec,
+  soxr_quality_spec_t const * q_spec,
+  soxr_runtime_spec_t const * runtime_spec)
+{
+  double oi_ratio = input_rate? output_rate? output_rate / input_rate : -1 : output_rate? -1 : 0;
+  static const float datatype_full_scale[] = {1, 1, 65536.*32768, 32768};
+  soxr_t p = 0;
+  soxr_error_t error = 0;
+
+  if (q_spec && q_spec->e)  error = q_spec->e;
+  else if (io_spec && (io_spec->itype | io_spec->otype) >= SOXR_SPLIT * 2)
+    error = "invalid io datatype(s)";
+
+  if (!error && !(p = calloc(sizeof(*p), 1))) error = "malloc failed";
+
+  if (p) {
+    p->q_spec = q_spec? *q_spec : soxr_quality_spec(SOXR_HQ, 0);
+    p->oi_ratio = oi_ratio;
+    p->num_channels = num_channels;
+    if (io_spec)
+      p->io_spec = *io_spec;
+    else
+      p->io_spec.scale = 1;
+
+    p->runtime_spec = runtime_spec? *runtime_spec : soxr_runtime_spec(1);
+    p->io_spec.scale *= datatype_full_scale[p->io_spec.otype & 3] /
+                        datatype_full_scale[p->io_spec.itype & 3];
+    p->seed = (unsigned long)time(0) ^ (unsigned long)p;
+
+#if HAVE_SINGLE_PRECISION
+    if (!HAVE_DOUBLE_PRECISION || (p->q_spec.bits <= 20 && !(p->q_spec.flags & SOXR_DOUBLE_PRECISION))) {
+      p->deinterleave = (deinterleave_t)_soxr_deinterleave_f;
+      p->interleave = (interleave_t)_soxr_interleave_f;
+      memcpy(&p->control_block,
+#if HAVE_SIMD
+          cpu_has_simd()? &_soxr_rate32s_cb :
+#endif
+          &_soxr_rate32_cb, sizeof(p->control_block));
+    }
+#if HAVE_DOUBLE_PRECISION
+    else
+#endif
+#endif
+#if HAVE_DOUBLE_PRECISION
+    {
+      p->deinterleave = (deinterleave_t)_soxr_deinterleave;
+      p->interleave = (interleave_t)_soxr_interleave;
+      memcpy(&p->control_block, &_soxr_rate64_cb, sizeof(p->control_block));
+    }
+#endif
+
+    if (p->num_channels && oi_ratio)
+      error = soxr_set_oi_ratio(p, oi_ratio);
+  }
+  if (error)
+    soxr_delete(p), p = 0;
+  if (error0)
+    *error0 = error;
+  return p;
+}
+
+
+
+soxr_error_t soxr_set_input_fn(soxr_t p,
+    soxr_input_fn_t input_fn, void * input_fn_state)
+{
+  p->input_fn_state = input_fn_state;
+  p->input_fn = input_fn;
+  return 0;
+}
+
+
+
+static void soxr_delete0(soxr_t p)
+{
+  unsigned i;
+
+  if (p->resamplers) for (i = 0; i < p->num_channels; ++i) {
+    if (p->resamplers[i])
+      resampler_close(p->resamplers[i]);
+    free(p->resamplers[i]);
+  }
+  free(p->resamplers);
+  free(p->channel_ptrs);
+  free(p->shared);
+
+  memset(p, 0, sizeof(*p));
+}
+
+
+
+double soxr_delay(soxr_t p)
+{
+  return (p && !p->error && p->resamplers)? resampler_delay(p->resamplers[0]) : 0;
+}
+
+
+
+static soxr_error_t fatal_error(soxr_t p, soxr_error_t error)
+{
+  soxr_delete0(p);
+  return p->error = error;
+}
+
+
+
+static soxr_error_t initialise(soxr_t p)
+{
+  unsigned i;
+  size_t shared_size, channel_size;
+
+  resampler_sizes(&shared_size, &channel_size);
+  p->channel_ptrs = calloc(sizeof(*p->channel_ptrs), p->num_channels);
+  p->shared = calloc(shared_size, 1);
+  p->resamplers = calloc(sizeof(*p->resamplers), p->num_channels);
+  if (!p->shared || !p->channel_ptrs || !p->resamplers)
+    return fatal_error(p, "malloc failed");
+
+  for (i = 0; i < p->num_channels; ++i) {
+    soxr_error_t error;
+    if (!(p->resamplers[i] = calloc(channel_size, 1)))
+      return fatal_error(p, "malloc failed");
+    error = resampler_create(
+        p->resamplers[i],
+        p->shared,
+        p->oi_ratio,
+        &p->q_spec,
+        &p->runtime_spec,
+        p->io_spec.scale);
+    if (error)
+      return fatal_error(p, error);
+  }
+  return 0;
+}
+
+
+
+soxr_error_t soxr_set_num_channels(soxr_t p, unsigned num_channels)
+{
+  if (!p)                return "invalid soxr_t pointer";
+  if (num_channels == p->num_channels) return p->error;
+  if (!num_channels)     return "invalid # of channels";
+  if (p->resamplers)     return "# of channels can't be changed";
+  p->num_channels = num_channels;
+  return soxr_set_oi_ratio(p, p->oi_ratio);
+}
+
+
+
+soxr_error_t soxr_set_oi_ratio(soxr_t p, double oi_ratio)
+{
+  unsigned i;
+  soxr_error_t error;
+  if (!p)                 return "invalid soxr_t pointer";
+  if ((error = p->error)) return error;
+  if (!p->num_channels)   return "must set # channels before O/I ratio";
+  if (oi_ratio <= 0)      return "O/I ratio out-of-range";
+  if (!p->channel_ptrs) {
+    p->oi_ratio = oi_ratio;
+    return initialise(p);
+  }
+  if (p->control_block.set_oi_ratio) {
+    for (i = 0; !error && i < p->num_channels; ++i)
+      resampler_set_oi_ratio(p->resamplers[i], oi_ratio);
+    return error;
+  }
+  return fabs(p->oi_ratio - oi_ratio) < 1e-15? 0 :
+    "Varying O/I ratio is not supported with this quality level";
+}
+
+
+
+#if 0
+soxr_error_t soxr_set_pitch(soxr_t p, long pitch)
+{
+  return soxr_set_oi_ratio(p, pow(2, -(double)pitch / OCTAVE_MULT));
+}
+#endif
+
+
+
+void soxr_delete(soxr_t p)
+{
+  if (p)
+    soxr_delete0(p), free(p);
+}
+
+
+
+soxr_error_t soxr_clear(soxr_t p) /* TODO: this, properly. */
+{
+  if (p) {
+    struct soxr_t tmp = *p;
+    soxr_delete0(p);
+    memset(p, 0, sizeof(*p));
+    p->input_fn = tmp.input_fn;
+    p->runtime_spec = tmp.runtime_spec;
+    p->q_spec = tmp.q_spec;
+    p->io_spec = tmp.io_spec;
+    p->num_channels = tmp.num_channels;
+    p->input_fn_state = tmp.input_fn_state;
+    p->control_block = tmp.control_block;
+    p->deinterleave = tmp.deinterleave;
+    p->interleave = tmp.interleave;
+    return 0;
+  }
+  return "invalid soxr_t pointer";
+}
+
+
+
+static void soxr_input_1ch(soxr_t p, unsigned i, soxr_cbuf_t src, size_t len)
+{
+  sample_t * dest = resampler_input(p->resamplers[i], NULL, len);
+  (*p->deinterleave)(&dest, p->io_spec.itype, &src, len, 1);
+}
+
+
+
+static size_t soxr_input(soxr_t p, void const * in, size_t len)
+{
+  bool separated = !!(p->io_spec.itype & SOXR_SPLIT);
+  unsigned i;
+  if (!p || p->error) return 0;
+  if (!in && len) {p->error = "null input buffer pointer"; return 0;}
+  if (!len) {
+    p->flushing = true;
+    return 0;
+  }
+  if (separated)
+    for (i = 0; i < p->num_channels; ++i)
+      soxr_input_1ch(p, i, ((soxr_cbufs_t)in)[i], len);
+  else {
+    for (i = 0; i < p->num_channels; ++i)
+      p->channel_ptrs[i] = resampler_input(p->resamplers[i], NULL, len);
+    (*p->deinterleave)(
+        (sample_t **)p->channel_ptrs, p->io_spec.itype, &in, len, p->num_channels);
+  }
+  return len;
+}
+
+
+
+static size_t soxr_output_1ch(soxr_t p, unsigned i, soxr_buf_t dest, size_t len, bool separated)
+{
+  sample_t const * src;
+  if (p->flushing)
+    resampler_flush(p->resamplers[i]);
+  resampler_process(p->resamplers[i]);
+  src = resampler_output(p->resamplers[i], NULL, &len);
+  if (separated)
+  p->clips += (p->interleave)(p->io_spec.otype, &dest, &src,
+      len, 1, (p->io_spec.flags & SOXR_NO_DITHER)? 0 : &p->seed);
+  else p->channel_ptrs[i] = (void /* const */ *)src;;
+  return len;
+}
+
+
+
+static size_t soxr_output_no_callback(soxr_t p, soxr_buf_t out, size_t len)
+{
+  unsigned i;
+  size_t done = 0;
+  bool separated = !!(p->io_spec.otype & SOXR_SPLIT);
+#if defined _OPENMP
+  if (!p->runtime_spec.num_threads && p->num_channels > 1)
+#pragma omp parallel for
+  for (i = 0; i < p->num_channels; ++i) {
+    size_t done1;
+    done1 = soxr_output_1ch(p, i, ((soxr_bufs_t)out)[i], len, separated);
+    if (!i)
+      done = done1;
+  } else
+#endif
+  for (i = 0; i < p->num_channels; ++i)
+    done = soxr_output_1ch(p, i, ((soxr_bufs_t)out)[i], len, separated);
+
+  if (!separated)
+    p->clips += (p->interleave)(p->io_spec.otype, &out, (sample_t const * const *)p->channel_ptrs,
+        done, p->num_channels, (p->io_spec.flags & SOXR_NO_DITHER)? 0 : &p->seed);
+  return done;
+}
+
+
+
+size_t soxr_output(soxr_t p, void * out, size_t len0)
+{
+  size_t odone, odone0 = 0, olen = len0, osize, idone;
+  void const * in = out; /* Set to !=0, so that caller may leave unset. */
+
+  if (!p || p->error) return 0;
+  if (!out && len0) {p->error = "null output buffer pointer"; return 0;}
+
+  do {
+    odone = soxr_output_no_callback(p, out, olen);
+    odone0 += odone;
+    if (odone0 == len0 || !p->input_fn)
+      break;
+
+    osize = soxr_datatype_size(p->io_spec.otype) * p->num_channels;
+    out = (char *)out + osize * odone;
+    olen -= odone;
+    idone = p->input_fn(p->input_fn_state, &in, (size_t)ceil((double)olen /p->oi_ratio));
+    if (!in)
+      p->error = "input function reported failure";
+    else soxr_input(p, in, idone);
+  } while (in && (odone || idone));
+  return odone0;
+}
+
+
+
+static size_t soxr_i_for_o(soxr_t p, size_t olen, size_t ilen)
+{
+  size_t result;
+#if 0
+  if (p->runtime_spec.flags & SOXR_STRICT_BUFFERING)
+    result = rate_i_for_o(p->resamplers[0], olen);
+  else
+#endif
+    result = (size_t)ceil((double)olen / p->oi_ratio);
+  return min(result, ilen);
+}
+
+
+
+static size_t soxr_o_for_i(soxr_t p, size_t ilen, size_t olen)
+{
+  size_t result = (size_t)ceil((double)ilen * p->oi_ratio);
+  return min(result, olen);
+}
+
+
+
+soxr_error_t soxr_process(soxr_t p,
+    void const * in , size_t ilen0, size_t * idone0,
+    void       * out, size_t olen , size_t * odone0)
+{
+  size_t ilen, idone, odone = 0;
+  unsigned i;
+  bool flush_requested = false;
+
+  if (!p) return "null pointer";
+
+  if (!in)
+    flush_requested = true, ilen = ilen0 = 0;
+  else {
+    if ((ptrdiff_t)ilen0 < 0)
+      flush_requested = true, ilen0 = 1 + ~ilen0;
+    if (1 || flush_requested)
+      ilen = soxr_i_for_o(p, olen, ilen0);
+    else
+      ilen = ilen0, olen = soxr_o_for_i(p, ilen, olen);
+  }
+  p->flushing |= ilen == ilen0 && flush_requested;
+
+  if (!out && !in)
+    idone = ilen;
+  else if (p->io_spec.itype & p->io_spec.otype & SOXR_SPLIT) { /* Both i & o */
+#if defined _OPENMP
+    if (!p->runtime_spec.num_threads && p->num_channels > 1)
+#pragma omp parallel for
+    for (i = 0; i < p->num_channels; ++i) {
+      size_t done;
+      if (in)
+        soxr_input_1ch(p, i, ((soxr_cbufs_t)in)[i], ilen);
+      done = soxr_output_1ch(p, i, ((soxr_bufs_t)out)[i], olen, true);
+      if (!i)
+        odone = done;
+    } else
+#endif
+    for (i = 0; i < p->num_channels; ++i) {
+      if (in)
+        soxr_input_1ch(p, i, ((soxr_cbufs_t)in)[i], ilen);
+      odone = soxr_output_1ch(p, i, ((soxr_bufs_t)out)[i], olen, true);
+    }
+    idone = ilen;
+  }
+  else {
+    idone = soxr_input (p, in , ilen);
+    odone = soxr_output(p, out, olen);
+  }
+  if (idone0) *idone0 = idone;
+  if (odone0) *odone0 = odone;
+  return p->error;
+}
+
+
+
+soxr_error_t soxr_oneshot(
+    double irate, double orate,
+    unsigned num_channels,
+    void const * in , size_t ilen, size_t * idone,
+    void * out, size_t olen, size_t * odone,
+    soxr_io_spec_t const * io_spec,
+    soxr_quality_spec_t const * q_spec,
+    soxr_runtime_spec_t const * runtime_spec)
+{
+  soxr_t resampler;
+  soxr_error_t error = q_spec? q_spec->e : 0;
+  if (!error) {
+    soxr_quality_spec_t q_spec1;
+    if (!q_spec)
+      q_spec1 = soxr_quality_spec(SOXR_LQ, 0), q_spec = &q_spec1;
+    resampler = soxr_create(irate, orate, num_channels,
+        &error, io_spec, q_spec, runtime_spec);
+  }
+  if (!error) {
+    ilen = 1 + ~ilen;
+    error = soxr_process(resampler, in, ilen, idone, out, olen, odone);
+    soxr_delete(resampler);
+  }
+  return error;
+}
+
+
+
+soxr_error_t soxr_set_error(soxr_t p, soxr_error_t error)
+{
+  if (!p) return "null pointer";
+  if (!p->error && p->error != error) return p->error;
+  p->error = error;
+  return 0;
+}
--- a/lib-src/libsoxr/src/soxr.h
+++ b/lib-src/libsoxr/src/soxr.h
@@ -0,0 +1,307 @@
+/* SoX Resampler Library       Copyright (c) 2007-12 robs@users.sourceforge.net
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+
+
+/* -------------------------------- Gubbins --------------------------------- */
+
+#if !defined soxr_included
+#define soxr_included
+
+
+#if defined __cplusplus
+  #include <cstddef>
+  extern "C" {
+#else
+  #include <stddef.h>
+#endif
+
+#if defined SOXR_DLL
+  #if defined soxr_EXPORTS
+    #define _ __declspec(dllexport)
+  #else
+    #define _ __declspec(dllimport)
+  #endif
+#else
+  #define _
+#endif
+
+typedef struct soxr_io_spec_t soxr_io_spec_t;
+typedef struct soxr_quality_spec_t soxr_quality_spec_t;
+typedef struct soxr_runtime_spec_t soxr_runtime_spec_t;
+
+
+
+/* ---------------------------- API conventions --------------------------------
+
+Buffer lengths (and occupancies) are expressed as the number of contained
+samples per channel.
+
+Parameter names for buffer lengths have the suffix `len'.
+
+A single-character `i' or 'o' is often used in names to give context as
+input or output (e.g. ilen, olen).                                            */
+
+
+
+/* --------------------------- Type declarations ---------------------------- */
+
+typedef struct soxr_t * soxr_t;        /* A resampler for 1 or more channels. */
+typedef char const    * soxr_error_t;  /* 0:no-error; non-0:error. */
+
+typedef void       * soxr_buf_t;  /* 1 buffer of channel-interleaved samples. */
+typedef void const * soxr_cbuf_t;                        /* Ditto; read-only. */
+
+typedef soxr_buf_t const  * soxr_bufs_t;/* Or, a separate buffer for each ch. */
+typedef soxr_cbuf_t const * soxr_cbufs_t;                /* Ditto; read-only. */
+
+typedef void const * soxr_in_t;      /* Either a soxr_cbuf_t or soxr_cbufs_t,
+                                        depending on itype in soxr_io_spec_t. */
+typedef void       * soxr_out_t;     /* Either a soxr_buf_t or soxr_bufs_t,
+                                        depending on otype in soxr_io_spec_t. */
+
+
+
+/* --------------------------- API main functions --------------------------- */
+
+_ char const    * soxr_version(void);  /* Query library version: "x.y.z". */
+
+#define soxr_strerror(e)               /* Soxr counterpart to strerror. */     \
+    ((e)?(e):"no error")
+
+
+/* Create a stream resampler: */
+
+_ soxr_t soxr_create(
+    double      input_rate,      /* Input sample-rate. */
+    double      output_rate,     /* Output sample-rate. */
+    unsigned    num_channels,    /* Number of channels to be used. */
+        /* All following arguments are optional (may be set to NULL). */
+    soxr_error_t *,              /* To report any error during creation. */
+    soxr_io_spec_t const *,      /* To specify non-default I/O formats. */
+    soxr_quality_spec_t const *, /* To specify non-default resampling quality.*/
+    soxr_runtime_spec_t const *);/* To specify non-default runtime resources. */
+
+
+
+/* If not using an app-supplied input function, after creating a stream
+ * resampler, repeatedly call: */
+
+_ soxr_error_t soxr_process(
+    soxr_t      resampler,      /* As returned by soxr_create. */
+                            /* Input (to be resampled): */
+    soxr_in_t   in,             /* Interleaved or split input buffer(s). */
+    size_t      ilen,           /* Input buf. length (samples per channel). */
+    size_t      * idone,        /* To return actual # samples used (<= ilen). */
+                            /* Output (resampled): */
+    soxr_out_t  out,            /* Interleaved or split output buffer(s).*/
+    size_t      olen,           /* Output buf. length (samples per channel). */
+    size_t      * odone);       /* To return actual # samples out (<= olen). */
+
+
+
+/* If using an app-supplied input function, it must look and behave like this:*/
+
+typedef size_t /* data_len */
+  (* soxr_input_fn_t)(         /* Supply data to be resampled. */
+    void * input_fn_state,     /* As given to soxr_set_input_fn. */
+    soxr_in_t * data,          /* Returned data; see below. N.B. ptr to ptr(s)*/
+    size_t requested_len);     /* Samples per channel, >= returned data_len.
+
+  data_len  *data     Indicates    Meaning
+   ------- -------   ------------  -------------------------
+     !=0     !=0       Success     *data contains data to be
+                                   input to the resampler.
+      0    !=0 (or   End-of-input  No data is available nor
+           not set)                shall be available.
+      0       0        Failure     An error occurred whilst trying to
+                                   source data to be input to the resampler.  */
+
+/* and be registered with a previously created stream resampler using: */
+
+_ soxr_error_t soxr_set_input_fn(/* Set (or reset) an input function.*/
+    soxr_t resampler,            /* As returned by soxr_create. */
+    soxr_input_fn_t,             /* Function to supply data to be resampled.*/
+    void * input_fn_state);      /* If needed by the input function. */
+
+/* then repeatedly call: */
+
+_ size_t /*odone*/ soxr_output(/* Resample and output a portion of the signal.*/
+    soxr_t resampler,            /* As returned by soxr_create. */
+    soxr_out_t data,             /* App-supplied buffer(s) for resampled data.*/
+    size_t olen);                /* Amount of data to output; >= odone. */
+
+
+
+/* Common stream resampler operations: */
+
+_ soxr_error_t soxr_error(soxr_t);   /* Query error status. */
+_ size_t     * soxr_num_clips(soxr_t); /* Query int. clip counter (for R/W). */
+_ double       soxr_delay(soxr_t);   /* Query current delay in output samples.*/
+_ char const * soxr_engine(soxr_t p);/* Query resampling engine name. */
+
+_ soxr_error_t soxr_clear(soxr_t);   /* Ready for fresh signal, same config. */
+_ void         soxr_delete(soxr_t);  /* Free resources. */
+
+
+
+/* `Short-cut', single call to resample a (probably short) signal held entirely
+ * in memory.  See soxr_create and soxr_process above for parameter details. */
+
+_ soxr_error_t soxr_oneshot(
+    double         input_rate,
+    double         output_rate,
+    unsigned       num_channels,
+    soxr_in_t    in , size_t ilen, size_t * idone,
+    soxr_out_t   out, size_t olen, size_t * odone,
+    soxr_io_spec_t const *,
+    soxr_quality_spec_t const *,
+    soxr_runtime_spec_t const *);
+
+
+
+/* -------------------------- API type definitions -------------------------- */
+
+typedef enum {          /* Datatypes supported for I/O to/from the resampler: */
+  /* Internal; do not use: */
+  SOXR_FLOAT32, SOXR_FLOAT64, SOXR_INT32, SOXR_INT16, SOXR_SPLIT = 4,
+
+  /* Use for interleaved channels: */
+  SOXR_FLOAT32_I = SOXR_FLOAT32, SOXR_FLOAT64_I, SOXR_INT32_I, SOXR_INT16_I,
+
+  /* Use for split channels: */
+  SOXR_FLOAT32_S = SOXR_SPLIT  , SOXR_FLOAT64_S, SOXR_INT32_S, SOXR_INT16_S
+
+} soxr_datatype_t;
+
+#define soxr_datatype_size(x)  /* Returns `sizeof' a soxr_datatype_t sample. */\
+  ((unsigned char *)"\4\10\4\2")[(x)&3]
+
+
+
+struct soxr_io_spec_t {                                          /* Typically */
+  soxr_datatype_t itype;     /* Input datatype.                SOXR_FLOAT32_I */
+  soxr_datatype_t otype;     /* Output datatype.               SOXR_FLOAT32_I */
+  double scale;              /* Linear gain to apply during resampling.  1    */
+  void * e;                  /* Reserved for internal use                0    */
+  unsigned long flags;       /* Per the following #defines.              0    */
+};
+
+#define SOXR_TPDF              0     /* Applicable only if otype is INT16. */
+#define SOXR_NO_DITHER         8u    /* Disable the above. */
+
+
+
+struct soxr_quality_spec_t {                                     /* Typically */
+  double bits;               /* Required bit-accuracy (pass + stop).    20    */
+  double phase;              /* Linear/minimum etc. phase. [0,100]      50    */
+  double bw_pc;              /* Pass-band % (0dB pt.) to preserve.     91.3   */
+  double anti_aliasing_pc;   /* % bandwidth without aliasing.           100   */
+  void * e;                  /* Reserved for internal use.               0    */
+  unsigned long flags;       /* Per the following #defines.              0    */
+};
+
+#define SOXR_ROLLOFF_SMALL     0u    /* <= 0.01 dB */
+#define SOXR_ROLLOFF_MEDIUM    1u    /* <= 0.35 dB */
+#define SOXR_ROLLOFF_NONE      2u    /* For Chebyshev bandwidth. */
+
+#define SOXR_MAINTAIN_3DB_PT   4u  /* Reserved for internal use. */
+#define SOXR_HI_PREC_CLOCK     8u  /* Increase `irrational' ratio accuracy. */
+#define SOXR_DOUBLE_PRECISION 16u  /* Use double prec. even @ bitdepths <= 20.*/
+
+
+
+struct soxr_runtime_spec_t {                                     /* Typically */
+  unsigned log2_min_dft_size;/* For DFT efficiency. [8,15]              10    */
+  unsigned log2_large_dft_size;/* For DFT efficiency. [16,20]           17    */
+  unsigned coef_size_kbytes; /* For SOXR_COEF_INTERP_AUTO (below).      400   */
+  unsigned num_threads;      /* If built so. 0 means `automatic'.        1    */
+  void * e;                  /* Reserved for internal use.               0    */
+  unsigned long flags;       /* Per the following #defines.              0    */
+};
+                                   /* For `irrational' ratios only: */
+#define SOXR_COEF_INTERP_AUTO  0u    /* Auto select coef. interpolation. */
+#define SOXR_COEF_INTERP_LOW   1u    /* Man. select: less CPU, more memory. */
+#define SOXR_COEF_INTERP_HIGH  2u    /* Man. select: more CPU, less memory. */
+
+#define SOXR_STRICT_BUFFERING  4u  /* Reserved for future use. */
+#define SOXR_NOSMALLINTOPT     8u  /* More CPU, less latency for 3/2, 3/4 etc.*/
+
+
+
+/* -------------------------- API type constructors ------------------------- */
+
+/* These functions allow setting of the most commonly-used structure
+ * parameters, with other parameters being given default values.  The default
+ * values may then be overridden, directly in the structure, if needed.  */
+
+_ soxr_quality_spec_t soxr_quality_spec(
+    unsigned long recipe,       /* Per the #defines immediately below. */
+    unsigned long flags);       /* As soxr_quality_spec_t.flags. */
+
+                                  /* The 5 standard qualities found in SoX: */
+#define SOXR_QQ                 0   /* 'Quick' cubic interpolation. */
+#define SOXR_LQ                 1   /* 'Low' 16-bit with larger rolloff. */
+#define SOXR_MQ                 2   /* 'Medium' 16-bit with medium rolloff. */
+#define SOXR_HQ                 SOXR_20_BITQ /* 'High quality'. */
+#define SOXR_VHQ                SOXR_28_BITQ /* 'Very high quality'. */
+
+#define SOXR_16_BITQ            3
+#define SOXR_20_BITQ            4
+#define SOXR_24_BITQ            5
+#define SOXR_28_BITQ            6
+#define SOXR_32_BITQ            7
+                                    /* Libsamplerate equivalent qualities: */
+#define SOXR_LSR0Q              8     /* 'Best sinc'. */
+#define SOXR_LSR1Q              9     /* 'Medium sinc'. */
+#define SOXR_LSR2Q              10    /* 'Fast sinc'. */
+
+#define SOXR_LINEAR_PHASE       0x00
+#define SOXR_INTERMEDIATE_PHASE 0x10
+#define SOXR_MINIMUM_PHASE      0x30
+#define SOXR_STEEP_FILTER       0x40
+#define SOXR_ALLOW_ALIASING     0x80  /* Reserved for future use. */
+
+
+
+_ soxr_runtime_spec_t soxr_runtime_spec(
+    unsigned num_threads);
+
+
+
+_ soxr_io_spec_t soxr_io_spec(
+    soxr_datatype_t itype,
+    soxr_datatype_t otype);
+
+
+
+/* --------------------------- Internal use only ---------------------------- */
+
+_ soxr_error_t soxr_set_error(soxr_t, soxr_error_t);
+_ soxr_error_t soxr_set_num_channels(soxr_t, unsigned);
+_ soxr_error_t soxr_set_oi_ratio(soxr_t, double);
+_ soxr_error_t soxr_set_pitch(soxr_t, long);
+
+
+
+#undef _
+
+#if defined __cplusplus
+}
+#endif
+
+#endif