MightyPork/tangara-fw
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
jacqueline
2023-08-03 15:32:28 +10:00
parent fbebc52511
commit 3511852f39
22 changed files with 607 additions and 126 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/libsamplerate/libsamplerate-0.2.2/include/samplerate.h
+4 -4
View File
@@ -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.
lib/libsamplerate/libsamplerate-0.2.2/src/common.h
+7 -7
View File
@@ -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 */
lib/libsamplerate/libsamplerate-0.2.2/src/samplerate.c
+4 -4
View File
@@ -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) ;
lib/libsamplerate/libsamplerate-0.2.2/src/src_linear.c
+3 -3
View File
@@ -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 ++ ;
} ;
lib/libsamplerate/libsamplerate-0.2.2/src/src_sinc.c
+44 -44
View File
@@ -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 ;
lib/libsamplerate/libsamplerate-0.2.2/src/src_zoh.c
+1 -1
View File
@@ -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)