Something went wrong. Try again.
Reactos
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533/*** Copyright (c) 2002-2016, Erik de Castro Lopo <erikd@mega-nerd.com>** All rights reserved.**** This code is released under 2-clause BSD license. Please see the** file at : https://github.com/erikd/libsamplerate/blob/master/COPYING*/
#include "precomp.h"
static int psrc_set_converter (SRC_PRIVATE *psrc, int converter_type) ;
SRC_STATE *src_new (int converter_type, int channels, int *error){ SRC_PRIVATE *psrc ;
if (error) *error = SRC_ERR_NO_ERROR ;
if (channels < 1) { if (error) *error = SRC_ERR_BAD_CHANNEL_COUNT ; return NULL ; } ;
if ((psrc = calloc (1, sizeof (*psrc))) == NULL) { if (error) *error = SRC_ERR_MALLOC_FAILED ; return NULL ; } ;
psrc->channels = channels ; psrc->mode = SRC_MODE_PROCESS ;
if (psrc_set_converter (psrc, converter_type) != SRC_ERR_NO_ERROR) { if (error) *error = SRC_ERR_BAD_CONVERTER ; free (psrc) ; psrc = NULL ; } ;
src_reset ((SRC_STATE*) psrc) ;
return (SRC_STATE*) psrc ;} /* src_new */
SRC_STATE*src_callback_new (src_callback_t func, int converter_type, int channels, int *error, void* cb_data){ SRC_STATE *src_state ;
if (func == NULL) { if (error) *error = SRC_ERR_BAD_CALLBACK ; return NULL ; } ;
if (error != NULL) *error = 0 ;
if ((src_state = src_new (converter_type, channels, error)) == NULL) return NULL ;
src_reset (src_state) ;
((SRC_PRIVATE*) src_state)->mode = SRC_MODE_CALLBACK ; ((SRC_PRIVATE*) src_state)->callback_func = func ; ((SRC_PRIVATE*) src_state)->user_callback_data = cb_data ;
return src_state ;} /* src_callback_new */
SRC_STATE *src_delete (SRC_STATE *state){ SRC_PRIVATE *psrc ;
psrc = (SRC_PRIVATE*) state ; if (psrc) { if (psrc->private_data) free (psrc->private_data) ; memset (psrc, 0, sizeof (SRC_PRIVATE)) ; free (psrc) ; } ;
return NULL ;} /* src_state */
intsrc_process (SRC_STATE *state, SRC_DATA *data){ SRC_PRIVATE *psrc ; int error ;
psrc = (SRC_PRIVATE*) state ;
if (psrc == NULL) return SRC_ERR_BAD_STATE ; if (psrc->vari_process == NULL || psrc->const_process == NULL) return SRC_ERR_BAD_PROC_PTR ;
if (psrc->mode != SRC_MODE_PROCESS) return SRC_ERR_BAD_MODE ;
/* Check for valid SRC_DATA first. */ if (data == NULL) return SRC_ERR_BAD_DATA ;
/* And that data_in and data_out are valid. */ if (data->data_in == NULL || data->data_out == NULL) return SRC_ERR_BAD_DATA_PTR ;
/* Check src_ratio is in range. */ if (is_bad_src_ratio (data->src_ratio)) return SRC_ERR_BAD_SRC_RATIO ;
if (data->input_frames < 0) data->input_frames = 0 ; if (data->output_frames < 0) data->output_frames = 0 ;
if (data->data_in < data->data_out) { if (data->data_in + data->input_frames * psrc->channels > data->data_out) { /*-printf ("\n\ndata_in: %p data_out: %p\n", (void*) (data->data_in + data->input_frames * psrc->channels), (void*) data->data_out) ;-*/ return SRC_ERR_DATA_OVERLAP ; } ; } else if (data->data_out + data->output_frames * psrc->channels > data->data_in) { /*-printf ("\n\ndata_in : %p ouput frames: %ld data_out: %p\n", (void*) data->data_in, data->output_frames, (void*) data->data_out) ;
printf ("data_out: %p (%p) data_in: %p\n", (void*) data->data_out, (void*) (data->data_out + data->input_frames * psrc->channels), (void*) data->data_in) ;-*/ return SRC_ERR_DATA_OVERLAP ; } ;
/* Set the input and output counts to zero. */ data->input_frames_used = 0 ; data->output_frames_gen = 0 ;
/* Special case for when last_ratio has not been set. */ if (psrc->last_ratio < (1.0 / SRC_MAX_RATIO)) psrc->last_ratio = data->src_ratio ;
/* Now process. */ if (fabs (psrc->last_ratio - data->src_ratio) < 1e-15) error = psrc->const_process (psrc, data) ; else error = psrc->vari_process (psrc, data) ;
return error ;} /* src_process */
longsrc_callback_read (SRC_STATE *state, double src_ratio, long frames, float *data){ SRC_PRIVATE *psrc ; SRC_DATA src_data ;
long output_frames_gen ; int error = 0 ;
if (state == NULL) return 0 ;
if (frames <= 0) return 0 ;
psrc = (SRC_PRIVATE*) state ;
if (psrc->mode != SRC_MODE_CALLBACK) { psrc->error = SRC_ERR_BAD_MODE ; return 0 ; } ;
if (psrc->callback_func == NULL) { psrc->error = SRC_ERR_NULL_CALLBACK ; return 0 ; } ;
memset (&src_data, 0, sizeof (src_data)) ;
/* Check src_ratio is in range. */ if (is_bad_src_ratio (src_ratio)) { psrc->error = SRC_ERR_BAD_SRC_RATIO ; return 0 ; } ;
/* Switch modes temporarily. */ src_data.src_ratio = src_ratio ; src_data.data_out = data ; src_data.output_frames = frames ;
src_data.data_in = psrc->saved_data ; src_data.input_frames = psrc->saved_frames ;
output_frames_gen = 0 ; while (output_frames_gen < frames) { /* Use a dummy array for the case where the callback function ** returns without setting the ptr. */ float dummy [1] ;
if (src_data.input_frames == 0) { float *ptr = dummy ;
src_data.input_frames = psrc->callback_func (psrc->user_callback_data, &ptr) ; src_data.data_in = ptr ;
if (src_data.input_frames == 0) src_data.end_of_input = 1 ; } ;
/* ** Now call process function. However, we need to set the mode ** to SRC_MODE_PROCESS first and when we return set it back to ** SRC_MODE_CALLBACK. */ psrc->mode = SRC_MODE_PROCESS ; error = src_process (state, &src_data) ; psrc->mode = SRC_MODE_CALLBACK ;
if (error != 0) break ;
src_data.data_in += src_data.input_frames_used * psrc->channels ; src_data.input_frames -= src_data.input_frames_used ;
src_data.data_out += src_data.output_frames_gen * psrc->channels ; src_data.output_frames -= src_data.output_frames_gen ;
output_frames_gen += src_data.output_frames_gen ;
if (src_data.end_of_input == SRC_TRUE && src_data.output_frames_gen == 0) break ; } ;
psrc->saved_data = src_data.data_in ; psrc->saved_frames = src_data.input_frames ;
if (error != 0) { psrc->error = error ; return 0 ; } ;
return output_frames_gen ;} /* src_callback_read */
/*==========================================================================*/
intsrc_set_ratio (SRC_STATE *state, double new_ratio){ SRC_PRIVATE *psrc ;
psrc = (SRC_PRIVATE*) state ;
if (psrc == NULL) return SRC_ERR_BAD_STATE ; if (psrc->vari_process == NULL || psrc->const_process == NULL) return SRC_ERR_BAD_PROC_PTR ;
if (is_bad_src_ratio (new_ratio)) return SRC_ERR_BAD_SRC_RATIO ;
psrc->last_ratio = new_ratio ;
return SRC_ERR_NO_ERROR ;} /* src_set_ratio */
intsrc_get_channels (SRC_STATE *state){ SRC_PRIVATE *psrc ;
psrc = (SRC_PRIVATE*) state ;
if (psrc == NULL) return SRC_ERR_BAD_STATE ; if (psrc->vari_process == NULL || psrc->const_process == NULL) return SRC_ERR_BAD_PROC_PTR ;
return psrc->channels ;} /* src_get_channels */
intsrc_reset (SRC_STATE *state){ SRC_PRIVATE *psrc ;
if ((psrc = (SRC_PRIVATE*) state) == NULL) return SRC_ERR_BAD_STATE ;
if (psrc->reset != NULL) psrc->reset (psrc) ;
psrc->last_position = 0.0 ; psrc->last_ratio = 0.0 ;
psrc->saved_data = NULL ; psrc->saved_frames = 0 ;
psrc->error = SRC_ERR_NO_ERROR ;
return SRC_ERR_NO_ERROR ;} /* src_reset */
/*==============================================================================** Control functions.*/
const char *src_get_name (int converter_type){ const char *desc ;
if ((desc = sinc_get_name (converter_type)) != NULL) return desc ;
if ((desc = zoh_get_name (converter_type)) != NULL) return desc ;
if ((desc = linear_get_name (converter_type)) != NULL) return desc ;
return NULL ;} /* src_get_name */
const char *src_get_description (int converter_type){ const char *desc ;
if ((desc = sinc_get_description (converter_type)) != NULL) return desc ;
if ((desc = zoh_get_description (converter_type)) != NULL) return desc ;
if ((desc = linear_get_description (converter_type)) != NULL) return desc ;
return NULL ;} /* src_get_description */
const char *src_get_version (void){ return PACKAGE "-" VERSION " (c) 2002-2008 Erik de Castro Lopo" ;} /* src_get_version */
intsrc_is_valid_ratio (double ratio){ if (is_bad_src_ratio (ratio)) return SRC_FALSE ;
return SRC_TRUE ;} /* src_is_valid_ratio */
/*==============================================================================** Error reporting functions.*/
intsrc_error (SRC_STATE *state){ if (state) return ((SRC_PRIVATE*) state)->error ; return SRC_ERR_NO_ERROR ;} /* src_error */
const char*src_strerror (int error){ switch (error) { case SRC_ERR_NO_ERROR : return "No error." ; case SRC_ERR_MALLOC_FAILED : return "Malloc failed." ; case SRC_ERR_BAD_STATE : return "SRC_STATE pointer is NULL." ; case SRC_ERR_BAD_DATA : return "SRC_DATA pointer is NULL." ; case SRC_ERR_BAD_DATA_PTR : return "SRC_DATA->data_out or SRC_DATA->data_in is NULL." ; case SRC_ERR_NO_PRIVATE : return "Internal error. No private data." ;
case SRC_ERR_BAD_SRC_RATIO : return "SRC ratio outside [1/" SRC_MAX_RATIO_STR ", " SRC_MAX_RATIO_STR "] range." ;
case SRC_ERR_BAD_SINC_STATE : return "src_process() called without reset after end_of_input." ; case SRC_ERR_BAD_PROC_PTR : return "Internal error. No process pointer." ; case SRC_ERR_SHIFT_BITS : return "Internal error. SHIFT_BITS too large." ; case SRC_ERR_FILTER_LEN : return "Internal error. Filter length too large." ; case SRC_ERR_BAD_CONVERTER : return "Bad converter number." ; case SRC_ERR_BAD_CHANNEL_COUNT : return "Channel count must be >= 1." ; case SRC_ERR_SINC_BAD_BUFFER_LEN : return "Internal error. Bad buffer length. Please report this." ; case SRC_ERR_SIZE_INCOMPATIBILITY : return "Internal error. Input data / internal buffer size difference. Please report this." ; case SRC_ERR_BAD_PRIV_PTR : return "Internal error. Private pointer is NULL. Please report this." ; case SRC_ERR_DATA_OVERLAP : return "Input and output data arrays overlap." ; case SRC_ERR_BAD_CALLBACK : return "Supplied callback function pointer is NULL." ; case SRC_ERR_BAD_MODE : return "Calling mode differs from initialisation mode (ie process v callback)." ; case SRC_ERR_NULL_CALLBACK : return "Callback function pointer is NULL in src_callback_read ()." ; case SRC_ERR_NO_VARIABLE_RATIO : return "This converter only allows constant conversion ratios." ; case SRC_ERR_SINC_PREPARE_DATA_BAD_LEN : return "Internal error : Bad length in prepare_data ()." ; case SRC_ERR_BAD_INTERNAL_STATE : return "Error : Someone is trampling on my internal state." ;
case SRC_ERR_MAX_ERROR : return "Placeholder. No error defined for this error number." ;
default : break ; }
return NULL ;} /* src_strerror */
/*==============================================================================** Simple interface for performing a single conversion from input buffer to** output buffer at a fixed conversion ratio.*/
intsrc_simple (SRC_DATA *src_data, int converter, int channels){ SRC_STATE *src_state ; int error ;
if ((src_state = src_new (converter, channels, &error)) == NULL) return error ;
src_data->end_of_input = 1 ; /* Only one buffer worth of input. */
error = src_process (src_state, src_data) ;
src_delete (src_state) ;
return error ;} /* src_simple */
voidsrc_short_to_float_array (const short *in, float *out, int len){ while (len) { len -- ; out [len] = (float) (in [len] / (1.0 * 0x8000)) ; } ;
return ;} /* src_short_to_float_array */
voidsrc_float_to_short_array (const float *in, short *out, int len){ double scaled_value ;
while (len) { len -- ;
scaled_value = in [len] * (8.0 * 0x10000000) ; if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF)) { out [len] = 32767 ; continue ; } ; if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000)) { out [len] = -32768 ; continue ; } ;
out [len] = (short) (lrint (scaled_value) >> 16) ; } ;
} /* src_float_to_short_array */
voidsrc_int_to_float_array (const int *in, float *out, int len){ while (len) { len -- ; out [len] = (float) (in [len] / (8.0 * 0x10000000)) ; } ;
return ;} /* src_int_to_float_array */
voidsrc_float_to_int_array (const float *in, int *out, int len){ double scaled_value ;
while (len) { len -- ;
scaled_value = in [len] * (8.0 * 0x10000000) ; if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF)) { out [len] = 0x7fffffff ; continue ; } ; if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000)) { out [len] = -1 - 0x7fffffff ; continue ; } ;
out [len] = lrint (scaled_value) ; } ;
} /* src_float_to_int_array */
/*==============================================================================** Private functions.*/
static intpsrc_set_converter (SRC_PRIVATE *psrc, int converter_type){ if (sinc_set_converter (psrc, converter_type) == SRC_ERR_NO_ERROR) return SRC_ERR_NO_ERROR ;
if (zoh_set_converter (psrc, converter_type) == SRC_ERR_NO_ERROR) return SRC_ERR_NO_ERROR ;
if (linear_set_converter (psrc, converter_type) == SRC_ERR_NO_ERROR) return SRC_ERR_NO_ERROR ;
return SRC_ERR_BAD_CONVERTER ;} /* psrc_set_converter */