diff options
Diffstat (limited to 'silk/float/silk_SigProc_FLP.h')
| -rw-r--r-- | silk/float/silk_SigProc_FLP.h | 96 |
1 files changed, 48 insertions, 48 deletions
diff --git a/silk/float/silk_SigProc_FLP.h b/silk/float/silk_SigProc_FLP.h index 05e620c8..b1019245 100644 --- a/silk/float/silk_SigProc_FLP.h +++ b/silk/float/silk_SigProc_FLP.h @@ -42,43 +42,43 @@ extern "C" /* Chirp (bw expand) LP AR filter */ void silk_bwexpander_FLP( - SKP_float *ar, /* io AR filter to be expanded (without leading 1) */ + silk_float *ar, /* io AR filter to be expanded (without leading 1) */ const opus_int d, /* i length of ar */ - const SKP_float chirp /* i chirp factor (typically in range (0..1) ) */ + const silk_float chirp /* i chirp factor (typically in range (0..1) ) */ ); /* compute inverse of LPC prediction gain, and */ /* test if LPC coefficients are stable (all poles within unit circle) */ /* this code is based on silk_FLP_a2k() */ opus_int silk_LPC_inverse_pred_gain_FLP( /* O: returns 1 if unstable, otherwise 0 */ - SKP_float *invGain, /* O: inverse prediction gain, energy domain */ - const SKP_float *A, /* I: prediction coefficients [order] */ + silk_float *invGain, /* O: inverse prediction gain, energy domain */ + const silk_float *A, /* I: prediction coefficients [order] */ opus_int32 order /* I: prediction order */ ); -SKP_float silk_schur_FLP( /* O returns residual energy */ - SKP_float refl_coef[], /* O reflection coefficients (length order) */ - const SKP_float auto_corr[], /* I autocorrelation sequence (length order+1) */ +silk_float silk_schur_FLP( /* O returns residual energy */ + silk_float refl_coef[], /* O reflection coefficients (length order) */ + const silk_float auto_corr[], /* I autocorrelation sequence (length order+1) */ opus_int order /* I order */ ); void silk_k2a_FLP( - SKP_float *A, /* O: prediction coefficients [order] */ - const SKP_float *rc, /* I: reflection coefficients [order] */ + silk_float *A, /* O: prediction coefficients [order] */ + const silk_float *rc, /* I: reflection coefficients [order] */ opus_int32 order /* I: prediction order */ ); /* Solve the normal equations using the Levinson-Durbin recursion */ -SKP_float silk_levinsondurbin_FLP( /* O prediction error energy */ - SKP_float A[], /* O prediction coefficients [order] */ - const SKP_float corr[], /* I input auto-correlations [order + 1] */ +silk_float silk_levinsondurbin_FLP( /* O prediction error energy */ + silk_float A[], /* O prediction coefficients [order] */ + const silk_float corr[], /* I input auto-correlations [order + 1] */ const opus_int order /* I prediction order */ ); /* compute autocorrelation */ void silk_autocorrelation_FLP( - SKP_float *results, /* o result (length correlationCount) */ - const SKP_float *inputData, /* i input data to correlate */ + silk_float *results, /* o result (length correlationCount) */ + const silk_float *inputData, /* i input data to correlate */ opus_int inputDataSize, /* i length of input */ opus_int correlationCount /* i number of correlation taps to compute */ ); @@ -89,14 +89,14 @@ void silk_autocorrelation_FLP( #define SigProc_PE_MAX_COMPLEX 2 opus_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoiced */ - const SKP_float *signal, /* I signal of length PE_FRAME_LENGTH_MS*Fs_kHz */ + const silk_float *signal, /* I signal of length PE_FRAME_LENGTH_MS*Fs_kHz */ opus_int *pitch_out, /* O 4 pitch lag values */ opus_int16 *lagIndex, /* O lag Index */ opus_int8 *contourIndex, /* O pitch contour Index */ - SKP_float *LTPCorr, /* I/O normalized correlation; input: value from previous frame */ + silk_float *LTPCorr, /* I/O normalized correlation; input: value from previous frame */ opus_int prevLag, /* I last lag of previous frame; set to zero is unvoiced */ - const SKP_float search_thres1, /* I first stage threshold for lag candidates 0 - 1 */ - const SKP_float search_thres2, /* I final threshold for lag candidates 0 - 1 */ + const silk_float search_thres1, /* I first stage threshold for lag candidates 0 - 1 */ + const silk_float search_thres2, /* I final threshold for lag candidates 0 - 1 */ const opus_int Fs_kHz, /* I sample frequency (kHz) */ const opus_int complexity, /* I Complexity setting, 0-2, where 2 is highest */ const opus_int nb_subfr /* I number of 5 ms subframes */ @@ -105,47 +105,47 @@ opus_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvo #define PI (3.1415926536f) void silk_insertion_sort_decreasing_FLP( - SKP_float *a, /* I/O: Unsorted / Sorted vector */ + silk_float *a, /* I/O: Unsorted / Sorted vector */ opus_int *idx, /* O: Index vector for the sorted elements */ const opus_int L, /* I: Vector length */ const opus_int K /* I: Number of correctly sorted positions */ ); /* Compute reflection coefficients from input signal */ -SKP_float silk_burg_modified_FLP( /* O returns residual energy */ - SKP_float A[], /* O prediction coefficients (length order) */ - const SKP_float x[], /* I input signal, length: nb_subfr*(D+L_sub) */ +silk_float silk_burg_modified_FLP( /* O returns residual energy */ + silk_float A[], /* O prediction coefficients (length order) */ + const silk_float x[], /* I input signal, length: nb_subfr*(D+L_sub) */ const opus_int subfr_length, /* I input signal subframe length (including D preceeding samples) */ const opus_int nb_subfr, /* I number of subframes stacked in x */ - const SKP_float WhiteNoiseFrac, /* I fraction added to zero-lag autocorrelation */ + const silk_float WhiteNoiseFrac, /* I fraction added to zero-lag autocorrelation */ const opus_int D /* I order */ ); /* multiply a vector by a constant */ void silk_scale_vector_FLP( - SKP_float *data1, - SKP_float gain, + silk_float *data1, + silk_float gain, opus_int dataSize ); /* copy and multiply a vector by a constant */ void silk_scale_copy_vector_FLP( - SKP_float *data_out, - const SKP_float *data_in, - SKP_float gain, + silk_float *data_out, + const silk_float *data_in, + silk_float gain, opus_int dataSize ); -/* inner product of two SKP_float arrays, with result as double */ +/* inner product of two silk_float arrays, with result as double */ double silk_inner_product_FLP( - const SKP_float *data1, - const SKP_float *data2, + const silk_float *data1, + const silk_float *data2, opus_int dataSize ); -/* sum of squares of a SKP_float array, with result as double */ +/* sum of squares of a silk_float array, with result as double */ double silk_energy_FLP( - const SKP_float *data, + const silk_float *data, opus_int dataSize ); @@ -153,21 +153,21 @@ double silk_energy_FLP( /* MACROS */ /********************************************************************/ -#define SKP_min_float(a, b) (((a) < (b)) ? (a) : (b)) -#define SKP_max_float(a, b) (((a) > (b)) ? (a) : (b)) -#define SKP_abs_float(a) ((SKP_float)fabs(a)) +#define silk_min_float(a, b) (((a) < (b)) ? (a) : (b)) +#define silk_max_float(a, b) (((a) > (b)) ? (a) : (b)) +#define silk_abs_float(a) ((silk_float)fabs(a)) -#define SKP_LIMIT_float( a, limit1, limit2) ((limit1) > (limit2) ? ((a) > (limit1) ? (limit1) : ((a) < (limit2) ? (limit2) : (a))) \ +#define silk_LIMIT_float( a, limit1, limit2) ((limit1) > (limit2) ? ((a) > (limit1) ? (limit1) : ((a) < (limit2) ? (limit2) : (a))) \ : ((a) > (limit2) ? (limit2) : ((a) < (limit1) ? (limit1) : (a)))) /* sigmoid function */ -static inline SKP_float SKP_sigmoid(SKP_float x) +static inline silk_float silk_sigmoid(silk_float x) { - return (SKP_float)(1.0 / (1.0 + exp(-x))); + return (silk_float)(1.0 / (1.0 + exp(-x))); } /* floating-point to integer conversion (rounding) */ -static inline opus_int32 SKP_float2int(double x) +static inline opus_int32 silk_float2int(double x) { #ifdef _WIN32 double t = x + 6755399441055744.0; @@ -178,9 +178,9 @@ static inline opus_int32 SKP_float2int(double x) } /* floating-point to integer conversion (rounding) */ -static inline void SKP_float2short_array( +static inline void silk_float2short_array( opus_int16 *out, - const SKP_float *in, + const silk_float *in, opus_int32 length ) { @@ -188,29 +188,29 @@ static inline void SKP_float2short_array( for (k = length-1; k >= 0; k--) { #ifdef _WIN32 double t = in[k] + 6755399441055744.0; - out[k] = (opus_int16)SKP_SAT16(*(( opus_int32 * )( &t ))); + out[k] = (opus_int16)silk_SAT16(*(( opus_int32 * )( &t ))); #else double x = in[k]; - out[k] = (opus_int16)SKP_SAT16( ( x > 0 ) ? x + 0.5 : x - 0.5 ); + out[k] = (opus_int16)silk_SAT16( ( x > 0 ) ? x + 0.5 : x - 0.5 ); #endif } } /* integer to floating-point conversion */ -static inline void SKP_short2float_array( - SKP_float *out, +static inline void silk_short2float_array( + silk_float *out, const opus_int16 *in, opus_int32 length ) { opus_int32 k; for (k = length-1; k >= 0; k--) { - out[k] = (SKP_float)in[k]; + out[k] = (silk_float)in[k]; } } /* using log2() helps the fixed-point conversion */ -static inline SKP_float silk_log2( double x ) { return ( SKP_float )( 3.32192809488736 * log10( x ) ); } +static inline silk_float silk_log2( double x ) { return ( silk_float )( 3.32192809488736 * log10( x ) ); } #ifdef __cplusplus } |