Add very limited resampling (it's slow as shit)

6 files changed, 63 insertions, 63 deletions

diff --git a/lib/libsamplerate/libsamplerate-0.2.2/include/samplerate.h b/lib/libsamplerate/libsamplerate-0.2.2/include/samplerate.h
index a3d5ae1a..c06024d2 100755
--- a/lib/libsamplerate/libsamplerate-0.2.2/include/samplerate.h
+++ b/lib/libsamplerate/libsamplerate-0.2.2/include/samplerate.h
@@ -32,7 +32,7 @@ typedef struct
 
 	int		end_of_input ;
 
-	double	src_ratio ;
+	float src_ratio ;
 } SRC_DATA ;
 
 /*
@@ -89,7 +89,7 @@ int src_process (SRC_STATE *state, SRC_DATA *data) ;
 **	Callback based processing function. Read up to frames worth of data from
 **	the converter int *data and return frames read or -1 on error.
 */
-long src_callback_read (SRC_STATE *state, double src_ratio, long frames, float *data) ;
+long src_callback_read (SRC_STATE *state, float src_ratio, long frames, float *data) ;
 
 /*
 **	Simple interface for performing a single conversion from input buffer to
@@ -119,7 +119,7 @@ const char *src_get_version (void) ;
 **	Returns non zero on error.
 */
 
-int src_set_ratio (SRC_STATE *state, double new_ratio) ;
+int src_set_ratio (SRC_STATE *state, float new_ratio) ;
 
 /*
 **	Get the current channel count.
@@ -142,7 +142,7 @@ int src_reset (SRC_STATE *state) ;
 ** otherwise.
 */
 
-int src_is_valid_ratio (double ratio) ;
+int src_is_valid_ratio (float ratio) ;
 
 /*
 **	Return an error number.
diff --git a/lib/libsamplerate/libsamplerate-0.2.2/src/common.h b/lib/libsamplerate/libsamplerate-0.2.2/src/common.h
index c5b7d90b..b9343313 100755
--- a/lib/libsamplerate/libsamplerate-0.2.2/src/common.h
+++ b/lib/libsamplerate/libsamplerate-0.2.2/src/common.h
@@ -156,7 +156,7 @@ struct SRC_STATE_tag
 {
 	SRC_STATE_VT *vt ;
 
-	double	last_ratio, last_position ;
+	float	last_ratio, last_position ;
 
 	SRC_ERROR	error ;
 	int		channels ;
@@ -209,7 +209,7 @@ static inline int
 #ifdef USE_TARGET_ATTRIBUTE
 __attribute__((target("sse2")))
 #endif
-psf_lrint (double x)
+psf_lrint (float x)
 {
 	return _mm_cvtsd_si32 (_mm_load_sd (&x)) ;
 }
@@ -221,7 +221,7 @@ static inline int psf_lrintf (float x)
 	return lrintf (x) ;
 } /* psf_lrintf */
 
-static inline int psf_lrint (double x)
+static inline int psf_lrint (float x)
 {
 	return lrint (x) ;
 } /* psf_lrint */
@@ -231,9 +231,9 @@ static inline int psf_lrint (double x)
 **	Common static inline functions.
 */
 
-static inline double
-fmod_one (double x)
-{	double res ;
+static inline float
+fmod_one (float x)
+{	float res ;
 
 	res = x - psf_lrint (x) ;
 	if (res < 0.0)
@@ -243,7 +243,7 @@ fmod_one (double x)
 } /* fmod_one */
 
 static inline int
-is_bad_src_ratio (double ratio)
+is_bad_src_ratio (float ratio)
 {	return (ratio < (1.0 / SRC_MAX_RATIO) || ratio > (1.0 * SRC_MAX_RATIO)) ;
 } /* is_bad_src_ratio */
 
diff --git a/lib/libsamplerate/libsamplerate-0.2.2/src/samplerate.c b/lib/libsamplerate/libsamplerate-0.2.2/src/samplerate.c
index 6a51f279..700d42f7 100755
--- a/lib/libsamplerate/libsamplerate-0.2.2/src/samplerate.c
+++ b/lib/libsamplerate/libsamplerate-0.2.2/src/samplerate.c
@@ -143,7 +143,7 @@ src_process (SRC_STATE *state, SRC_DATA *data)
 } /* src_process */
 
 long
-src_callback_read (SRC_STATE *state, double src_ratio, long frames, float *data)
+src_callback_read (SRC_STATE *state, float src_ratio, long frames, float *data)
 {
 	SRC_DATA	src_data ;
 
@@ -238,7 +238,7 @@ src_callback_read (SRC_STATE *state, double src_ratio, long frames, float *data)
 */
 
 int
-src_set_ratio (SRC_STATE *state, double new_ratio)
+src_set_ratio (SRC_STATE *state, float new_ratio)
 {
 	if (state == NULL)
 		return SRC_ERR_BAD_STATE ;
@@ -321,7 +321,7 @@ src_get_version (void)
 } /* src_get_version */
 
 int
-src_is_valid_ratio (double ratio)
+src_is_valid_ratio (float ratio)
 {
 	if (is_bad_src_ratio (ratio))
 		return SRC_FALSE ;
@@ -461,7 +461,7 @@ src_int_to_float_array (const int *in, float *out, int len)
 
 void
 src_float_to_int_array (const float *in, int *out, int len)
-{	double scaled_value ;
+{	float scaled_value ;
 
 	for (int i = 0 ; i < len ; i++)
 	{	scaled_value = in [i] * (8.0 * 0x10000000) ;
diff --git a/lib/libsamplerate/libsamplerate-0.2.2/src/src_linear.c b/lib/libsamplerate/libsamplerate-0.2.2/src/src_linear.c
index 43a0fd40..360166a7 100755
--- a/lib/libsamplerate/libsamplerate-0.2.2/src/src_linear.c
+++ b/lib/libsamplerate/libsamplerate-0.2.2/src/src_linear.c
@@ -53,7 +53,7 @@ static SRC_STATE_VT linear_state_vt =
 static SRC_ERROR
 linear_vari_process (SRC_STATE *state, SRC_DATA *data)
 {	LINEAR_DATA *priv ;
-	double		src_ratio, input_index, rem ;
+	float		src_ratio, input_index, rem ;
 	int			ch ;
 
 	if (data->input_frames <= 0)
@@ -93,7 +93,7 @@ linear_vari_process (SRC_STATE *state, SRC_DATA *data)
 
 		for (ch = 0 ; ch < state->channels ; ch++)
 		{	data->data_out [priv->out_gen] = (float) (priv->last_value [ch] + input_index *
-										((double) data->data_in [ch] - priv->last_value [ch])) ;
+										((float) data->data_in [ch] - priv->last_value [ch])) ;
 			priv->out_gen ++ ;
 			} ;
 
@@ -120,7 +120,7 @@ linear_vari_process (SRC_STATE *state, SRC_DATA *data)
 
 		for (ch = 0 ; ch < state->channels ; ch++)
 		{	data->data_out [priv->out_gen] = (float) (data->data_in [priv->in_used - state->channels + ch] + input_index *
-						((double) data->data_in [priv->in_used + ch] - data->data_in [priv->in_used - state->channels + ch])) ;
+						((float) data->data_in [priv->in_used + ch] - data->data_in [priv->in_used - state->channels + ch])) ;
 			priv->out_gen ++ ;
 			} ;
 
diff --git a/lib/libsamplerate/libsamplerate-0.2.2/src/src_sinc.c b/lib/libsamplerate/libsamplerate-0.2.2/src/src_sinc.c
index 716c4a40..0a594e47 100755
--- a/lib/libsamplerate/libsamplerate-0.2.2/src/src_sinc.c
+++ b/lib/libsamplerate/libsamplerate-0.2.2/src/src_sinc.c
@@ -26,7 +26,7 @@
 #define MAKE_INCREMENT_T(x) 	((increment_t) (x))
 
 #define	SHIFT_BITS				12
-#define	FP_ONE					((double) (((increment_t) 1) << SHIFT_BITS))
+#define	FP_ONE					((float) (((increment_t) 1) << SHIFT_BITS))
 #define	INV_FP_ONE				(1.0 / FP_ONE)
 
 /* Customixe max channls from Kconfig. */
@@ -61,14 +61,14 @@ typedef struct
 
 	int		coeff_half_len, index_inc ;
 
-	double	src_ratio, input_index ;
+	float	src_ratio, input_index ;
 
 	coeff_t const	*coeffs ;
 
 	int		b_current, b_end, b_real_end, b_len ;
 
 	/* Sure hope noone does more than 128 channels at once. */
-	double left_calc [MAX_CHANNELS], right_calc [MAX_CHANNELS] ;
+	float left_calc [MAX_CHANNELS], right_calc [MAX_CHANNELS] ;
 
 	float	*buffer ;
 } SINC_FILTER ;
@@ -131,9 +131,9 @@ static SRC_STATE_VT sinc_mono_state_vt =
 } ;
 
 static inline increment_t
-double_to_fp (double x)
+float_to_fp (float x)
 {	return (increment_t) (psf_lrint ((x) * FP_ONE)) ;
-} /* double_to_fp */
+} /* float_to_fp */
 
 static inline increment_t
 int_to_fp (int x)
@@ -150,10 +150,10 @@ fp_fraction_part (increment_t x)
 {	return ((x) & ((((increment_t) 1) << SHIFT_BITS) - 1)) ;
 } /* fp_fraction_part */
 
-static inline double
-fp_to_double (increment_t x)
+static inline float
+fp_to_float (increment_t x)
 {	return fp_fraction_part (x) * INV_FP_ONE ;
-} /* fp_to_double */
+} /* fp_to_float */
 
 static inline int
 int_div_ceil (int divident, int divisor) /* == (int) ceil ((float) divident / divisor) */
@@ -367,9 +367,9 @@ sinc_copy (SRC_STATE *state)
 **	Beware all ye who dare pass this point. There be dragons here.
 */
 
-static inline double
+static inline float
 calc_output_single (SINC_FILTER *filter, increment_t increment, increment_t start_filter_index)
-{	double		fraction, left, right, icoeff ;
+{	float		fraction, left, right, icoeff ;
 	increment_t	filter_index, max_filter_index ;
 	int			data_index, coeff_count, indx ;
 
@@ -391,7 +391,7 @@ calc_output_single (SINC_FILTER *filter, increment_t increment, increment_t star
 	}
 	left = 0.0 ;
 	while (filter_index >= MAKE_INCREMENT_T (0))
-	{	fraction = fp_to_double (filter_index) ;
+	{	fraction = fp_to_float (filter_index) ;
 		indx = fp_to_int (filter_index) ;
 		assert (indx >= 0 && indx + 1 < filter->coeff_half_len + 2) ;
 		icoeff = filter->coeffs [indx] + fraction * (filter->coeffs [indx + 1] - filter->coeffs [indx]) ;
@@ -411,7 +411,7 @@ calc_output_single (SINC_FILTER *filter, increment_t increment, increment_t star
 
 	right = 0.0 ;
 	do
-	{	fraction = fp_to_double (filter_index) ;
+	{	fraction = fp_to_float (filter_index) ;
 		indx = fp_to_int (filter_index) ;
 		assert (indx < filter->coeff_half_len + 2) ;
 		icoeff = filter->coeffs [indx] + fraction * (filter->coeffs [indx + 1] - filter->coeffs [indx]) ;
@@ -430,7 +430,7 @@ calc_output_single (SINC_FILTER *filter, increment_t increment, increment_t star
 static SRC_ERROR
 sinc_mono_vari_process (SRC_STATE *state, SRC_DATA *data)
 {	SINC_FILTER *filter ;
-	double		input_index, src_ratio, count, float_increment, terminate, rem ;
+	float		input_index, src_ratio, count, float_increment, terminate, rem ;
 	increment_t	increment, start_filter_index ;
 	int			half_filter_chan_len, samples_in_hand ;
 
@@ -493,9 +493,9 @@ sinc_mono_vari_process (SRC_STATE *state, SRC_DATA *data)
 			src_ratio = state->last_ratio + filter->out_gen * (data->src_ratio - state->last_ratio) / filter->out_count ;
 
 		float_increment = filter->index_inc * (src_ratio < 1.0 ? src_ratio : 1.0) ;
-		increment = double_to_fp (float_increment) ;
+		increment = float_to_fp (float_increment) ;
 
-		start_filter_index = double_to_fp (input_index * float_increment) ;
+		start_filter_index = float_to_fp (input_index * float_increment) ;
 
 		data->data_out [filter->out_gen] = (float) ((float_increment / filter->index_inc) *
 										calc_output_single (filter, increment, start_filter_index)) ;
@@ -521,8 +521,8 @@ sinc_mono_vari_process (SRC_STATE *state, SRC_DATA *data)
 } /* sinc_mono_vari_process */
 
 static inline void
-calc_output_stereo (SINC_FILTER *filter, int channels, increment_t increment, increment_t start_filter_index, double scale, float * output)
-{	double		fraction, left [2], right [2], icoeff ;
+calc_output_stereo (SINC_FILTER *filter, int channels, increment_t increment, increment_t start_filter_index, float scale, float * output)
+{	float		fraction, left [2], right [2], icoeff ;
 	increment_t	filter_index, max_filter_index ;
 	int			data_index, coeff_count, indx ;
 
@@ -544,7 +544,7 @@ calc_output_stereo (SINC_FILTER *filter, int channels, increment_t increment, in
 	}
 	left [0] = left [1] = 0.0 ;
 	while (filter_index >= MAKE_INCREMENT_T (0))
-	{	fraction = fp_to_double (filter_index) ;
+	{	fraction = fp_to_float (filter_index) ;
 		indx = fp_to_int (filter_index) ;
 		assert (indx >= 0 && indx + 1 < filter->coeff_half_len + 2) ;
 		icoeff = filter->coeffs [indx] + fraction * (filter->coeffs [indx + 1] - filter->coeffs [indx]) ;
@@ -565,7 +565,7 @@ calc_output_stereo (SINC_FILTER *filter, int channels, increment_t increment, in
 
 	right [0] = right [1] = 0.0 ;
 	do
-	{	fraction = fp_to_double (filter_index) ;
+	{	fraction = fp_to_float (filter_index) ;
 		indx = fp_to_int (filter_index) ;
 		assert (indx >= 0 && indx + 1 < filter->coeff_half_len + 2) ;
 		icoeff = filter->coeffs [indx] + fraction * (filter->coeffs [indx + 1] - filter->coeffs [indx]) ;
@@ -586,7 +586,7 @@ calc_output_stereo (SINC_FILTER *filter, int channels, increment_t increment, in
 SRC_ERROR
 sinc_stereo_vari_process (SRC_STATE *state, SRC_DATA *data)
 {	SINC_FILTER *filter ;
-	double		input_index, src_ratio, count, float_increment, terminate, rem ;
+	float		input_index, src_ratio, count, float_increment, terminate, rem ;
 	increment_t	increment, start_filter_index ;
 	int			half_filter_chan_len, samples_in_hand ;
 
@@ -649,9 +649,9 @@ sinc_stereo_vari_process (SRC_STATE *state, SRC_DATA *data)
 			src_ratio = state->last_ratio + filter->out_gen * (data->src_ratio - state->last_ratio) / filter->out_count ;
 
 		float_increment = filter->index_inc * (src_ratio < 1.0 ? src_ratio : 1.0) ;
-		increment = double_to_fp (float_increment) ;
+		increment = float_to_fp (float_increment) ;
 
-		start_filter_index = double_to_fp (input_index * float_increment) ;
+		start_filter_index = float_to_fp (input_index * float_increment) ;
 
 		calc_output_stereo (filter, state->channels, increment, start_filter_index, float_increment / filter->index_inc, data->data_out + filter->out_gen) ;
 		filter->out_gen += 2 ;
@@ -676,8 +676,8 @@ sinc_stereo_vari_process (SRC_STATE *state, SRC_DATA *data)
 } /* sinc_stereo_vari_process */
 
 static inline void
-calc_output_quad (SINC_FILTER *filter, int channels, increment_t increment, increment_t start_filter_index, double scale, float * output)
-{	double		fraction, left [4], right [4], icoeff ;
+calc_output_quad (SINC_FILTER *filter, int channels, increment_t increment, increment_t start_filter_index, float scale, float * output)
+{	float		fraction, left [4], right [4], icoeff ;
 	increment_t	filter_index, max_filter_index ;
 	int			data_index, coeff_count, indx ;
 
@@ -699,7 +699,7 @@ calc_output_quad (SINC_FILTER *filter, int channels, increment_t increment, incr
 	}
 	left [0] = left [1] = left [2] = left [3] = 0.0 ;
 	while (filter_index >= MAKE_INCREMENT_T (0))
-	{	fraction = fp_to_double (filter_index) ;
+	{	fraction = fp_to_float (filter_index) ;
 		indx = fp_to_int (filter_index) ;
 		assert (indx >= 0 && indx + 1 < filter->coeff_half_len + 2) ;
 		icoeff = filter->coeffs [indx] + fraction * (filter->coeffs [indx + 1] - filter->coeffs [indx]) ;
@@ -720,7 +720,7 @@ calc_output_quad (SINC_FILTER *filter, int channels, increment_t increment, incr
 
 	right [0] = right [1] = right [2] = right [3] = 0.0 ;
 	do
-	{	fraction = fp_to_double (filter_index) ;
+	{	fraction = fp_to_float (filter_index) ;
 		indx = fp_to_int (filter_index) ;
 		assert (indx >= 0 && indx + 1 < filter->coeff_half_len + 2) ;
 		icoeff = filter->coeffs [indx] + fraction * (filter->coeffs [indx + 1] - filter->coeffs [indx]) ;
@@ -742,7 +742,7 @@ calc_output_quad (SINC_FILTER *filter, int channels, increment_t increment, incr
 SRC_ERROR
 sinc_quad_vari_process (SRC_STATE *state, SRC_DATA *data)
 {	SINC_FILTER *filter ;
-	double		input_index, src_ratio, count, float_increment, terminate, rem ;
+	float		input_index, src_ratio, count, float_increment, terminate, rem ;
 	increment_t	increment, start_filter_index ;
 	int			half_filter_chan_len, samples_in_hand ;
 
@@ -805,9 +805,9 @@ sinc_quad_vari_process (SRC_STATE *state, SRC_DATA *data)
 			src_ratio = state->last_ratio + filter->out_gen * (data->src_ratio - state->last_ratio) / filter->out_count ;
 
 		float_increment = filter->index_inc * (src_ratio < 1.0 ? src_ratio : 1.0) ;
-		increment = double_to_fp (float_increment) ;
+		increment = float_to_fp (float_increment) ;
 
-		start_filter_index = double_to_fp (input_index * float_increment) ;
+		start_filter_index = float_to_fp (input_index * float_increment) ;
 
 		calc_output_quad (filter, state->channels, increment, start_filter_index, float_increment / filter->index_inc, data->data_out + filter->out_gen) ;
 		filter->out_gen += 4 ;
@@ -832,8 +832,8 @@ sinc_quad_vari_process (SRC_STATE *state, SRC_DATA *data)
 } /* sinc_quad_vari_process */
 
 static inline void
-calc_output_hex (SINC_FILTER *filter, int channels, increment_t increment, increment_t start_filter_index, double scale, float * output)
-{	double		fraction, left [6], right [6], icoeff ;
+calc_output_hex (SINC_FILTER *filter, int channels, increment_t increment, increment_t start_filter_index, float scale, float * output)
+{	float		fraction, left [6], right [6], icoeff ;
 	increment_t	filter_index, max_filter_index ;
 	int			data_index, coeff_count, indx ;
 
@@ -855,7 +855,7 @@ calc_output_hex (SINC_FILTER *filter, int channels, increment_t increment, incre
 	}
 	left [0] = left [1] = left [2] = left [3] = left [4] = left [5] = 0.0 ;
 	while (filter_index >= MAKE_INCREMENT_T (0))
-	{	fraction = fp_to_double (filter_index) ;
+	{	fraction = fp_to_float (filter_index) ;
 		indx = fp_to_int (filter_index) ;
 		assert (indx >= 0 && indx + 1 < filter->coeff_half_len + 2) ;
 		icoeff = filter->coeffs [indx] + fraction * (filter->coeffs [indx + 1] - filter->coeffs [indx]) ;
@@ -876,7 +876,7 @@ calc_output_hex (SINC_FILTER *filter, int channels, increment_t increment, incre
 
 	right [0] = right [1] = right [2] = right [3] = right [4] = right [5] = 0.0 ;
 	do
-	{	fraction = fp_to_double (filter_index) ;
+	{	fraction = fp_to_float (filter_index) ;
 		indx = fp_to_int (filter_index) ;
 		assert (indx >= 0 && indx + 1 < filter->coeff_half_len + 2) ;
 		icoeff = filter->coeffs [indx] + fraction * (filter->coeffs [indx + 1] - filter->coeffs [indx]) ;
@@ -897,7 +897,7 @@ calc_output_hex (SINC_FILTER *filter, int channels, increment_t increment, incre
 SRC_ERROR
 sinc_hex_vari_process (SRC_STATE *state, SRC_DATA *data)
 {	SINC_FILTER *filter ;
-	double		input_index, src_ratio, count, float_increment, terminate, rem ;
+	float		input_index, src_ratio, count, float_increment, terminate, rem ;
 	increment_t	increment, start_filter_index ;
 	int			half_filter_chan_len, samples_in_hand ;
 
@@ -960,9 +960,9 @@ sinc_hex_vari_process (SRC_STATE *state, SRC_DATA *data)
 			src_ratio = state->last_ratio + filter->out_gen * (data->src_ratio - state->last_ratio) / filter->out_count ;
 
 		float_increment = filter->index_inc * (src_ratio < 1.0 ? src_ratio : 1.0) ;
-		increment = double_to_fp (float_increment) ;
+		increment = float_to_fp (float_increment) ;
 
-		start_filter_index = double_to_fp (input_index * float_increment) ;
+		start_filter_index = float_to_fp (input_index * float_increment) ;
 
 		calc_output_hex (filter, state->channels, increment, start_filter_index, float_increment / filter->index_inc, data->data_out + filter->out_gen) ;
 		filter->out_gen += 6 ;
@@ -987,10 +987,10 @@ sinc_hex_vari_process (SRC_STATE *state, SRC_DATA *data)
 } /* sinc_hex_vari_process */
 
 static inline void
-calc_output_multi (SINC_FILTER *filter, increment_t increment, increment_t start_filter_index, int channels, double scale, float * output)
-{	double		fraction, icoeff ;
+calc_output_multi (SINC_FILTER *filter, increment_t increment, increment_t start_filter_index, int channels, float scale, float * output)
+{	float		fraction, icoeff ;
 	/* The following line is 1999 ISO Standard C. If your compiler complains, get a better compiler. */
-	double		*left, *right ;
+	float		*left, *right ;
 	increment_t	filter_index, max_filter_index ;
 	int			data_index, coeff_count, indx ;
 
@@ -1017,7 +1017,7 @@ calc_output_multi (SINC_FILTER *filter, increment_t increment, increment_t start
 	memset (left, 0, sizeof (left [0]) * channels) ;
 
 	while (filter_index >= MAKE_INCREMENT_T (0))
-	{	fraction = fp_to_double (filter_index) ;
+	{	fraction = fp_to_float (filter_index) ;
 		indx = fp_to_int (filter_index) ;
 		assert (indx >= 0 && indx + 1 < filter->coeff_half_len + 2) ;
 		icoeff = filter->coeffs [indx] + fraction * (filter->coeffs [indx + 1] - filter->coeffs [indx]) ;
@@ -1039,7 +1039,7 @@ calc_output_multi (SINC_FILTER *filter, increment_t increment, increment_t start
 
 	memset (right, 0, sizeof (right [0]) * channels) ;
 	do
-	{	fraction = fp_to_double (filter_index) ;
+	{	fraction = fp_to_float (filter_index) ;
 		indx = fp_to_int (filter_index) ;
 		assert (indx >= 0 && indx + 1 < filter->coeff_half_len + 2) ;
 		icoeff = filter->coeffs [indx] + fraction * (filter->coeffs [indx + 1] - filter->coeffs [indx]) ;
@@ -1062,7 +1062,7 @@ calc_output_multi (SINC_FILTER *filter, increment_t increment, increment_t start
 static SRC_ERROR
 sinc_multichan_vari_process (SRC_STATE *state, SRC_DATA *data)
 {	SINC_FILTER *filter ;
-	double		input_index, src_ratio, count, float_increment, terminate, rem ;
+	float		input_index, src_ratio, count, float_increment, terminate, rem ;
 	increment_t	increment, start_filter_index ;
 	int			half_filter_chan_len, samples_in_hand ;
 
@@ -1125,9 +1125,9 @@ sinc_multichan_vari_process (SRC_STATE *state, SRC_DATA *data)
 			src_ratio = state->last_ratio + filter->out_gen * (data->src_ratio - state->last_ratio) / filter->out_count ;
 
 		float_increment = filter->index_inc * (src_ratio < 1.0 ? src_ratio : 1.0) ;
-		increment = double_to_fp (float_increment) ;
+		increment = float_to_fp (float_increment) ;
 
-		start_filter_index = double_to_fp (input_index * float_increment) ;
+		start_filter_index = float_to_fp (input_index * float_increment) ;
 
 		calc_output_multi (filter, increment, start_filter_index, state->channels, float_increment / filter->index_inc, data->data_out + filter->out_gen) ;
 		filter->out_gen += state->channels ;
diff --git a/lib/libsamplerate/libsamplerate-0.2.2/src/src_zoh.c b/lib/libsamplerate/libsamplerate-0.2.2/src/src_zoh.c
index 41ba79a1..c389d6cf 100755
--- a/lib/libsamplerate/libsamplerate-0.2.2/src/src_zoh.c
+++ b/lib/libsamplerate/libsamplerate-0.2.2/src/src_zoh.c
@@ -51,7 +51,7 @@ static SRC_STATE_VT zoh_state_vt =
 static SRC_ERROR
 zoh_vari_process (SRC_STATE *state, SRC_DATA *data)
 {	ZOH_DATA 	*priv ;
-	double		src_ratio, input_index, rem ;
+	float		src_ratio, input_index, rem ;
 	int			ch ;
 
 	if (data->input_frames <= 0)