Renaming the SKP_ prefix to silk_
authorJean-Marc Valin <jmvalin@jmvalin.ca>
Fri, 16 Sep 2011 07:58:26 +0000 (00:58 -0700)
committerJean-Marc Valin <jmvalin@jmvalin.ca>
Fri, 16 Sep 2011 07:58:26 +0000 (00:58 -0700)
145 files changed:
silk/fixed/silk_LTP_analysis_filter_FIX.c
silk/fixed/silk_LTP_scale_ctrl_FIX.c
silk/fixed/silk_corrMatrix_FIX.c
silk/fixed/silk_encode_frame_FIX.c
silk/fixed/silk_find_LPC_FIX.c
silk/fixed/silk_find_LTP_FIX.c
silk/fixed/silk_find_pitch_lags_FIX.c
silk/fixed/silk_find_pred_coefs_FIX.c
silk/fixed/silk_noise_shape_analysis_FIX.c
silk/fixed/silk_prefilter_FIX.c
silk/fixed/silk_process_gains_FIX.c
silk/fixed/silk_regularize_correlations_FIX.c
silk/fixed/silk_residual_energy16_FIX.c
silk/fixed/silk_residual_energy_FIX.c
silk/fixed/silk_solve_LS_FIX.c
silk/fixed/silk_structs_FIX.h
silk/fixed/silk_warped_autocorrelation_FIX.c
silk/float/silk_LPC_analysis_filter_FLP.c
silk/float/silk_LPC_inv_pred_gain_FLP.c
silk/float/silk_LTP_analysis_filter_FLP.c
silk/float/silk_LTP_scale_ctrl_FLP.c
silk/float/silk_SigProc_FLP.h
silk/float/silk_apply_sine_window_FLP.c
silk/float/silk_autocorrelation_FLP.c
silk/float/silk_burg_modified_FLP.c
silk/float/silk_bwexpander_FLP.c
silk/float/silk_corrMatrix_FLP.c
silk/float/silk_encode_frame_FLP.c
silk/float/silk_energy_FLP.c
silk/float/silk_find_LPC_FLP.c
silk/float/silk_find_LTP_FLP.c
silk/float/silk_find_pitch_lags_FLP.c
silk/float/silk_find_pred_coefs_FLP.c
silk/float/silk_inner_product_FLP.c
silk/float/silk_k2a_FLP.c
silk/float/silk_levinsondurbin_FLP.c
silk/float/silk_main_FLP.h
silk/float/silk_noise_shape_analysis_FLP.c
silk/float/silk_pitch_analysis_core_FLP.c
silk/float/silk_prefilter_FLP.c
silk/float/silk_process_gains_FLP.c
silk/float/silk_regularize_correlations_FLP.c
silk/float/silk_residual_energy_FLP.c
silk/float/silk_scale_copy_vector_FLP.c
silk/float/silk_scale_vector_FLP.c
silk/float/silk_schur_FLP.c
silk/float/silk_solve_LS_FLP.c
silk/float/silk_sort_FLP.c
silk/float/silk_structs_FLP.h
silk/float/silk_warped_autocorrelation_FLP.c
silk/float/silk_wrappers_FLP.c
silk/silk_A2NLSF.c
silk/silk_CNG.c
silk/silk_HP_variable_cutoff.c
silk/silk_Inlines.h
silk/silk_LPC_analysis_filter.c
silk/silk_LPC_inv_pred_gain.c
silk/silk_LP_variable_cutoff.c
silk/silk_MacroCount.h
silk/silk_MacroDebug.h
silk/silk_NLSF2A.c
silk/silk_NLSF_VQ.c
silk/silk_NLSF_VQ_weights_laroia.c
silk/silk_NLSF_decode.c
silk/silk_NLSF_del_dec_quant.c
silk/silk_NLSF_encode.c
silk/silk_NLSF_stabilize.c
silk/silk_NLSF_unpack.c
silk/silk_NSQ.c
silk/silk_NSQ_del_dec.c
silk/silk_PLC.c
silk/silk_SigProc_FIX.h
silk/silk_VAD.c
silk/silk_VQ_WMat_EC.c
silk/silk_ana_filt_bank_1.c
silk/silk_apply_sine_window.c
silk/silk_array_maxabs.c
silk/silk_autocorr.c
silk/silk_biquad_alt.c
silk/silk_burg_modified.c
silk/silk_bwexpander.c
silk/silk_bwexpander_32.c
silk/silk_check_control_input.c
silk/silk_code_signs.c
silk/silk_control_SNR.c
silk/silk_control_audio_bandwidth.c
silk/silk_control_codec.c
silk/silk_create_init_destroy.c
silk/silk_debug.c
silk/silk_debug.h
silk/silk_dec_API.c
silk/silk_decode_core.c
silk/silk_decode_frame.c
silk/silk_decode_indices.c
silk/silk_decode_parameters.c
silk/silk_decode_pitch.c
silk/silk_decode_pulses.c
silk/silk_decoder_set_fs.c
silk/silk_enc_API.c
silk/silk_encode_indices.c
silk/silk_encode_pulses.c
silk/silk_gain_quant.c
silk/silk_init_encoder.c
silk/silk_inner_prod_aligned.c
silk/silk_interpolate.c
silk/silk_k2a.c
silk/silk_k2a_Q16.c
silk/silk_lin2log.c
silk/silk_log2lin.c
silk/silk_macros.h
silk/silk_pitch_analysis_core.c
silk/silk_process_NLSFs.c
silk/silk_quant_LTP_gains.c
silk/silk_resampler.c
silk/silk_resampler_down2.c
silk/silk_resampler_down2_3.c
silk/silk_resampler_down3.c
silk/silk_resampler_private_AR2.c
silk/silk_resampler_private_ARMA4.c
silk/silk_resampler_private_IIR_FIR.c
silk/silk_resampler_private_copy.c
silk/silk_resampler_private_down4.c
silk/silk_resampler_private_down_FIR.c
silk/silk_resampler_private_up2_HQ.c
silk/silk_resampler_private_up4.c
silk/silk_resampler_rom.c
silk/silk_resampler_up2.c
silk/silk_scale_copy_vector16.c
silk/silk_scale_vector.c
silk/silk_schur.c
silk/silk_schur64.c
silk/silk_shell_coder.c
silk/silk_sigm_Q15.c
silk/silk_sort.c
silk/silk_stereo_LR_to_MS.c
silk/silk_stereo_MS_to_LR.c
silk/silk_stereo_decode_pred.c
silk/silk_stereo_encode_pred.c
silk/silk_stereo_find_predictor.c
silk/silk_stereo_quant_pred.c
silk/silk_structs.h
silk/silk_sum_sqr_shift.c
silk/silk_typedef.h
src/opus_decoder.c
src/opus_encoder.c

index 1d65b8c..7809a32 100644 (file)
@@ -62,17 +62,17 @@ void silk_LTP_analysis_filter_FIX(
             LTP_res_ptr[ i ] = x_ptr[ i ];
 
             /* Long-term prediction */
-            LTP_est = SKP_SMULBB( x_lag_ptr[ LTP_ORDER / 2 ], Btmp_Q14[ 0 ] );
+            LTP_est = silk_SMULBB( x_lag_ptr[ LTP_ORDER / 2 ], Btmp_Q14[ 0 ] );
             for( j = 1; j < LTP_ORDER; j++ ) {
-                LTP_est = SKP_SMLABB_ovflw( LTP_est, x_lag_ptr[ LTP_ORDER / 2 - j ], Btmp_Q14[ j ] );
+                LTP_est = silk_SMLABB_ovflw( LTP_est, x_lag_ptr[ LTP_ORDER / 2 - j ], Btmp_Q14[ j ] );
             }
-            LTP_est = SKP_RSHIFT_ROUND( LTP_est, 14 ); /* round and -> Q0*/
+            LTP_est = silk_RSHIFT_ROUND( LTP_est, 14 ); /* round and -> Q0*/
 
             /* Subtract long-term prediction */
-            LTP_res_ptr[ i ] = ( opus_int16 )SKP_SAT16( ( opus_int32 )x_ptr[ i ] - LTP_est );
+            LTP_res_ptr[ i ] = ( opus_int16 )silk_SAT16( ( opus_int32 )x_ptr[ i ] - LTP_est );
 
             /* Scale residual */
-            LTP_res_ptr[ i ] = SKP_SMULWB( invGains_Q16[ k ], LTP_res_ptr[ i ] );
+            LTP_res_ptr[ i ] = silk_SMULWB( invGains_Q16[ k ], LTP_res_ptr[ i ] );
 
             x_lag_ptr++;
         }
index b6b427f..abd5356 100644 (file)
@@ -39,15 +39,15 @@ void silk_LTP_scale_ctrl_FIX(
     opus_int round_loss;
 
     /* 1st order high-pass filter */
-    psEnc->HPLTPredCodGain_Q7 = SKP_max_int( psEncCtrl->LTPredCodGain_Q7 - SKP_RSHIFT( psEnc->prevLTPredCodGain_Q7, 1 ), 0 )
-        + SKP_RSHIFT( psEnc->HPLTPredCodGain_Q7, 1 );
+    psEnc->HPLTPredCodGain_Q7 = silk_max_int( psEncCtrl->LTPredCodGain_Q7 - silk_RSHIFT( psEnc->prevLTPredCodGain_Q7, 1 ), 0 )
+        + silk_RSHIFT( psEnc->HPLTPredCodGain_Q7, 1 );
     psEnc->prevLTPredCodGain_Q7 = psEncCtrl->LTPredCodGain_Q7;
 
     /* Only scale if first frame in packet */
     if( psEnc->sCmn.nFramesEncoded == 0 ) {
         round_loss = psEnc->sCmn.PacketLoss_perc + psEnc->sCmn.nFramesPerPacket - 1;
-        psEnc->sCmn.indices.LTP_scaleIndex = (opus_int8)SKP_LIMIT(
-            SKP_SMULWB( SKP_SMULBB( round_loss, psEnc->HPLTPredCodGain_Q7 ), SILK_FIX_CONST( 0.1, 9 ) ), 0, 2 );
+        psEnc->sCmn.indices.LTP_scaleIndex = (opus_int8)silk_LIMIT(
+            silk_SMULWB( silk_SMULBB( round_loss, psEnc->HPLTPredCodGain_Q7 ), SILK_FIX_CONST( 0.1, 9 ) ), 0, 2 );
     } else {
         /* Default is minimum scaling */
         psEnc->sCmn.indices.LTP_scaleIndex = 0;
index 20655c3..4475b9c 100644 (file)
@@ -57,13 +57,13 @@ void silk_corrVector_FIX(
         for( lag = 0; lag < order; lag++ ) {
             inner_prod = 0;
             for( i = 0; i < L; i++ ) {
-                inner_prod += SKP_RSHIFT32( SKP_SMULBB( ptr1[ i ], ptr2[i] ), rshifts );
+                inner_prod += silk_RSHIFT32( silk_SMULBB( ptr1[ i ], ptr2[i] ), rshifts );
             }
             Xt[ lag ] = inner_prod; /* X[:,lag]'*t */
             ptr1--; /* Go to next column of X */
         }
     } else {
-        SKP_assert( rshifts == 0 );
+        silk_assert( rshifts == 0 );
         for( lag = 0; lag < order; lag++ ) {
             Xt[ lag ] = silk_inner_prod_aligned( ptr1, ptr2, L ); /* X[:,lag]'*t */
             ptr1--; /* Go to next column of X */
@@ -88,19 +88,19 @@ void silk_corrMatrix_FIX(
     /* Calculate energy to find shift used to fit in 32 bits */
     silk_sum_sqr_shift( &energy, &rshifts_local, x, L + order - 1 );
     /* Add shifts to get the desired head room */
-    head_room_rshifts = SKP_max( head_room - silk_CLZ32( energy ), 0 );
+    head_room_rshifts = silk_max( head_room - silk_CLZ32( energy ), 0 );
 
-    energy = SKP_RSHIFT32( energy, head_room_rshifts );
+    energy = silk_RSHIFT32( energy, head_room_rshifts );
     rshifts_local += head_room_rshifts;
 
     /* Calculate energy of first column (0) of X: X[:,0]'*X[:,0] */
     /* Remove contribution of first order - 1 samples */
     for( i = 0; i < order - 1; i++ ) {
-        energy -= SKP_RSHIFT32( SKP_SMULBB( x[ i ], x[ i ] ), rshifts_local );
+        energy -= silk_RSHIFT32( silk_SMULBB( x[ i ], x[ i ] ), rshifts_local );
     }
     if( rshifts_local < *rshifts ) {
         /* Adjust energy */
-        energy = SKP_RSHIFT32( energy, *rshifts - rshifts_local );
+        energy = silk_RSHIFT32( energy, *rshifts - rshifts_local );
         rshifts_local = *rshifts;
     }
 
@@ -109,8 +109,8 @@ void silk_corrMatrix_FIX(
     matrix_ptr( XX, 0, 0, order ) = energy;
     ptr1 = &x[ order - 1 ]; /* First sample of column 0 of X */
     for( j = 1; j < order; j++ ) {
-        energy = SKP_SUB32( energy, SKP_RSHIFT32( SKP_SMULBB( ptr1[ L - j ], ptr1[ L - j ] ), rshifts_local ) );
-        energy = SKP_ADD32( energy, SKP_RSHIFT32( SKP_SMULBB( ptr1[ -j ], ptr1[ -j ] ), rshifts_local ) );
+        energy = silk_SUB32( energy, silk_RSHIFT32( silk_SMULBB( ptr1[ L - j ], ptr1[ L - j ] ), rshifts_local ) );
+        energy = silk_ADD32( energy, silk_RSHIFT32( silk_SMULBB( ptr1[ -j ], ptr1[ -j ] ), rshifts_local ) );
         matrix_ptr( XX, j, j, order ) = energy;
     }
 
@@ -122,14 +122,14 @@ void silk_corrMatrix_FIX(
             /* Inner product of column 0 and column lag: X[:,0]'*X[:,lag] */
             energy = 0;
             for( i = 0; i < L; i++ ) {
-                energy += SKP_RSHIFT32( SKP_SMULBB( ptr1[ i ], ptr2[i] ), rshifts_local );
+                energy += silk_RSHIFT32( silk_SMULBB( ptr1[ i ], ptr2[i] ), rshifts_local );
             }
             /* Calculate remaining off diagonal: X[:,j]'*X[:,j + lag] */
             matrix_ptr( XX, lag, 0, order ) = energy;
             matrix_ptr( XX, 0, lag, order ) = energy;
             for( j = 1; j < ( order - lag ); j++ ) {
-                energy = SKP_SUB32( energy, SKP_RSHIFT32( SKP_SMULBB( ptr1[ L - j ], ptr2[ L - j ] ), rshifts_local ) );
-                energy = SKP_ADD32( energy, SKP_RSHIFT32( SKP_SMULBB( ptr1[ -j ], ptr2[ -j ] ), rshifts_local ) );
+                energy = silk_SUB32( energy, silk_RSHIFT32( silk_SMULBB( ptr1[ L - j ], ptr2[ L - j ] ), rshifts_local ) );
+                energy = silk_ADD32( energy, silk_RSHIFT32( silk_SMULBB( ptr1[ -j ], ptr2[ -j ] ), rshifts_local ) );
                 matrix_ptr( XX, lag + j, j, order ) = energy;
                 matrix_ptr( XX, j, lag + j, order ) = energy;
             }
@@ -143,8 +143,8 @@ void silk_corrMatrix_FIX(
             matrix_ptr( XX, 0, lag, order ) = energy;
             /* Calculate remaining off diagonal: X[:,j]'*X[:,j + lag] */
             for( j = 1; j < ( order - lag ); j++ ) {
-                energy = SKP_SUB32( energy, SKP_SMULBB( ptr1[ L - j ], ptr2[ L - j ] ) );
-                energy = SKP_SMLABB( energy, ptr1[ -j ], ptr2[ -j ] );
+                energy = silk_SUB32( energy, silk_SMULBB( ptr1[ L - j ], ptr2[ L - j ] ) );
+                energy = silk_SMLABB( energy, ptr1[ -j ], ptr2[ -j ] );
                 matrix_ptr( XX, lag + j, j, order ) = energy;
                 matrix_ptr( XX, j, lag + j, order ) = energy;
             }
index 079577b..ad52207 100644 (file)
@@ -96,7 +96,7 @@ TOC(VAD)
     /*******************************************/
     /* Copy new frame to front of input buffer */
     /*******************************************/
-    SKP_memcpy( x_frame + LA_SHAPE_MS * psEnc->sCmn.fs_kHz, psEnc->sCmn.inputBuf + 1, psEnc->sCmn.frame_length * sizeof( opus_int16 ) );
+    silk_memcpy( x_frame + LA_SHAPE_MS * psEnc->sCmn.fs_kHz, psEnc->sCmn.inputBuf + 1, psEnc->sCmn.frame_length * sizeof( opus_int16 ) );
 
     /*****************************************/
     /* Find pitch lags, initial LPC analysis */
@@ -156,7 +156,7 @@ TIC(NSQ)
 TOC(NSQ)
 
     /* Update input buffer */
-    SKP_memmove( psEnc->x_buf, &psEnc->x_buf[ psEnc->sCmn.frame_length ],
+    silk_memmove( psEnc->x_buf, &psEnc->x_buf[ psEnc->sCmn.frame_length ],
         ( psEnc->sCmn.ltp_mem_length + LA_SHAPE_MS * psEnc->sCmn.fs_kHz ) * sizeof( opus_int16 ) );
 
     /* Parameters needed for next frame */
@@ -191,7 +191,7 @@ TOC(ENCODE_PULSES)
     psEnc->sCmn.first_frame_after_reset = 0;
     if( ++psEnc->sCmn.nFramesEncoded >= psEnc->sCmn.nFramesPerPacket ) {
         /* Payload size */
-        *pnBytesOut = SKP_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );
+        *pnBytesOut = silk_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );
 
         /* Reset the number of frames in payload buffer */
         psEnc->sCmn.nFramesEncoded = 0;
@@ -203,40 +203,40 @@ TOC(ENCODE_FRAME)
 
 #ifdef SAVE_ALL_INTERNAL_DATA
     {
-        SKP_float tmp[ MAX_NB_SUBFR * LTP_ORDER ];
+        silk_float tmp[ MAX_NB_SUBFR * LTP_ORDER ];
         int i;
         DEBUG_STORE_DATA( xf.dat,                   x_frame + LA_SHAPE_MS * psEnc->sCmn.fs_kHz, psEnc->sCmn.frame_length * sizeof( opus_int16 ) );
         DEBUG_STORE_DATA( xfw.dat,                  xfw,                            psEnc->sCmn.frame_length    * sizeof( opus_int16 ) );
         DEBUG_STORE_DATA( pitchL.dat,               sEncCtrl.pitchL,                psEnc->sCmn.nb_subfr        * sizeof( opus_int ) );
         for( i = 0; i < psEnc->sCmn.nb_subfr * LTP_ORDER; i++ ) {
-            tmp[ i ] = (SKP_float)sEncCtrl.LTPCoef_Q14[ i ] / 16384.0f;
+            tmp[ i ] = (silk_float)sEncCtrl.LTPCoef_Q14[ i ] / 16384.0f;
         }
-        DEBUG_STORE_DATA( pitchG_quantized.dat,     tmp,                            psEnc->sCmn.nb_subfr * LTP_ORDER * sizeof( SKP_float ) );
+        DEBUG_STORE_DATA( pitchG_quantized.dat,     tmp,                            psEnc->sCmn.nb_subfr * LTP_ORDER * sizeof( silk_float ) );
         for( i = 0; i <psEnc->sCmn.predictLPCOrder; i++ ) {
-            tmp[ i ] = (SKP_float)sEncCtrl.PredCoef_Q12[ 1 ][ i ] / 4096.0f;
+            tmp[ i ] = (silk_float)sEncCtrl.PredCoef_Q12[ 1 ][ i ] / 4096.0f;
         }
-        DEBUG_STORE_DATA( PredCoef.dat,             tmp,                            psEnc->sCmn.predictLPCOrder * sizeof( SKP_float ) );
-
-        tmp[ 0 ] = (SKP_float)sEncCtrl.LTPredCodGain_Q7 / 128.0f;
-        DEBUG_STORE_DATA( LTPredCodGain.dat,        tmp,                            sizeof( SKP_float ) );
-        tmp[ 0 ] = (SKP_float)psEnc->LTPCorr_Q15 / 32768.0f;
-        DEBUG_STORE_DATA( LTPcorr.dat,              tmp,                            sizeof( SKP_float ) );
-        tmp[ 0 ] = (SKP_float)psEnc->sCmn.input_tilt_Q15 / 32768.0f;
-        DEBUG_STORE_DATA( tilt.dat,                 tmp,                            sizeof( SKP_float ) );
+        DEBUG_STORE_DATA( PredCoef.dat,             tmp,                            psEnc->sCmn.predictLPCOrder * sizeof( silk_float ) );
+
+        tmp[ 0 ] = (silk_float)sEncCtrl.LTPredCodGain_Q7 / 128.0f;
+        DEBUG_STORE_DATA( LTPredCodGain.dat,        tmp,                            sizeof( silk_float ) );
+        tmp[ 0 ] = (silk_float)psEnc->LTPCorr_Q15 / 32768.0f;
+        DEBUG_STORE_DATA( LTPcorr.dat,              tmp,                            sizeof( silk_float ) );
+        tmp[ 0 ] = (silk_float)psEnc->sCmn.input_tilt_Q15 / 32768.0f;
+        DEBUG_STORE_DATA( tilt.dat,                 tmp,                            sizeof( silk_float ) );
         for( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
-            tmp[ i ] = (SKP_float)sEncCtrl.Gains_Q16[ i ] / 65536.0f;
+            tmp[ i ] = (silk_float)sEncCtrl.Gains_Q16[ i ] / 65536.0f;
         }
-        DEBUG_STORE_DATA( gains.dat,                tmp,                            psEnc->sCmn.nb_subfr * sizeof( SKP_float ) );
+        DEBUG_STORE_DATA( gains.dat,                tmp,                            psEnc->sCmn.nb_subfr * sizeof( silk_float ) );
         DEBUG_STORE_DATA( gains_indices.dat,        &psEnc->sCmn.indices.GainsIndices, psEnc->sCmn.nb_subfr * sizeof( opus_int ) );
-        tmp[ 0 ] = (SKP_float)sEncCtrl.current_SNR_dB_Q7 / 128.0f;
-        DEBUG_STORE_DATA( current_SNR_db.dat,       tmp,                            sizeof( SKP_float ) );
+        tmp[ 0 ] = (silk_float)sEncCtrl.current_SNR_dB_Q7 / 128.0f;
+        DEBUG_STORE_DATA( current_SNR_db.dat,       tmp,                            sizeof( silk_float ) );
         DEBUG_STORE_DATA( quantOffsetType.dat,      &psEnc->sCmn.indices.quantOffsetType, sizeof( opus_int ) );
-        tmp[ 0 ] = (SKP_float)psEnc->sCmn.speech_activity_Q8 / 256.0f;
-        DEBUG_STORE_DATA( speech_activity.dat,      tmp,                            sizeof( SKP_float ) );
+        tmp[ 0 ] = (silk_float)psEnc->sCmn.speech_activity_Q8 / 256.0f;
+        DEBUG_STORE_DATA( speech_activity.dat,      tmp,                            sizeof( silk_float ) );
         for( i = 0; i < VAD_N_BANDS; i++ ) {
-            tmp[ i ] = (SKP_float)psEnc->sCmn.input_quality_bands_Q15[ i ] / 32768.0f;
+            tmp[ i ] = (silk_float)psEnc->sCmn.input_quality_bands_Q15[ i ] / 32768.0f;
         }
-        DEBUG_STORE_DATA( input_quality_bands.dat,  tmp,                       VAD_N_BANDS * sizeof( SKP_float ) );
+        DEBUG_STORE_DATA( input_quality_bands.dat,  tmp,                       VAD_N_BANDS * sizeof( silk_float ) );
         DEBUG_STORE_DATA( signalType.dat,           &psEnc->sCmn.indices.signalType,         sizeof( opus_int8) );
         DEBUG_STORE_DATA( lag_index.dat,            &psEnc->sCmn.indices.lagIndex,           sizeof( opus_int16 ) );
         DEBUG_STORE_DATA( contour_index.dat,        &psEnc->sCmn.indices.contourIndex,       sizeof( opus_int8 ) );
@@ -264,11 +264,11 @@ void silk_LBRR_encode_FIX(
         psEnc->sCmn.LBRR_flags[ psEnc->sCmn.nFramesEncoded ] = 1;
 
         /* Copy noise shaping quantizer state and quantization indices from regular encoding */
-        SKP_memcpy( &sNSQ_LBRR, &psEnc->sCmn.sNSQ, sizeof( silk_nsq_state ) );
-        SKP_memcpy( psIndices_LBRR, &psEnc->sCmn.indices, sizeof( SideInfoIndices ) );
+        silk_memcpy( &sNSQ_LBRR, &psEnc->sCmn.sNSQ, sizeof( silk_nsq_state ) );
+        silk_memcpy( psIndices_LBRR, &psEnc->sCmn.indices, sizeof( SideInfoIndices ) );
 
         /* Save original gains */
-        SKP_memcpy( TempGains_Q16, psEncCtrl->Gains_Q16, psEnc->sCmn.nb_subfr * sizeof( opus_int32 ) );
+        silk_memcpy( TempGains_Q16, psEncCtrl->Gains_Q16, psEnc->sCmn.nb_subfr * sizeof( opus_int32 ) );
 
         if( psEnc->sCmn.nFramesEncoded == 0 || psEnc->sCmn.LBRR_flags[ psEnc->sCmn.nFramesEncoded - 1 ] == 0 ) {
             /* First frame in packet or previous frame not LBRR coded */
@@ -276,7 +276,7 @@ void silk_LBRR_encode_FIX(
 
             /* Increase Gains to get target LBRR rate */
             psIndices_LBRR->GainsIndices[ 0 ] = psIndices_LBRR->GainsIndices[ 0 ] + psEnc->sCmn.LBRR_GainIncreases;
-            psIndices_LBRR->GainsIndices[ 0 ] = SKP_min_int( psIndices_LBRR->GainsIndices[ 0 ], N_LEVELS_QGAIN - 1 );
+            psIndices_LBRR->GainsIndices[ 0 ] = silk_min_int( psIndices_LBRR->GainsIndices[ 0 ], N_LEVELS_QGAIN - 1 );
         }
 
         /* Decode to get gains in sync with decoder         */
@@ -300,6 +300,6 @@ void silk_LBRR_encode_FIX(
         }
 
         /* Restore original gains */
-        SKP_memcpy( psEncCtrl->Gains_Q16, TempGains_Q16, psEnc->sCmn.nb_subfr * sizeof( opus_int32 ) );
+        silk_memcpy( psEncCtrl->Gains_Q16, TempGains_Q16, psEnc->sCmn.nb_subfr * sizeof( opus_int32 ) );
     }
 }
index 44d702d..a1bda7a 100644 (file)
@@ -83,11 +83,11 @@ void silk_find_LPC_FIX(
         shift = res_tmp_nrg_Q - res_nrg_Q;
         if( shift >= 0 ) {
             if( shift < 32 ) {
-                res_nrg = res_nrg - SKP_RSHIFT( res_tmp_nrg, shift );
+                res_nrg = res_nrg - silk_RSHIFT( res_tmp_nrg, shift );
             }
         } else {
-            SKP_assert( shift > -32 );
-            res_nrg   = SKP_RSHIFT( res_nrg, -shift ) - res_tmp_nrg;
+            silk_assert( shift > -32 );
+            res_nrg   = silk_RSHIFT( res_nrg, -shift ) - res_tmp_nrg;
             res_nrg_Q = res_tmp_nrg_Q;
         }
 
@@ -95,7 +95,7 @@ void silk_find_LPC_FIX(
         silk_A2NLSF( NLSF_Q15, a_tmp_Q16, LPC_order );
 
         /* Search over interpolation indices to find the one with lowest residual energy */
-        res_nrg_2nd = SKP_int32_MAX;
+        res_nrg_2nd = silk_int32_MAX;
         for( k = 3; k >= 0; k-- ) {
             /* Interpolate NLSFs for first half */
             silk_interpolate( NLSF0_Q15, prev_NLSFq_Q15, NLSF_Q15, k, LPC_order );
@@ -112,36 +112,36 @@ void silk_find_LPC_FIX(
             /* Add subframe energies from first half frame */
             shift = rshift0 - rshift1;
             if( shift >= 0 ) {
-                res_nrg1         = SKP_RSHIFT( res_nrg1, shift );
+                res_nrg1         = silk_RSHIFT( res_nrg1, shift );
                 res_nrg_interp_Q = -rshift0;
             } else {
-                res_nrg0         = SKP_RSHIFT( res_nrg0, -shift );
+                res_nrg0         = silk_RSHIFT( res_nrg0, -shift );
                 res_nrg_interp_Q = -rshift1;
             }
-            res_nrg_interp = SKP_ADD32( res_nrg0, res_nrg1 );
+            res_nrg_interp = silk_ADD32( res_nrg0, res_nrg1 );
 
             /* Compare with first half energy without NLSF interpolation, or best interpolated value so far */
             shift = res_nrg_interp_Q - res_nrg_Q;
             if( shift >= 0 ) {
-                if( SKP_RSHIFT( res_nrg_interp, shift ) < res_nrg ) {
-                    isInterpLower = SKP_TRUE;
+                if( silk_RSHIFT( res_nrg_interp, shift ) < res_nrg ) {
+                    isInterpLower = silk_TRUE;
                 } else {
-                    isInterpLower = SKP_FALSE;
+                    isInterpLower = silk_FALSE;
                 }
             } else {
                 if( -shift < 32 ) {
-                    if( res_nrg_interp < SKP_RSHIFT( res_nrg, -shift ) ) {
-                        isInterpLower = SKP_TRUE;
+                    if( res_nrg_interp < silk_RSHIFT( res_nrg, -shift ) ) {
+                        isInterpLower = silk_TRUE;
                     } else {
-                        isInterpLower = SKP_FALSE;
+                        isInterpLower = silk_FALSE;
                     }
                 } else {
-                    isInterpLower = SKP_FALSE;
+                    isInterpLower = silk_FALSE;
                 }
             }
 
             /* Determine whether current interpolated NLSFs are best so far */
-            if( isInterpLower == SKP_TRUE ) {
+            if( isInterpLower == silk_TRUE ) {
                 /* Interpolation has lower residual energy */
                 res_nrg   = res_nrg_interp;
                 res_nrg_Q = res_nrg_interp_Q;
@@ -157,5 +157,5 @@ void silk_find_LPC_FIX(
         silk_A2NLSF( NLSF_Q15, a_Q16, LPC_order );
     }
 
-    SKP_assert( *interpIndex == 4 || ( useInterpNLSFs && !firstFrameAfterReset && nb_subfr == MAX_NB_SUBFR ) );
+    silk_assert( *interpIndex == 4 || ( useInterpNLSFs && !firstFrameAfterReset && nb_subfr == MAX_NB_SUBFR ) );
 }
index 53d0765..eaeaba1 100644 (file)
@@ -80,7 +80,7 @@ void silk_find_LTP_FIX(
         /* Assure headroom */
         LZs = silk_CLZ32( rr[k] );
         if( LZs < LTP_CORRS_HEAD_ROOM ) {
-            rr[ k ] = SKP_RSHIFT_ROUND( rr[ k ], LTP_CORRS_HEAD_ROOM - LZs );
+            rr[ k ] = silk_RSHIFT_ROUND( rr[ k ], LTP_CORRS_HEAD_ROOM - LZs );
             rr_shifts += ( LTP_CORRS_HEAD_ROOM - LZs );
         }
         corr_rshifts[ k ] = rr_shifts;
@@ -89,14 +89,14 @@ void silk_find_LTP_FIX(
         /* The correlation vector always has lower max abs value than rr and/or RR so head room is assured */
         silk_corrVector_FIX( lag_ptr, r_ptr, subfr_length, LTP_ORDER, Rr, corr_rshifts[ k ] );  /* Rr_fix_ptr   in Q( -corr_rshifts[ k ] ) */
         if( corr_rshifts[ k ] > rr_shifts ) {
-            rr[ k ] = SKP_RSHIFT( rr[ k ], corr_rshifts[ k ] - rr_shifts ); /* rr[ k ] in Q( -corr_rshifts[ k ] ) */
+            rr[ k ] = silk_RSHIFT( rr[ k ], corr_rshifts[ k ] - rr_shifts ); /* rr[ k ] in Q( -corr_rshifts[ k ] ) */
         }
-        SKP_assert( rr[ k ] >= 0 );
+        silk_assert( rr[ k ] >= 0 );
 
         regu = 1;
-        regu = SKP_SMLAWB( regu, rr[ k ], SILK_FIX_CONST( LTP_DAMPING/3, 16 ) );
-        regu = SKP_SMLAWB( regu, matrix_ptr( WLTP_ptr, 0, 0, LTP_ORDER ), SILK_FIX_CONST( LTP_DAMPING/3, 16 ) );
-        regu = SKP_SMLAWB( regu, matrix_ptr( WLTP_ptr, LTP_ORDER-1, LTP_ORDER-1, LTP_ORDER ), SILK_FIX_CONST( LTP_DAMPING/3, 16 ) );
+        regu = silk_SMLAWB( regu, rr[ k ], SILK_FIX_CONST( LTP_DAMPING/3, 16 ) );
+        regu = silk_SMLAWB( regu, matrix_ptr( WLTP_ptr, 0, 0, LTP_ORDER ), SILK_FIX_CONST( LTP_DAMPING/3, 16 ) );
+        regu = silk_SMLAWB( regu, matrix_ptr( WLTP_ptr, LTP_ORDER-1, LTP_ORDER-1, LTP_ORDER ), SILK_FIX_CONST( LTP_DAMPING/3, 16 ) );
         silk_regularize_correlations_FIX( WLTP_ptr, &rr[k], regu, LTP_ORDER );
 
         silk_solve_LDL_FIX( WLTP_ptr, LTP_ORDER, Rr, b_Q16 ); /* WLTP_fix_ptr and Rr_fix_ptr both in Q(-corr_rshifts[k]) */
@@ -108,29 +108,29 @@ void silk_find_LTP_FIX(
         nrg[ k ] = silk_residual_energy16_covar_FIX( b_Q14_ptr, WLTP_ptr, Rr, rr[ k ], LTP_ORDER, 14 ); /* nrg_fix in Q( -corr_rshifts[ k ] ) */
 
         /* temp = Wght[ k ] / ( nrg[ k ] * Wght[ k ] + 0.01f * subfr_length ); */
-        extra_shifts = SKP_min_int( corr_rshifts[ k ], LTP_CORRS_HEAD_ROOM );
-        denom32 = SKP_LSHIFT_SAT32( SKP_SMULWB( nrg[ k ], Wght_Q15[ k ] ), 1 + extra_shifts ) + /* Q( -corr_rshifts[ k ] + extra_shifts ) */
-            SKP_RSHIFT( SKP_SMULWB( subfr_length, 655 ), corr_rshifts[ k ] - extra_shifts );    /* Q( -corr_rshifts[ k ] + extra_shifts ) */
-        denom32 = SKP_max( denom32, 1 );
-        SKP_assert( ((opus_int64)Wght_Q15[ k ] << 16 ) < SKP_int32_MAX );                        /* Wght always < 0.5 in Q0 */
-        temp32 = SKP_DIV32( SKP_LSHIFT( ( opus_int32 )Wght_Q15[ k ], 16 ), denom32 );            /* Q( 15 + 16 + corr_rshifts[k] - extra_shifts ) */
-        temp32 = SKP_RSHIFT( temp32, 31 + corr_rshifts[ k ] - extra_shifts - 26 );              /* Q26 */
+        extra_shifts = silk_min_int( corr_rshifts[ k ], LTP_CORRS_HEAD_ROOM );
+        denom32 = silk_LSHIFT_SAT32( silk_SMULWB( nrg[ k ], Wght_Q15[ k ] ), 1 + extra_shifts ) + /* Q( -corr_rshifts[ k ] + extra_shifts ) */
+            silk_RSHIFT( silk_SMULWB( subfr_length, 655 ), corr_rshifts[ k ] - extra_shifts );    /* Q( -corr_rshifts[ k ] + extra_shifts ) */
+        denom32 = silk_max( denom32, 1 );
+        silk_assert( ((opus_int64)Wght_Q15[ k ] << 16 ) < silk_int32_MAX );                        /* Wght always < 0.5 in Q0 */
+        temp32 = silk_DIV32( silk_LSHIFT( ( opus_int32 )Wght_Q15[ k ], 16 ), denom32 );            /* Q( 15 + 16 + corr_rshifts[k] - extra_shifts ) */
+        temp32 = silk_RSHIFT( temp32, 31 + corr_rshifts[ k ] - extra_shifts - 26 );              /* Q26 */
 
         /* Limit temp such that the below scaling never wraps around */
         WLTP_max = 0;
         for( i = 0; i < LTP_ORDER * LTP_ORDER; i++ ) {
-            WLTP_max = SKP_max( WLTP_ptr[ i ], WLTP_max );
+            WLTP_max = silk_max( WLTP_ptr[ i ], WLTP_max );
         }
         lshift = silk_CLZ32( WLTP_max ) - 1 - 3; /* keep 3 bits free for vq_nearest_neighbor_fix */
-        SKP_assert( 26 - 18 + lshift >= 0 );
+        silk_assert( 26 - 18 + lshift >= 0 );
         if( 26 - 18 + lshift < 31 ) {
-            temp32 = SKP_min_32( temp32, SKP_LSHIFT( ( opus_int32 )1, 26 - 18 + lshift ) );
+            temp32 = silk_min_32( temp32, silk_LSHIFT( ( opus_int32 )1, 26 - 18 + lshift ) );
         }
 
         silk_scale_vector32_Q26_lshift_18( WLTP_ptr, temp32, LTP_ORDER * LTP_ORDER ); /* WLTP_ptr in Q( 18 - corr_rshifts[ k ] ) */
 
         w[ k ] = matrix_ptr( WLTP_ptr, LTP_ORDER/2, LTP_ORDER/2, LTP_ORDER ); /* w in Q( 18 - corr_rshifts[ k ] ) */
-        SKP_assert( w[k] >= 0 );
+        silk_assert( w[k] >= 0 );
 
         r_ptr     += subfr_length;
         b_Q14_ptr += LTP_ORDER;
@@ -139,24 +139,24 @@ void silk_find_LTP_FIX(
 
     maxRshifts = 0;
     for( k = 0; k < nb_subfr; k++ ) {
-        maxRshifts = SKP_max_int( corr_rshifts[ k ], maxRshifts );
+        maxRshifts = silk_max_int( corr_rshifts[ k ], maxRshifts );
     }
 
     /* Compute LTP coding gain */
     if( LTPredCodGain_Q7 != NULL ) {
         LPC_LTP_res_nrg = 0;
         LPC_res_nrg     = 0;
-        SKP_assert( LTP_CORRS_HEAD_ROOM >= 2 ); /* Check that no overflow will happen when adding */
+        silk_assert( LTP_CORRS_HEAD_ROOM >= 2 ); /* Check that no overflow will happen when adding */
         for( k = 0; k < nb_subfr; k++ ) {
-            LPC_res_nrg     = SKP_ADD32( LPC_res_nrg,     SKP_RSHIFT( SKP_ADD32( SKP_SMULWB(  rr[ k ], Wght_Q15[ k ] ), 1 ), 1 + ( maxRshifts - corr_rshifts[ k ] ) ) ); /*  Q( -maxRshifts ) */
-            LPC_LTP_res_nrg = SKP_ADD32( LPC_LTP_res_nrg, SKP_RSHIFT( SKP_ADD32( SKP_SMULWB( nrg[ k ], Wght_Q15[ k ] ), 1 ), 1 + ( maxRshifts - corr_rshifts[ k ] ) ) ); /*  Q( -maxRshifts ) */
+            LPC_res_nrg     = silk_ADD32( LPC_res_nrg,     silk_RSHIFT( silk_ADD32( silk_SMULWB(  rr[ k ], Wght_Q15[ k ] ), 1 ), 1 + ( maxRshifts - corr_rshifts[ k ] ) ) ); /*  Q( -maxRshifts ) */
+            LPC_LTP_res_nrg = silk_ADD32( LPC_LTP_res_nrg, silk_RSHIFT( silk_ADD32( silk_SMULWB( nrg[ k ], Wght_Q15[ k ] ), 1 ), 1 + ( maxRshifts - corr_rshifts[ k ] ) ) ); /*  Q( -maxRshifts ) */
         }
-        LPC_LTP_res_nrg = SKP_max( LPC_LTP_res_nrg, 1 ); /* avoid division by zero */
+        LPC_LTP_res_nrg = silk_max( LPC_LTP_res_nrg, 1 ); /* avoid division by zero */
 
         div_Q16 = silk_DIV32_varQ( LPC_res_nrg, LPC_LTP_res_nrg, 16 );
-        *LTPredCodGain_Q7 = ( opus_int )SKP_SMULBB( 3, silk_lin2log( div_Q16 ) - ( 16 << 7 ) );
+        *LTPredCodGain_Q7 = ( opus_int )silk_SMULBB( 3, silk_lin2log( div_Q16 ) - ( 16 << 7 ) );
 
-        SKP_assert( *LTPredCodGain_Q7 == ( opus_int )SKP_SAT16( SKP_MUL( 3, silk_lin2log( div_Q16 ) - ( 16 << 7 ) ) ) );
+        silk_assert( *LTPredCodGain_Q7 == ( opus_int )silk_SAT16( silk_MUL( 3, silk_lin2log( div_Q16 ) - ( 16 << 7 ) ) ) );
     }
 
     /* smoothing */
@@ -176,30 +176,30 @@ void silk_find_LTP_FIX(
     max_abs_d_Q14 = 0;
     max_w_bits    = 0;
     for( k = 0; k < nb_subfr; k++ ) {
-        max_abs_d_Q14 = SKP_max_32( max_abs_d_Q14, SKP_abs( d_Q14[ k ] ) );
+        max_abs_d_Q14 = silk_max_32( max_abs_d_Q14, silk_abs( d_Q14[ k ] ) );
         /* w[ k ] is in Q( 18 - corr_rshifts[ k ] ) */
         /* Find bits needed in Q( 18 - maxRshifts ) */
-        max_w_bits = SKP_max_32( max_w_bits, 32 - silk_CLZ32( w[ k ] ) + corr_rshifts[ k ] - maxRshifts );
+        max_w_bits = silk_max_32( max_w_bits, 32 - silk_CLZ32( w[ k ] ) + corr_rshifts[ k ] - maxRshifts );
     }
 
-    /* max_abs_d_Q14 = (5 << 15); worst case, i.e. LTP_ORDER * -SKP_int16_MIN */
-    SKP_assert( max_abs_d_Q14 <= ( 5 << 15 ) );
+    /* max_abs_d_Q14 = (5 << 15); worst case, i.e. LTP_ORDER * -silk_int16_MIN */
+    silk_assert( max_abs_d_Q14 <= ( 5 << 15 ) );
 
     /* How many bits is needed for w*d' in Q( 18 - maxRshifts ) in the worst case, of all d_Q14's being equal to max_abs_d_Q14 */
     extra_shifts = max_w_bits + 32 - silk_CLZ32( max_abs_d_Q14 ) - 14;
 
     /* Subtract what we got available; bits in output var plus maxRshifts */
     extra_shifts -= ( 32 - 1 - 2 + maxRshifts ); /* Keep sign bit free as well as 2 bits for accumulation */
-    extra_shifts = SKP_max_int( extra_shifts, 0 );
+    extra_shifts = silk_max_int( extra_shifts, 0 );
 
     maxRshifts_wxtra = maxRshifts + extra_shifts;
 
-    temp32 = SKP_RSHIFT( 262, maxRshifts + extra_shifts ) + 1; /* 1e-3f in Q( 18 - (maxRshifts + extra_shifts) ) */
+    temp32 = silk_RSHIFT( 262, maxRshifts + extra_shifts ) + 1; /* 1e-3f in Q( 18 - (maxRshifts + extra_shifts) ) */
     wd = 0;
     for( k = 0; k < nb_subfr; k++ ) {
         /* w has at least 2 bits of headroom so no overflow should happen */
-        temp32 = SKP_ADD32( temp32,                     SKP_RSHIFT( w[ k ], maxRshifts_wxtra - corr_rshifts[ k ] ) );                    /* Q( 18 - maxRshifts_wxtra ) */
-        wd     = SKP_ADD32( wd, SKP_LSHIFT( SKP_SMULWW( SKP_RSHIFT( w[ k ], maxRshifts_wxtra - corr_rshifts[ k ] ), d_Q14[ k ] ), 2 ) ); /* Q( 18 - maxRshifts_wxtra ) */
+        temp32 = silk_ADD32( temp32,                     silk_RSHIFT( w[ k ], maxRshifts_wxtra - corr_rshifts[ k ] ) );                    /* Q( 18 - maxRshifts_wxtra ) */
+        wd     = silk_ADD32( wd, silk_LSHIFT( silk_SMULWW( silk_RSHIFT( w[ k ], maxRshifts_wxtra - corr_rshifts[ k ] ), d_Q14[ k ] ), 2 ) ); /* Q( 18 - maxRshifts_wxtra ) */
     }
     m_Q12 = silk_DIV32_varQ( wd, temp32, 12 );
 
@@ -207,25 +207,25 @@ void silk_find_LTP_FIX(
     for( k = 0; k < nb_subfr; k++ ) {
         /* w_fix[ k ] from Q( 18 - corr_rshifts[ k ] ) to Q( 16 ) */
         if( 2 - corr_rshifts[k] > 0 ) {
-            temp32 = SKP_RSHIFT( w[ k ], 2 - corr_rshifts[ k ] );
+            temp32 = silk_RSHIFT( w[ k ], 2 - corr_rshifts[ k ] );
         } else {
-            temp32 = SKP_LSHIFT_SAT32( w[ k ], corr_rshifts[ k ] - 2 );
+            temp32 = silk_LSHIFT_SAT32( w[ k ], corr_rshifts[ k ] - 2 );
         }
 
-        g_Q26 = SKP_MUL(
-            SKP_DIV32(
+        g_Q26 = silk_MUL(
+            silk_DIV32(
                 SILK_FIX_CONST( LTP_SMOOTHING, 26 ),
-                SKP_RSHIFT( SILK_FIX_CONST( LTP_SMOOTHING, 26 ), 10 ) + temp32 ),                                       /* Q10 */
-            SKP_LSHIFT_SAT32( SKP_SUB_SAT32( ( opus_int32 )m_Q12, SKP_RSHIFT( d_Q14[ k ], 2 ) ), 4 ) );  /* Q16 */
+                silk_RSHIFT( SILK_FIX_CONST( LTP_SMOOTHING, 26 ), 10 ) + temp32 ),                                       /* Q10 */
+            silk_LSHIFT_SAT32( silk_SUB_SAT32( ( opus_int32 )m_Q12, silk_RSHIFT( d_Q14[ k ], 2 ) ), 4 ) );  /* Q16 */
 
         temp32 = 0;
         for( i = 0; i < LTP_ORDER; i++ ) {
-            delta_b_Q14[ i ] = SKP_max_16( b_Q14_ptr[ i ], 1638 );  /* 1638_Q14 = 0.1_Q0 */
+            delta_b_Q14[ i ] = silk_max_16( b_Q14_ptr[ i ], 1638 );  /* 1638_Q14 = 0.1_Q0 */
             temp32 += delta_b_Q14[ i ];                          /* Q14 */
         }
-        temp32 = SKP_DIV32( g_Q26, temp32 ); /* Q14->Q12 */
+        temp32 = silk_DIV32( g_Q26, temp32 ); /* Q14->Q12 */
         for( i = 0; i < LTP_ORDER; i++ ) {
-            b_Q14_ptr[ i ] = SKP_LIMIT_32( ( opus_int32 )b_Q14_ptr[ i ] + SKP_SMULWB( SKP_LSHIFT_SAT32( temp32, 4 ), delta_b_Q14[ i ] ), -16000, 28000 );
+            b_Q14_ptr[ i ] = silk_LIMIT_32( ( opus_int32 )b_Q14_ptr[ i ] + silk_SMULWB( silk_LSHIFT_SAT32( temp32, 4 ), delta_b_Q14[ i ] ), -16000, 28000 );
         }
         b_Q14_ptr += LTP_ORDER;
     }
@@ -240,6 +240,6 @@ void silk_fit_LTP(
     opus_int i;
 
     for( i = 0; i < LTP_ORDER; i++ ) {
-        LTP_coefs_Q14[ i ] = ( opus_int16 )SKP_SAT16( SKP_RSHIFT_ROUND( LTP_coefs_Q16[ i ], 2 ) );
+        LTP_coefs_Q14[ i ] = ( opus_int16 )silk_SAT16( silk_RSHIFT_ROUND( LTP_coefs_Q16[ i ], 2 ) );
     }
 }
index 69a7fcb..ba69668 100644 (file)
@@ -55,7 +55,7 @@ void silk_find_pitch_lags_FIX(
     buf_len = psEnc->sCmn.la_pitch + psEnc->sCmn.frame_length + psEnc->sCmn.ltp_mem_length;
 
     /* Safty check */
-    SKP_assert( buf_len >= psEnc->sCmn.pitch_LPC_win_length );
+    silk_assert( buf_len >= psEnc->sCmn.pitch_LPC_win_length );
 
     x_buf = x - psEnc->sCmn.ltp_mem_length;
 
@@ -73,31 +73,31 @@ void silk_find_pitch_lags_FIX(
     /* Middle un - windowed samples */
     Wsig_ptr  += psEnc->sCmn.la_pitch;
     x_buf_ptr += psEnc->sCmn.la_pitch;
-    SKP_memcpy( Wsig_ptr, x_buf_ptr, ( psEnc->sCmn.pitch_LPC_win_length - SKP_LSHIFT( psEnc->sCmn.la_pitch, 1 ) ) * sizeof( opus_int16 ) );
+    silk_memcpy( Wsig_ptr, x_buf_ptr, ( psEnc->sCmn.pitch_LPC_win_length - silk_LSHIFT( psEnc->sCmn.la_pitch, 1 ) ) * sizeof( opus_int16 ) );
 
     /* Last LA_LTP samples */
-    Wsig_ptr  += psEnc->sCmn.pitch_LPC_win_length - SKP_LSHIFT( psEnc->sCmn.la_pitch, 1 );
-    x_buf_ptr += psEnc->sCmn.pitch_LPC_win_length - SKP_LSHIFT( psEnc->sCmn.la_pitch, 1 );
+    Wsig_ptr  += psEnc->sCmn.pitch_LPC_win_length - silk_LSHIFT( psEnc->sCmn.la_pitch, 1 );
+    x_buf_ptr += psEnc->sCmn.pitch_LPC_win_length - silk_LSHIFT( psEnc->sCmn.la_pitch, 1 );
     silk_apply_sine_window( Wsig_ptr, x_buf_ptr, 2, psEnc->sCmn.la_pitch );
 
     /* Calculate autocorrelation sequence */
     silk_autocorr( auto_corr, &scale, Wsig, psEnc->sCmn.pitch_LPC_win_length, psEnc->sCmn.pitchEstimationLPCOrder + 1 );
 
     /* Add white noise, as fraction of energy */
-    auto_corr[ 0 ] = SKP_SMLAWB( auto_corr[ 0 ], auto_corr[ 0 ], SILK_FIX_CONST( FIND_PITCH_WHITE_NOISE_FRACTION, 16 ) ) + 1;
+    auto_corr[ 0 ] = silk_SMLAWB( auto_corr[ 0 ], auto_corr[ 0 ], SILK_FIX_CONST( FIND_PITCH_WHITE_NOISE_FRACTION, 16 ) ) + 1;
 
     /* Calculate the reflection coefficients using schur */
     res_nrg = silk_schur( rc_Q15, auto_corr, psEnc->sCmn.pitchEstimationLPCOrder );
 
     /* Prediction gain */
-    psEncCtrl->predGain_Q16 = silk_DIV32_varQ( auto_corr[ 0 ], SKP_max_int( res_nrg, 1 ), 16 );
+    psEncCtrl->predGain_Q16 = silk_DIV32_varQ( auto_corr[ 0 ], silk_max_int( res_nrg, 1 ), 16 );
 
     /* Convert reflection coefficients to prediction coefficients */
     silk_k2a( A_Q24, rc_Q15, psEnc->sCmn.pitchEstimationLPCOrder );
 
     /* Convert From 32 bit Q24 to 16 bit Q12 coefs */
     for( i = 0; i < psEnc->sCmn.pitchEstimationLPCOrder; i++ ) {
-        A_Q12[ i ] = ( opus_int16 )SKP_SAT16( SKP_RSHIFT( A_Q24[ i ], 12 ) );
+        A_Q12[ i ] = ( opus_int16 )silk_SAT16( silk_RSHIFT( A_Q24[ i ], 12 ) );
     }
 
     /* Do BWE */
@@ -111,11 +111,11 @@ void silk_find_pitch_lags_FIX(
     if( psEnc->sCmn.indices.signalType != TYPE_NO_VOICE_ACTIVITY && psEnc->sCmn.first_frame_after_reset == 0 ) {
         /* Threshold for pitch estimator */
         thrhld_Q15 = SILK_FIX_CONST( 0.6, 15 );
-        thrhld_Q15 = SKP_SMLABB( thrhld_Q15, SILK_FIX_CONST( -0.004, 15 ), psEnc->sCmn.pitchEstimationLPCOrder );
-        thrhld_Q15 = SKP_SMLABB( thrhld_Q15, SILK_FIX_CONST( -0.1,   7  ), psEnc->sCmn.speech_activity_Q8 );
-        thrhld_Q15 = SKP_SMLABB( thrhld_Q15, SILK_FIX_CONST( -0.15,  15 ), SKP_RSHIFT( psEnc->sCmn.prevSignalType, 1 ) );
-        thrhld_Q15 = SKP_SMLAWB( thrhld_Q15, SILK_FIX_CONST( -0.1,   16 ), psEnc->sCmn.input_tilt_Q15 );
-        thrhld_Q15 = SKP_SAT16(  thrhld_Q15 );
+        thrhld_Q15 = silk_SMLABB( thrhld_Q15, SILK_FIX_CONST( -0.004, 15 ), psEnc->sCmn.pitchEstimationLPCOrder );
+        thrhld_Q15 = silk_SMLABB( thrhld_Q15, SILK_FIX_CONST( -0.1,   7  ), psEnc->sCmn.speech_activity_Q8 );
+        thrhld_Q15 = silk_SMLABB( thrhld_Q15, SILK_FIX_CONST( -0.15,  15 ), silk_RSHIFT( psEnc->sCmn.prevSignalType, 1 ) );
+        thrhld_Q15 = silk_SMLAWB( thrhld_Q15, SILK_FIX_CONST( -0.1,   16 ), psEnc->sCmn.input_tilt_Q15 );
+        thrhld_Q15 = silk_SAT16(  thrhld_Q15 );
 
         /*****************************************/
         /* Call pitch estimator                  */
@@ -129,7 +129,7 @@ void silk_find_pitch_lags_FIX(
             psEnc->sCmn.indices.signalType = TYPE_UNVOICED;
         }
     } else {
-        SKP_memset( psEncCtrl->pitchL, 0, sizeof( psEncCtrl->pitchL ) );
+        silk_memset( psEncCtrl->pitchL, 0, sizeof( psEncCtrl->pitchL ) );
         psEnc->sCmn.indices.lagIndex = 0;
         psEnc->sCmn.indices.contourIndex = 0;
         psEnc->LTPCorr_Q15 = 0;
index c5d7d57..f7ad87f 100644 (file)
@@ -48,33 +48,33 @@ void silk_find_pred_coefs_FIX(
     opus_int         LTP_corrs_rshift[ MAX_NB_SUBFR ];
 
     /* weighting for weighted least squares */
-    min_gain_Q16 = SKP_int32_MAX >> 6;
+    min_gain_Q16 = silk_int32_MAX >> 6;
     for( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
-        min_gain_Q16 = SKP_min( min_gain_Q16, psEncCtrl->Gains_Q16[ i ] );
+        min_gain_Q16 = silk_min( min_gain_Q16, psEncCtrl->Gains_Q16[ i ] );
     }
     for( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
         /* Divide to Q16 */
-        SKP_assert( psEncCtrl->Gains_Q16[ i ] > 0 );
+        silk_assert( psEncCtrl->Gains_Q16[ i ] > 0 );
         /* Invert and normalize gains, and ensure that maximum invGains_Q16 is within range of a 16 bit int */
         invGains_Q16[ i ] = silk_DIV32_varQ( min_gain_Q16, psEncCtrl->Gains_Q16[ i ], 16 - 2 );
 
         /* Ensure Wght_Q15 a minimum value 1 */
-        invGains_Q16[ i ] = SKP_max( invGains_Q16[ i ], 363 );
+        invGains_Q16[ i ] = silk_max( invGains_Q16[ i ], 363 );
 
         /* Square the inverted gains */
-        SKP_assert( invGains_Q16[ i ] == SKP_SAT16( invGains_Q16[ i ] ) );
-        tmp = SKP_SMULWB( invGains_Q16[ i ], invGains_Q16[ i ] );
-        Wght_Q15[ i ] = SKP_RSHIFT( tmp, 1 );
+        silk_assert( invGains_Q16[ i ] == silk_SAT16( invGains_Q16[ i ] ) );
+        tmp = silk_SMULWB( invGains_Q16[ i ], invGains_Q16[ i ] );
+        Wght_Q15[ i ] = silk_RSHIFT( tmp, 1 );
 
         /* Invert the inverted and normalized gains */
-        local_gains[ i ] = SKP_DIV32( ( 1 << 16 ), invGains_Q16[ i ] );
+        local_gains[ i ] = silk_DIV32( ( 1 << 16 ), invGains_Q16[ i ] );
     }
 
     if( psEnc->sCmn.indices.signalType == TYPE_VOICED ) {
         /**********/
         /* VOICED */
         /**********/
-        SKP_assert( psEnc->sCmn.ltp_mem_length - psEnc->sCmn.predictLPCOrder >= psEncCtrl->pitchL[ 0 ] + LTP_ORDER / 2 );
+        silk_assert( psEnc->sCmn.ltp_mem_length - psEnc->sCmn.predictLPCOrder >= psEncCtrl->pitchL[ 0 ] + LTP_ORDER / 2 );
 
         /* LTP analysis */
         silk_find_LTP_FIX( psEncCtrl->LTPCoef_Q14, WLTP, &psEncCtrl->LTPredCodGain_Q7,
@@ -106,7 +106,7 @@ void silk_find_pred_coefs_FIX(
             x_ptr     += psEnc->sCmn.subfr_length;
         }
 
-        SKP_memset( psEncCtrl->LTPCoef_Q14, 0, psEnc->sCmn.nb_subfr * LTP_ORDER * sizeof( opus_int16 ) );
+        silk_memset( psEncCtrl->LTPCoef_Q14, 0, psEnc->sCmn.nb_subfr * LTP_ORDER * sizeof( opus_int16 ) );
         psEncCtrl->LTPredCodGain_Q7 = 0;
     }
 
@@ -127,5 +127,5 @@ void silk_find_pred_coefs_FIX(
         psEnc->sCmn.subfr_length, psEnc->sCmn.nb_subfr, psEnc->sCmn.predictLPCOrder );
 
     /* Copy to prediction struct for use in next frame for fluctuation reduction */
-    SKP_memcpy( psEnc->sCmn.prev_NLSFq_Q15, NLSF_Q15, sizeof( psEnc->sCmn.prev_NLSFq_Q15 ) );
+    silk_memcpy( psEnc->sCmn.prev_NLSFq_Q15, NLSF_Q15, sizeof( psEnc->sCmn.prev_NLSFq_Q15 ) );
 }
index ea26832..c4789e6 100644 (file)
@@ -45,9 +45,9 @@ static inline opus_int32 warped_gain( /* gain in Q16*/
     lambda_Q16 = -lambda_Q16;
     gain_Q24 = coefs_Q24[ order - 1 ];
     for( i = order - 2; i >= 0; i-- ) {
-        gain_Q24 = SKP_SMLAWB( coefs_Q24[ i ], gain_Q24, lambda_Q16 );
+        gain_Q24 = silk_SMLAWB( coefs_Q24[ i ], gain_Q24, lambda_Q16 );
     }
-    gain_Q24  = SKP_SMLAWB( SILK_FIX_CONST( 1.0, 24 ), gain_Q24, -lambda_Q16 );
+    gain_Q24  = silk_SMLAWB( SILK_FIX_CONST( 1.0, 24 ), gain_Q24, -lambda_Q16 );
     return silk_INVERSE32_varQ( gain_Q24, 40 );
 }
 
@@ -67,25 +67,25 @@ static inline void limit_warped_coefs(
     /* Convert to monic coefficients */
     lambda_Q16 = -lambda_Q16;
     for( i = order - 1; i > 0; i-- ) {
-        coefs_syn_Q24[ i - 1 ] = SKP_SMLAWB( coefs_syn_Q24[ i - 1 ], coefs_syn_Q24[ i ], lambda_Q16 );
-        coefs_ana_Q24[ i - 1 ] = SKP_SMLAWB( coefs_ana_Q24[ i - 1 ], coefs_ana_Q24[ i ], lambda_Q16 );
+        coefs_syn_Q24[ i - 1 ] = silk_SMLAWB( coefs_syn_Q24[ i - 1 ], coefs_syn_Q24[ i ], lambda_Q16 );
+        coefs_ana_Q24[ i - 1 ] = silk_SMLAWB( coefs_ana_Q24[ i - 1 ], coefs_ana_Q24[ i ], lambda_Q16 );
     }
     lambda_Q16 = -lambda_Q16;
-    nom_Q16  = SKP_SMLAWB( SILK_FIX_CONST( 1.0, 16 ), -lambda_Q16,        lambda_Q16 );
-    den_Q24  = SKP_SMLAWB( SILK_FIX_CONST( 1.0, 24 ), coefs_syn_Q24[ 0 ], lambda_Q16 );
+    nom_Q16  = silk_SMLAWB( SILK_FIX_CONST( 1.0, 16 ), -lambda_Q16,        lambda_Q16 );
+    den_Q24  = silk_SMLAWB( SILK_FIX_CONST( 1.0, 24 ), coefs_syn_Q24[ 0 ], lambda_Q16 );
     gain_syn_Q16 = silk_DIV32_varQ( nom_Q16, den_Q24, 24 );
-    den_Q24  = SKP_SMLAWB( SILK_FIX_CONST( 1.0, 24 ), coefs_ana_Q24[ 0 ], lambda_Q16 );
+    den_Q24  = silk_SMLAWB( SILK_FIX_CONST( 1.0, 24 ), coefs_ana_Q24[ 0 ], lambda_Q16 );
     gain_ana_Q16 = silk_DIV32_varQ( nom_Q16, den_Q24, 24 );
     for( i = 0; i < order; i++ ) {
-        coefs_syn_Q24[ i ] = SKP_SMULWW( gain_syn_Q16, coefs_syn_Q24[ i ] );
-        coefs_ana_Q24[ i ] = SKP_SMULWW( gain_ana_Q16, coefs_ana_Q24[ i ] );
+        coefs_syn_Q24[ i ] = silk_SMULWW( gain_syn_Q16, coefs_syn_Q24[ i ] );
+        coefs_ana_Q24[ i ] = silk_SMULWW( gain_ana_Q16, coefs_ana_Q24[ i ] );
     }
 
     for( iter = 0; iter < 10; iter++ ) {
         /* Find maximum absolute value */
         maxabs_Q24 = -1;
         for( i = 0; i < order; i++ ) {
-            tmp = SKP_max( SKP_abs_int32( coefs_syn_Q24[ i ] ), SKP_abs_int32( coefs_ana_Q24[ i ] ) );
+            tmp = silk_max( silk_abs_int32( coefs_syn_Q24[ i ] ), silk_abs_int32( coefs_ana_Q24[ i ] ) );
             if( tmp > maxabs_Q24 ) {
                 maxabs_Q24 = tmp;
                 ind = i;
@@ -98,41 +98,41 @@ static inline void limit_warped_coefs(
 
         /* Convert back to true warped coefficients */
         for( i = 1; i < order; i++ ) {
-            coefs_syn_Q24[ i - 1 ] = SKP_SMLAWB( coefs_syn_Q24[ i - 1 ], coefs_syn_Q24[ i ], lambda_Q16 );
-            coefs_ana_Q24[ i - 1 ] = SKP_SMLAWB( coefs_ana_Q24[ i - 1 ], coefs_ana_Q24[ i ], lambda_Q16 );
+            coefs_syn_Q24[ i - 1 ] = silk_SMLAWB( coefs_syn_Q24[ i - 1 ], coefs_syn_Q24[ i ], lambda_Q16 );
+            coefs_ana_Q24[ i - 1 ] = silk_SMLAWB( coefs_ana_Q24[ i - 1 ], coefs_ana_Q24[ i ], lambda_Q16 );
         }
         gain_syn_Q16 = silk_INVERSE32_varQ( gain_syn_Q16, 32 );
         gain_ana_Q16 = silk_INVERSE32_varQ( gain_ana_Q16, 32 );
         for( i = 0; i < order; i++ ) {
-            coefs_syn_Q24[ i ] = SKP_SMULWW( gain_syn_Q16, coefs_syn_Q24[ i ] );
-            coefs_ana_Q24[ i ] = SKP_SMULWW( gain_ana_Q16, coefs_ana_Q24[ i ] );
+            coefs_syn_Q24[ i ] = silk_SMULWW( gain_syn_Q16, coefs_syn_Q24[ i ] );
+            coefs_ana_Q24[ i ] = silk_SMULWW( gain_ana_Q16, coefs_ana_Q24[ i ] );
         }
 
         /* Apply bandwidth expansion */
         chirp_Q16 = SILK_FIX_CONST( 0.99, 16 ) - silk_DIV32_varQ(
-            SKP_SMULWB( maxabs_Q24 - limit_Q24, SKP_SMLABB( SILK_FIX_CONST( 0.8, 10 ), SILK_FIX_CONST( 0.1, 10 ), iter ) ),
-            SKP_MUL( maxabs_Q24, ind + 1 ), 22 );
+            silk_SMULWB( maxabs_Q24 - limit_Q24, silk_SMLABB( SILK_FIX_CONST( 0.8, 10 ), SILK_FIX_CONST( 0.1, 10 ), iter ) ),
+            silk_MUL( maxabs_Q24, ind + 1 ), 22 );
         silk_bwexpander_32( coefs_syn_Q24, order, chirp_Q16 );
         silk_bwexpander_32( coefs_ana_Q24, order, chirp_Q16 );
 
         /* Convert to monic warped coefficients */
         lambda_Q16 = -lambda_Q16;
         for( i = order - 1; i > 0; i-- ) {
-            coefs_syn_Q24[ i - 1 ] = SKP_SMLAWB( coefs_syn_Q24[ i - 1 ], coefs_syn_Q24[ i ], lambda_Q16 );
-            coefs_ana_Q24[ i - 1 ] = SKP_SMLAWB( coefs_ana_Q24[ i - 1 ], coefs_ana_Q24[ i ], lambda_Q16 );
+            coefs_syn_Q24[ i - 1 ] = silk_SMLAWB( coefs_syn_Q24[ i - 1 ], coefs_syn_Q24[ i ], lambda_Q16 );
+            coefs_ana_Q24[ i - 1 ] = silk_SMLAWB( coefs_ana_Q24[ i - 1 ], coefs_ana_Q24[ i ], lambda_Q16 );
         }
         lambda_Q16 = -lambda_Q16;
-        nom_Q16  = SKP_SMLAWB( SILK_FIX_CONST( 1.0, 16 ), -lambda_Q16,        lambda_Q16 );
-        den_Q24  = SKP_SMLAWB( SILK_FIX_CONST( 1.0, 24 ), coefs_syn_Q24[ 0 ], lambda_Q16 );
+        nom_Q16  = silk_SMLAWB( SILK_FIX_CONST( 1.0, 16 ), -lambda_Q16,        lambda_Q16 );
+        den_Q24  = silk_SMLAWB( SILK_FIX_CONST( 1.0, 24 ), coefs_syn_Q24[ 0 ], lambda_Q16 );
         gain_syn_Q16 = silk_DIV32_varQ( nom_Q16, den_Q24, 24 );
-        den_Q24  = SKP_SMLAWB( SILK_FIX_CONST( 1.0, 24 ), coefs_ana_Q24[ 0 ], lambda_Q16 );
+        den_Q24  = silk_SMLAWB( SILK_FIX_CONST( 1.0, 24 ), coefs_ana_Q24[ 0 ], lambda_Q16 );
         gain_ana_Q16 = silk_DIV32_varQ( nom_Q16, den_Q24, 24 );
         for( i = 0; i < order; i++ ) {
-            coefs_syn_Q24[ i ] = SKP_SMULWW( gain_syn_Q16, coefs_syn_Q24[ i ] );
-            coefs_ana_Q24[ i ] = SKP_SMULWW( gain_ana_Q16, coefs_ana_Q24[ i ] );
+            coefs_syn_Q24[ i ] = silk_SMULWW( gain_syn_Q16, coefs_syn_Q24[ i ] );
+            coefs_ana_Q24[ i ] = silk_SMULWW( gain_ana_Q16, coefs_ana_Q24[ i ] );
         }
     }
-    SKP_assert( 0 );
+    silk_assert( 0 );
 }
 
 /**************************************************************/
@@ -167,29 +167,29 @@ void silk_noise_shape_analysis_FIX(
     SNR_adj_dB_Q7 = psEnc->sCmn.SNR_dB_Q7;
 
     /* Input quality is the average of the quality in the lowest two VAD bands */
-    psEncCtrl->input_quality_Q14 = ( opus_int )SKP_RSHIFT( ( opus_int32 )psEnc->sCmn.input_quality_bands_Q15[ 0 ]
+    psEncCtrl->input_quality_Q14 = ( opus_int )silk_RSHIFT( ( opus_int32 )psEnc->sCmn.input_quality_bands_Q15[ 0 ]
         + psEnc->sCmn.input_quality_bands_Q15[ 1 ], 2 );
 
     /* Coding quality level, between 0.0_Q0 and 1.0_Q0, but in Q14 */
-    psEncCtrl->coding_quality_Q14 = SKP_RSHIFT( silk_sigm_Q15( SKP_RSHIFT_ROUND( SNR_adj_dB_Q7 -
+    psEncCtrl->coding_quality_Q14 = silk_RSHIFT( silk_sigm_Q15( silk_RSHIFT_ROUND( SNR_adj_dB_Q7 -
         SILK_FIX_CONST( 18.0, 7 ), 4 ) ), 1 );
 
     /* Reduce coding SNR during low speech activity */
     if( psEnc->sCmn.useCBR == 0 ) {
         b_Q8 = SILK_FIX_CONST( 1.0, 8 ) - psEnc->sCmn.speech_activity_Q8;
-        b_Q8 = SKP_SMULWB( SKP_LSHIFT( b_Q8, 8 ), b_Q8 );
-        SNR_adj_dB_Q7 = SKP_SMLAWB( SNR_adj_dB_Q7,
-            SKP_SMULBB( SILK_FIX_CONST( -BG_SNR_DECR_dB, 7 ) >> ( 4 + 1 ), b_Q8 ),                                       /* Q11*/
-            SKP_SMULWB( SILK_FIX_CONST( 1.0, 14 ) + psEncCtrl->input_quality_Q14, psEncCtrl->coding_quality_Q14 ) );     /* Q12*/
+        b_Q8 = silk_SMULWB( silk_LSHIFT( b_Q8, 8 ), b_Q8 );
+        SNR_adj_dB_Q7 = silk_SMLAWB( SNR_adj_dB_Q7,
+            silk_SMULBB( SILK_FIX_CONST( -BG_SNR_DECR_dB, 7 ) >> ( 4 + 1 ), b_Q8 ),                                       /* Q11*/
+            silk_SMULWB( SILK_FIX_CONST( 1.0, 14 ) + psEncCtrl->input_quality_Q14, psEncCtrl->coding_quality_Q14 ) );     /* Q12*/
     }
 
     if( psEnc->sCmn.indices.signalType == TYPE_VOICED ) {
         /* Reduce gains for periodic signals */
-        SNR_adj_dB_Q7 = SKP_SMLAWB( SNR_adj_dB_Q7, SILK_FIX_CONST( HARM_SNR_INCR_dB, 8 ), psEnc->LTPCorr_Q15 );
+        SNR_adj_dB_Q7 = silk_SMLAWB( SNR_adj_dB_Q7, SILK_FIX_CONST( HARM_SNR_INCR_dB, 8 ), psEnc->LTPCorr_Q15 );
     } else {
         /* For unvoiced signals and low-quality input, adjust the quality slower than SNR_dB setting */
-        SNR_adj_dB_Q7 = SKP_SMLAWB( SNR_adj_dB_Q7,
-            SKP_SMLAWB( SILK_FIX_CONST( 6.0, 9 ), -SILK_FIX_CONST( 0.4, 18 ), psEnc->sCmn.SNR_dB_Q7 ),
+        SNR_adj_dB_Q7 = silk_SMLAWB( SNR_adj_dB_Q7,
+            silk_SMLAWB( SILK_FIX_CONST( 6.0, 9 ), -SILK_FIX_CONST( 0.4, 18 ), psEnc->sCmn.SNR_dB_Q7 ),
             SILK_FIX_CONST( 1.0, 14 ) - psEncCtrl->input_quality_Q14 );
     }
 
@@ -203,23 +203,23 @@ void silk_noise_shape_analysis_FIX(
         psEncCtrl->sparseness_Q8 = 0;
     } else {
         /* Sparseness measure, based on relative fluctuations of energy per 2 milliseconds */
-        nSamples = SKP_LSHIFT( psEnc->sCmn.fs_kHz, 1 );
+        nSamples = silk_LSHIFT( psEnc->sCmn.fs_kHz, 1 );
         energy_variation_Q7 = 0;
         log_energy_prev_Q7  = 0;
         pitch_res_ptr = pitch_res;
-        for( k = 0; k < SKP_SMULBB( SUB_FRAME_LENGTH_MS, psEnc->sCmn.nb_subfr ) / 2; k++ ) {
+        for( k = 0; k < silk_SMULBB( SUB_FRAME_LENGTH_MS, psEnc->sCmn.nb_subfr ) / 2; k++ ) {
             silk_sum_sqr_shift( &nrg, &scale, pitch_res_ptr, nSamples );
-            nrg += SKP_RSHIFT( nSamples, scale );           /* Q(-scale)*/
+            nrg += silk_RSHIFT( nSamples, scale );           /* Q(-scale)*/
 
             log_energy_Q7 = silk_lin2log( nrg );
             if( k > 0 ) {
-                energy_variation_Q7 += SKP_abs( log_energy_Q7 - log_energy_prev_Q7 );
+                energy_variation_Q7 += silk_abs( log_energy_Q7 - log_energy_prev_Q7 );
             }
             log_energy_prev_Q7 = log_energy_Q7;
             pitch_res_ptr += nSamples;
         }
 
-        psEncCtrl->sparseness_Q8 = SKP_RSHIFT( silk_sigm_Q15( SKP_SMULWB( energy_variation_Q7 -
+        psEncCtrl->sparseness_Q8 = silk_RSHIFT( silk_sigm_Q15( silk_SMULWB( energy_variation_Q7 -
             SILK_FIX_CONST( 5.0, 7 ), SILK_FIX_CONST( 0.1, 16 ) ) ), 7 );
 
         /* Set quantization offset depending on sparseness measure */
@@ -230,26 +230,26 @@ void silk_noise_shape_analysis_FIX(
         }
 
         /* Increase coding SNR for sparse signals */
-        SNR_adj_dB_Q7 = SKP_SMLAWB( SNR_adj_dB_Q7, SILK_FIX_CONST( SPARSE_SNR_INCR_dB, 15 ), psEncCtrl->sparseness_Q8 - SILK_FIX_CONST( 0.5, 8 ) );
+        SNR_adj_dB_Q7 = silk_SMLAWB( SNR_adj_dB_Q7, SILK_FIX_CONST( SPARSE_SNR_INCR_dB, 15 ), psEncCtrl->sparseness_Q8 - SILK_FIX_CONST( 0.5, 8 ) );
     }
 
     /*******************************/
     /* Control bandwidth expansion */
     /*******************************/
     /* More BWE for signals with high prediction gain */
-    strength_Q16 = SKP_SMULWB( psEncCtrl->predGain_Q16, SILK_FIX_CONST( FIND_PITCH_WHITE_NOISE_FRACTION, 16 ) );
+    strength_Q16 = silk_SMULWB( psEncCtrl->predGain_Q16, SILK_FIX_CONST( FIND_PITCH_WHITE_NOISE_FRACTION, 16 ) );
     BWExp1_Q16 = BWExp2_Q16 = silk_DIV32_varQ( SILK_FIX_CONST( BANDWIDTH_EXPANSION, 16 ),
-        SKP_SMLAWW( SILK_FIX_CONST( 1.0, 16 ), strength_Q16, strength_Q16 ), 16 );
-    delta_Q16  = SKP_SMULWB( SILK_FIX_CONST( 1.0, 16 ) - SKP_SMULBB( 3, psEncCtrl->coding_quality_Q14 ),
+        silk_SMLAWW( SILK_FIX_CONST( 1.0, 16 ), strength_Q16, strength_Q16 ), 16 );
+    delta_Q16  = silk_SMULWB( SILK_FIX_CONST( 1.0, 16 ) - silk_SMULBB( 3, psEncCtrl->coding_quality_Q14 ),
         SILK_FIX_CONST( LOW_RATE_BANDWIDTH_EXPANSION_DELTA, 16 ) );
-    BWExp1_Q16 = SKP_SUB32( BWExp1_Q16, delta_Q16 );
-    BWExp2_Q16 = SKP_ADD32( BWExp2_Q16, delta_Q16 );
+    BWExp1_Q16 = silk_SUB32( BWExp1_Q16, delta_Q16 );
+    BWExp2_Q16 = silk_ADD32( BWExp2_Q16, delta_Q16 );
     /* BWExp1 will be applied after BWExp2, so make it relative */
-    BWExp1_Q16 = SKP_DIV32_16( SKP_LSHIFT( BWExp1_Q16, 14 ), SKP_RSHIFT( BWExp2_Q16, 2 ) );
+    BWExp1_Q16 = silk_DIV32_16( silk_LSHIFT( BWExp1_Q16, 14 ), silk_RSHIFT( BWExp2_Q16, 2 ) );
 
     if( psEnc->sCmn.warping_Q16 > 0 ) {
         /* Slightly more warping in analysis will move quantization noise up in frequency, where it's better masked */
-        warping_Q16 = SKP_SMLAWB( psEnc->sCmn.warping_Q16, psEncCtrl->coding_quality_Q14, SILK_FIX_CONST( 0.01, 18 ) );
+        warping_Q16 = silk_SMLAWB( psEnc->sCmn.warping_Q16, psEncCtrl->coding_quality_Q14, SILK_FIX_CONST( 0.01, 18 ) );
     } else {
         warping_Q16 = 0;
     }
@@ -261,11 +261,11 @@ void silk_noise_shape_analysis_FIX(
         /* Apply window: sine slope followed by flat part followed by cosine slope */
         opus_int shift, slope_part, flat_part;
         flat_part = psEnc->sCmn.fs_kHz * 3;
-        slope_part = SKP_RSHIFT( psEnc->sCmn.shapeWinLength - flat_part, 1 );
+        slope_part = silk_RSHIFT( psEnc->sCmn.shapeWinLength - flat_part, 1 );
 
         silk_apply_sine_window( x_windowed, x_ptr, 1, slope_part );
         shift = slope_part;
-        SKP_memcpy( x_windowed + shift, x_ptr + shift, flat_part * sizeof(opus_int16) );
+        silk_memcpy( x_windowed + shift, x_ptr + shift, flat_part * sizeof(opus_int16) );
         shift += flat_part;
         silk_apply_sine_window( x_windowed + shift, x_ptr + shift, 2, slope_part );
 
@@ -281,19 +281,19 @@ void silk_noise_shape_analysis_FIX(
         }
 
         /* Add white noise, as a fraction of energy */
-        auto_corr[0] = SKP_ADD32( auto_corr[0], SKP_max_32( SKP_SMULWB( SKP_RSHIFT( auto_corr[ 0 ], 4 ),
+        auto_corr[0] = silk_ADD32( auto_corr[0], silk_max_32( silk_SMULWB( silk_RSHIFT( auto_corr[ 0 ], 4 ),
             SILK_FIX_CONST( SHAPE_WHITE_NOISE_FRACTION, 20 ) ), 1 ) );
 
         /* Calculate the reflection coefficients using schur */
         nrg = silk_schur64( refl_coef_Q16, auto_corr, psEnc->sCmn.shapingLPCOrder );
-        SKP_assert( nrg >= 0 );
+        silk_assert( nrg >= 0 );
 
         /* Convert reflection coefficients to prediction coefficients */
         silk_k2a_Q16( AR2_Q24, refl_coef_Q16, psEnc->sCmn.shapingLPCOrder );
 
         Qnrg = -scale;          /* range: -12...30*/
-        SKP_assert( Qnrg >= -12 );
-        SKP_assert( Qnrg <=  30 );
+        silk_assert( Qnrg >= -12 );
+        silk_assert( Qnrg <=  30 );
 
         /* Make sure that Qnrg is an even number */
         if( Qnrg & 1 ) {
@@ -307,15 +307,15 @@ void silk_noise_shape_analysis_FIX(
         sqrt_nrg[ k ] = tmp32;
         Qnrg_vec[ k ] = Qnrg;
 
-        psEncCtrl->Gains_Q16[ k ] = SKP_LSHIFT_SAT32( tmp32, 16 - Qnrg );
+        psEncCtrl->Gains_Q16[ k ] = silk_LSHIFT_SAT32( tmp32, 16 - Qnrg );
 
         if( psEnc->sCmn.warping_Q16 > 0 ) {
             /* Adjust gain for warping */
             gain_mult_Q16 = warped_gain( AR2_Q24, warping_Q16, psEnc->sCmn.shapingLPCOrder );
-            SKP_assert( psEncCtrl->Gains_Q16[ k ] >= 0 );
-            psEncCtrl->Gains_Q16[ k ] = SKP_SMULWW( psEncCtrl->Gains_Q16[ k ], gain_mult_Q16 );
+            silk_assert( psEncCtrl->Gains_Q16[ k ] >= 0 );
+            psEncCtrl->Gains_Q16[ k ] = silk_SMULWW( psEncCtrl->Gains_Q16[ k ], gain_mult_Q16 );
             if( psEncCtrl->Gains_Q16[ k ] < 0 ) {
-                psEncCtrl->Gains_Q16[ k ] = SKP_int32_MAX;
+                psEncCtrl->Gains_Q16[ k ] = silk_int32_MAX;
             }
         }
 
@@ -323,10 +323,10 @@ void silk_noise_shape_analysis_FIX(
         silk_bwexpander_32( AR2_Q24, psEnc->sCmn.shapingLPCOrder, BWExp2_Q16 );
 
         /* Compute noise shaping filter coefficients */
-        SKP_memcpy( AR1_Q24, AR2_Q24, psEnc->sCmn.shapingLPCOrder * sizeof( opus_int32 ) );
+        silk_memcpy( AR1_Q24, AR2_Q24, psEnc->sCmn.shapingLPCOrder * sizeof( opus_int32 ) );
 
         /* Bandwidth expansion for analysis filter shaping */
-        SKP_assert( BWExp1_Q16 <= SILK_FIX_CONST( 1.0, 16 ) );
+        silk_assert( BWExp1_Q16 <= SILK_FIX_CONST( 1.0, 16 ) );
         silk_bwexpander_32( AR1_Q24, psEnc->sCmn.shapingLPCOrder, BWExp1_Q16 );
 
         /* Ratio of prediction gains, in energy domain */
@@ -334,7 +334,7 @@ void silk_noise_shape_analysis_FIX(
         silk_LPC_inverse_pred_gain_Q24( &nrg,         AR1_Q24, psEnc->sCmn.shapingLPCOrder );
 
         /*psEncCtrl->GainsPre[ k ] = 1.0f - 0.7f * ( 1.0f - pre_nrg / nrg ) = 0.3f + 0.7f * pre_nrg / nrg;*/
-        pre_nrg_Q30 = SKP_LSHIFT32( SKP_SMULWB( pre_nrg_Q30, SILK_FIX_CONST( 0.7, 15 ) ), 1 );
+        pre_nrg_Q30 = silk_LSHIFT32( silk_SMULWB( pre_nrg_Q30, SILK_FIX_CONST( 0.7, 15 ) ), 1 );
         psEncCtrl->GainsPre_Q14[ k ] = ( opus_int ) SILK_FIX_CONST( 0.3, 14 ) + silk_DIV32_varQ( pre_nrg_Q30, nrg, 14 );
 
         /* Convert to monic warped prediction coefficients and limit absolute values */
@@ -342,8 +342,8 @@ void silk_noise_shape_analysis_FIX(
 
         /* Convert from Q24 to Q13 and store in int16 */
         for( i = 0; i < psEnc->sCmn.shapingLPCOrder; i++ ) {
-            psEncCtrl->AR1_Q13[ k * MAX_SHAPE_LPC_ORDER + i ] = (opus_int16)SKP_SAT16( SKP_RSHIFT_ROUND( AR1_Q24[ i ], 11 ) );
-            psEncCtrl->AR2_Q13[ k * MAX_SHAPE_LPC_ORDER + i ] = (opus_int16)SKP_SAT16( SKP_RSHIFT_ROUND( AR2_Q24[ i ], 11 ) );
+            psEncCtrl->AR1_Q13[ k * MAX_SHAPE_LPC_ORDER + i ] = (opus_int16)silk_SAT16( silk_RSHIFT_ROUND( AR1_Q24[ i ], 11 ) );
+            psEncCtrl->AR2_Q13[ k * MAX_SHAPE_LPC_ORDER + i ] = (opus_int16)silk_SAT16( silk_RSHIFT_ROUND( AR2_Q24[ i ], 11 ) );
         }
     }
 
@@ -351,47 +351,47 @@ void silk_noise_shape_analysis_FIX(
     /* Gain tweaking */
     /*****************/
     /* Increase gains during low speech activity and put lower limit on gains */
-    gain_mult_Q16 = silk_log2lin( -SKP_SMLAWB( -SILK_FIX_CONST( 16.0, 7 ), SNR_adj_dB_Q7, SILK_FIX_CONST( 0.16, 16 ) ) );
-    gain_add_Q16  = silk_log2lin(  SKP_SMLAWB(  SILK_FIX_CONST( 16.0, 7 ), SILK_FIX_CONST( MIN_QGAIN_DB, 7 ), SILK_FIX_CONST( 0.16, 16 ) ) );
-    SKP_assert( gain_mult_Q16 > 0 );
+    gain_mult_Q16 = silk_log2lin( -silk_SMLAWB( -SILK_FIX_CONST( 16.0, 7 ), SNR_adj_dB_Q7, SILK_FIX_CONST( 0.16, 16 ) ) );
+    gain_add_Q16  = silk_log2lin(  silk_SMLAWB(  SILK_FIX_CONST( 16.0, 7 ), SILK_FIX_CONST( MIN_QGAIN_DB, 7 ), SILK_FIX_CONST( 0.16, 16 ) ) );
+    silk_assert( gain_mult_Q16 > 0 );
     for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) {
-        psEncCtrl->Gains_Q16[ k ] = SKP_SMULWW( psEncCtrl->Gains_Q16[ k ], gain_mult_Q16 );
-        SKP_assert( psEncCtrl->Gains_Q16[ k ] >= 0 );
-        psEncCtrl->Gains_Q16[ k ] = SKP_ADD_POS_SAT32( psEncCtrl->Gains_Q16[ k ], gain_add_Q16 );
+        psEncCtrl->Gains_Q16[ k ] = silk_SMULWW( psEncCtrl->Gains_Q16[ k ], gain_mult_Q16 );
+        silk_assert( psEncCtrl->Gains_Q16[ k ] >= 0 );
+        psEncCtrl->Gains_Q16[ k ] = silk_ADD_POS_SAT32( psEncCtrl->Gains_Q16[ k ], gain_add_Q16 );
     }
 
-    gain_mult_Q16 = SILK_FIX_CONST( 1.0, 16 ) + SKP_RSHIFT_ROUND( SKP_MLA( SILK_FIX_CONST( INPUT_TILT, 26 ),
+    gain_mult_Q16 = SILK_FIX_CONST( 1.0, 16 ) + silk_RSHIFT_ROUND( silk_MLA( SILK_FIX_CONST( INPUT_TILT, 26 ),
         psEncCtrl->coding_quality_Q14, SILK_FIX_CONST( HIGH_RATE_INPUT_TILT, 12 ) ), 10 );
     for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) {
-        psEncCtrl->GainsPre_Q14[ k ] = SKP_SMULWB( gain_mult_Q16, psEncCtrl->GainsPre_Q14[ k ] );
+        psEncCtrl->GainsPre_Q14[ k ] = silk_SMULWB( gain_mult_Q16, psEncCtrl->GainsPre_Q14[ k ] );
     }
 
     /************************************************/
     /* Control low-frequency shaping and noise tilt */
     /************************************************/
     /* Less low frequency shaping for noisy inputs */
-    strength_Q16 = SKP_MUL( SILK_FIX_CONST( LOW_FREQ_SHAPING, 4 ), SKP_SMLAWB( SILK_FIX_CONST( 1.0, 12 ),
+    strength_Q16 = silk_MUL( SILK_FIX_CONST( LOW_FREQ_SHAPING, 4 ), silk_SMLAWB( SILK_FIX_CONST( 1.0, 12 ),
         SILK_FIX_CONST( LOW_QUALITY_LOW_FREQ_SHAPING_DECR, 13 ), psEnc->sCmn.input_quality_bands_Q15[ 0 ] - SILK_FIX_CONST( 1.0, 15 ) ) );
-    strength_Q16 = SKP_RSHIFT( SKP_MUL( strength_Q16, psEnc->sCmn.speech_activity_Q8 ), 8 );
+    strength_Q16 = silk_RSHIFT( silk_MUL( strength_Q16, psEnc->sCmn.speech_activity_Q8 ), 8 );
     if( psEnc->sCmn.indices.signalType == TYPE_VOICED ) {
         /* Reduce low frequencies quantization noise for periodic signals, depending on pitch lag */
         /*f = 400; freqz([1, -0.98 + 2e-4 * f], [1, -0.97 + 7e-4 * f], 2^12, Fs); axis([0, 1000, -10, 1])*/
-        opus_int fs_kHz_inv = SKP_DIV32_16( SILK_FIX_CONST( 0.2, 14 ), psEnc->sCmn.fs_kHz );
+        opus_int fs_kHz_inv = silk_DIV32_16( SILK_FIX_CONST( 0.2, 14 ), psEnc->sCmn.fs_kHz );
         for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) {
-            b_Q14 = fs_kHz_inv + SKP_DIV32_16( SILK_FIX_CONST( 3.0, 14 ), psEncCtrl->pitchL[ k ] );
+            b_Q14 = fs_kHz_inv + silk_DIV32_16( SILK_FIX_CONST( 3.0, 14 ), psEncCtrl->pitchL[ k ] );
             /* Pack two coefficients in one int32 */
-            psEncCtrl->LF_shp_Q14[ k ]  = SKP_LSHIFT( SILK_FIX_CONST( 1.0, 14 ) - b_Q14 - SKP_SMULWB( strength_Q16, b_Q14 ), 16 );
+            psEncCtrl->LF_shp_Q14[ k ]  = silk_LSHIFT( SILK_FIX_CONST( 1.0, 14 ) - b_Q14 - silk_SMULWB( strength_Q16, b_Q14 ), 16 );
             psEncCtrl->LF_shp_Q14[ k ] |= (opus_uint16)( b_Q14 - SILK_FIX_CONST( 1.0, 14 ) );
         }
-        SKP_assert( SILK_FIX_CONST( HARM_HP_NOISE_COEF, 24 ) < SILK_FIX_CONST( 0.5, 24 ) ); /* Guarantees that second argument to SMULWB() is within range of an opus_int16*/
+        silk_assert( SILK_FIX_CONST( HARM_HP_NOISE_COEF, 24 ) < SILK_FIX_CONST( 0.5, 24 ) ); /* Guarantees that second argument to SMULWB() is within range of an opus_int16*/
         Tilt_Q16 = - SILK_FIX_CONST( HP_NOISE_COEF, 16 ) -
-            SKP_SMULWB( SILK_FIX_CONST( 1.0, 16 ) - SILK_FIX_CONST( HP_NOISE_COEF, 16 ),
-                SKP_SMULWB( SILK_FIX_CONST( HARM_HP_NOISE_COEF, 24 ), psEnc->sCmn.speech_activity_Q8 ) );
+            silk_SMULWB( SILK_FIX_CONST( 1.0, 16 ) - SILK_FIX_CONST( HP_NOISE_COEF, 16 ),
+                silk_SMULWB( SILK_FIX_CONST( HARM_HP_NOISE_COEF, 24 ), psEnc->sCmn.speech_activity_Q8 ) );
     } else {
-        b_Q14 = SKP_DIV32_16( 21299, psEnc->sCmn.fs_kHz ); /* 1.3_Q0 = 21299_Q14*/
+        b_Q14 = silk_DIV32_16( 21299, psEnc->sCmn.fs_kHz ); /* 1.3_Q0 = 21299_Q14*/
         /* Pack two coefficients in one int32 */
-        psEncCtrl->LF_shp_Q14[ 0 ]  = SKP_LSHIFT( SILK_FIX_CONST( 1.0, 14 ) - b_Q14 -
-            SKP_SMULWB( strength_Q16, SKP_SMULWB( SILK_FIX_CONST( 0.6, 16 ), b_Q14 ) ), 16 );
+        psEncCtrl->LF_shp_Q14[ 0 ]  = silk_LSHIFT( SILK_FIX_CONST( 1.0, 14 ) - b_Q14 -
+            silk_SMULWB( strength_Q16, silk_SMULWB( SILK_FIX_CONST( 0.6, 16 ), b_Q14 ) ), 16 );
         psEncCtrl->LF_shp_Q14[ 0 ] |= (opus_uint16)( b_Q14 - SILK_FIX_CONST( 1.0, 14 ) );
         for( k = 1; k < psEnc->sCmn.nb_subfr; k++ ) {
             psEncCtrl->LF_shp_Q14[ k ] = psEncCtrl->LF_shp_Q14[ 0 ];
@@ -403,22 +403,22 @@ void silk_noise_shape_analysis_FIX(
     /* HARMONIC SHAPING CONTROL */
     /****************************/
     /* Control boosting of harmonic frequencies */
-    HarmBoost_Q16 = SKP_SMULWB( SKP_SMULWB( SILK_FIX_CONST( 1.0, 17 ) - SKP_LSHIFT( psEncCtrl->coding_quality_Q14, 3 ),
+    HarmBoost_Q16 = silk_SMULWB( silk_SMULWB( SILK_FIX_CONST( 1.0, 17 ) - silk_LSHIFT( psEncCtrl->coding_quality_Q14, 3 ),
         psEnc->LTPCorr_Q15 ), SILK_FIX_CONST( LOW_RATE_HARMONIC_BOOST, 16 ) );
 
     /* More harmonic boost for noisy input signals */
-    HarmBoost_Q16 = SKP_SMLAWB( HarmBoost_Q16,
-        SILK_FIX_CONST( 1.0, 16 ) - SKP_LSHIFT( psEncCtrl->input_quality_Q14, 2 ), SILK_FIX_CONST( LOW_INPUT_QUALITY_HARMONIC_BOOST, 16 ) );
+    HarmBoost_Q16 = silk_SMLAWB( HarmBoost_Q16,
+        SILK_FIX_CONST( 1.0, 16 ) - silk_LSHIFT( psEncCtrl->input_quality_Q14, 2 ), SILK_FIX_CONST( LOW_INPUT_QUALITY_HARMONIC_BOOST, 16 ) );
 
     if( USE_HARM_SHAPING && psEnc->sCmn.indices.signalType == TYPE_VOICED ) {
         /* More harmonic noise shaping for high bitrates or noisy input */
-        HarmShapeGain_Q16 = SKP_SMLAWB( SILK_FIX_CONST( HARMONIC_SHAPING, 16 ),
-                SILK_FIX_CONST( 1.0, 16 ) - SKP_SMULWB( SILK_FIX_CONST( 1.0, 18 ) - SKP_LSHIFT( psEncCtrl->coding_quality_Q14, 4 ),
+        HarmShapeGain_Q16 = silk_SMLAWB( SILK_FIX_CONST( HARMONIC_SHAPING, 16 ),
+                SILK_FIX_CONST( 1.0, 16 ) - silk_SMULWB( SILK_FIX_CONST( 1.0, 18 ) - silk_LSHIFT( psEncCtrl->coding_quality_Q14, 4 ),
                 psEncCtrl->input_quality_Q14 ), SILK_FIX_CONST( HIGH_RATE_OR_LOW_QUALITY_HARMONIC_SHAPING, 16 ) );
 
         /* Less harmonic noise shaping for less periodic signals */
-        HarmShapeGain_Q16 = SKP_SMULWB( SKP_LSHIFT( HarmShapeGain_Q16, 1 ),
-            silk_SQRT_APPROX( SKP_LSHIFT( psEnc->LTPCorr_Q15, 15 ) ) );
+        HarmShapeGain_Q16 = silk_SMULWB( silk_LSHIFT( HarmShapeGain_Q16, 1 ),
+            silk_SQRT_APPROX( silk_LSHIFT( psEnc->LTPCorr_Q15, 15 ) ) );
     } else {
         HarmShapeGain_Q16 = 0;
     }
@@ -428,14 +428,14 @@ void silk_noise_shape_analysis_FIX(
     /*************************/
     for( k = 0; k < MAX_NB_SUBFR; k++ ) {
         psShapeSt->HarmBoost_smth_Q16 =
-            SKP_SMLAWB( psShapeSt->HarmBoost_smth_Q16,     HarmBoost_Q16     - psShapeSt->HarmBoost_smth_Q16,     SILK_FIX_CONST( SUBFR_SMTH_COEF, 16 ) );
+            silk_SMLAWB( psShapeSt->HarmBoost_smth_Q16,     HarmBoost_Q16     - psShapeSt->HarmBoost_smth_Q16,     SILK_FIX_CONST( SUBFR_SMTH_COEF, 16 ) );
         psShapeSt->HarmShapeGain_smth_Q16 =
-            SKP_SMLAWB( psShapeSt->HarmShapeGain_smth_Q16, HarmShapeGain_Q16 - psShapeSt->HarmShapeGain_smth_Q16, SILK_FIX_CONST( SUBFR_SMTH_COEF, 16 ) );
+            silk_SMLAWB( psShapeSt->HarmShapeGain_smth_Q16, HarmShapeGain_Q16 - psShapeSt->HarmShapeGain_smth_Q16, SILK_FIX_CONST( SUBFR_SMTH_COEF, 16 ) );
         psShapeSt->Tilt_smth_Q16 =
-            SKP_SMLAWB( psShapeSt->Tilt_smth_Q16,          Tilt_Q16          - psShapeSt->Tilt_smth_Q16,          SILK_FIX_CONST( SUBFR_SMTH_COEF, 16 ) );
+            silk_SMLAWB( psShapeSt->Tilt_smth_Q16,          Tilt_Q16          - psShapeSt->Tilt_smth_Q16,          SILK_FIX_CONST( SUBFR_SMTH_COEF, 16 ) );
 
-        psEncCtrl->HarmBoost_Q14[ k ]     = ( opus_int )SKP_RSHIFT_ROUND( psShapeSt->HarmBoost_smth_Q16,     2 );
-        psEncCtrl->HarmShapeGain_Q14[ k ] = ( opus_int )SKP_RSHIFT_ROUND( psShapeSt->HarmShapeGain_smth_Q16, 2 );
-        psEncCtrl->Tilt_Q14[ k ]          = ( opus_int )SKP_RSHIFT_ROUND( psShapeSt->Tilt_smth_Q16,          2 );
+        psEncCtrl->HarmBoost_Q14[ k ]     = ( opus_int )silk_RSHIFT_ROUND( psShapeSt->HarmBoost_smth_Q16,     2 );
+        psEncCtrl->HarmShapeGain_Q14[ k ] = ( opus_int )silk_RSHIFT_ROUND( psShapeSt->HarmShapeGain_smth_Q16, 2 );
+        psEncCtrl->Tilt_Q14[ k ]          = ( opus_int )silk_RSHIFT_ROUND( psShapeSt->Tilt_smth_Q16,          2 );
     }
 }
index d9b16a3..f4c1bb2 100644 (file)
@@ -58,30 +58,30 @@ void silk_warped_LPC_analysis_filter_FIX(
     opus_int32   acc_Q11, tmp1, tmp2;
 
     /* Order must be even */
-    SKP_assert( ( order & 1 ) == 0 );
+    silk_assert( ( order & 1 ) == 0 );
 
     for( n = 0; n < length; n++ ) {
         /* Output of lowpass section */
-        tmp2 = SKP_SMLAWB( state[ 0 ], state[ 1 ], lambda_Q16 );
-        state[ 0 ] = SKP_LSHIFT( input[ n ], 14 );
+        tmp2 = silk_SMLAWB( state[ 0 ], state[ 1 ], lambda_Q16 );
+        state[ 0 ] = silk_LSHIFT( input[ n ], 14 );
         /* Output of allpass section */
-        tmp1 = SKP_SMLAWB( state[ 1 ], state[ 2 ] - tmp2, lambda_Q16 );
+        tmp1 = silk_SMLAWB( state[ 1 ], state[ 2 ] - tmp2, lambda_Q16 );
         state[ 1 ] = tmp2;
-        acc_Q11 = SKP_SMULWB( tmp2, coef_Q13[ 0 ] );
+        acc_Q11 = silk_SMULWB( tmp2, coef_Q13[ 0 ] );
         /* Loop over allpass sections */
         for( i = 2; i < order; i += 2 ) {
             /* Output of allpass section */
-            tmp2 = SKP_SMLAWB( state[ i ], state[ i + 1 ] - tmp1, lambda_Q16 );
+            tmp2 = silk_SMLAWB( state[ i ], state[ i + 1 ] - tmp1, lambda_Q16 );
             state[ i ] = tmp1;
-            acc_Q11 = SKP_SMLAWB( acc_Q11, tmp1, coef_Q13[ i - 1 ] );
+            acc_Q11 = silk_SMLAWB( acc_Q11, tmp1, coef_Q13[ i - 1 ] );
             /* Output of allpass section */
-            tmp1 = SKP_SMLAWB( state[ i + 1 ], state[ i + 2 ] - tmp2, lambda_Q16 );
+            tmp1 = silk_SMLAWB( state[ i + 1 ], state[ i + 2 ] - tmp2, lambda_Q16 );
             state[ i + 1 ] = tmp2;
-            acc_Q11 = SKP_SMLAWB( acc_Q11, tmp2, coef_Q13[ i ] );
+            acc_Q11 = silk_SMLAWB( acc_Q11, tmp2, coef_Q13[ i ] );
         }
         state[ order ] = tmp1;
-        acc_Q11 = SKP_SMLAWB( acc_Q11, tmp1, coef_Q13[ order - 1 ] );
-        res[ n ] = ( opus_int16 )SKP_SAT16( ( opus_int32 )input[ n ] - SKP_RSHIFT_ROUND( acc_Q11, 11 ) );
+        acc_Q11 = silk_SMLAWB( acc_Q11, tmp1, coef_Q13[ order - 1 ] );
+        res[ n ] = ( opus_int16 )silk_SAT16( ( opus_int32 )input[ n ] - silk_RSHIFT_ROUND( acc_Q11, 11 ) );
     }
 }
 
@@ -115,10 +115,10 @@ void silk_prefilter_FIX(
         }
 
         /* Noise shape parameters */
-        HarmShapeGain_Q12 = SKP_SMULWB( psEncCtrl->HarmShapeGain_Q14[ k ], 16384 - psEncCtrl->HarmBoost_Q14[ k ] );
-        SKP_assert( HarmShapeGain_Q12 >= 0 );
-        HarmShapeFIRPacked_Q12  =                          SKP_RSHIFT( HarmShapeGain_Q12, 2 );
-        HarmShapeFIRPacked_Q12 |= SKP_LSHIFT( ( opus_int32 )SKP_RSHIFT( HarmShapeGain_Q12, 1 ), 16 );
+        HarmShapeGain_Q12 = silk_SMULWB( psEncCtrl->HarmShapeGain_Q14[ k ], 16384 - psEncCtrl->HarmBoost_Q14[ k ] );
+        silk_assert( HarmShapeGain_Q12 >= 0 );
+        HarmShapeFIRPacked_Q12  =                          silk_RSHIFT( HarmShapeGain_Q12, 2 );
+        HarmShapeFIRPacked_Q12 |= silk_LSHIFT( ( opus_int32 )silk_RSHIFT( HarmShapeGain_Q12, 1 ), 16 );
         Tilt_Q14    = psEncCtrl->Tilt_Q14[   k ];
         LF_shp_Q14  = psEncCtrl->LF_shp_Q14[ k ];
         AR1_shp_Q13 = &psEncCtrl->AR1_Q13[   k * MAX_SHAPE_LPC_ORDER ];
@@ -128,16 +128,16 @@ void silk_prefilter_FIX(
             psEnc->sCmn.warping_Q16, psEnc->sCmn.subfr_length, psEnc->sCmn.shapingLPCOrder );
 
         /* reduce (mainly) low frequencies during harmonic emphasis */
-        B_Q12[ 0 ] = SKP_RSHIFT_ROUND( psEncCtrl->GainsPre_Q14[ k ], 2 );
-        tmp_32 = SKP_SMLABB( SILK_FIX_CONST( INPUT_TILT, 26 ), psEncCtrl->HarmBoost_Q14[ k ], HarmShapeGain_Q12 );   /* Q26 */
-        tmp_32 = SKP_SMLABB( tmp_32, psEncCtrl->coding_quality_Q14, SILK_FIX_CONST( HIGH_RATE_INPUT_TILT, 12 ) );    /* Q26 */
-        tmp_32 = SKP_SMULWB( tmp_32, -psEncCtrl->GainsPre_Q14[ k ] );                                               /* Q24 */
-        tmp_32 = SKP_RSHIFT_ROUND( tmp_32, 12 );                                                                    /* Q12 */
-        B_Q12[ 1 ]= SKP_SAT16( tmp_32 );
-
-        x_filt_Q12[ 0 ] = SKP_SMLABB( SKP_SMULBB( st_res[ 0 ], B_Q12[ 0 ] ), P->sHarmHP, B_Q12[ 1 ] );
+        B_Q12[ 0 ] = silk_RSHIFT_ROUND( psEncCtrl->GainsPre_Q14[ k ], 2 );
+        tmp_32 = silk_SMLABB( SILK_FIX_CONST( INPUT_TILT, 26 ), psEncCtrl->HarmBoost_Q14[ k ], HarmShapeGain_Q12 );   /* Q26 */
+        tmp_32 = silk_SMLABB( tmp_32, psEncCtrl->coding_quality_Q14, SILK_FIX_CONST( HIGH_RATE_INPUT_TILT, 12 ) );    /* Q26 */
+        tmp_32 = silk_SMULWB( tmp_32, -psEncCtrl->GainsPre_Q14[ k ] );                                               /* Q24 */
+        tmp_32 = silk_RSHIFT_ROUND( tmp_32, 12 );                                                                    /* Q12 */
+        B_Q12[ 1 ]= silk_SAT16( tmp_32 );
+
+        x_filt_Q12[ 0 ] = silk_SMLABB( silk_SMULBB( st_res[ 0 ], B_Q12[ 0 ] ), P->sHarmHP, B_Q12[ 1 ] );
         for( j = 1; j < psEnc->sCmn.subfr_length; j++ ) {
-            x_filt_Q12[ j ] = SKP_SMLABB( SKP_SMULBB( st_res[ j ], B_Q12[ 0 ] ), st_res[ j - 1 ], B_Q12[ 1 ] );
+            x_filt_Q12[ j ] = silk_SMLABB( silk_SMULBB( st_res[ j ], B_Q12[ 0 ] ), st_res[ j - 1 ], B_Q12[ 1 ] );
         }
         P->sHarmHP = st_res[ psEnc->sCmn.subfr_length - 1 ];
 
@@ -177,25 +177,25 @@ static inline void silk_prefilt_FIX(
     for( i = 0; i < length; i++ ) {
         if( lag > 0 ) {
             /* unrolled loop */
-            SKP_assert( HARM_SHAPE_FIR_TAPS == 3 );
+            silk_assert( HARM_SHAPE_FIR_TAPS == 3 );
             idx = lag + LTP_shp_buf_idx;
-            n_LTP_Q12 = SKP_SMULBB(            LTP_shp_buf[ ( idx - HARM_SHAPE_FIR_TAPS / 2 - 1) & LTP_MASK ], HarmShapeFIRPacked_Q12 );
-            n_LTP_Q12 = SKP_SMLABT( n_LTP_Q12, LTP_shp_buf[ ( idx - HARM_SHAPE_FIR_TAPS / 2    ) & LTP_MASK ], HarmShapeFIRPacked_Q12 );
-            n_LTP_Q12 = SKP_SMLABB( n_LTP_Q12, LTP_shp_buf[ ( idx - HARM_SHAPE_FIR_TAPS / 2 + 1) & LTP_MASK ], HarmShapeFIRPacked_Q12 );
+            n_LTP_Q12 = silk_SMULBB(            LTP_shp_buf[ ( idx - HARM_SHAPE_FIR_TAPS / 2 - 1) & LTP_MASK ], HarmShapeFIRPacked_Q12 );
+            n_LTP_Q12 = silk_SMLABT( n_LTP_Q12, LTP_shp_buf[ ( idx - HARM_SHAPE_FIR_TAPS / 2    ) & LTP_MASK ], HarmShapeFIRPacked_Q12 );
+            n_LTP_Q12 = silk_SMLABB( n_LTP_Q12, LTP_shp_buf[ ( idx - HARM_SHAPE_FIR_TAPS / 2 + 1) & LTP_MASK ], HarmShapeFIRPacked_Q12 );
         } else {
             n_LTP_Q12 = 0;
         }
 
-        n_Tilt_Q10 = SKP_SMULWB( sLF_AR_shp_Q12, Tilt_Q14 );
-        n_LF_Q10   = SKP_SMLAWB( SKP_SMULWT( sLF_AR_shp_Q12, LF_shp_Q14 ), sLF_MA_shp_Q12, LF_shp_Q14 );
+        n_Tilt_Q10 = silk_SMULWB( sLF_AR_shp_Q12, Tilt_Q14 );
+        n_LF_Q10   = silk_SMLAWB( silk_SMULWT( sLF_AR_shp_Q12, LF_shp_Q14 ), sLF_MA_shp_Q12, LF_shp_Q14 );
 
-        sLF_AR_shp_Q12 = SKP_SUB32( st_res_Q12[ i ], SKP_LSHIFT( n_Tilt_Q10, 2 ) );
-        sLF_MA_shp_Q12 = SKP_SUB32( sLF_AR_shp_Q12,  SKP_LSHIFT( n_LF_Q10,   2 ) );
+        sLF_AR_shp_Q12 = silk_SUB32( st_res_Q12[ i ], silk_LSHIFT( n_Tilt_Q10, 2 ) );
+        sLF_MA_shp_Q12 = silk_SUB32( sLF_AR_shp_Q12,  silk_LSHIFT( n_LF_Q10,   2 ) );
 
         LTP_shp_buf_idx = ( LTP_shp_buf_idx - 1 ) & LTP_MASK;
-        LTP_shp_buf[ LTP_shp_buf_idx ] = ( opus_int16 )SKP_SAT16( SKP_RSHIFT_ROUND( sLF_MA_shp_Q12, 12 ) );
+        LTP_shp_buf[ LTP_shp_buf_idx ] = ( opus_int16 )silk_SAT16( silk_RSHIFT_ROUND( sLF_MA_shp_Q12, 12 ) );
 
-        xw[i] = ( opus_int16 )SKP_SAT16( SKP_RSHIFT_ROUND( SKP_SUB32( sLF_MA_shp_Q12, n_LTP_Q12 ), 12 ) );
+        xw[i] = ( opus_int16 )silk_SAT16( silk_RSHIFT_ROUND( silk_SUB32( sLF_MA_shp_Q12, n_LTP_Q12 ), 12 ) );
     }
 
     /* Copy temp variable back to state */
index 049d53f..405faa5 100644 (file)
@@ -44,44 +44,44 @@ void silk_process_gains_FIX(
 
     /* Gain reduction when LTP coding gain is high */
     if( psEnc->sCmn.indices.signalType == TYPE_VOICED ) {
-        /*s = -0.5f * SKP_sigmoid( 0.25f * ( psEncCtrl->LTPredCodGain - 12.0f ) ); */
-        s_Q16 = -silk_sigm_Q15( SKP_RSHIFT_ROUND( psEncCtrl->LTPredCodGain_Q7 - SILK_FIX_CONST( 12.0, 7 ), 4 ) );
+        /*s = -0.5f * silk_sigmoid( 0.25f * ( psEncCtrl->LTPredCodGain - 12.0f ) ); */
+        s_Q16 = -silk_sigm_Q15( silk_RSHIFT_ROUND( psEncCtrl->LTPredCodGain_Q7 - SILK_FIX_CONST( 12.0, 7 ), 4 ) );
         for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) {
-            psEncCtrl->Gains_Q16[ k ] = SKP_SMLAWB( psEncCtrl->Gains_Q16[ k ], psEncCtrl->Gains_Q16[ k ], s_Q16 );
+            psEncCtrl->Gains_Q16[ k ] = silk_SMLAWB( psEncCtrl->Gains_Q16[ k ], psEncCtrl->Gains_Q16[ k ], s_Q16 );
         }
     }
 
     /* Limit the quantized signal */
     /* InvMaxSqrVal = pow( 2.0f, 0.33f * ( 21.0f - SNR_dB ) ) / subfr_length; */
-    InvMaxSqrVal_Q16 = SKP_DIV32_16( silk_log2lin(
-        SKP_SMULWB( SILK_FIX_CONST( 21 + 16 / 0.33, 7 ) - psEnc->sCmn.SNR_dB_Q7, SILK_FIX_CONST( 0.33, 16 ) ) ), psEnc->sCmn.subfr_length );
+    InvMaxSqrVal_Q16 = silk_DIV32_16( silk_log2lin(
+        silk_SMULWB( SILK_FIX_CONST( 21 + 16 / 0.33, 7 ) - psEnc->sCmn.SNR_dB_Q7, SILK_FIX_CONST( 0.33, 16 ) ) ), psEnc->sCmn.subfr_length );
 
     for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) {
         /* Soft limit on ratio residual energy and squared gains */
         ResNrg     = psEncCtrl->ResNrg[ k ];
-        ResNrgPart = SKP_SMULWW( ResNrg, InvMaxSqrVal_Q16 );
+        ResNrgPart = silk_SMULWW( ResNrg, InvMaxSqrVal_Q16 );
         if( psEncCtrl->ResNrgQ[ k ] > 0 ) {
-            ResNrgPart = SKP_RSHIFT_ROUND( ResNrgPart, psEncCtrl->ResNrgQ[ k ] );
+            ResNrgPart = silk_RSHIFT_ROUND( ResNrgPart, psEncCtrl->ResNrgQ[ k ] );
         } else {
-            if( ResNrgPart >= SKP_RSHIFT( SKP_int32_MAX, -psEncCtrl->ResNrgQ[ k ] ) ) {
-                ResNrgPart = SKP_int32_MAX;
+            if( ResNrgPart >= silk_RSHIFT( silk_int32_MAX, -psEncCtrl->ResNrgQ[ k ] ) ) {
+                ResNrgPart = silk_int32_MAX;
             } else {
-                ResNrgPart = SKP_LSHIFT( ResNrgPart, -psEncCtrl->ResNrgQ[ k ] );
+                ResNrgPart = silk_LSHIFT( ResNrgPart, -psEncCtrl->ResNrgQ[ k ] );
             }
         }
         gain = psEncCtrl->Gains_Q16[ k ];
-        gain_squared = SKP_ADD_SAT32( ResNrgPart, SKP_SMMUL( gain, gain ) );
-        if( gain_squared < SKP_int16_MAX ) {
+        gain_squared = silk_ADD_SAT32( ResNrgPart, silk_SMMUL( gain, gain ) );
+        if( gain_squared < silk_int16_MAX ) {
             /* recalculate with higher precision */
-            gain_squared = SKP_SMLAWW( SKP_LSHIFT( ResNrgPart, 16 ), gain, gain );
-            SKP_assert( gain_squared > 0 );
+            gain_squared = silk_SMLAWW( silk_LSHIFT( ResNrgPart, 16 ), gain, gain );
+            silk_assert( gain_squared > 0 );
             gain = silk_SQRT_APPROX( gain_squared );                    /* Q8   */
-            gain = SKP_min( gain, SKP_int32_MAX >> 8 );
-            psEncCtrl->Gains_Q16[ k ] = SKP_LSHIFT_SAT32( gain, 8 );        /* Q16  */
+            gain = silk_min( gain, silk_int32_MAX >> 8 );
+            psEncCtrl->Gains_Q16[ k ] = silk_LSHIFT_SAT32( gain, 8 );        /* Q16  */
         } else {
             gain = silk_SQRT_APPROX( gain_squared );                    /* Q0   */
-            gain = SKP_min( gain, SKP_int32_MAX >> 16 );
-            psEncCtrl->Gains_Q16[ k ] = SKP_LSHIFT_SAT32( gain, 16 );       /* Q16  */
+            gain = silk_min( gain, silk_int32_MAX >> 16 );
+            psEncCtrl->Gains_Q16[ k ] = silk_LSHIFT_SAT32( gain, 16 );       /* Q16  */
         }
     }
 
@@ -91,7 +91,7 @@ void silk_process_gains_FIX(
 
     /* Set quantizer offset for voiced signals. Larger offset when LTP coding gain is low or tilt is high (ie low-pass) */
     if( psEnc->sCmn.indices.signalType == TYPE_VOICED ) {
-        if( psEncCtrl->LTPredCodGain_Q7 + SKP_RSHIFT( psEnc->sCmn.input_tilt_Q15, 8 ) > SILK_FIX_CONST( 1.0, 7 ) ) {
+        if( psEncCtrl->LTPredCodGain_Q7 + silk_RSHIFT( psEnc->sCmn.input_tilt_Q15, 8 ) > SILK_FIX_CONST( 1.0, 7 ) ) {
             psEnc->sCmn.indices.quantOffsetType = 0;
         } else {
             psEnc->sCmn.indices.quantOffsetType = 1;
@@ -101,12 +101,12 @@ void silk_process_gains_FIX(
     /* Quantizer boundary adjustment */
     quant_offset_Q10 = silk_Quantization_Offsets_Q10[ psEnc->sCmn.indices.signalType >> 1 ][ psEnc->sCmn.indices.quantOffsetType ];
     psEncCtrl->Lambda_Q10 = SILK_FIX_CONST( LAMBDA_OFFSET, 10 )
-                          + SKP_SMULBB( SILK_FIX_CONST( LAMBDA_DELAYED_DECISIONS, 10 ), psEnc->sCmn.nStatesDelayedDecision )
-                          + SKP_SMULWB( SILK_FIX_CONST( LAMBDA_SPEECH_ACT,        18 ), psEnc->sCmn.speech_activity_Q8     )
-                          + SKP_SMULWB( SILK_FIX_CONST( LAMBDA_INPUT_QUALITY,     12 ), psEncCtrl->input_quality_Q14       )
-                          + SKP_SMULWB( SILK_FIX_CONST( LAMBDA_CODING_QUALITY,    12 ), psEncCtrl->coding_quality_Q14      )
-                          + SKP_SMULWB( SILK_FIX_CONST( LAMBDA_QUANT_OFFSET,      16 ), quant_offset_Q10                   );
+                          + silk_SMULBB( SILK_FIX_CONST( LAMBDA_DELAYED_DECISIONS, 10 ), psEnc->sCmn.nStatesDelayedDecision )
+                          + silk_SMULWB( SILK_FIX_CONST( LAMBDA_SPEECH_ACT,        18 ), psEnc->sCmn.speech_activity_Q8     )
+                          + silk_SMULWB( SILK_FIX_CONST( LAMBDA_INPUT_QUALITY,     12 ), psEncCtrl->input_quality_Q14       )
+                          + silk_SMULWB( SILK_FIX_CONST( LAMBDA_CODING_QUALITY,    12 ), psEncCtrl->coding_quality_Q14      )
+                          + silk_SMULWB( SILK_FIX_CONST( LAMBDA_QUANT_OFFSET,      16 ), quant_offset_Q10                   );
 
-    SKP_assert( psEncCtrl->Lambda_Q10 > 0 );
-    SKP_assert( psEncCtrl->Lambda_Q10 < SILK_FIX_CONST( 2, 10 ) );
+    silk_assert( psEncCtrl->Lambda_Q10 > 0 );
+    silk_assert( psEncCtrl->Lambda_Q10 < SILK_FIX_CONST( 2, 10 ) );
 }
index 040936b..926c812 100644 (file)
@@ -41,7 +41,7 @@ void silk_regularize_correlations_FIX(
 {
     opus_int i;
     for( i = 0; i < D; i++ ) {
-        matrix_ptr( &XX[ 0 ], i, i, D ) = SKP_ADD32( matrix_ptr( &XX[ 0 ], i, i, D ), noise );
+        matrix_ptr( &XX[ 0 ], i, i, D ) = silk_ADD32( matrix_ptr( &XX[ 0 ], i, i, D ), noise );
     }
     xx[ 0 ] += noise;
 }
index fe3b2f1..08a3b0f 100644 (file)
@@ -47,35 +47,35 @@ opus_int32 silk_residual_energy16_covar_FIX(
     const opus_int32 *pRow;
 
     /* Safety checks */
-    SKP_assert( D >=  0 );
-    SKP_assert( D <= 16 );
-    SKP_assert( cQ >  0 );
-    SKP_assert( cQ < 16 );
+    silk_assert( D >=  0 );
+    silk_assert( D <= 16 );
+    silk_assert( cQ >  0 );
+    silk_assert( cQ < 16 );
 
     lshifts = 16 - cQ;
     Qxtra = lshifts;
 
     c_max = 0;
     for( i = 0; i < D; i++ ) {
-        c_max = SKP_max_32( c_max, SKP_abs( ( opus_int32 )c[ i ] ) );
+        c_max = silk_max_32( c_max, silk_abs( ( opus_int32 )c[ i ] ) );
     }
-    Qxtra = SKP_min_int( Qxtra, silk_CLZ32( c_max ) - 17 );
+    Qxtra = silk_min_int( Qxtra, silk_CLZ32( c_max ) - 17 );
 
-    w_max = SKP_max_32( wXX[ 0 ], wXX[ D * D - 1 ] );
-    Qxtra = SKP_min_int( Qxtra, silk_CLZ32( SKP_MUL( D, SKP_RSHIFT( SKP_SMULWB( w_max, c_max ), 4 ) ) ) - 5 );
-    Qxtra = SKP_max_int( Qxtra, 0 );
+    w_max = silk_max_32( wXX[ 0 ], wXX[ D * D - 1 ] );
+    Qxtra = silk_min_int( Qxtra, silk_CLZ32( silk_MUL( D, silk_RSHIFT( silk_SMULWB( w_max, c_max ), 4 ) ) ) - 5 );
+    Qxtra = silk_max_int( Qxtra, 0 );
     for( i = 0; i < D; i++ ) {
-        cn[ i ] = SKP_LSHIFT( ( opus_int )c[ i ], Qxtra );
-        SKP_assert( SKP_abs(cn[i]) <= ( SKP_int16_MAX + 1 ) ); /* Check that SKP_SMLAWB can be used */
+        cn[ i ] = silk_LSHIFT( ( opus_int )c[ i ], Qxtra );
+        silk_assert( silk_abs(cn[i]) <= ( silk_int16_MAX + 1 ) ); /* Check that silk_SMLAWB can be used */
     }
     lshifts -= Qxtra;
 
     /* Compute wxx - 2 * wXx * c */
     tmp = 0;
     for( i = 0; i < D; i++ ) {
-        tmp = SKP_SMLAWB( tmp, wXx[ i ], cn[ i ] );
+        tmp = silk_SMLAWB( tmp, wXx[ i ], cn[ i ] );
     }
-    nrg = SKP_RSHIFT( wxx, 1 + lshifts ) - tmp;                         /* Q: -lshifts - 1 */
+    nrg = silk_RSHIFT( wxx, 1 + lshifts ) - tmp;                         /* Q: -lshifts - 1 */
 
     /* Add c' * wXX * c, assuming wXX is symmetric */
     tmp2 = 0;
@@ -83,20 +83,20 @@ opus_int32 silk_residual_energy16_covar_FIX(
         tmp = 0;
         pRow = &wXX[ i * D ];
         for( j = i + 1; j < D; j++ ) {
-            tmp = SKP_SMLAWB( tmp, pRow[ j ], cn[ j ] );
+            tmp = silk_SMLAWB( tmp, pRow[ j ], cn[ j ] );
         }
-        tmp  = SKP_SMLAWB( tmp,  SKP_RSHIFT( pRow[ i ], 1 ), cn[ i ] );
-        tmp2 = SKP_SMLAWB( tmp2, tmp,                        cn[ i ] );
+        tmp  = silk_SMLAWB( tmp,  silk_RSHIFT( pRow[ i ], 1 ), cn[ i ] );
+        tmp2 = silk_SMLAWB( tmp2, tmp,                        cn[ i ] );
     }
-    nrg = SKP_ADD_LSHIFT32( nrg, tmp2, lshifts );                       /* Q: -lshifts - 1 */
+    nrg = silk_ADD_LSHIFT32( nrg, tmp2, lshifts );                       /* Q: -lshifts - 1 */
 
     /* Keep one bit free always, because we add them for LSF interpolation */
     if( nrg < 1 ) {
         nrg = 1;
-    } else if( nrg > SKP_RSHIFT( SKP_int32_MAX, lshifts + 2 ) ) {
-        nrg = SKP_int32_MAX >> 1;
+    } else if( nrg > silk_RSHIFT( silk_int32_MAX, lshifts + 2 ) ) {
+        nrg = silk_int32_MAX >> 1;
     } else {
-        nrg = SKP_LSHIFT( nrg, lshifts + 1 );                           /* Q0 */
+        nrg = silk_LSHIFT( nrg, lshifts + 1 );                           /* Q0 */
     }
     return nrg;
 
index a1e5ebd..eed19ed 100644 (file)
@@ -79,13 +79,13 @@ void silk_residual_energy_FIX(
         lz1 = silk_CLZ32( nrgs[  i ] ) - 1;
         lz2 = silk_CLZ32( gains[ i ] ) - 1;
 
-        tmp32 = SKP_LSHIFT32( gains[ i ], lz2 );
+        tmp32 = silk_LSHIFT32( gains[ i ], lz2 );
 
         /* Find squared gains */
-        tmp32 = SKP_SMMUL( tmp32, tmp32 ); /* Q( 2 * lz2 - 32 )*/
+        tmp32 = silk_SMMUL( tmp32, tmp32 ); /* Q( 2 * lz2 - 32 )*/
 
         /* Scale energies */
-        nrgs[ i ] = SKP_SMMUL( tmp32, SKP_LSHIFT32( nrgs[ i ], lz1 ) ); /* Q( nrgsQ[ i ] + lz1 + 2 * lz2 - 32 - 32 )*/
+        nrgs[ i ] = silk_SMMUL( tmp32, silk_LSHIFT32( nrgs[ i ], lz1 ) ); /* Q( nrgsQ[ i ] + lz1 + 2 * lz2 - 32 - 32 )*/
         nrgsQ[ i ] += lz1 + 2 * lz2 - 32 - 32;
     }
 }
index 3742370..40abd14 100644 (file)
@@ -83,7 +83,7 @@ void silk_solve_LDL_FIX(
     opus_int32 Y[      MAX_MATRIX_SIZE ];
     inv_D_t   inv_D[  MAX_MATRIX_SIZE ];
 
-    SKP_assert( M <= MAX_MATRIX_SIZE );
+    silk_assert( M <= MAX_MATRIX_SIZE );
 
     /***************************************************
     Factorize A by LDL such that A = L*D*L',
@@ -122,26 +122,26 @@ static inline void silk_LDL_factorize_FIX(
     opus_int32 v_Q0[ MAX_MATRIX_SIZE ], D_Q0[ MAX_MATRIX_SIZE ];
     opus_int32 one_div_diag_Q36, one_div_diag_Q40, one_div_diag_Q48;
 
-    SKP_assert( M <= MAX_MATRIX_SIZE );
+    silk_assert( M <= MAX_MATRIX_SIZE );
 
     status = 1;
-    diag_min_value = SKP_max_32( SKP_SMMUL( SKP_ADD_SAT32( A[ 0 ], A[ SKP_SMULBB( M, M ) - 1 ] ), SILK_FIX_CONST( FIND_LTP_COND_FAC, 31 ) ), 1 << 9 );
+    diag_min_value = silk_max_32( silk_SMMUL( silk_ADD_SAT32( A[ 0 ], A[ silk_SMULBB( M, M ) - 1 ] ), SILK_FIX_CONST( FIND_LTP_COND_FAC, 31 ) ), 1 << 9 );
     for( loop_count = 0; loop_count < M && status == 1; loop_count++ ) {
         status = 0;
         for( j = 0; j < M; j++ ) {
             ptr1 = matrix_adr( L_Q16, j, 0, M );
             tmp_32 = 0;
             for( i = 0; i < j; i++ ) {
-                v_Q0[ i ] = SKP_SMULWW(         D_Q0[ i ], ptr1[ i ] ); /* Q0 */
-                tmp_32    = SKP_SMLAWW( tmp_32, v_Q0[ i ], ptr1[ i ] ); /* Q0 */
+                v_Q0[ i ] = silk_SMULWW(         D_Q0[ i ], ptr1[ i ] ); /* Q0 */
+                tmp_32    = silk_SMLAWW( tmp_32, v_Q0[ i ], ptr1[ i ] ); /* Q0 */
             }
-            tmp_32 = SKP_SUB32( matrix_ptr( A, j, j, M ), tmp_32 );
+            tmp_32 = silk_SUB32( matrix_ptr( A, j, j, M ), tmp_32 );
 
             if( tmp_32 < diag_min_value ) {
-                tmp_32 = SKP_SUB32( SKP_SMULBB( loop_count + 1, diag_min_value ), tmp_32 );
+                tmp_32 = silk_SUB32( silk_SMULBB( loop_count + 1, diag_min_value ), tmp_32 );
                 /* Matrix not positive semi-definite, or ill conditioned */
                 for( i = 0; i < M; i++ ) {
-                    matrix_ptr( A, i, i, M ) = SKP_ADD32( matrix_ptr( A, i, i, M ), tmp_32 );
+                    matrix_ptr( A, i, i, M ) = silk_ADD32( matrix_ptr( A, i, i, M ), tmp_32 );
                 }
                 status = 1;
                 break;
@@ -150,9 +150,9 @@ static inline void silk_LDL_factorize_FIX(
 
             /* two-step division */
             one_div_diag_Q36 = silk_INVERSE32_varQ( tmp_32, 36 );                    /* Q36 */
-            one_div_diag_Q40 = SKP_LSHIFT( one_div_diag_Q36, 4 );                   /* Q40 */
-            err = SKP_SUB32( 1 << 24, SKP_SMULWW( tmp_32, one_div_diag_Q40 ) );     /* Q24 */
-            one_div_diag_Q48 = SKP_SMULWW( err, one_div_diag_Q40 );                 /* Q48 */
+            one_div_diag_Q40 = silk_LSHIFT( one_div_diag_Q36, 4 );                   /* Q40 */
+            err = silk_SUB32( 1 << 24, silk_SMULWW( tmp_32, one_div_diag_Q40 ) );     /* Q24 */
+            one_div_diag_Q48 = silk_SMULWW( err, one_div_diag_Q40 );                 /* Q48 */
 
             /* Save 1/Ds */
             inv_D[ j ].Q36_part = one_div_diag_Q36;
@@ -164,13 +164,13 @@ static inline void silk_LDL_factorize_FIX(
             for( i = j + 1; i < M; i++ ) {
                 tmp_32 = 0;
                 for( k = 0; k < j; k++ ) {
-                    tmp_32 = SKP_SMLAWW( tmp_32, v_Q0[ k ], ptr2[ k ] ); /* Q0 */
+                    tmp_32 = silk_SMLAWW( tmp_32, v_Q0[ k ], ptr2[ k ] ); /* Q0 */
                 }
-                tmp_32 = SKP_SUB32( ptr1[ i ], tmp_32 ); /* always < max(Correlation) */
+                tmp_32 = silk_SUB32( ptr1[ i ], tmp_32 ); /* always < max(Correlation) */
 
                 /* tmp_32 / D_Q0[j] : Divide to Q16 */
-                matrix_ptr( L_Q16, i, j, M ) = SKP_ADD32( SKP_SMMUL( tmp_32, one_div_diag_Q48 ),
-                    SKP_RSHIFT( SKP_SMULWW( tmp_32, one_div_diag_Q36 ), 4 ) );
+                matrix_ptr( L_Q16, i, j, M ) = silk_ADD32( silk_SMMUL( tmp_32, one_div_diag_Q48 ),
+                    silk_RSHIFT( silk_SMULWW( tmp_32, one_div_diag_Q36 ), 4 ) );
 
                 /* go to next column */
                 ptr2 += M;
@@ -178,7 +178,7 @@ static inline void silk_LDL_factorize_FIX(
         }
     }
 
-    SKP_assert( status == 0 );
+    silk_assert( status == 0 );
 }
 
 static inline void silk_LS_divide_Q16_FIX(
@@ -196,7 +196,7 @@ static inline void silk_LS_divide_Q16_FIX(
         one_div_diag_Q48 = inv_D[ i ].Q48_part;
 
         tmp_32 = T[ i ];
-        T[ i ] = SKP_ADD32( SKP_SMMUL( tmp_32, one_div_diag_Q48 ), SKP_RSHIFT( SKP_SMULWW( tmp_32, one_div_diag_Q36 ), 4 ) );
+        T[ i ] = silk_ADD32( silk_SMMUL( tmp_32, one_div_diag_Q48 ), silk_RSHIFT( silk_SMULWW( tmp_32, one_div_diag_Q36 ), 4 ) );
     }
 }
 
@@ -216,9 +216,9 @@ static inline void silk_LS_SolveFirst_FIX(
         ptr32 = matrix_adr( L_Q16, i, 0, M );
         tmp_32 = 0;
         for( j = 0; j < i; j++ ) {
-            tmp_32 = SKP_SMLAWW( tmp_32, ptr32[ j ], x_Q16[ j ] );
+            tmp_32 = silk_SMLAWW( tmp_32, ptr32[ j ], x_Q16[ j ] );
         }
-        x_Q16[ i ] = SKP_SUB32( b[ i ], tmp_32 );
+        x_Q16[ i ] = silk_SUB32( b[ i ], tmp_32 );
     }
 }
 
@@ -238,8 +238,8 @@ static inline void silk_LS_SolveLast_FIX(
         ptr32 = matrix_adr( L_Q16, 0, i, M );
         tmp_32 = 0;
         for( j = M - 1; j > i; j-- ) {
-            tmp_32 = SKP_SMLAWW( tmp_32, ptr32[ SKP_SMULBB( j, M ) ], x_Q16[ j ] );
+            tmp_32 = silk_SMLAWW( tmp_32, ptr32[ silk_SMULBB( j, M ) ], x_Q16[ j ] );
         }
-        x_Q16[ i ] = SKP_SUB32( b[ i ], tmp_32 );
+        x_Q16[ i ] = silk_SUB32( b[ i ], tmp_32 );
     }
 }
index 6cd74f1..4d5cfc3 100644 (file)
@@ -70,7 +70,7 @@ typedef struct {
     silk_prefilter_state_FIX    sPrefilt;                   /* Prefilter State                                                  */
 
     /* Buffer for find pitch and noise shape analysis */
-    SKP_DWORD_ALIGN opus_int16   x_buf[ 2 * MAX_FRAME_LENGTH + LA_SHAPE_MAX ];/* Buffer for find pitch and noise shape analysis  */
+    silk_DWORD_ALIGN opus_int16   x_buf[ 2 * MAX_FRAME_LENGTH + LA_SHAPE_MAX ];/* Buffer for find pitch and noise shape analysis  */
     opus_int                     LTPCorr_Q15;                /* Normalized correlation from pitch lag estimator                  */
 
     /* Parameters For LTP scaling Control */
@@ -84,15 +84,15 @@ typedef struct {
 typedef struct {
     /* Prediction and coding parameters */
     opus_int32                   Gains_Q16[ MAX_NB_SUBFR ];
-    SKP_DWORD_ALIGN opus_int16   PredCoef_Q12[ 2 ][ MAX_LPC_ORDER ];
+    silk_DWORD_ALIGN opus_int16   PredCoef_Q12[ 2 ][ MAX_LPC_ORDER ];
     opus_int16                   LTPCoef_Q14[ LTP_ORDER * MAX_NB_SUBFR ];
     opus_int                     LTP_scale_Q14;
     opus_int                     pitchL[ MAX_NB_SUBFR ];
 
     /* Noise shaping parameters */
     /* Testing */
-    SKP_DWORD_ALIGN opus_int16 AR1_Q13[ MAX_NB_SUBFR * MAX_SHAPE_LPC_ORDER ];
-    SKP_DWORD_ALIGN opus_int16 AR2_Q13[ MAX_NB_SUBFR * MAX_SHAPE_LPC_ORDER ];
+    silk_DWORD_ALIGN opus_int16 AR1_Q13[ MAX_NB_SUBFR * MAX_SHAPE_LPC_ORDER ];
+    silk_DWORD_ALIGN opus_int16 AR2_Q13[ MAX_NB_SUBFR * MAX_SHAPE_LPC_ORDER ];
     opus_int32   LF_shp_Q14[        MAX_NB_SUBFR ];          /* Packs two int16 coefficients per int32 value             */
     opus_int     GainsPre_Q14[      MAX_NB_SUBFR ];
     opus_int     HarmBoost_Q14[     MAX_NB_SUBFR ];
index 2c80cfe..0eadda4 100644 (file)
@@ -50,39 +50,39 @@ void silk_warped_autocorrelation_FIX(
     opus_int64 corr_QC[  MAX_SHAPE_LPC_ORDER + 1 ] = { 0 };
 
     /* Order must be even */
-    SKP_assert( ( order & 1 ) == 0 );
-    SKP_assert( 2 * QS - QC >= 0 );
+    silk_assert( ( order & 1 ) == 0 );
+    silk_assert( 2 * QS - QC >= 0 );
 
     /* Loop over samples */
     for( n = 0; n < length; n++ ) {
-        tmp1_QS = SKP_LSHIFT32( ( opus_int32 )input[ n ], QS );
+        tmp1_QS = silk_LSHIFT32( ( opus_int32 )input[ n ], QS );
         /* Loop over allpass sections */
         for( i = 0; i < order; i += 2 ) {
             /* Output of allpass section */
-            tmp2_QS = SKP_SMLAWB( state_QS[ i ], state_QS[ i + 1 ] - tmp1_QS, warping_Q16 );
+            tmp2_QS = silk_SMLAWB( state_QS[ i ], state_QS[ i + 1 ] - tmp1_QS, warping_Q16 );
             state_QS[ i ]  = tmp1_QS;
-            corr_QC[  i ] += SKP_RSHIFT64( SKP_SMULL( tmp1_QS, state_QS[ 0 ] ), 2 * QS - QC );
+            corr_QC[  i ] += silk_RSHIFT64( silk_SMULL( tmp1_QS, state_QS[ 0 ] ), 2 * QS - QC );
             /* Output of allpass section */
-            tmp1_QS = SKP_SMLAWB( state_QS[ i + 1 ], state_QS[ i + 2 ] - tmp2_QS, warping_Q16 );
+            tmp1_QS = silk_SMLAWB( state_QS[ i + 1 ], state_QS[ i + 2 ] - tmp2_QS, warping_Q16 );
             state_QS[ i + 1 ]  = tmp2_QS;
-            corr_QC[  i + 1 ] += SKP_RSHIFT64( SKP_SMULL( tmp2_QS, state_QS[ 0 ] ), 2 * QS - QC );
+            corr_QC[  i + 1 ] += silk_RSHIFT64( silk_SMULL( tmp2_QS, state_QS[ 0 ] ), 2 * QS - QC );
         }
         state_QS[ order ] = tmp1_QS;
-        corr_QC[  order ] += SKP_RSHIFT64( SKP_SMULL( tmp1_QS, state_QS[ 0 ] ), 2 * QS - QC );
+        corr_QC[  order ] += silk_RSHIFT64( silk_SMULL( tmp1_QS, state_QS[ 0 ] ), 2 * QS - QC );
     }
 
     lsh = silk_CLZ64( corr_QC[ 0 ] ) - 35;
-    lsh = SKP_LIMIT( lsh, -12 - QC, 30 - QC );
+    lsh = silk_LIMIT( lsh, -12 - QC, 30 - QC );
     *scale = -( QC + lsh );
-    SKP_assert( *scale >= -30 && *scale <= 12 );
+    silk_assert( *scale >= -30 && *scale <= 12 );
     if( lsh >= 0 ) {
         for( i = 0; i < order + 1; i++ ) {
-            corr[ i ] = ( opus_int32 )SKP_CHECK_FIT32( SKP_LSHIFT64( corr_QC[ i ], lsh ) );
+            corr[ i ] = ( opus_int32 )silk_CHECK_FIT32( silk_LSHIFT64( corr_QC[ i ], lsh ) );
         }
     } else {
         for( i = 0; i < order + 1; i++ ) {
-            corr[ i ] = ( opus_int32 )SKP_CHECK_FIT32( SKP_RSHIFT64( corr_QC[ i ], -lsh ) );
+            corr[ i ] = ( opus_int32 )silk_CHECK_FIT32( silk_RSHIFT64( corr_QC[ i ], -lsh ) );
         }
     }
-    SKP_assert( corr_QC[ 0 ] >= 0 ); /* If breaking, decrease QC*/
+    silk_assert( corr_QC[ 0 ] >= 0 ); /* If breaking, decrease QC*/
 }
index c221812..1cfd1d7 100644 (file)
@@ -41,15 +41,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /* 16th order LPC analysis filter, does not write first 16 samples */
 void silk_LPC_analysis_filter16_FLP(
-          SKP_float                 r_LPC[],            /* O    LPC residual signal                     */
-    const SKP_float                 PredCoef[],         /* I    LPC coefficients                        */
-    const SKP_float                 s[],                /* I    Input signal                            */
+          silk_float                 r_LPC[],            /* O    LPC residual signal                     */
+    const silk_float                 PredCoef[],         /* I    LPC coefficients                        */
+    const silk_float                 s[],                /* I    Input signal                            */
     const opus_int                   length              /* I    Length of input signal                  */
 )
 {
     opus_int   ix;
-    SKP_float LPC_pred;
-    const SKP_float *s_ptr;
+    silk_float LPC_pred;
+    const silk_float *s_ptr;
 
     for ( ix = 16; ix < length; ix++) {
         s_ptr = &s[ix - 1];
@@ -79,15 +79,15 @@ void silk_LPC_analysis_filter16_FLP(
 
 /* 14th order LPC analysis filter, does not write first 14 samples */
 void silk_LPC_analysis_filter14_FLP(
-          SKP_float                 r_LPC[],            /* O    LPC residual signal                     */
-    const SKP_float                 PredCoef[],         /* I    LPC coefficients                        */
-    const SKP_float                 s[],                /* I    Input signal                            */
+          silk_float                 r_LPC[],            /* O    LPC residual signal                     */
+    const silk_float                 PredCoef[],         /* I    LPC coefficients                        */
+    const silk_float                 s[],                /* I    Input signal                            */
     const opus_int                   length              /* I    Length of input signal                  */
 )
 {
     opus_int   ix;
-    SKP_float LPC_pred;
-    const SKP_float *s_ptr;
+    silk_float LPC_pred;
+    const silk_float *s_ptr;
 
     for ( ix = 14; ix < length; ix++) {
         s_ptr = &s[ix - 1];
@@ -115,15 +115,15 @@ void silk_LPC_analysis_filter14_FLP(
 
 /* 12th order LPC analysis filter, does not write first 12 samples */
 void silk_LPC_analysis_filter12_FLP(
-          SKP_float                 r_LPC[],            /* O    LPC residual signal                     */
-    const SKP_float                 PredCoef[],         /* I    LPC coefficients                        */
-    const SKP_float                 s[],                /* I    Input signal                            */
+          silk_float                 r_LPC[],            /* O    LPC residual signal                     */
+    const silk_float                 PredCoef[],         /* I    LPC coefficients                        */
+    const silk_float                 s[],                /* I    Input signal                            */
     const opus_int                   length              /* I    Length of input signal                  */
 )
 {
     opus_int   ix;
-    SKP_float LPC_pred;
-    const SKP_float *s_ptr;
+    silk_float LPC_pred;
+    const silk_float *s_ptr;
 
     for ( ix = 12; ix < length; ix++) {
         s_ptr = &s[ix - 1];
@@ -149,15 +149,15 @@ void silk_LPC_analysis_filter12_FLP(
 
 /* 10th order LPC analysis filter, does not write first 10 samples */
 void silk_LPC_analysis_filter10_FLP(
-          SKP_float                 r_LPC[],            /* O    LPC residual signal                     */
-    const SKP_float                 PredCoef[],         /* I    LPC coefficients                        */
-    const SKP_float                 s[],                /* I    Input signal                            */
+          silk_float                 r_LPC[],            /* O    LPC residual signal                     */
+    const silk_float                 PredCoef[],         /* I    LPC coefficients                        */
+    const silk_float                 s[],                /* I    Input signal                            */
     const opus_int                   length              /* I    Length of input signal                  */
 )
 {
     opus_int   ix;
-    SKP_float LPC_pred;
-    const SKP_float *s_ptr;
+    silk_float LPC_pred;
+    const silk_float *s_ptr;
 
     for ( ix = 10; ix < length; ix++) {
         s_ptr = &s[ix - 1];
@@ -181,15 +181,15 @@ void silk_LPC_analysis_filter10_FLP(
 
 /* 8th order LPC analysis filter, does not write first 8 samples */
 void silk_LPC_analysis_filter8_FLP(
-          SKP_float                 r_LPC[],            /* O    LPC residual signal                     */
-    const SKP_float                 PredCoef[],         /* I    LPC coefficients                        */
-    const SKP_float                 s[],                /* I    Input signal                            */
+          silk_float                 r_LPC[],            /* O    LPC residual signal                     */
+    const silk_float                 PredCoef[],         /* I    LPC coefficients                        */
+    const silk_float                 s[],                /* I    Input signal                            */
     const opus_int                   length              /* I    Length of input signal                  */
 )
 {
     opus_int   ix;
-    SKP_float LPC_pred;
-    const SKP_float *s_ptr;
+    silk_float LPC_pred;
+    const silk_float *s_ptr;
 
     for ( ix = 8; ix < length; ix++) {
         s_ptr = &s[ix - 1];
@@ -211,15 +211,15 @@ void silk_LPC_analysis_filter8_FLP(
 
 /* 6th order LPC analysis filter, does not write first 6 samples */
 void silk_LPC_analysis_filter6_FLP(
-          SKP_float                 r_LPC[],            /* O    LPC residual signal                     */
-    const SKP_float                 PredCoef[],         /* I    LPC coefficients                        */
-    const SKP_float                 s[],                /* I    Input signal                            */
+          silk_float                 r_LPC[],            /* O    LPC residual signal                     */
+    const silk_float                 PredCoef[],         /* I    LPC coefficients                        */
+    const silk_float                 s[],                /* I    Input signal                            */
     const opus_int                   length              /* I    Length of input signal                  */
 )
 {
     opus_int   ix;
-    SKP_float LPC_pred;
-    const SKP_float *s_ptr;
+    silk_float LPC_pred;
+    const silk_float *s_ptr;
 
     for ( ix = 6; ix < length; ix++) {
         s_ptr = &s[ix - 1];
@@ -245,14 +245,14 @@ void silk_LPC_analysis_filter6_FLP(
 /************************************************/
 
 void silk_LPC_analysis_filter_FLP(
-          SKP_float                 r_LPC[],            /* O    LPC residual signal                     */
-    const SKP_float                 PredCoef[],         /* I    LPC coefficients                        */
-    const SKP_float                 s[],                /* I    Input signal                            */
+          silk_float                 r_LPC[],            /* O    LPC residual signal                     */
+    const silk_float                 PredCoef[],         /* I    LPC coefficients                        */
+    const silk_float                 s[],                /* I    Input signal                            */
     const opus_int                   length,             /* I    Length of input signal                  */
     const opus_int                   Order               /* I    LPC order                               */
 )
 {
-    SKP_assert( Order <= length );
+    silk_assert( Order <= length );
 
     switch( Order ) {
         case 6:
@@ -280,11 +280,11 @@ void silk_LPC_analysis_filter_FLP(
         break;
 
         default:
-            SKP_assert( 0 );
+            silk_assert( 0 );
         break;
     }
 
     /* Set first Order output samples to zero */
-    SKP_memset( r_LPC, 0, Order * sizeof( SKP_float ) );
+    silk_memset( r_LPC, 0, Order * sizeof( silk_float ) );
 }
 
index bbff53a..29c0c0d 100644 (file)
@@ -38,18 +38,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /* test if LPC coefficients are stable (all poles within unit circle)   */
 /* this code is based on silk_a2k_FLP()                               */
 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                        */
 )
 {
     opus_int   k, n;
     double    rc, rc_mult1, rc_mult2;
-    SKP_float Atmp[ 2 ][ SILK_MAX_ORDER_LPC ];
-    SKP_float *Aold, *Anew;
+    silk_float Atmp[ 2 ][ SILK_MAX_ORDER_LPC ];
+    silk_float *Aold, *Anew;
 
     Anew = Atmp[ order & 1 ];
-    SKP_memcpy( Anew, A, order * sizeof(SKP_float) );
+    silk_memcpy( Anew, A, order * sizeof(silk_float) );
 
     *invGain = 1.0f;
     for( k = order - 1; k > 0; k-- ) {
@@ -59,12 +59,12 @@ opus_int silk_LPC_inverse_pred_gain_FLP(   /* O:   returns 1 if unstable, otherw
         }
         rc_mult1 = 1.0f - rc * rc;
         rc_mult2 = 1.0f / rc_mult1;
-        *invGain *= (SKP_float)rc_mult1;
+        *invGain *= (silk_float)rc_mult1;
         /* swap pointers */
         Aold = Anew;
         Anew = Atmp[ k & 1 ];
         for( n = 0; n < k; n++ ) {
-            Anew[ n ] = (SKP_float)( ( Aold[ n ] - Aold[ k - n - 1 ] * rc ) * rc_mult2 );
+            Anew[ n ] = (silk_float)( ( Aold[ n ] - Aold[ k - n - 1 ] * rc ) * rc_mult2 );
         }
     }
     rc = -Anew[ 0 ];
@@ -72,6 +72,6 @@ opus_int silk_LPC_inverse_pred_gain_FLP(   /* O:   returns 1 if unstable, otherw
         return 1;
     }
     rc_mult1 = 1.0f - rc * rc;
-    *invGain *= (SKP_float)rc_mult1;
+    *invGain *= (silk_float)rc_mult1;
     return 0;
 }
index a02d09d..4b54c0f 100644 (file)
@@ -32,20 +32,20 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "silk_main_FLP.h"
 
 void silk_LTP_analysis_filter_FLP(
-          SKP_float         *LTP_res,                       /* O    LTP res MAX_NB_SUBFR*(pre_lgth+subfr_lngth) */
-    const SKP_float         *x,                             /* I    Input signal, with preceeding samples       */
-    const SKP_float         B[ LTP_ORDER * MAX_NB_SUBFR ],  /* I    LTP coefficients for each subframe          */
+          silk_float         *LTP_res,                       /* O    LTP res MAX_NB_SUBFR*(pre_lgth+subfr_lngth) */
+    const silk_float         *x,                             /* I    Input signal, with preceeding samples       */
+    const silk_float         B[ LTP_ORDER * MAX_NB_SUBFR ],  /* I    LTP coefficients for each subframe          */
     const opus_int           pitchL[   MAX_NB_SUBFR ],       /* I    Pitch lags                                  */
-    const SKP_float         invGains[ MAX_NB_SUBFR ],       /* I    Inverse quantization gains                  */
+    const silk_float         invGains[ MAX_NB_SUBFR ],       /* I    Inverse quantization gains                  */
     const opus_int           subfr_length,                   /* I    Length of each subframe                     */
     const opus_int           nb_subfr,                       /* I    number of subframes                         */
     const opus_int           pre_length                      /* I    Preceeding samples for each subframe        */
 )
 {
-    const SKP_float *x_ptr, *x_lag_ptr;
-    SKP_float   Btmp[ LTP_ORDER ];
-    SKP_float   *LTP_res_ptr;
-    SKP_float   inv_gain;
+    const silk_float *x_ptr, *x_lag_ptr;
+    silk_float   Btmp[ LTP_ORDER ];
+    silk_float   *LTP_res_ptr;
+    silk_float   inv_gain;
     opus_int     k, i, j;
 
     x_ptr = x;
index 7ff2325..bd4405d 100644 (file)
@@ -40,17 +40,17 @@ void silk_LTP_scale_ctrl_FLP(
 
     /* 1st order high-pass filter */
     /*g_HP(n) = g(n) - 0.5 * g(n-1) + 0.5 * g_HP(n-1);*/
-    psEnc->HPLTPredCodGain = SKP_max_float( psEncCtrl->LTPredCodGain - 0.5f * psEnc->prevLTPredCodGain, 0.0f )
+    psEnc->HPLTPredCodGain = silk_max_float( psEncCtrl->LTPredCodGain - 0.5f * psEnc->prevLTPredCodGain, 0.0f )
                             + 0.5f * psEnc->HPLTPredCodGain;
     psEnc->prevLTPredCodGain = psEncCtrl->LTPredCodGain;
 
     /* Only scale if first frame in packet */
     if( psEnc->sCmn.nFramesEncoded == 0 ) {
         round_loss = psEnc->sCmn.PacketLoss_perc + psEnc->sCmn.nFramesPerPacket;
-        psEnc->sCmn.indices.LTP_scaleIndex = (opus_int8)SKP_LIMIT( round_loss * psEnc->HPLTPredCodGain * 0.1f, 0.0f, 2.0f );
+        psEnc->sCmn.indices.LTP_scaleIndex = (opus_int8)silk_LIMIT( round_loss * psEnc->HPLTPredCodGain * 0.1f, 0.0f, 2.0f );
     } else {
         /* Default is minimum scaling */
         psEnc->sCmn.indices.LTP_scaleIndex = 0;
     }
-    psEncCtrl->LTP_scale = (SKP_float)silk_LTPScales_table_Q14[ psEnc->sCmn.indices.LTP_scaleIndex ] / 16384.0f;
+    psEncCtrl->LTP_scale = (silk_float)silk_LTPScales_table_Q14[ psEnc->sCmn.indices.LTP_scaleIndex ] / 16384.0f;
 }
index 05e620c..b101924 100644 (file)
@@ -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
 }
index def9933..9a82d9c 100644 (file)
@@ -36,19 +36,19 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /*  1 -> sine window from 0 to pi/2                                                                     */
 /*  2 -> sine window from pi/2 to pi                                                                    */
 void silk_apply_sine_window_FLP(
-          SKP_float                 px_win[],           /* O    Pointer to windowed signal              */
-    const SKP_float                 px[],               /* I    Pointer to input signal                 */
+          silk_float                 px_win[],           /* O    Pointer to windowed signal              */
+    const silk_float                 px[],               /* I    Pointer to input signal                 */
     const opus_int                   win_type,           /* I    Selects a window type                   */
     const opus_int                   length              /* I    Window length, multiple of 4            */
 )
 {
     opus_int   k;
-    SKP_float freq, c, S0, S1;
+    silk_float freq, c, S0, S1;
 
-    SKP_assert( win_type == 1 || win_type == 2 );
+    silk_assert( win_type == 1 || win_type == 2 );
 
     /* Length must be multiple of 4 */
-    SKP_assert( ( length & 3 ) == 0 );
+    silk_assert( ( length & 3 ) == 0 );
 
     freq = PI / ( length + 1 );
 
index 540512c..5c6662a 100644 (file)
@@ -34,8 +34,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /* 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       */
 )
@@ -47,6 +47,6 @@ void silk_autocorrelation_FLP(
     }
 
     for( i = 0; i < correlationCount; i++ ) {
-        results[ i ] =  (SKP_float)silk_inner_product_FLP( inputData, inputData + i, inputDataSize - i );
+        results[ i ] =  (silk_float)silk_inner_product_FLP( inputData, inputData + i, inputDataSize - i );
     }
 }
index bf9278d..24806ae 100644 (file)
@@ -35,35 +35,35 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define MAX_NB_SUBFR                4
 
 /* 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                                                           */
 )
 {
     opus_int         k, n, s;
     double          C0, num, nrg_f, nrg_b, rc, Atmp, tmp1, tmp2;
-    const SKP_float *x_ptr;
+    const silk_float *x_ptr;
     double          C_first_row[ SILK_MAX_ORDER_LPC ], C_last_row[ SILK_MAX_ORDER_LPC ];
     double          CAf[ SILK_MAX_ORDER_LPC + 1 ], CAb[ SILK_MAX_ORDER_LPC + 1 ];
     double          Af[ SILK_MAX_ORDER_LPC ];
 
-    SKP_assert( subfr_length * nb_subfr <= MAX_FRAME_SIZE );
-    SKP_assert( nb_subfr <= MAX_NB_SUBFR );
+    silk_assert( subfr_length * nb_subfr <= MAX_FRAME_SIZE );
+    silk_assert( nb_subfr <= MAX_NB_SUBFR );
 
     /* Compute autocorrelations, added over subframes */
     C0 = silk_energy_FLP( x, nb_subfr * subfr_length );
-    SKP_memset( C_first_row, 0, SILK_MAX_ORDER_LPC * sizeof( double ) );
+    silk_memset( C_first_row, 0, SILK_MAX_ORDER_LPC * sizeof( double ) );
     for( s = 0; s < nb_subfr; s++ ) {
         x_ptr = x + s * subfr_length;
         for( n = 1; n < D + 1; n++ ) {
             C_first_row[ n - 1 ] += silk_inner_product_FLP( x_ptr, x_ptr + n, subfr_length - n );
         }
     }
-    SKP_memcpy( C_last_row, C_first_row, SILK_MAX_ORDER_LPC * sizeof( double ) );
+    silk_memcpy( C_last_row, C_first_row, SILK_MAX_ORDER_LPC * sizeof( double ) );
 
     /* Initialize */
     CAb[ 0 ] = CAf[ 0 ] = C0 + WhiteNoiseFrac * C0 + 1e-9f;
@@ -109,12 +109,12 @@ SKP_float silk_burg_modified_FLP(   /* O    returns residual energy
             nrg_b += CAb[ k + 1 ] * Atmp;
             nrg_f += CAf[ k + 1 ] * Atmp;
         }
-        SKP_assert( nrg_f > 0.0 );
-        SKP_assert( nrg_b > 0.0 );
+        silk_assert( nrg_f > 0.0 );
+        silk_assert( nrg_b > 0.0 );
 
         /* Calculate the next order reflection (parcor) coefficient */
         rc = -2.0 * num / ( nrg_f + nrg_b );
-        SKP_assert( rc > -1.0 && rc < 1.0 );
+        silk_assert( rc > -1.0 && rc < 1.0 );
 
         /* Update the AR coefficients */
         for( k = 0; k < (n + 1) >> 1; k++ ) {
@@ -140,9 +140,9 @@ SKP_float silk_burg_modified_FLP(   /* O    returns residual energy
         Atmp = Af[ k ];
         nrg_f += CAf[ k + 1 ] * Atmp;
         tmp1  += Atmp * Atmp;
-        A[ k ] = (SKP_float)(-Atmp);
+        A[ k ] = (silk_float)(-Atmp);
     }
     nrg_f -= WhiteNoiseFrac * C0 * tmp1;
 
-    return (SKP_float)nrg_f;
+    return (silk_float)nrg_f;
 }
index ddae86a..4a0088a 100644 (file)
@@ -34,13 +34,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /* Chirp (bw expand) LP AR filter */
 void silk_bwexpander_FLP(
-    SKP_float           *ar,        /* I/O  AR filter to be expanded (without leading 1)    */
+    silk_float           *ar,        /* I/O  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) )       */
 )
 {
     opus_int   i;
-    SKP_float cfac = chirp;
+    silk_float cfac = chirp;
 
     for( i = 0; i < d - 1; i++ ) {
         ar[ i ] *=  cfac;
index 1d92da8..d66107a 100644 (file)
@@ -37,56 +37,56 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /* Calculates correlation vector X'*t */
 void silk_corrVector_FLP(
-    const SKP_float                 *x,                 /* I    x vector [L+order-1] used to create X   */
-    const SKP_float                 *t,                 /* I    Target vector [L]                       */
+    const silk_float                 *x,                 /* I    x vector [L+order-1] used to create X   */
+    const silk_float                 *t,                 /* I    Target vector [L]                       */
     const opus_int                   L,                  /* I    Length of vecors                        */
     const opus_int                   Order,              /* I    Max lag for correlation                 */
-          SKP_float                 *Xt                 /* O    X'*t correlation vector [order]         */
+          silk_float                 *Xt                 /* O    X'*t correlation vector [order]         */
 )
 {
     opus_int lag;
-    const SKP_float *ptr1;
+    const silk_float *ptr1;
 
     ptr1 = &x[ Order - 1 ];                     /* Points to first sample of column 0 of X: X[:,0] */
     for( lag = 0; lag < Order; lag++ ) {
         /* Calculate X[:,lag]'*t */
-        Xt[ lag ] = (SKP_float)silk_inner_product_FLP( ptr1, t, L );
+        Xt[ lag ] = (silk_float)silk_inner_product_FLP( ptr1, t, L );
         ptr1--;                                 /* Next column of X */
     }
 }
 
 /* Calculates correlation matrix X'*X */
 void silk_corrMatrix_FLP(
-    const SKP_float                 *x,                 /* I    x vector [ L+order-1 ] used to create X */
+    const silk_float                 *x,                 /* I    x vector [ L+order-1 ] used to create X */
     const opus_int                   L,                  /* I    Length of vectors                       */
     const opus_int                   Order,              /* I    Max lag for correlation                 */
-          SKP_float                 *XX                 /* O    X'*X correlation matrix [order x order] */
+          silk_float                 *XX                 /* O    X'*X correlation matrix [order x order] */
 )
 {
     opus_int j, lag;
     double  energy;
-    const SKP_float *ptr1, *ptr2;
+    const silk_float *ptr1, *ptr2;
 
     ptr1 = &x[ Order - 1 ];                     /* First sample of column 0 of X */
     energy = silk_energy_FLP( ptr1, L );  /* X[:,0]'*X[:,0] */
-    matrix_ptr( XX, 0, 0, Order ) = ( SKP_float )energy;
+    matrix_ptr( XX, 0, 0, Order ) = ( silk_float )energy;
     for( j = 1; j < Order; j++ ) {
         /* Calculate X[:,j]'*X[:,j] */
         energy += ptr1[ -j ] * ptr1[ -j ] - ptr1[ L - j ] * ptr1[ L - j ];
-        matrix_ptr( XX, j, j, Order ) = ( SKP_float )energy;
+        matrix_ptr( XX, j, j, Order ) = ( silk_float )energy;
     }
 
     ptr2 = &x[ Order - 2 ];                     /* First sample of column 1 of X */
     for( lag = 1; lag < Order; lag++ ) {
         /* Calculate X[:,0]'*X[:,lag] */
         energy = silk_inner_product_FLP( ptr1, ptr2, L );
-        matrix_ptr( XX, lag, 0, Order ) = ( SKP_float )energy;
-        matrix_ptr( XX, 0, lag, Order ) = ( SKP_float )energy;
+        matrix_ptr( XX, lag, 0, Order ) = ( silk_float )energy;
+        matrix_ptr( XX, 0, lag, Order ) = ( silk_float )energy;
         /* Calculate X[:,j]'*X[:,j + lag] */
         for( j = 1; j < ( Order - lag ); j++ ) {
             energy += ptr1[ -j ] * ptr2[ -j ] - ptr1[ L - j ] * ptr2[ L - j ];
-            matrix_ptr( XX, lag + j, j, Order ) = ( SKP_float )energy;
-            matrix_ptr( XX, j, lag + j, Order ) = ( SKP_float )energy;
+            matrix_ptr( XX, lag + j, j, Order ) = ( silk_float )energy;
+            matrix_ptr( XX, j, lag + j, Order ) = ( silk_float )energy;
         }
         ptr2--;                                 /* Next column of X */
     }
index 2fc701d..fce6160 100644 (file)
@@ -43,9 +43,9 @@ opus_int silk_encode_frame_FLP(
 {
     silk_encoder_control_FLP sEncCtrl;
     opus_int     i, ret = 0;
-    SKP_float   *x_frame, *res_pitch_frame;
-    SKP_float   xfw[ MAX_FRAME_LENGTH ];
-    SKP_float   res_pitch[ 2 * MAX_FRAME_LENGTH + LA_PITCH_MAX ];
+    silk_float   *x_frame, *res_pitch_frame;
+    silk_float   xfw[ MAX_FRAME_LENGTH ];
+    silk_float   res_pitch[ 2 * MAX_FRAME_LENGTH + LA_PITCH_MAX ];
 
 TIC(ENCODE_FRAME)
 
@@ -96,7 +96,7 @@ TOC(VAD)
     /*******************************************/
     /* Copy new frame to front of input buffer */
     /*******************************************/
-    SKP_short2float_array( x_frame + LA_SHAPE_MS * psEnc->sCmn.fs_kHz, psEnc->sCmn.inputBuf + 1, psEnc->sCmn.frame_length );
+    silk_short2float_array( x_frame + LA_SHAPE_MS * psEnc->sCmn.fs_kHz, psEnc->sCmn.inputBuf + 1, psEnc->sCmn.frame_length );
 
     /* Add tiny signal to avoid high CPU load from denormalized floating point numbers */
     for( i = 0; i < 8; i++ ) {
@@ -153,8 +153,8 @@ TIC(NSQ)
 TOC(NSQ)
 
     /* Update input buffer */
-    SKP_memmove( psEnc->x_buf, &psEnc->x_buf[ psEnc->sCmn.frame_length ],
-        ( psEnc->sCmn.ltp_mem_length + LA_SHAPE_MS * psEnc->sCmn.fs_kHz ) * sizeof( SKP_float ) );
+    silk_memmove( psEnc->x_buf, &psEnc->x_buf[ psEnc->sCmn.frame_length ],
+        ( psEnc->sCmn.ltp_mem_length + LA_SHAPE_MS * psEnc->sCmn.fs_kHz ) * sizeof( silk_float ) );
 
     /* Parameters needed for next frame */
     psEnc->sCmn.prevLag        = sEncCtrl.pitchL[ psEnc->sCmn.nb_subfr - 1 ];
@@ -188,7 +188,7 @@ TOC(ENCODE_PULSES)
     psEnc->sCmn.first_frame_after_reset = 0;
     if( ++psEnc->sCmn.nFramesEncoded >= psEnc->sCmn.nFramesPerPacket ) {
         /* Payload size */
-        *pnBytesOut = SKP_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );
+        *pnBytesOut = silk_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );
 
         /* Reset the number of frames in payload buffer */
         psEnc->sCmn.nFramesEncoded = 0;
@@ -200,11 +200,11 @@ TOC(ENCODE_FRAME)
 
 #ifdef SAVE_ALL_INTERNAL_DATA
     /*DEBUG_STORE_DATA( xf.dat,                   pIn_HP_LP,                           psEnc->sCmn.frame_length * sizeof( opus_int16 ) );*/
-    /*DEBUG_STORE_DATA( xfw.dat,                  xfw,                                 psEnc->sCmn.frame_length * sizeof( SKP_float ) );*/
+    /*DEBUG_STORE_DATA( xfw.dat,                  xfw,                                 psEnc->sCmn.frame_length * sizeof( silk_float ) );*/
     DEBUG_STORE_DATA( pitchL.dat,               sEncCtrl.pitchL,                                 MAX_NB_SUBFR * sizeof( opus_int   ) );
-    DEBUG_STORE_DATA( pitchG_quantized.dat,     sEncCtrl.LTPCoef,            psEnc->sCmn.nb_subfr * LTP_ORDER * sizeof( SKP_float ) );
-    DEBUG_STORE_DATA( LTPcorr.dat,              &psEnc->LTPCorr,                                                sizeof( SKP_float ) );
-    DEBUG_STORE_DATA( gains.dat,                sEncCtrl.Gains,                          psEnc->sCmn.nb_subfr * sizeof( SKP_float ) );
+    DEBUG_STORE_DATA( pitchG_quantized.dat,     sEncCtrl.LTPCoef,            psEnc->sCmn.nb_subfr * LTP_ORDER * sizeof( silk_float ) );
+    DEBUG_STORE_DATA( LTPcorr.dat,              &psEnc->LTPCorr,                                                sizeof( silk_float ) );
+    DEBUG_STORE_DATA( gains.dat,                sEncCtrl.Gains,                          psEnc->sCmn.nb_subfr * sizeof( silk_float ) );
     DEBUG_STORE_DATA( gains_indices.dat,        &psEnc->sCmn.indices.GainsIndices,       psEnc->sCmn.nb_subfr * sizeof( opus_int8  ) );
     DEBUG_STORE_DATA( quantOffsetType.dat,      &psEnc->sCmn.indices.quantOffsetType,                           sizeof( opus_int8  ) );
     DEBUG_STORE_DATA( speech_activity_q8.dat,   &psEnc->sCmn.speech_activity_Q8,                                sizeof( opus_int   ) );
@@ -212,9 +212,9 @@ TOC(ENCODE_FRAME)
     DEBUG_STORE_DATA( lag_index.dat,            &psEnc->sCmn.indices.lagIndex,                                  sizeof( opus_int16 ) );
     DEBUG_STORE_DATA( contour_index.dat,        &psEnc->sCmn.indices.contourIndex,                              sizeof( opus_int8  ) );
     DEBUG_STORE_DATA( per_index.dat,            &psEnc->sCmn.indices.PERIndex,                                  sizeof( opus_int8  ) );
-    DEBUG_STORE_DATA( PredCoef.dat,             &sEncCtrl.PredCoef[ 1 ],          psEnc->sCmn.predictLPCOrder * sizeof( SKP_float ) );
+    DEBUG_STORE_DATA( PredCoef.dat,             &sEncCtrl.PredCoef[ 1 ],          psEnc->sCmn.predictLPCOrder * sizeof( silk_float ) );
     DEBUG_STORE_DATA( ltp_scale_idx.dat,        &psEnc->sCmn.indices.LTP_scaleIndex,                            sizeof( opus_int8   ) );
-    /*DEBUG_STORE_DATA( xq.dat,                   psEnc->sCmn.sNSQ.xqBuf,                psEnc->sCmn.frame_length * sizeof( SKP_float ) );*/
+    /*DEBUG_STORE_DATA( xq.dat,                   psEnc->sCmn.sNSQ.xqBuf,                psEnc->sCmn.frame_length * sizeof( silk_float ) );*/
 #endif
     return ret;
 }
@@ -223,12 +223,12 @@ TOC(ENCODE_FRAME)
 void silk_LBRR_encode_FLP(
     silk_encoder_state_FLP          *psEnc,             /* I/O  Encoder state FLP                       */
     silk_encoder_control_FLP        *psEncCtrl,         /* I/O  Encoder control FLP                     */
-    const SKP_float                 xfw[]               /* I    Input signal                            */
+    const silk_float                 xfw[]               /* I    Input signal                            */
 )
 {
     opus_int     k;
     opus_int32   Gains_Q16[ MAX_NB_SUBFR ];
-    SKP_float   TempGains[ MAX_NB_SUBFR ];
+    silk_float   TempGains[ MAX_NB_SUBFR ];
     SideInfoIndices *psIndices_LBRR = &psEnc->sCmn.indices_LBRR[ psEnc->sCmn.nFramesEncoded ];
     silk_nsq_state sNSQ_LBRR;
 
@@ -239,11 +239,11 @@ void silk_LBRR_encode_FLP(
         psEnc->sCmn.LBRR_flags[ psEnc->sCmn.nFramesEncoded ] = 1;
 
         /* Copy noise shaping quantizer state and quantization indices from regular encoding */
-        SKP_memcpy( &sNSQ_LBRR, &psEnc->sCmn.sNSQ, sizeof( silk_nsq_state ) );
-        SKP_memcpy( psIndices_LBRR, &psEnc->sCmn.indices, sizeof( SideInfoIndices ) );
+        silk_memcpy( &sNSQ_LBRR, &psEnc->sCmn.sNSQ, sizeof( silk_nsq_state ) );
+        silk_memcpy( psIndices_LBRR, &psEnc->sCmn.indices, sizeof( SideInfoIndices ) );
 
         /* Save original gains */
-        SKP_memcpy( TempGains, psEncCtrl->Gains, psEnc->sCmn.nb_subfr * sizeof( SKP_float ) );
+        silk_memcpy( TempGains, psEncCtrl->Gains, psEnc->sCmn.nb_subfr * sizeof( silk_float ) );
 
         if( psEnc->sCmn.nFramesEncoded == 0 || psEnc->sCmn.LBRR_flags[ psEnc->sCmn.nFramesEncoded - 1 ] == 0 ) {
             /* First frame in packet or previous frame not LBRR coded */
@@ -251,7 +251,7 @@ void silk_LBRR_encode_FLP(
 
             /* Increase Gains to get target LBRR rate */
             psIndices_LBRR->GainsIndices[ 0 ] += psEnc->sCmn.LBRR_GainIncreases;
-            psIndices_LBRR->GainsIndices[ 0 ] = SKP_min_int( psIndices_LBRR->GainsIndices[ 0 ], N_LEVELS_QGAIN - 1 );
+            psIndices_LBRR->GainsIndices[ 0 ] = silk_min_int( psIndices_LBRR->GainsIndices[ 0 ], N_LEVELS_QGAIN - 1 );
         }
 
         /* Decode to get gains in sync with decoder */
@@ -270,6 +270,6 @@ void silk_LBRR_encode_FLP(
             psEnc->sCmn.pulses_LBRR[ psEnc->sCmn.nFramesEncoded ], xfw );
 
         /* Restore original gains */
-        SKP_memcpy( psEncCtrl->Gains, TempGains, psEnc->sCmn.nb_subfr * sizeof( SKP_float ) );
+        silk_memcpy( psEncCtrl->Gains, TempGains, psEnc->sCmn.nb_subfr * sizeof( silk_float ) );
     }
 }
index 2995f31..bb6c780 100644 (file)
@@ -31,9 +31,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "silk_SigProc_FLP.h"
 
-/* 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
 )
 {
@@ -55,6 +55,6 @@ double silk_energy_FLP(
         result += data[ i ] * data[ i ];
     }
 
-    SKP_assert( result >= 0.0 );
+    silk_assert( result >= 0.0 );
     return result;
 }
index 463b889..f98e950 100644 (file)
@@ -39,19 +39,19 @@ void silk_find_LPC_FLP(
     const opus_int                   useInterpNLSFs,         /* I    Flag                                    */
     const opus_int                   firstFrameAfterReset,   /* I    Flag                                    */
     const opus_int                   LPC_order,              /* I    LPC order                               */
-    const SKP_float                 x[],                    /* I    Input signal                            */
+    const silk_float                 x[],                    /* I    Input signal                            */
     const opus_int                   subfr_length,           /* I    Subframe length incl preceeding samples */
     const opus_int                   nb_subfr                /* I:   Number of subframes                     */
 )
 {
     opus_int     k;
-    SKP_float   a[ MAX_LPC_ORDER ];
+    silk_float   a[ MAX_LPC_ORDER ];
 
     /* Used only for NLSF interpolation */
     double      res_nrg, res_nrg_2nd, res_nrg_interp;
     opus_int16   NLSF0_Q15[ MAX_LPC_ORDER ];
-    SKP_float   a_tmp[ MAX_LPC_ORDER ];
-    SKP_float   LPC_res[ ( MAX_FRAME_LENGTH + MAX_NB_SUBFR * MAX_LPC_ORDER ) / 2 ];
+    silk_float   a_tmp[ MAX_LPC_ORDER ];
+    silk_float   LPC_res[ ( MAX_FRAME_LENGTH + MAX_NB_SUBFR * MAX_LPC_ORDER ) / 2 ];
 
     /* Default: No interpolation */
     *interpIndex = 4;
@@ -77,7 +77,7 @@ void silk_find_LPC_FLP(
         silk_A2NLSF_FLP( NLSF_Q15, a_tmp, LPC_order );
 
         /* Search over interpolation indices to find the one with lowest residual energy */
-        res_nrg_2nd = SKP_float_MAX;
+        res_nrg_2nd = silk_float_MAX;
         for( k = 3; k >= 0; k-- ) {
             /* Interpolate NLSFs for first half */
             silk_interpolate( NLSF0_Q15, prev_NLSFq_Q15, NLSF_Q15, k, LPC_order );
@@ -109,5 +109,5 @@ void silk_find_LPC_FLP(
         silk_A2NLSF_FLP( NLSF_Q15, a, LPC_order );
     }
 
-    SKP_assert( *interpIndex == 4 || ( useInterpNLSFs && !firstFrameAfterReset && nb_subfr == MAX_NB_SUBFR ) );
+    silk_assert( *interpIndex == 4 || ( useInterpNLSFs && !firstFrameAfterReset && nb_subfr == MAX_NB_SUBFR ) );
 }
index deb3361..faf1b98 100644 (file)
@@ -33,24 +33,24 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "silk_tuning_parameters.h"
 
 void silk_find_LTP_FLP(
-          SKP_float b[ MAX_NB_SUBFR * LTP_ORDER ],          /* O    LTP coefs                               */
-          SKP_float WLTP[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ], /* O    Weight for LTP quantization       */
-          SKP_float *LTPredCodGain,                         /* O    LTP coding gain                         */
-    const SKP_float r_lpc[],                                /* I    LPC residual                            */
+          silk_float b[ MAX_NB_SUBFR * LTP_ORDER ],          /* O    LTP coefs                               */
+          silk_float WLTP[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ], /* O    Weight for LTP quantization       */
+          silk_float *LTPredCodGain,                         /* O    LTP coding gain                         */
+    const silk_float r_lpc[],                                /* I    LPC residual                            */
     const opus_int   lag[  MAX_NB_SUBFR ],                   /* I    LTP lags                                */
-    const SKP_float Wght[ MAX_NB_SUBFR ],                   /* I    Weights                                 */
+    const silk_float Wght[ MAX_NB_SUBFR ],                   /* I    Weights                                 */
     const opus_int   subfr_length,                           /* I    Subframe length                         */
     const opus_int   nb_subfr,                               /* I    number of subframes                     */
     const opus_int   mem_offset                              /* I    Number of samples in LTP memory         */
 )
 {
     opus_int   i, k;
-    SKP_float *b_ptr, temp, *WLTP_ptr;
-    SKP_float LPC_res_nrg, LPC_LTP_res_nrg;
-    SKP_float d[ MAX_NB_SUBFR ], m, g, delta_b[ LTP_ORDER ];
-    SKP_float w[ MAX_NB_SUBFR ], nrg[ MAX_NB_SUBFR ], regu;
-    SKP_float Rr[ LTP_ORDER ], rr[ MAX_NB_SUBFR ];
-    const SKP_float *r_ptr, *lag_ptr;
+    silk_float *b_ptr, temp, *WLTP_ptr;
+    silk_float LPC_res_nrg, LPC_LTP_res_nrg;
+    silk_float d[ MAX_NB_SUBFR ], m, g, delta_b[ LTP_ORDER ];
+    silk_float w[ MAX_NB_SUBFR ], nrg[ MAX_NB_SUBFR ], regu;
+    silk_float Rr[ LTP_ORDER ], rr[ MAX_NB_SUBFR ];
+    const silk_float *r_ptr, *lag_ptr;
 
     b_ptr    = b;
     WLTP_ptr = WLTP;
@@ -61,7 +61,7 @@ void silk_find_LTP_FLP(
         silk_corrMatrix_FLP( lag_ptr, subfr_length, LTP_ORDER, WLTP_ptr );
         silk_corrVector_FLP( lag_ptr, r_ptr, subfr_length, LTP_ORDER, Rr );
 
-        rr[ k ] = ( SKP_float )silk_energy_FLP( r_ptr, subfr_length );
+        rr[ k ] = ( silk_float )silk_energy_FLP( r_ptr, subfr_length );
         regu = 1.0f + rr[ k ] +
             matrix_ptr( WLTP_ptr, 0, 0, LTP_ORDER ) +
             matrix_ptr( WLTP_ptr, LTP_ORDER-1, LTP_ORDER-1, LTP_ORDER );
@@ -90,7 +90,7 @@ void silk_find_LTP_FLP(
             LPC_LTP_res_nrg += nrg[ k ] * Wght[ k ];
         }
 
-        SKP_assert( LPC_LTP_res_nrg > 0 );
+        silk_assert( LPC_LTP_res_nrg > 0 );
         *LTPredCodGain = 3.0f * silk_log2( LPC_res_nrg / LPC_LTP_res_nrg );
     }
 
@@ -120,7 +120,7 @@ void silk_find_LTP_FLP(
         g = LTP_SMOOTHING / ( LTP_SMOOTHING + w[ k ] ) * ( m - d[ k ] );
         temp = 0;
         for( i = 0; i < LTP_ORDER; i++ ) {
-            delta_b[ i ] = SKP_max_float( b_ptr[ i ], 0.1f );
+            delta_b[ i ] = silk_max_float( b_ptr[ i ], 0.1f );
             temp += delta_b[ i ];
         }
         temp = g / temp;
index 382bcd5..05629ea 100644 (file)
@@ -36,18 +36,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 void silk_find_pitch_lags_FLP(
     silk_encoder_state_FLP          *psEnc,             /* I/O  Encoder state FLP                       */
     silk_encoder_control_FLP        *psEncCtrl,         /* I/O  Encoder control FLP                     */
-          SKP_float                 res[],              /* O    Residual                                */
-    const SKP_float                 x[]                 /* I    Speech signal                           */
+          silk_float                 res[],              /* O    Residual                                */
+    const silk_float                 x[]                 /* I    Speech signal                           */
 )
 {
     opus_int   buf_len;
-    SKP_float thrhld, res_nrg;
-    const SKP_float *x_buf_ptr, *x_buf;
-    SKP_float auto_corr[ MAX_FIND_PITCH_LPC_ORDER + 1 ];
-    SKP_float A[         MAX_FIND_PITCH_LPC_ORDER ];
-    SKP_float refl_coef[ MAX_FIND_PITCH_LPC_ORDER ];
-    SKP_float Wsig[      FIND_PITCH_LPC_WIN_MAX ];
-    SKP_float *Wsig_ptr;
+    silk_float thrhld, res_nrg;
+    const silk_float *x_buf_ptr, *x_buf;
+    silk_float auto_corr[ MAX_FIND_PITCH_LPC_ORDER + 1 ];
+    silk_float A[         MAX_FIND_PITCH_LPC_ORDER ];
+    silk_float refl_coef[ MAX_FIND_PITCH_LPC_ORDER ];
+    silk_float Wsig[      FIND_PITCH_LPC_WIN_MAX ];
+    silk_float *Wsig_ptr;
 
     /******************************************/
     /* Setup buffer lengths etc based on Fs   */
@@ -55,7 +55,7 @@ void silk_find_pitch_lags_FLP(
     buf_len = psEnc->sCmn.la_pitch + psEnc->sCmn.frame_length + psEnc->sCmn.ltp_mem_length;
 
     /* Safty check */
-    SKP_assert( buf_len >= psEnc->sCmn.pitch_LPC_win_length );
+    silk_assert( buf_len >= psEnc->sCmn.pitch_LPC_win_length );
 
     x_buf = x - psEnc->sCmn.ltp_mem_length;
 
@@ -73,7 +73,7 @@ void silk_find_pitch_lags_FLP(
     /* Middle non-windowed samples */
     Wsig_ptr  += psEnc->sCmn.la_pitch;
     x_buf_ptr += psEnc->sCmn.la_pitch;
-    SKP_memcpy( Wsig_ptr, x_buf_ptr, ( psEnc->sCmn.pitch_LPC_win_length - ( psEnc->sCmn.la_pitch << 1 ) ) * sizeof( SKP_float ) );
+    silk_memcpy( Wsig_ptr, x_buf_ptr, ( psEnc->sCmn.pitch_LPC_win_length - ( psEnc->sCmn.la_pitch << 1 ) ) * sizeof( silk_float ) );
 
     /* Last LA_LTP samples */
     Wsig_ptr  += psEnc->sCmn.pitch_LPC_win_length - ( psEnc->sCmn.la_pitch << 1 );
@@ -90,7 +90,7 @@ void silk_find_pitch_lags_FLP(
     res_nrg = silk_schur_FLP( refl_coef, auto_corr, psEnc->sCmn.pitchEstimationLPCOrder );
 
     /* Prediction gain */
-    psEncCtrl->predGain = auto_corr[ 0 ] / SKP_max_float( res_nrg, 1.0f );
+    psEncCtrl->predGain = auto_corr[ 0 ] / silk_max_float( res_nrg, 1.0f );
 
     /* Convert reflection coefficients to prediction coefficients */
     silk_k2a_FLP( A, refl_coef, psEnc->sCmn.pitchEstimationLPCOrder );
@@ -123,7 +123,7 @@ void silk_find_pitch_lags_FLP(
             psEnc->sCmn.indices.signalType = TYPE_UNVOICED;
         }
     } else {
-        SKP_memset( psEncCtrl->pitchL, 0, sizeof( psEncCtrl->pitchL ) );
+        silk_memset( psEncCtrl->pitchL, 0, sizeof( psEncCtrl->pitchL ) );
         psEnc->sCmn.indices.lagIndex = 0;
         psEnc->sCmn.indices.contourIndex = 0;
         psEnc->LTPCorr = 0;
index 5803615..9ad3377 100644 (file)
@@ -35,20 +35,20 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 void silk_find_pred_coefs_FLP(
     silk_encoder_state_FLP          *psEnc,             /* I/O  Encoder state FLP                       */
     silk_encoder_control_FLP        *psEncCtrl,         /* I/O  Encoder control FLP                     */
-    const SKP_float                 res_pitch[],        /* I    Residual from pitch analysis            */
-    const SKP_float                 x[]                 /* I    Speech signal                           */
+    const silk_float                 res_pitch[],        /* I    Residual from pitch analysis            */
+    const silk_float                 x[]                 /* I    Speech signal                           */
 )
 {
     opus_int         i;
-    SKP_float       WLTP[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ];
-    SKP_float       invGains[ MAX_NB_SUBFR ], Wght[ MAX_NB_SUBFR ];
+    silk_float       WLTP[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ];
+    silk_float       invGains[ MAX_NB_SUBFR ], Wght[ MAX_NB_SUBFR ];
     opus_int16       NLSF_Q15[ MAX_LPC_ORDER ];
-    const SKP_float *x_ptr;
-    SKP_float       *x_pre_ptr, LPC_in_pre[ MAX_NB_SUBFR * MAX_LPC_ORDER + MAX_FRAME_LENGTH ];
+    const silk_float *x_ptr;
+    silk_float       *x_pre_ptr, LPC_in_pre[ MAX_NB_SUBFR * MAX_LPC_ORDER + MAX_FRAME_LENGTH ];
 
     /* Weighting for weighted least squares */
     for( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
-        SKP_assert( psEncCtrl->Gains[ i ] > 0.0f );
+        silk_assert( psEncCtrl->Gains[ i ] > 0.0f );
         invGains[ i ] = 1.0f / psEncCtrl->Gains[ i ];
         Wght[ i ]     = invGains[ i ] * invGains[ i ];
     }
@@ -57,7 +57,7 @@ void silk_find_pred_coefs_FLP(
         /**********/
         /* VOICED */
         /**********/
-        SKP_assert( psEnc->sCmn.ltp_mem_length - psEnc->sCmn.predictLPCOrder >= psEncCtrl->pitchL[ 0 ] + LTP_ORDER / 2 );
+        silk_assert( psEnc->sCmn.ltp_mem_length - psEnc->sCmn.predictLPCOrder >= psEncCtrl->pitchL[ 0 ] + LTP_ORDER / 2 );
 
         /* LTP analysis */
         silk_find_LTP_FLP( psEncCtrl->LTPCoef, WLTP, &psEncCtrl->LTPredCodGain, res_pitch,
@@ -93,7 +93,7 @@ void silk_find_pred_coefs_FLP(
             x_ptr     += psEnc->sCmn.subfr_length;
         }
 
-        SKP_memset( psEncCtrl->LTPCoef, 0, psEnc->sCmn.nb_subfr * LTP_ORDER * sizeof( SKP_float ) );
+        silk_memset( psEncCtrl->LTPCoef, 0, psEnc->sCmn.nb_subfr * LTP_ORDER * sizeof( silk_float ) );
         psEncCtrl->LTPredCodGain = 0.0f;
     }
 
@@ -112,6 +112,6 @@ TOC(LSF_quant);
         psEnc->sCmn.subfr_length, psEnc->sCmn.nb_subfr, psEnc->sCmn.predictLPCOrder );
 
     /* Copy to prediction struct for use in next frame for fluctuation reduction */
-    SKP_memcpy( psEnc->sCmn.prev_NLSFq_Q15, NLSF_Q15, sizeof( psEnc->sCmn.prev_NLSFq_Q15 ) );
+    silk_memcpy( psEnc->sCmn.prev_NLSFq_Q15, NLSF_Q15, sizeof( psEnc->sCmn.prev_NLSFq_Q15 ) );
 }
 
index 963cc77..18444e1 100644 (file)
@@ -31,10 +31,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "silk_SigProc_FLP.h"
 
-/* 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(      /* O    result              */
-    const SKP_float     *data1,         /* I    vector 1            */
-    const SKP_float     *data2,         /* I    vector 2            */
+    const silk_float     *data1,         /* I    vector 1            */
+    const silk_float     *data2,         /* I    vector 2            */
     opus_int             dataSize        /* I    length of vectors   */
 )
 {
index 318b8d6..dd2081b 100644 (file)
@@ -33,13 +33,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /* step up function, converts reflection coefficients to prediction coefficients */
 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                            */
 )
 {
     opus_int   k, n;
-    SKP_float Atmp[ SILK_MAX_ORDER_LPC ];
+    silk_float Atmp[ SILK_MAX_ORDER_LPC ];
 
     for( k = 0; k < order; k++ ){
         for( n = 0; n < k; n++ ){
index 113204b..05933bb 100644 (file)
@@ -32,21 +32,21 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "silk_SigProc_FLP.h"
 
 /* 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                            */
 )
 {
     opus_int   i, mHalf, m;
-    SKP_float min_nrg, nrg, t, km, Atmp1, Atmp2;
+    silk_float min_nrg, nrg, t, km, Atmp1, Atmp2;
 
     min_nrg = 1e-12f * corr[ 0 ] + 1e-9f;
     nrg = corr[ 0 ];
-    nrg = SKP_max_float(min_nrg, nrg);
+    nrg = silk_max_float(min_nrg, nrg);
     A[ 0 ] = corr[ 1 ] / nrg;
     nrg -= A[ 0 ] * corr[ 1 ];
-    nrg = SKP_max_float(min_nrg, nrg);
+    nrg = silk_max_float(min_nrg, nrg);
 
     for( m = 1; m < order; m++ )
     {
@@ -60,7 +60,7 @@ SKP_float silk_levinsondurbin_FLP(    /* O    prediction error energy
 
         /* residual energy */
         nrg -= km * t;
-        nrg = SKP_max_float(min_nrg, nrg);
+        nrg = silk_max_float(min_nrg, nrg);
 
         mHalf = m >> 1;
         for( i = 0; i < mHalf; i++ ) {
index ddd5a61..da65861 100644 (file)
@@ -65,7 +65,7 @@ opus_int silk_encode_frame_FLP(
 void silk_LBRR_encode_FLP(
     silk_encoder_state_FLP          *psEnc,             /* I/O  Encoder state FLP                       */
     silk_encoder_control_FLP        *psEncCtrl,         /* I/O  Encoder control FLP                     */
-    const SKP_float                 xfw[]               /* I    Input signal                            */
+    const silk_float                 xfw[]               /* I    Input signal                            */
 );
 
 /* Initializes the Silk encoder state */
@@ -89,8 +89,8 @@ opus_int silk_control_encoder(
 void silk_prefilter_FLP(
     silk_encoder_state_FLP              *psEnc,         /* I/O  Encoder state FLP                       */
     const silk_encoder_control_FLP      *psEncCtrl,     /* I    Encoder control FLP                     */
-          SKP_float                     xw[],           /* O    Weighted signal                         */
-    const SKP_float                     x[]             /* I    Speech signal                           */
+          silk_float                     xw[],           /* O    Weighted signal                         */
+    const silk_float                     x[]             /* I    Speech signal                           */
 );
 
 /**************************/
@@ -100,15 +100,15 @@ void silk_prefilter_FLP(
 void silk_noise_shape_analysis_FLP(
     silk_encoder_state_FLP          *psEnc,             /* I/O  Encoder state FLP                       */
     silk_encoder_control_FLP        *psEncCtrl,         /* I/O  Encoder control FLP                     */
-    const SKP_float                 *pitch_res,         /* I    LPC residual from pitch analysis        */
-    const SKP_float                 *x                  /* I    Input signal [frame_length + la_shape]  */
+    const silk_float                 *pitch_res,         /* I    LPC residual from pitch analysis        */
+    const silk_float                 *x                  /* I    Input signal [frame_length + la_shape]  */
 );
 
 /* Autocorrelations for a warped frequency axis */
 void silk_warped_autocorrelation_FLP(
-          SKP_float                 *corr,              /* O    Result [order + 1]                      */
-    const SKP_float                 *input,             /* I    Input data to correlate                 */
-    const SKP_float                 warping,            /* I    Warping coefficient                     */
+          silk_float                 *corr,              /* O    Result [order + 1]                      */
+    const silk_float                 *input,             /* I    Input data to correlate                 */
+    const silk_float                 warping,            /* I    Warping coefficient                     */
     const opus_int                   length,             /* I    Length of input                         */
     const opus_int                   order               /* I    Correlation order (even)                */
 );
@@ -126,16 +126,16 @@ void silk_LTP_scale_ctrl_FLP(
 void silk_find_pitch_lags_FLP(
     silk_encoder_state_FLP          *psEnc,             /* I/O  Encoder state FLP                       */
     silk_encoder_control_FLP        *psEncCtrl,         /* I/O  Encoder control FLP                     */
-          SKP_float                 res[],              /* O    Residual                                */
-    const SKP_float                 x[]                 /* I    Speech signal                           */
+          silk_float                 res[],              /* O    Residual                                */
+    const silk_float                 x[]                 /* I    Speech signal                           */
 );
 
 /* Find LPC and LTP coefficients */
 void silk_find_pred_coefs_FLP(
     silk_encoder_state_FLP          *psEnc,             /* I/O  Encoder state FLP                       */
     silk_encoder_control_FLP        *psEncCtrl,         /* I/O  Encoder control FLP                     */
-    const SKP_float                 res_pitch[],        /* I    Residual from pitch analysis            */
-    const SKP_float                 x[]                 /* I    Speech signal                           */
+    const silk_float                 res_pitch[],        /* I    Residual from pitch analysis            */
+    const silk_float                 x[]                 /* I    Speech signal                           */
 );
 
 /* LPC analysis */
@@ -146,30 +146,30 @@ void silk_find_LPC_FLP(
     const opus_int                   useInterpNLSFs,         /* I    Flag                                    */
     const opus_int                   firstFrameAfterReset,   /* I    Flag                                    */
     const opus_int                   LPC_order,              /* I    LPC order                               */
-    const SKP_float                 x[],                    /* I    Input signal                            */
+    const silk_float                 x[],                    /* I    Input signal                            */
     const opus_int                   subfr_length,           /* I    Subframe length incl preceeding samples */
     const opus_int                   nb_subfr                /* I:   Number of subframes                     */
 );
 
 /* LTP analysis */
 void silk_find_LTP_FLP(
-          SKP_float b[ MAX_NB_SUBFR * LTP_ORDER ],          /* O    LTP coefs                               */
-          SKP_float WLTP[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ], /* O    Weight for LTP quantization       */
-          SKP_float *LTPredCodGain,                         /* O    LTP coding gain                         */
-    const SKP_float r_lpc[],                                /* I    LPC residual                            */
+          silk_float b[ MAX_NB_SUBFR * LTP_ORDER ],          /* O    LTP coefs                               */
+          silk_float WLTP[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ], /* O    Weight for LTP quantization       */
+          silk_float *LTPredCodGain,                         /* O    LTP coding gain                         */
+    const silk_float r_lpc[],                                /* I    LPC residual                            */
     const opus_int   lag[  MAX_NB_SUBFR ],                   /* I    LTP lags                                */
-    const SKP_float Wght[ MAX_NB_SUBFR ],                   /* I    Weights                                 */
+    const silk_float Wght[ MAX_NB_SUBFR ],                   /* I    Weights                                 */
     const opus_int   subfr_length,                           /* I    Subframe length                         */
     const opus_int   nb_subfr,                               /* I    number of subframes                     */
     const opus_int   mem_offset                              /* I    Number of samples in LTP memory         */
 );
 
 void silk_LTP_analysis_filter_FLP(
-          SKP_float         *LTP_res,                   /* O    LTP res MAX_NB_SUBFR*(pre_lgth+subfr_lngth) */
-    const SKP_float         *x,                         /* I    Input signal, with preceeding samples       */
-    const SKP_float         B[ LTP_ORDER * MAX_NB_SUBFR ],  /* I    LTP coefficients for each subframe      */
+          silk_float         *LTP_res,                   /* O    LTP res MAX_NB_SUBFR*(pre_lgth+subfr_lngth) */
+    const silk_float         *x,                         /* I    Input signal, with preceeding samples       */
+    const silk_float         B[ LTP_ORDER * MAX_NB_SUBFR ],  /* I    LTP coefficients for each subframe      */
     const opus_int           pitchL[   MAX_NB_SUBFR ],   /* I    Pitch lags                                  */
-    const SKP_float         invGains[ MAX_NB_SUBFR ],   /* I    Inverse quantization gains                  */
+    const silk_float         invGains[ MAX_NB_SUBFR ],   /* I    Inverse quantization gains                  */
     const opus_int           subfr_length,               /* I    Length of each subframe                     */
     const opus_int           nb_subfr,                   /* I    number of subframes                         */
     const opus_int           pre_length                  /* I    Preceeding samples for each subframe        */
@@ -178,10 +178,10 @@ void silk_LTP_analysis_filter_FLP(
 /* Calculates residual energies of input subframes where all subframes have LPC_order   */
 /* of preceeding samples                                                                */
 void silk_residual_energy_FLP(
-          SKP_float             nrgs[ MAX_NB_SUBFR ],   /* O    Residual energy per subframe            */
-    const SKP_float             x[],                    /* I    Input signal                            */
-          SKP_float             a[ 2 ][ MAX_LPC_ORDER ],/* I    AR coefs for each frame half            */
-    const SKP_float             gains[],                /* I    Quantization gains                      */
+          silk_float             nrgs[ MAX_NB_SUBFR ],   /* O    Residual energy per subframe            */
+    const silk_float             x[],                    /* I    Input signal                            */
+          silk_float             a[ 2 ][ MAX_LPC_ORDER ],/* I    AR coefs for each frame half            */
+    const silk_float             gains[],                /* I    Quantization gains                      */
     const opus_int               subfr_length,           /* I    Subframe length                         */
     const opus_int               nb_subfr,               /* I    number of subframes                     */
     const opus_int               LPC_order               /* I    LPC order                               */
@@ -189,19 +189,19 @@ void silk_residual_energy_FLP(
 
 /* 16th order LPC analysis filter */
 void silk_LPC_analysis_filter_FLP(
-          SKP_float                 r_LPC[],            /* O    LPC residual signal                     */
-    const SKP_float                 PredCoef[],         /* I    LPC coefficients                        */
-    const SKP_float                 s[],                /* I    Input signal                            */
+          silk_float                 r_LPC[],            /* O    LPC residual signal                     */
+    const silk_float                 PredCoef[],         /* I    LPC coefficients                        */
+    const silk_float                 s[],                /* I    Input signal                            */
     const opus_int                   length,             /* I    Length of input signal                  */
     const opus_int                   Order               /* I    LPC order                               */
 );
 
 /* LTP tap quantizer */
 void silk_quant_LTP_gains_FLP(
-          SKP_float B[ MAX_NB_SUBFR * LTP_ORDER ],              /* I/O  (Un-)quantized LTP gains                */
+          silk_float B[ MAX_NB_SUBFR * LTP_ORDER ],              /* I/O  (Un-)quantized LTP gains                */
           opus_int8  cbk_index[ MAX_NB_SUBFR ],                  /* O    Codebook index                          */
           opus_int8  *periodicity_index,                         /* O    Periodicity index                       */
-    const SKP_float W[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ],  /* I    Error weights                           */
+    const silk_float W[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ],  /* I    Error weights                           */
     const opus_int   mu_Q10,                                     /* I    Mu value (R/D tradeoff)                 */
     const opus_int   lowComplexity,                              /* I    Flag for low complexity                 */
     const opus_int   nb_subfr                                    /* I    number of subframes                     */
@@ -213,29 +213,29 @@ void silk_quant_LTP_gains_FLP(
 /* Limit, stabilize, and quantize NLSFs */
 void silk_process_NLSFs_FLP(
     silk_encoder_state              *psEncC,                            /* I/O  Encoder state                               */
-    SKP_float                       PredCoef[ 2 ][ MAX_LPC_ORDER ],     /* O    Prediction coefficients                     */
+    silk_float                       PredCoef[ 2 ][ MAX_LPC_ORDER ],     /* O    Prediction coefficients                     */
     opus_int16                       NLSF_Q15[      MAX_LPC_ORDER ],     /* I/O  Normalized LSFs (quant out) (0 - (2^15-1))  */
     const opus_int16                 prev_NLSF_Q15[ MAX_LPC_ORDER ]      /* I    Previous Normalized LSFs (0 - (2^15-1))     */
 );
 
 /* Residual energy: nrg = wxx - 2 * wXx * c + c' * wXX * c */
-SKP_float silk_residual_energy_covar_FLP(           /* O    Weighted residual energy                */
-    const SKP_float                 *c,                 /* I    Filter coefficients                     */
-          SKP_float                 *wXX,               /* I/O  Weighted correlation matrix, reg. out   */
-    const SKP_float                 *wXx,               /* I    Weighted correlation vector             */
-    const SKP_float                 wxx,                /* I    Weighted correlation value              */
+silk_float silk_residual_energy_covar_FLP(           /* O    Weighted residual energy                */
+    const silk_float                 *c,                 /* I    Filter coefficients                     */
+          silk_float                 *wXX,               /* I/O  Weighted correlation matrix, reg. out   */
+    const silk_float                 *wXx,               /* I    Weighted correlation vector             */
+    const silk_float                 wxx,                /* I    Weighted correlation value              */
     const opus_int                   D                   /* I    Dimension                               */
 );
 
 /* Entropy constrained MATRIX-weighted VQ, for a single input data vector */
 void silk_VQ_WMat_EC_FLP(
           opus_int                   *ind,               /* O    Index of best codebook vector           */
-          SKP_float                 *rate_dist,         /* O    Best weighted quant. error + mu * rate  */
-    const SKP_float                 *in,                /* I    Input vector to be quantized            */
-    const SKP_float                 *W,                 /* I    Weighting matrix                        */
+          silk_float                 *rate_dist,         /* O    Best weighted quant. error + mu * rate  */
+    const silk_float                 *in,                /* I    Input vector to be quantized            */
+    const silk_float                 *W,                 /* I    Weighting matrix                        */
     const opus_int16                 *cb,                /* I    Codebook                                */
     const opus_int16                 *cl_Q6,             /* I    Code length for each codebook vector    */
-    const SKP_float                 mu,                 /* I    Tradeoff between WSSE and rate          */
+    const silk_float                 mu,                 /* I    Tradeoff between WSSE and rate          */
     const opus_int                   L                   /* I    Number of vectors in codebook           */
 );
 
@@ -250,35 +250,35 @@ void silk_process_gains_FLP(
 /******************/
 /* Calculates correlation matrix X'*X */
 void silk_corrMatrix_FLP(
-    const SKP_float                 *x,                 /* I    x vector [ L+order-1 ] used to create X */
+    const silk_float                 *x,                 /* I    x vector [ L+order-1 ] used to create X */
     const opus_int                   L,                  /* I    Length of vectors                       */
     const opus_int                   Order,              /* I    Max lag for correlation                 */
-          SKP_float                 *XX                 /* O    X'*X correlation matrix [order x order] */
+          silk_float                 *XX                 /* O    X'*X correlation matrix [order x order] */
 );
 
 /* Calculates correlation vector X'*t */
 void silk_corrVector_FLP(
-    const SKP_float                 *x,                 /* I    x vector [L+order-1] used to create X   */
-    const SKP_float                 *t,                 /* I    Target vector [L]                       */
+    const silk_float                 *x,                 /* I    x vector [L+order-1] used to create X   */
+    const silk_float                 *t,                 /* I    Target vector [L]                       */
     const opus_int                   L,                  /* I    Length of vecors                        */
     const opus_int                   Order,              /* I    Max lag for correlation                 */
-          SKP_float                 *Xt                 /* O    X'*t correlation vector [order]         */
+          silk_float                 *Xt                 /* O    X'*t correlation vector [order]         */
 );
 
 /* Add noise to matrix diagonal */
 void silk_regularize_correlations_FLP(
-          SKP_float                 *XX,                /* I/O  Correlation matrices                    */
-          SKP_float                 *xx,                /* I/O  Correlation values                      */
-    const SKP_float                 noise,              /* I    Noise energy to add                     */
+          silk_float                 *XX,                /* I/O  Correlation matrices                    */
+          silk_float                 *xx,                /* I/O  Correlation values                      */
+    const silk_float                 noise,              /* I    Noise energy to add                     */
     const opus_int                   D                   /* I    Dimension of XX                         */
 );
 
 /* Function to solve linear equation Ax = b, where A is an MxM symmetric matrix */
 void silk_solve_LDL_FLP(
-          SKP_float                 *A,                 /* I/O  Symmetric square matrix, out: reg.      */
+          silk_float                 *A,                 /* I/O  Symmetric square matrix, out: reg.      */
     const opus_int                   M,                  /* I    Size of matrix                          */
-    const SKP_float                 *b,                 /* I    Pointer to b vector                     */
-          SKP_float                 *x                  /* O    Pointer to x solution vector            */
+    const silk_float                 *b,                 /* I    Pointer to b vector                     */
+          silk_float                 *x                  /* O    Pointer to x solution vector            */
 );
 
 /* Apply sine window to signal vector.                                                                  */
@@ -286,8 +286,8 @@ void silk_solve_LDL_FLP(
 /*  1 -> sine window from 0 to pi/2                                                                     */
 /*  2 -> sine window from pi/2 to pi                                                                    */
 void silk_apply_sine_window_FLP(
-          SKP_float                 px_win[],           /* O    Pointer to windowed signal              */
-    const SKP_float                 px[],               /* I    Pointer to input signal                 */
+          silk_float                 px_win[],           /* O    Pointer to windowed signal              */
+    const silk_float                 px[],               /* I    Pointer to input signal                 */
     const opus_int                   win_type,           /* I    Selects a window type                   */
     const opus_int                   length              /* I    Window length, multiple of 4            */
 );
@@ -297,13 +297,13 @@ void silk_apply_sine_window_FLP(
 /* Convert AR filter coefficients to NLSF parameters */
 void silk_A2NLSF_FLP(
           opus_int16                 *NLSF_Q15,          /* O    NLSF vector      [ LPC_order ]          */
-    const SKP_float                 *pAR,               /* I    LPC coefficients [ LPC_order ]          */
+    const silk_float                 *pAR,               /* I    LPC coefficients [ LPC_order ]          */
     const opus_int                   LPC_order           /* I    LPC order                               */
 );
 
 /* Convert NLSF parameters to AR prediction filter coefficients */
 void silk_NLSF2A_FLP(
-          SKP_float                 *pAR,               /* O    LPC coefficients [ LPC_order ]          */
+          silk_float                 *pAR,               /* O    LPC coefficients [ LPC_order ]          */
     const opus_int16                 *NLSF_Q15,          /* I    NLSF vector      [ LPC_order ]          */
     const opus_int                   LPC_order           /* I    LPC order                               */
 );
@@ -317,7 +317,7 @@ void silk_NSQ_wrapper_FLP(
     SideInfoIndices                 *psIndices,     /* I/O  Quantization indices                        */
     silk_nsq_state                  *psNSQ,         /* I/O  Noise Shaping Quantzation state             */
           opus_int8                  pulses[],       /* O    Quantized pulse signal                      */
-    const SKP_float                 x[]             /* I    Prefiltered input signal                    */
+    const silk_float                 x[]             /* I    Prefiltered input signal                    */
 );
 
 #ifdef __cplusplus
index 3005a0d..ac4c887 100644 (file)
@@ -34,33 +34,33 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /* Compute gain to make warped filter coefficients have a zero mean log frequency response on a     */
 /* non-warped frequency scale. (So that it can be implemented with a minimum-phase monic filter.)   */
-static inline SKP_float warped_gain(
-    const SKP_float     *coefs,
-    SKP_float           lambda,
+static inline silk_float warped_gain(
+    const silk_float     *coefs,
+    silk_float           lambda,
     opus_int             order
 ) {
     opus_int   i;
-    SKP_float gain;
+    silk_float gain;
 
     lambda = -lambda;
     gain = coefs[ order - 1 ];
     for( i = order - 2; i >= 0; i-- ) {
         gain = lambda * gain + coefs[ i ];
     }
-    return (SKP_float)( 1.0f / ( 1.0f - lambda * gain ) );
+    return (silk_float)( 1.0f / ( 1.0f - lambda * gain ) );
 }
 
 /* Convert warped filter coefficients to monic pseudo-warped coefficients and limit maximum     */
 /* amplitude of monic warped coefficients by using bandwidth expansion on the true coefficients */
 static inline void warped_true2monic_coefs(
-    SKP_float           *coefs_syn,
-    SKP_float           *coefs_ana,
-    SKP_float           lambda,
-    SKP_float           limit,
+    silk_float           *coefs_syn,
+    silk_float           *coefs_ana,
+    silk_float           lambda,
+    silk_float           limit,
     opus_int             order
 ) {
     opus_int   i, iter, ind = 0;
-    SKP_float tmp, maxabs, chirp, gain_syn, gain_ana;
+    silk_float tmp, maxabs, chirp, gain_syn, gain_ana;
 
     /* Convert to monic coefficients */
     for( i = order - 1; i > 0; i-- ) {
@@ -79,7 +79,7 @@ static inline void warped_true2monic_coefs(
         /* Find maximum absolute value */
         maxabs = -1.0f;
         for( i = 0; i < order; i++ ) {
-            tmp = SKP_max( SKP_abs_float( coefs_syn[ i ] ), SKP_abs_float( coefs_ana[ i ] ) );
+            tmp = silk_max( silk_abs_float( coefs_syn[ i ] ), silk_abs_float( coefs_ana[ i ] ) );
             if( tmp > maxabs ) {
                 maxabs = tmp;
                 ind = i;
@@ -119,25 +119,25 @@ static inline void warped_true2monic_coefs(
             coefs_ana[ i ] *= gain_ana;
         }
     }
-    SKP_assert( 0 );
+    silk_assert( 0 );
 }
 
 /* Compute noise shaping coefficients and initial gain values */
 void silk_noise_shape_analysis_FLP(
     silk_encoder_state_FLP          *psEnc,             /* I/O  Encoder state FLP                       */
     silk_encoder_control_FLP        *psEncCtrl,         /* I/O  Encoder control FLP                     */
-    const SKP_float                 *pitch_res,         /* I    LPC residual from pitch analysis        */
-    const SKP_float                 *x                  /* I    Input signal [frame_length + la_shape]  */
+    const silk_float                 *pitch_res,         /* I    LPC residual from pitch analysis        */
+    const silk_float                 *x                  /* I    Input signal [frame_length + la_shape]  */
 )
 {
     silk_shape_state_FLP *psShapeSt = &psEnc->sShape;
     opus_int     k, nSamples;
-    SKP_float   SNR_adj_dB, HarmBoost, HarmShapeGain, Tilt;
-    SKP_float   nrg, pre_nrg, log_energy, log_energy_prev, energy_variation;
-    SKP_float   delta, BWExp1, BWExp2, gain_mult, gain_add, strength, b, warping;
-    SKP_float   x_windowed[ SHAPE_LPC_WIN_MAX ];
-    SKP_float   auto_corr[ MAX_SHAPE_LPC_ORDER + 1 ];
-    const SKP_float *x_ptr, *pitch_res_ptr;
+    silk_float   SNR_adj_dB, HarmBoost, HarmShapeGain, Tilt;
+    silk_float   nrg, pre_nrg, log_energy, log_energy_prev, energy_variation;
+    silk_float   delta, BWExp1, BWExp2, gain_mult, gain_add, strength, b, warping;
+    silk_float   x_windowed[ SHAPE_LPC_WIN_MAX ];
+    silk_float   auto_corr[ MAX_SHAPE_LPC_ORDER + 1 ];
+    const silk_float *x_ptr, *pitch_res_ptr;
 
     /* Point to start of first LPC analysis block */
     x_ptr = x - psEnc->sCmn.la_shape;
@@ -151,7 +151,7 @@ void silk_noise_shape_analysis_FLP(
     psEncCtrl->input_quality = 0.5f * ( psEnc->sCmn.input_quality_bands_Q15[ 0 ] + psEnc->sCmn.input_quality_bands_Q15[ 1 ] ) * ( 1.0f / 32768.0f );
 
     /* Coding quality level, between 0.0 and 1.0 */
-    psEncCtrl->coding_quality = SKP_sigmoid( 0.25f * ( SNR_adj_dB - 18.0f ) );
+    psEncCtrl->coding_quality = silk_sigmoid( 0.25f * ( SNR_adj_dB - 18.0f ) );
 
     if( psEnc->sCmn.useCBR == 0 ) {
         /* Reduce coding SNR during low speech activity */
@@ -181,16 +181,16 @@ void silk_noise_shape_analysis_FLP(
         energy_variation = 0.0f;
         log_energy_prev  = 0.0f;
         pitch_res_ptr = pitch_res;
-        for( k = 0; k < SKP_SMULBB( SUB_FRAME_LENGTH_MS, psEnc->sCmn.nb_subfr ) / 2; k++ ) {
-            nrg = ( SKP_float )nSamples + ( SKP_float )silk_energy_FLP( pitch_res_ptr, nSamples );
+        for( k = 0; k < silk_SMULBB( SUB_FRAME_LENGTH_MS, psEnc->sCmn.nb_subfr ) / 2; k++ ) {
+            nrg = ( silk_float )nSamples + ( silk_float )silk_energy_FLP( pitch_res_ptr, nSamples );
             log_energy = silk_log2( nrg );
             if( k > 0 ) {
-                energy_variation += SKP_abs_float( log_energy - log_energy_prev );
+                energy_variation += silk_abs_float( log_energy - log_energy_prev );
             }
             log_energy_prev = log_energy;
             pitch_res_ptr += nSamples;
         }
-        psEncCtrl->sparseness = SKP_sigmoid( 0.4f * ( energy_variation - 5.0f ) );
+        psEncCtrl->sparseness = silk_sigmoid( 0.4f * ( energy_variation - 5.0f ) );
 
         /* Set quantization offset depending on sparseness measure */
         if( psEncCtrl->sparseness > SPARSENESS_THRESHOLD_QNT_OFFSET ) {
@@ -217,7 +217,7 @@ void silk_noise_shape_analysis_FLP(
 
     if( psEnc->sCmn.warping_Q16 > 0 ) {
         /* Slightly more warping in analysis will move quantization noise up in frequency, where it's better masked */
-        warping = (SKP_float)psEnc->sCmn.warping_Q16 / 65536.0f + 0.01f * psEncCtrl->coding_quality;
+        warping = (silk_float)psEnc->sCmn.warping_Q16 / 65536.0f + 0.01f * psEncCtrl->coding_quality;
     } else {
         warping = 0.0f;
     }
@@ -233,7 +233,7 @@ void silk_noise_shape_analysis_FLP(
 
         silk_apply_sine_window_FLP( x_windowed, x_ptr, 1, slope_part );
         shift = slope_part;
-        SKP_memcpy( x_windowed + shift, x_ptr + shift, flat_part * sizeof(SKP_float) );
+        silk_memcpy( x_windowed + shift, x_ptr + shift, flat_part * sizeof(silk_float) );
         shift += flat_part;
         silk_apply_sine_window_FLP( x_windowed + shift, x_ptr + shift, 2, slope_part );
 
@@ -254,7 +254,7 @@ void silk_noise_shape_analysis_FLP(
 
         /* Convert correlations to prediction coefficients, and compute residual energy */
         nrg = silk_levinsondurbin_FLP( &psEncCtrl->AR2[ k * MAX_SHAPE_LPC_ORDER ], auto_corr, psEnc->sCmn.shapingLPCOrder );
-        psEncCtrl->Gains[ k ] = ( SKP_float )sqrt( nrg );
+        psEncCtrl->Gains[ k ] = ( silk_float )sqrt( nrg );
 
         if( psEnc->sCmn.warping_Q16 > 0 ) {
             /* Adjust gain for warping */
@@ -265,10 +265,10 @@ void silk_noise_shape_analysis_FLP(
         silk_bwexpander_FLP( &psEncCtrl->AR2[ k * MAX_SHAPE_LPC_ORDER ], psEnc->sCmn.shapingLPCOrder, BWExp2 );
 
         /* Compute noise shaping filter coefficients */
-        SKP_memcpy(
+        silk_memcpy(
             &psEncCtrl->AR1[ k * MAX_SHAPE_LPC_ORDER ],
             &psEncCtrl->AR2[ k * MAX_SHAPE_LPC_ORDER ],
-            psEnc->sCmn.shapingLPCOrder * sizeof( SKP_float ) );
+            psEnc->sCmn.shapingLPCOrder * sizeof( silk_float ) );
 
         /* Bandwidth expansion for analysis filter shaping */
         silk_bwexpander_FLP( &psEncCtrl->AR1[ k * MAX_SHAPE_LPC_ORDER ], psEnc->sCmn.shapingLPCOrder, BWExp1 );
@@ -287,8 +287,8 @@ void silk_noise_shape_analysis_FLP(
     /* Gain tweaking */
     /*****************/
     /* Increase gains during low speech activity */
-    gain_mult = (SKP_float)pow( 2.0f, -0.16f * SNR_adj_dB );
-    gain_add  = (SKP_float)pow( 2.0f,  0.16f * MIN_QGAIN_DB );
+    gain_mult = (silk_float)pow( 2.0f, -0.16f * SNR_adj_dB );
+    gain_add  = (silk_float)pow( 2.0f,  0.16f * MIN_QGAIN_DB );
     for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) {
         psEncCtrl->Gains[ k ] *= gain_mult;
         psEncCtrl->Gains[ k ] += gain_add;
@@ -344,7 +344,7 @@ void silk_noise_shape_analysis_FLP(
             ( 1.0f - ( 1.0f - psEncCtrl->coding_quality ) * psEncCtrl->input_quality );
 
         /* Less harmonic noise shaping for less periodic signals */
-        HarmShapeGain *= ( SKP_float )sqrt( psEnc->LTPCorr );
+        HarmShapeGain *= ( silk_float )sqrt( psEnc->LTPCorr );
     } else {
         HarmShapeGain = 0.0f;
     }
index 1ff0797..5aaf41a 100644 (file)
@@ -49,8 +49,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /* Internally used functions                                */
 /************************************************************/
 static void silk_P_Ana_calc_corr_st3(
-    SKP_float cross_corr_st3[ PE_MAX_NB_SUBFR ][ PE_NB_CBKS_STAGE3_MAX ][ PE_NB_STAGE3_LAGS ], /* O 3 DIM correlation array */
-    const SKP_float  frame[],            /* I vector to correlate                                            */
+    silk_float cross_corr_st3[ PE_MAX_NB_SUBFR ][ PE_NB_CBKS_STAGE3_MAX ][ PE_NB_STAGE3_LAGS ], /* O 3 DIM correlation array */
+    const silk_float  frame[],            /* I vector to correlate                                            */
     opus_int         start_lag,          /* I start lag                                                      */
     opus_int         sf_length,          /* I sub frame length                                               */
     opus_int         nb_subfr,           /* I number of subframes                                            */
@@ -58,8 +58,8 @@ static void silk_P_Ana_calc_corr_st3(
 );
 
 static void silk_P_Ana_calc_energy_st3(
-    SKP_float energies_st3[ PE_MAX_NB_SUBFR ][ PE_NB_CBKS_STAGE3_MAX ][ PE_NB_STAGE3_LAGS ], /* O 3 DIM correlation array */
-    const SKP_float  frame[],            /* I vector to correlate                                            */
+    silk_float energies_st3[ PE_MAX_NB_SUBFR ][ PE_NB_CBKS_STAGE3_MAX ][ PE_NB_STAGE3_LAGS ], /* O 3 DIM correlation array */
+    const silk_float  frame[],            /* I vector to correlate                                            */
     opus_int         start_lag,          /* I start lag                                                      */
     opus_int         sf_length,          /* I sub frame length                                               */
     opus_int         nb_subfr,           /* I number of subframes                                            */
@@ -72,39 +72,39 @@ static void silk_P_Ana_calc_energy_st3(
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 */
 opus_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoiced                       */
-    const SKP_float  *frame,             /* I signal of length PE_FRAME_LENGTH_MS*Fs_kHz                     */
+    const silk_float  *frame,             /* 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                                    */
 )
 {
     opus_int   i, k, d, j;
-    SKP_float frame_8kHz[  PE_MAX_FRAME_LENGTH_MS * 8 ];
-    SKP_float frame_4kHz[  PE_MAX_FRAME_LENGTH_MS * 4 ];
+    silk_float frame_8kHz[  PE_MAX_FRAME_LENGTH_MS * 8 ];
+    silk_float frame_4kHz[  PE_MAX_FRAME_LENGTH_MS * 4 ];
     opus_int16 frame_8_FIX[ PE_MAX_FRAME_LENGTH_MS * 8 ];
     opus_int16 frame_4_FIX[ PE_MAX_FRAME_LENGTH_MS * 4 ];
     opus_int32 filt_state[ 6 ];
-    SKP_float threshold, contour_bias;
-    SKP_float C[ PE_MAX_NB_SUBFR][ (PE_MAX_LAG >> 1) + 5 ];
-    SKP_float CC[ PE_NB_CBKS_STAGE2_EXT ];
-    const SKP_float *target_ptr, *basis_ptr;
+    silk_float threshold, contour_bias;
+    silk_float C[ PE_MAX_NB_SUBFR][ (PE_MAX_LAG >> 1) + 5 ];
+    silk_float CC[ PE_NB_CBKS_STAGE2_EXT ];
+    const silk_float *target_ptr, *basis_ptr;
     double    cross_corr, normalizer, energy, energy_tmp;
     opus_int   d_srch[ PE_D_SRCH_LENGTH ];
     opus_int16 d_comp[ (PE_MAX_LAG >> 1) + 5 ];
     opus_int   length_d_srch, length_d_comp;
-    SKP_float Cmax, CCmax, CCmax_b, CCmax_new_b, CCmax_new;
+    silk_float Cmax, CCmax, CCmax_b, CCmax_new_b, CCmax_new;
     opus_int   CBimax, CBimax_new, lag, start_lag, end_lag, lag_new;
     opus_int   cbk_size;
-    SKP_float lag_log2, prevLag_log2, delta_lag_log2_sqr;
-    SKP_float energies_st3[ PE_MAX_NB_SUBFR ][ PE_NB_CBKS_STAGE3_MAX ][ PE_NB_STAGE3_LAGS ];
-    SKP_float cross_corr_st3[ PE_MAX_NB_SUBFR ][ PE_NB_CBKS_STAGE3_MAX ][ PE_NB_STAGE3_LAGS ];
+    silk_float lag_log2, prevLag_log2, delta_lag_log2_sqr;
+    silk_float energies_st3[ PE_MAX_NB_SUBFR ][ PE_NB_CBKS_STAGE3_MAX ][ PE_NB_STAGE3_LAGS ];
+    silk_float cross_corr_st3[ PE_MAX_NB_SUBFR ][ PE_NB_CBKS_STAGE3_MAX ][ PE_NB_STAGE3_LAGS ];
     opus_int   lag_counter;
     opus_int   frame_length, frame_length_8kHz, frame_length_4kHz;
     opus_int   sf_length, sf_length_8kHz, sf_length_4kHz;
@@ -114,14 +114,14 @@ opus_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoic
     const opus_int8 *Lag_CB_ptr;
 
     /* Check for valid sampling frequency */
-    SKP_assert( Fs_kHz == 8 || Fs_kHz == 12 || Fs_kHz == 16 );
+    silk_assert( Fs_kHz == 8 || Fs_kHz == 12 || Fs_kHz == 16 );
 
     /* Check for valid complexity setting */
-    SKP_assert( complexity >= SigProc_PE_MIN_COMPLEX );
-    SKP_assert( complexity <= SigProc_PE_MAX_COMPLEX );
+    silk_assert( complexity >= SigProc_PE_MIN_COMPLEX );
+    silk_assert( complexity <= SigProc_PE_MAX_COMPLEX );
 
-    SKP_assert( search_thres1 >= 0.0f && search_thres1 <= 1.0f );
-    SKP_assert( search_thres2 >= 0.0f && search_thres2 <= 1.0f );
+    silk_assert( search_thres1 >= 0.0f && search_thres1 <= 1.0f );
+    silk_assert( search_thres2 >= 0.0f && search_thres2 <= 1.0f );
 
     /* Setup frame lengths max / min lag for the sampling frequency */
     frame_length      = ( PE_LTP_MEM_LENGTH_MS + nb_subfr * PE_SUBFR_LENGTH_MS ) * Fs_kHz;
@@ -137,32 +137,32 @@ opus_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoic
     max_lag_4kHz      = PE_MAX_LAG_MS * 4;
     max_lag_8kHz      = PE_MAX_LAG_MS * 8 - 1;
 
-    SKP_memset(C, 0, sizeof(SKP_float) * nb_subfr * ((PE_MAX_LAG >> 1) + 5));
+    silk_memset(C, 0, sizeof(silk_float) * nb_subfr * ((PE_MAX_LAG >> 1) + 5));
 
     /* Resample from input sampled at Fs_kHz to 8 kHz */
     if( Fs_kHz == 16 ) {
         /* Resample to 16 -> 8 khz */
         opus_int16 frame_16_FIX[ 16 * PE_MAX_FRAME_LENGTH_MS ];
-        SKP_float2short_array( frame_16_FIX, frame, frame_length );
-        SKP_memset( filt_state, 0, 2 * sizeof( opus_int32 ) );
+        silk_float2short_array( frame_16_FIX, frame, frame_length );
+        silk_memset( filt_state, 0, 2 * sizeof( opus_int32 ) );
         silk_resampler_down2( filt_state, frame_8_FIX, frame_16_FIX, frame_length );
-        SKP_short2float_array( frame_8kHz, frame_8_FIX, frame_length_8kHz );
+        silk_short2float_array( frame_8kHz, frame_8_FIX, frame_length_8kHz );
     } else if( Fs_kHz == 12 ) {
         /* Resample to 12 -> 8 khz */
         opus_int16 frame_12_FIX[ 12 * PE_MAX_FRAME_LENGTH_MS ];
-        SKP_float2short_array( frame_12_FIX, frame, frame_length );
-        SKP_memset( filt_state, 0, 6 * sizeof( opus_int32 ) );
+        silk_float2short_array( frame_12_FIX, frame, frame_length );
+        silk_memset( filt_state, 0, 6 * sizeof( opus_int32 ) );
         silk_resampler_down2_3( filt_state, frame_8_FIX, frame_12_FIX, frame_length );
-        SKP_short2float_array( frame_8kHz, frame_8_FIX, frame_length_8kHz );
+        silk_short2float_array( frame_8kHz, frame_8_FIX, frame_length_8kHz );
     } else {
-        SKP_assert( Fs_kHz == 8 );
-        SKP_float2short_array( frame_8_FIX, frame, frame_length_8kHz );
+        silk_assert( Fs_kHz == 8 );
+        silk_float2short_array( frame_8_FIX, frame, frame_length_8kHz );
     }
 
     /* Decimate again to 4 kHz */
-    SKP_memset( filt_state, 0, 2 * sizeof( opus_int32 ) );
+    silk_memset( filt_state, 0, 2 * sizeof( opus_int32 ) );
     silk_resampler_down2( filt_state, frame_4_FIX, frame_8_FIX, frame_length_8kHz );
-    SKP_short2float_array( frame_4kHz, frame_4_FIX, frame_length_4kHz );
+    silk_short2float_array( frame_4kHz, frame_4_FIX, frame_length_4kHz );
 
     /* Low-pass filter */
     for( i = frame_length_4kHz - 1; i > 0; i-- ) {
@@ -172,31 +172,31 @@ opus_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoic
     /******************************************************************************
     * FIRST STAGE, operating in 4 khz
     ******************************************************************************/
-    target_ptr = &frame_4kHz[ SKP_LSHIFT( sf_length_4kHz, 2 ) ];
+    target_ptr = &frame_4kHz[ silk_LSHIFT( sf_length_4kHz, 2 ) ];
     for( k = 0; k < nb_subfr >> 1; k++ ) {
         /* Check that we are within range of the array */
-        SKP_assert( target_ptr >= frame_4kHz );
-        SKP_assert( target_ptr + sf_length_8kHz <= frame_4kHz + frame_length_4kHz );
+        silk_assert( target_ptr >= frame_4kHz );
+        silk_assert( target_ptr + sf_length_8kHz <= frame_4kHz + frame_length_4kHz );
 
         basis_ptr = target_ptr - min_lag_4kHz;
 
         /* Check that we are within range of the array */
-        SKP_assert( basis_ptr >= frame_4kHz );
-        SKP_assert( basis_ptr + sf_length_8kHz <= frame_4kHz + frame_length_4kHz );
+        silk_assert( basis_ptr >= frame_4kHz );
+        silk_assert( basis_ptr + sf_length_8kHz <= frame_4kHz + frame_length_4kHz );
 
         /* Calculate first vector products before loop */
         cross_corr = silk_inner_product_FLP( target_ptr, basis_ptr, sf_length_8kHz );
         normalizer = silk_energy_FLP( basis_ptr, sf_length_8kHz ) + sf_length_8kHz * 4000.0f;
 
-        C[ 0 ][ min_lag_4kHz ] += (SKP_float)(cross_corr / sqrt(normalizer));
+        C[ 0 ][ min_lag_4kHz ] += (silk_float)(cross_corr / sqrt(normalizer));
 
         /* From now on normalizer is computed recursively */
         for(d = min_lag_4kHz + 1; d <= max_lag_4kHz; d++) {
             basis_ptr--;
 
             /* Check that we are within range of the array */
-            SKP_assert( basis_ptr >= frame_4kHz );
-            SKP_assert( basis_ptr + sf_length_8kHz <= frame_4kHz + frame_length_4kHz );
+            silk_assert( basis_ptr >= frame_4kHz );
+            silk_assert( basis_ptr + sf_length_8kHz <= frame_4kHz + frame_length_4kHz );
 
             cross_corr = silk_inner_product_FLP(target_ptr, basis_ptr, sf_length_8kHz);
 
@@ -204,7 +204,7 @@ opus_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoic
             normalizer +=
                 basis_ptr[ 0 ] * basis_ptr[ 0 ] -
                 basis_ptr[ sf_length_8kHz ] * basis_ptr[ sf_length_8kHz ];
-            C[ 0 ][ d ] += (SKP_float)(cross_corr / sqrt( normalizer ));
+            C[ 0 ][ d ] += (silk_float)(cross_corr / sqrt( normalizer ));
         }
         /* Update target pointer */
         target_ptr += sf_length_8kHz;
@@ -217,19 +217,19 @@ opus_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoic
 
     /* Sort */
     length_d_srch = 4 + 2 * complexity;
-    SKP_assert( 3 * length_d_srch <= PE_D_SRCH_LENGTH );
+    silk_assert( 3 * length_d_srch <= PE_D_SRCH_LENGTH );
     silk_insertion_sort_decreasing_FLP( &C[ 0 ][ min_lag_4kHz ], d_srch, max_lag_4kHz - min_lag_4kHz + 1, length_d_srch );
 
     /* Escape if correlation is very low already here */
     Cmax = C[ 0 ][ min_lag_4kHz ];
-    target_ptr = &frame_4kHz[ SKP_SMULBB( sf_length_4kHz, nb_subfr ) ];
+    target_ptr = &frame_4kHz[ silk_SMULBB( sf_length_4kHz, nb_subfr ) ];
     energy = 1000.0f;
-    for( i = 0; i < SKP_LSHIFT( sf_length_4kHz, 2 ); i++ ) {
+    for( i = 0; i < silk_LSHIFT( sf_length_4kHz, 2 ); i++ ) {
         energy += target_ptr[i] * target_ptr[i];
     }
     threshold = Cmax * Cmax;
     if( energy / 16.0f > threshold ) {
-        SKP_memset( pitch_out, 0, nb_subfr * sizeof( opus_int ) );
+        silk_memset( pitch_out, 0, nb_subfr * sizeof( opus_int ) );
         *LTPCorr      = 0.0f;
         *lagIndex     = 0;
         *contourIndex = 0;
@@ -240,13 +240,13 @@ opus_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoic
     for( i = 0; i < length_d_srch; i++ ) {
         /* Convert to 8 kHz indices for the sorted correlation that exceeds the threshold */
         if( C[ 0 ][ min_lag_4kHz + i ] > threshold ) {
-            d_srch[ i ] = SKP_LSHIFT( d_srch[ i ] + min_lag_4kHz, 1 );
+            d_srch[ i ] = silk_LSHIFT( d_srch[ i ] + min_lag_4kHz, 1 );
         } else {
             length_d_srch = i;
             break;
         }
     }
-    SKP_assert( length_d_srch > 0 );
+    silk_assert( length_d_srch > 0 );
 
     for( i = min_lag_8kHz - 5; i < max_lag_8kHz + 5; i++ ) {
         d_comp[ i ] = 0;
@@ -287,7 +287,7 @@ opus_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoic
     /*********************************************************************************
     * Find energy of each subframe projected onto its history, for a range of delays
     *********************************************************************************/
-    SKP_memset( C, 0, PE_MAX_NB_SUBFR*((PE_MAX_LAG >> 1) + 5) * sizeof(SKP_float)); /* Is this needed?*/
+    silk_memset( C, 0, PE_MAX_NB_SUBFR*((PE_MAX_LAG >> 1) + 5) * sizeof(silk_float)); /* Is this needed?*/
 
     if( Fs_kHz == 8 ) {
         target_ptr = &frame[ PE_LTP_MEM_LENGTH_MS * 8 ];
@@ -302,7 +302,7 @@ opus_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoic
             cross_corr = silk_inner_product_FLP( basis_ptr, target_ptr, sf_length_8kHz );
             energy     = silk_energy_FLP( basis_ptr, sf_length_8kHz );
             if (cross_corr > 0.0f) {
-                C[ k ][ d ] = (SKP_float)(cross_corr * cross_corr / (energy * energy_tmp + eps));
+                C[ k ][ d ] = (silk_float)(cross_corr * cross_corr / (energy * energy_tmp + eps));
             } else {
                 C[ k ][ d ] = 0.0f;
             }
@@ -321,11 +321,11 @@ opus_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoic
 
     if( prevLag > 0 ) {
         if( Fs_kHz == 12 ) {
-            prevLag = SKP_LSHIFT( prevLag, 1 ) / 3;
+            prevLag = silk_LSHIFT( prevLag, 1 ) / 3;
         } else if( Fs_kHz == 16 ) {
-            prevLag = SKP_RSHIFT( prevLag, 1 );
+            prevLag = silk_RSHIFT( prevLag, 1 );
         }
-        prevLag_log2 = silk_log2((SKP_float)prevLag);
+        prevLag_log2 = silk_log2((silk_float)prevLag);
     } else {
         prevLag_log2 = 0;
     }
@@ -364,11 +364,11 @@ opus_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoic
                 CBimax_new = i;
             }
         }
-        CCmax_new = SKP_max_float(CCmax_new, 0.0f); /* To avoid taking square root of negative number later */
+        CCmax_new = silk_max_float(CCmax_new, 0.0f); /* To avoid taking square root of negative number later */
         CCmax_new_b = CCmax_new;
 
         /* Bias towards shorter lags */
-        lag_log2 = silk_log2((SKP_float)d);
+        lag_log2 = silk_log2((silk_float)d);
         CCmax_new_b -= PE_SHORTLAG_BIAS * nb_subfr * lag_log2;
 
         /* Bias towards previous lag */
@@ -391,7 +391,7 @@ opus_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoic
 
     if( lag == -1 ) {
         /* No suitable candidate found */
-        SKP_memset( pitch_out, 0, PE_MAX_NB_SUBFR * sizeof(opus_int) );
+        silk_memset( pitch_out, 0, PE_MAX_NB_SUBFR * sizeof(opus_int) );
         *LTPCorr      = 0.0f;
         *lagIndex     = 0;
         *contourIndex = 0;
@@ -402,22 +402,22 @@ opus_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoic
         /* Search in original signal */
 
         /* Compensate for decimation */
-        SKP_assert( lag == SKP_SAT16( lag ) );
+        silk_assert( lag == silk_SAT16( lag ) );
         if( Fs_kHz == 12 ) {
-            lag = SKP_RSHIFT_ROUND( SKP_SMULBB( lag, 3 ), 1 );
+            lag = silk_RSHIFT_ROUND( silk_SMULBB( lag, 3 ), 1 );
         } else if( Fs_kHz == 16 ) {
-            lag = SKP_LSHIFT( lag, 1 );
+            lag = silk_LSHIFT( lag, 1 );
         } else {
-            lag = SKP_SMULBB( lag, 3 );
+            lag = silk_SMULBB( lag, 3 );
         }
 
-        lag = SKP_LIMIT_int( lag, min_lag, max_lag );
-        start_lag = SKP_max_int( lag - 2, min_lag );
-        end_lag   = SKP_min_int( lag + 2, max_lag );
+        lag = silk_LIMIT_int( lag, min_lag, max_lag );
+        start_lag = silk_max_int( lag - 2, min_lag );
+        end_lag   = silk_min_int( lag + 2, max_lag );
         lag_new   = lag;                                    /* to avoid undefined lag */
         CBimax    = 0;                                      /* to avoid undefined lag */
-        SKP_assert( CCmax >= 0.0f );
-        *LTPCorr = (SKP_float)sqrt( CCmax / nb_subfr );     /* Output normalized correlation */
+        silk_assert( CCmax >= 0.0f );
+        *LTPCorr = (silk_float)sqrt( CCmax / nb_subfr );     /* Output normalized correlation */
 
         CCmax = -1000.0f;
 
@@ -426,7 +426,7 @@ opus_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoic
         silk_P_Ana_calc_energy_st3( energies_st3, frame, start_lag, sf_length, nb_subfr, complexity );
 
         lag_counter = 0;
-        SKP_assert( lag == SKP_SAT16( lag ) );
+        silk_assert( lag == silk_SAT16( lag ) );
         contour_bias = PE_FLATCONTOUR_BIAS / lag;
 
         /* Setup cbk parameters acording to complexity setting and frame length */
@@ -449,7 +449,7 @@ opus_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoic
                     cross_corr += cross_corr_st3[ k ][ j ][ lag_counter ];
                 }
                 if( cross_corr > 0.0 ) {
-                    CCmax_new = (SKP_float)(cross_corr * cross_corr / energy);
+                    CCmax_new = (silk_float)(cross_corr * cross_corr / energy);
                     /* Reduce depending on flatness of contour */
                     CCmax_new *= 1.0f - contour_bias * j;
                 } else {
@@ -474,22 +474,22 @@ opus_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoic
         *contourIndex = (opus_int8)CBimax;
     } else {
         /* Save Lags and correlation */
-        SKP_assert( CCmax >= 0.0f );
-        *LTPCorr = (SKP_float)sqrt( CCmax / nb_subfr ); /* Output normalized correlation */
+        silk_assert( CCmax >= 0.0f );
+        *LTPCorr = (silk_float)sqrt( CCmax / nb_subfr ); /* Output normalized correlation */
         for( k = 0; k < nb_subfr; k++ ) {
             pitch_out[ k ] = lag + matrix_ptr( Lag_CB_ptr, k, CBimax, cbk_size );
         }
         *lagIndex = (opus_int16)( lag - min_lag );
         *contourIndex = (opus_int8)CBimax;
     }
-    SKP_assert( *lagIndex >= 0 );
+    silk_assert( *lagIndex >= 0 );
     /* return as voiced */
     return 0;
 }
 
 static void silk_P_Ana_calc_corr_st3(
-    SKP_float cross_corr_st3[ PE_MAX_NB_SUBFR ][ PE_NB_CBKS_STAGE3_MAX ][ PE_NB_STAGE3_LAGS ], /* O 3 DIM correlation array */
-    const SKP_float  frame[],            /* I vector to correlate                                            */
+    silk_float cross_corr_st3[ PE_MAX_NB_SUBFR ][ PE_NB_CBKS_STAGE3_MAX ][ PE_NB_STAGE3_LAGS ], /* O 3 DIM correlation array */
+    const silk_float  frame[],            /* I vector to correlate                                            */
     opus_int         start_lag,          /* I start lag                                                      */
     opus_int         sf_length,          /* I sub frame length                                               */
     opus_int         nb_subfr,           /* I number of subframes                                            */
@@ -509,14 +509,14 @@ static void silk_P_Ana_calc_corr_st3(
      4*12*5 = 240 correlations, but more likely around 120.
      **********************************************************************/
 {
-    const SKP_float *target_ptr, *basis_ptr;
+    const silk_float *target_ptr, *basis_ptr;
     opus_int   i, j, k, lag_counter, lag_low, lag_high;
     opus_int   nb_cbk_search, delta, idx, cbk_size;
-    SKP_float scratch_mem[ SCRATCH_SIZE ];
+    silk_float scratch_mem[ SCRATCH_SIZE ];
     const opus_int8 *Lag_range_ptr, *Lag_CB_ptr;
 
-    SKP_assert( complexity >= SigProc_PE_MIN_COMPLEX );
-    SKP_assert( complexity <= SigProc_PE_MAX_COMPLEX );
+    silk_assert( complexity >= SigProc_PE_MIN_COMPLEX );
+    silk_assert( complexity <= SigProc_PE_MAX_COMPLEX );
 
     if( nb_subfr == PE_MAX_NB_SUBFR ){
         Lag_range_ptr = &silk_Lag_range_stage3[ complexity ][ 0 ][ 0 ];
@@ -524,14 +524,14 @@ static void silk_P_Ana_calc_corr_st3(
         nb_cbk_search = silk_nb_cbk_searchs_stage3[ complexity ];
         cbk_size      = PE_NB_CBKS_STAGE3_MAX;
     } else {
-        SKP_assert( nb_subfr == PE_MAX_NB_SUBFR >> 1);
+        silk_assert( nb_subfr == PE_MAX_NB_SUBFR >> 1);
         Lag_range_ptr = &silk_Lag_range_stage3_10_ms[ 0 ][ 0 ];
         Lag_CB_ptr    = &silk_CB_lags_stage3_10_ms[ 0 ][ 0 ];
         nb_cbk_search = PE_NB_CBKS_STAGE3_10MS;
         cbk_size      = PE_NB_CBKS_STAGE3_10MS;
     }
 
-    target_ptr = &frame[ SKP_LSHIFT( sf_length, 2 ) ]; /* Pointer to middle of frame */
+    target_ptr = &frame[ silk_LSHIFT( sf_length, 2 ) ]; /* Pointer to middle of frame */
     for( k = 0; k < nb_subfr; k++ ) {
         lag_counter = 0;
 
@@ -540,8 +540,8 @@ static void silk_P_Ana_calc_corr_st3(
         lag_high = matrix_ptr( Lag_range_ptr, k, 1, 2 );
         for( j = lag_low; j <= lag_high; j++ ) {
             basis_ptr = target_ptr - ( start_lag + j );
-            SKP_assert( lag_counter < SCRATCH_SIZE );
-            scratch_mem[ lag_counter ] = (SKP_float)silk_inner_product_FLP( target_ptr, basis_ptr, sf_length );
+            silk_assert( lag_counter < SCRATCH_SIZE );
+            scratch_mem[ lag_counter ] = (silk_float)silk_inner_product_FLP( target_ptr, basis_ptr, sf_length );
             lag_counter++;
         }
 
@@ -551,8 +551,8 @@ static void silk_P_Ana_calc_corr_st3(
             /* each code_book vector for each start lag */
             idx = matrix_ptr( Lag_CB_ptr, k, i, cbk_size ) - delta;
             for( j = 0; j < PE_NB_STAGE3_LAGS; j++ ) {
-                SKP_assert( idx + j < SCRATCH_SIZE );
-                SKP_assert( idx + j < lag_counter );
+                silk_assert( idx + j < SCRATCH_SIZE );
+                silk_assert( idx + j < lag_counter );
                 cross_corr_st3[ k ][ i ][ j ] = scratch_mem[ idx + j ];
             }
         }
@@ -561,8 +561,8 @@ static void silk_P_Ana_calc_corr_st3(
 }
 
 static void silk_P_Ana_calc_energy_st3(
-    SKP_float energies_st3[ PE_MAX_NB_SUBFR ][ PE_NB_CBKS_STAGE3_MAX ][ PE_NB_STAGE3_LAGS ], /* O 3 DIM correlation array */
-    const SKP_float  frame[],            /* I vector to correlate                                            */
+    silk_float energies_st3[ PE_MAX_NB_SUBFR ][ PE_NB_CBKS_STAGE3_MAX ][ PE_NB_STAGE3_LAGS ], /* O 3 DIM correlation array */
+    const silk_float  frame[],            /* I vector to correlate                                            */
     opus_int         start_lag,          /* I start lag                                                      */
     opus_int         sf_length,          /* I sub frame length                                               */
     opus_int         nb_subfr,           /* I number of subframes                                            */
@@ -573,15 +573,15 @@ Calculate the energies for first two subframes. The energies are
 calculated recursively.
 ****************************************************************/
 {
-    const SKP_float *target_ptr, *basis_ptr;
+    const silk_float *target_ptr, *basis_ptr;
     double    energy;
     opus_int   k, i, j, lag_counter;
     opus_int   nb_cbk_search, delta, idx, cbk_size, lag_diff;
-    SKP_float scratch_mem[ SCRATCH_SIZE ];
+    silk_float scratch_mem[ SCRATCH_SIZE ];
     const opus_int8 *Lag_range_ptr, *Lag_CB_ptr;
 
-    SKP_assert( complexity >= SigProc_PE_MIN_COMPLEX );
-    SKP_assert( complexity <= SigProc_PE_MAX_COMPLEX );
+    silk_assert( complexity >= SigProc_PE_MIN_COMPLEX );
+    silk_assert( complexity <= SigProc_PE_MAX_COMPLEX );
 
     if( nb_subfr == PE_MAX_NB_SUBFR ){
         Lag_range_ptr = &silk_Lag_range_stage3[ complexity ][ 0 ][ 0 ];
@@ -589,35 +589,35 @@ calculated recursively.
         nb_cbk_search = silk_nb_cbk_searchs_stage3[ complexity ];
         cbk_size      = PE_NB_CBKS_STAGE3_MAX;
     } else {
-        SKP_assert( nb_subfr == PE_MAX_NB_SUBFR >> 1);
+        silk_assert( nb_subfr == PE_MAX_NB_SUBFR >> 1);
         Lag_range_ptr = &silk_Lag_range_stage3_10_ms[ 0 ][ 0 ];
         Lag_CB_ptr    = &silk_CB_lags_stage3_10_ms[ 0 ][ 0 ];
         nb_cbk_search = PE_NB_CBKS_STAGE3_10MS;
         cbk_size      = PE_NB_CBKS_STAGE3_10MS;
     }
 
-    target_ptr = &frame[ SKP_LSHIFT( sf_length, 2 ) ];
+    target_ptr = &frame[ silk_LSHIFT( sf_length, 2 ) ];
     for( k = 0; k < nb_subfr; k++ ) {
         lag_counter = 0;
 
         /* Calculate the energy for first lag */
         basis_ptr = target_ptr - ( start_lag + matrix_ptr( Lag_range_ptr, k, 0, 2 ) );
         energy = silk_energy_FLP( basis_ptr, sf_length ) + 1e-3;
-        SKP_assert( energy >= 0.0 );
-        scratch_mem[lag_counter] = (SKP_float)energy;
+        silk_assert( energy >= 0.0 );
+        scratch_mem[lag_counter] = (silk_float)energy;
         lag_counter++;
 
         lag_diff = ( matrix_ptr( Lag_range_ptr, k, 1, 2 ) -  matrix_ptr( Lag_range_ptr, k, 0, 2 ) + 1 );
         for( i = 1; i < lag_diff; i++ ) {
             /* remove part outside new window */
             energy -= basis_ptr[sf_length - i] * basis_ptr[sf_length - i];
-            SKP_assert( energy >= 0.0 );
+            silk_assert( energy >= 0.0 );
 
             /* add part that comes into window */
             energy += basis_ptr[ -i ] * basis_ptr[ -i ];
-            SKP_assert( energy >= 0.0 );
-            SKP_assert( lag_counter < SCRATCH_SIZE );
-            scratch_mem[lag_counter] = (SKP_float)energy;
+            silk_assert( energy >= 0.0 );
+            silk_assert( lag_counter < SCRATCH_SIZE );
+            scratch_mem[lag_counter] = (silk_float)energy;
             lag_counter++;
         }
 
@@ -627,10 +627,10 @@ calculated recursively.
             /* each code_book vector for each start lag                     */
             idx = matrix_ptr( Lag_CB_ptr, k, i, cbk_size ) - delta;
             for( j = 0; j < PE_NB_STAGE3_LAGS; j++ ) {
-                SKP_assert( idx + j < SCRATCH_SIZE );
-                SKP_assert( idx + j < lag_counter );
+                silk_assert( idx + j < SCRATCH_SIZE );
+                silk_assert( idx + j < lag_counter );
                 energies_st3[ k ][ i ][ j ] = scratch_mem[ idx + j ];
-                SKP_assert( energies_st3[ k ][ i ][ j ] >= 0.0f );
+                silk_assert( energies_st3[ k ][ i ][ j ] >= 0.0f );
             }
         }
         target_ptr += sf_length;
index e52a494..6737559 100644 (file)
@@ -37,31 +37,31 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 static inline void silk_prefilt_FLP(
     silk_prefilter_state_FLP *P,/* I/O state */
-    SKP_float st_res[],             /* I */
-    SKP_float xw[],                 /* O */
-    SKP_float *HarmShapeFIR,        /* I */
-    SKP_float Tilt,                 /* I */
-    SKP_float LF_MA_shp,            /* I */
-    SKP_float LF_AR_shp,            /* I */
+    silk_float st_res[],             /* I */
+    silk_float xw[],                 /* O */
+    silk_float *HarmShapeFIR,        /* I */
+    silk_float Tilt,                 /* I */
+    silk_float LF_MA_shp,            /* I */
+    silk_float LF_AR_shp,            /* I */
     opus_int   lag,                  /* I */
     opus_int   length                /* I */
 );
 
 void silk_warped_LPC_analysis_filter_FLP(
-          SKP_float                 state[],            /* I/O  State [order + 1]                       */
-          SKP_float                 res[],              /* O    Residual signal [length]                */
-    const SKP_float                 coef[],             /* I    Coefficients [order]                    */
-    const SKP_float                 input[],            /* I    Input signal [length]                   */
-    const SKP_float                 lambda,             /* I    Warping factor                          */
+          silk_float                 state[],            /* I/O  State [order + 1]                       */
+          silk_float                 res[],              /* O    Residual signal [length]                */
+    const silk_float                 coef[],             /* I    Coefficients [order]                    */
+    const silk_float                 input[],            /* I    Input signal [length]                   */
+    const silk_float                 lambda,             /* I    Warping factor                          */
     const opus_int                   length,             /* I    Length of input signal                  */
     const opus_int                   order               /* I    Filter order (even)                     */
 )
 {
     opus_int     n, i;
-    SKP_float   acc, tmp1, tmp2;
+    silk_float   acc, tmp1, tmp2;
 
     /* Order must be even */
-    SKP_assert( ( order & 1 ) == 0 );
+    silk_assert( ( order & 1 ) == 0 );
 
     for( n = 0; n < length; n++ ) {
         /* Output of lowpass section */
@@ -94,19 +94,19 @@ void silk_warped_LPC_analysis_filter_FLP(
 void silk_prefilter_FLP(
     silk_encoder_state_FLP          *psEnc,         /* I/O  Encoder state FLP                       */
     const silk_encoder_control_FLP  *psEncCtrl,     /* I    Encoder control FLP                     */
-          SKP_float                     xw[],           /* O    Weighted signal                         */
-    const SKP_float                     x[]             /* I    Speech signal                           */
+          silk_float                     xw[],           /* O    Weighted signal                         */
+    const silk_float                     x[]             /* I    Speech signal                           */
 )
 {
     silk_prefilter_state_FLP *P = &psEnc->sPrefilt;
     opus_int   j, k, lag;
-    SKP_float HarmShapeGain, Tilt, LF_MA_shp, LF_AR_shp;
-    SKP_float B[ 2 ];
-    const SKP_float *AR1_shp;
-    const SKP_float *px;
-    SKP_float *pxw;
-    SKP_float HarmShapeFIR[ 3 ];
-    SKP_float st_res[ MAX_SUB_FRAME_LENGTH + MAX_LPC_ORDER ];
+    silk_float HarmShapeGain, Tilt, LF_MA_shp, LF_AR_shp;
+    silk_float B[ 2 ];
+    const silk_float *AR1_shp;
+    const silk_float *px;
+    silk_float *pxw;
+    silk_float HarmShapeFIR[ 3 ];
+    silk_float st_res[ MAX_SUB_FRAME_LENGTH + MAX_LPC_ORDER ];
 
     /* Setup pointers */
     px  = x;
@@ -130,7 +130,7 @@ void silk_prefilter_FLP(
 
         /* Short term FIR filtering */
         silk_warped_LPC_analysis_filter_FLP( P->sAR_shp, st_res, AR1_shp, px,
-            (SKP_float)psEnc->sCmn.warping_Q16 / 65536.0f, psEnc->sCmn.subfr_length, psEnc->sCmn.shapingLPCOrder );
+            (silk_float)psEnc->sCmn.warping_Q16 / 65536.0f, psEnc->sCmn.subfr_length, psEnc->sCmn.shapingLPCOrder );
 
         /* Reduce (mainly) low frequencies during harmonic emphasis */
         B[ 0 ] =  psEncCtrl->GainsPre[ k ];
@@ -155,21 +155,21 @@ void silk_prefilter_FLP(
 */
 static inline void silk_prefilt_FLP(
     silk_prefilter_state_FLP *P,/* I/O state */
-    SKP_float st_res[],                /* I */
-    SKP_float xw[],                    /* O */
-    SKP_float *HarmShapeFIR,        /* I */
-    SKP_float Tilt,                    /* I */
-    SKP_float LF_MA_shp,            /* I */
-    SKP_float LF_AR_shp,            /* I */
+    silk_float st_res[],                /* I */
+    silk_float xw[],                    /* O */
+    silk_float *HarmShapeFIR,        /* I */
+    silk_float Tilt,                    /* I */
+    silk_float LF_MA_shp,            /* I */
+    silk_float LF_AR_shp,            /* I */
     opus_int   lag,                    /* I */
     opus_int   length                /* I */
 )
 {
     opus_int   i;
     opus_int   idx, LTP_shp_buf_idx;
-    SKP_float n_Tilt, n_LF, n_LTP;
-    SKP_float sLF_AR_shp, sLF_MA_shp;
-    SKP_float *LTP_shp_buf;
+    silk_float n_Tilt, n_LF, n_LTP;
+    silk_float sLF_AR_shp, sLF_MA_shp;
+    silk_float *LTP_shp_buf;
 
     /* To speed up use temp variables instead of using the struct */
     LTP_shp_buf     = P->sLTP_shp;
@@ -179,7 +179,7 @@ static inline void silk_prefilt_FLP(
 
     for( i = 0; i < length; i++ ) {
         if( lag > 0 ) {
-            SKP_assert( HARM_SHAPE_FIR_TAPS == 3 );
+            silk_assert( HARM_SHAPE_FIR_TAPS == 3 );
             idx = lag + LTP_shp_buf_idx;
             n_LTP  = LTP_shp_buf[ ( idx - HARM_SHAPE_FIR_TAPS / 2 - 1) & LTP_MASK ] * HarmShapeFIR[ 0 ];
             n_LTP += LTP_shp_buf[ ( idx - HARM_SHAPE_FIR_TAPS / 2    ) & LTP_MASK ] * HarmShapeFIR[ 1 ];
index 2dceb02..33dada2 100644 (file)
@@ -41,24 +41,24 @@ void silk_process_gains_FLP(
     silk_shape_state_FLP *psShapeSt = &psEnc->sShape;
     opus_int     k;
     opus_int32   pGains_Q16[ MAX_NB_SUBFR ];
-    SKP_float   s, InvMaxSqrVal, gain, quant_offset;
+    silk_float   s, InvMaxSqrVal, gain, quant_offset;
 
     /* Gain reduction when LTP coding gain is high */
     if( psEnc->sCmn.indices.signalType == TYPE_VOICED ) {
-        s = 1.0f - 0.5f * SKP_sigmoid( 0.25f * ( psEncCtrl->LTPredCodGain - 12.0f ) );
+        s = 1.0f - 0.5f * silk_sigmoid( 0.25f * ( psEncCtrl->LTPredCodGain - 12.0f ) );
         for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) {
             psEncCtrl->Gains[ k ] *= s;
         }
     }
 
     /* Limit the quantized signal */
-    InvMaxSqrVal = ( SKP_float )( pow( 2.0f, 0.33f * ( 21.0f - psEnc->sCmn.SNR_dB_Q7 * ( 1 / 128.0f ) ) ) / psEnc->sCmn.subfr_length );
+    InvMaxSqrVal = ( silk_float )( pow( 2.0f, 0.33f * ( 21.0f - psEnc->sCmn.SNR_dB_Q7 * ( 1 / 128.0f ) ) ) / psEnc->sCmn.subfr_length );
 
     for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) {
         /* Soft limit on ratio residual energy and squared gains */
         gain = psEncCtrl->Gains[ k ];
-        gain = ( SKP_float )sqrt( gain * gain + psEncCtrl->ResNrg[ k ] * InvMaxSqrVal );
-        psEncCtrl->Gains[ k ] = SKP_min_float( gain, 32767.0f );
+        gain = ( silk_float )sqrt( gain * gain + psEncCtrl->ResNrg[ k ] * InvMaxSqrVal );
+        psEncCtrl->Gains[ k ] = silk_min_float( gain, 32767.0f );
     }
 
     /* Prepare gains for noise shaping quantization */
@@ -93,6 +93,6 @@ void silk_process_gains_FLP(
                       + LAMBDA_CODING_QUALITY    * psEncCtrl->coding_quality
                       + LAMBDA_QUANT_OFFSET      * quant_offset;
 
-    SKP_assert( psEncCtrl->Lambda > 0.0f );
-    SKP_assert( psEncCtrl->Lambda < 2.0f );
+    silk_assert( psEncCtrl->Lambda > 0.0f );
+    silk_assert( psEncCtrl->Lambda < 2.0f );
 }
index 9741ca9..7034dd3 100644 (file)
@@ -32,9 +32,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "silk_main_FLP.h"
 
 void silk_regularize_correlations_FLP(
-          SKP_float                 *XX,                /* I/O  Correlation matrices                    */
-          SKP_float                 *xx,                /* I/O  Correlation values                      */
-    const SKP_float                 noise,              /* I    Noise energy to add                     */
+          silk_float                 *XX,                /* I/O  Correlation matrices                    */
+          silk_float                 *xx,                /* I/O  Correlation values                      */
+    const silk_float                 noise,              /* I    Noise energy to add                     */
     const opus_int                   D                   /* I    Dimension of XX                         */
 )
 {
index fadd7cc..6ab9ecf 100644 (file)
@@ -35,19 +35,19 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define REGULARIZATION_FACTOR               1e-8f
 
 /* Residual energy: nrg = wxx - 2 * wXx * c + c' * wXX * c */
-SKP_float silk_residual_energy_covar_FLP(           /* O    Weighted residual energy                */
-    const SKP_float                 *c,                 /* I    Filter coefficients                     */
-          SKP_float                 *wXX,               /* I/O  Weighted correlation matrix, reg. out   */
-    const SKP_float                 *wXx,               /* I    Weighted correlation vector             */
-    const SKP_float                 wxx,                /* I    Weighted correlation value              */
+silk_float silk_residual_energy_covar_FLP(           /* O    Weighted residual energy                */
+    const silk_float                 *c,                 /* I    Filter coefficients                     */
+          silk_float                 *wXX,               /* I/O  Weighted correlation matrix, reg. out   */
+    const silk_float                 *wXx,               /* I    Weighted correlation vector             */
+    const silk_float                 wxx,                /* I    Weighted correlation value              */
     const opus_int                   D                   /* I    Dimension                               */
 )
 {
     opus_int   i, j, k;
-    SKP_float tmp, nrg = 0.0f, regularization;
+    silk_float tmp, nrg = 0.0f, regularization;
 
     /* Safety checks */
-    SKP_assert( D >= 0 );
+    silk_assert( D >= 0 );
 
     regularization = REGULARIZATION_FACTOR * ( wXX[ 0 ] + wXX[ D * D - 1 ] );
     for( k = 0; k < MAX_ITERATIONS_RESIDUAL_NRG; k++ ) {
@@ -79,7 +79,7 @@ SKP_float silk_residual_energy_covar_FLP(           /* O    Weighted residual en
         }
     }
     if( k == MAX_ITERATIONS_RESIDUAL_NRG ) {
-        SKP_assert( nrg == 0 );
+        silk_assert( nrg == 0 );
         nrg = 1.0f;
     }
 
@@ -89,29 +89,29 @@ SKP_float silk_residual_energy_covar_FLP(           /* O    Weighted residual en
 /* Calculates residual energies of input subframes where all subframes have LPC_order   */
 /* of preceeding samples                                                                */
 void silk_residual_energy_FLP(
-          SKP_float nrgs[ MAX_NB_SUBFR ],       /* O    Residual energy per subframe    */
-    const SKP_float x[],                        /* I    Input signal                    */
-          SKP_float a[ 2 ][ MAX_LPC_ORDER ],    /* I    AR coefs for each frame half    */
-    const SKP_float gains[],                    /* I    Quantization gains              */
+          silk_float nrgs[ MAX_NB_SUBFR ],       /* O    Residual energy per subframe    */
+    const silk_float x[],                        /* I    Input signal                    */
+          silk_float a[ 2 ][ MAX_LPC_ORDER ],    /* I    AR coefs for each frame half    */
+    const silk_float gains[],                    /* I    Quantization gains              */
     const opus_int   subfr_length,               /* I    Subframe length                 */
     const opus_int   nb_subfr,                   /* I    number of subframes             */
     const opus_int   LPC_order                   /* I    LPC order                       */
 )
 {
     opus_int     shift;
-    SKP_float   *LPC_res_ptr, LPC_res[ ( MAX_FRAME_LENGTH + MAX_NB_SUBFR * MAX_LPC_ORDER ) / 2 ];
+    silk_float   *LPC_res_ptr, LPC_res[ ( MAX_FRAME_LENGTH + MAX_NB_SUBFR * MAX_LPC_ORDER ) / 2 ];
 
     LPC_res_ptr = LPC_res + LPC_order;
     shift = LPC_order + subfr_length;
 
     /* Filter input to create the LPC residual for each frame half, and measure subframe energies */
     silk_LPC_analysis_filter_FLP( LPC_res, a[ 0 ], x + 0 * shift, 2 * shift, LPC_order );
-    nrgs[ 0 ] = ( SKP_float )( gains[ 0 ] * gains[ 0 ] * silk_energy_FLP( LPC_res_ptr + 0 * shift, subfr_length ) );
-    nrgs[ 1 ] = ( SKP_float )( gains[ 1 ] * gains[ 1 ] * silk_energy_FLP( LPC_res_ptr + 1 * shift, subfr_length ) );
+    nrgs[ 0 ] = ( silk_float )( gains[ 0 ] * gains[ 0 ] * silk_energy_FLP( LPC_res_ptr + 0 * shift, subfr_length ) );
+    nrgs[ 1 ] = ( silk_float )( gains[ 1 ] * gains[ 1 ] * silk_energy_FLP( LPC_res_ptr + 1 * shift, subfr_length ) );
 
     if( nb_subfr == MAX_NB_SUBFR ) {
         silk_LPC_analysis_filter_FLP( LPC_res, a[ 1 ], x + 2 * shift, 2 * shift, LPC_order );
-        nrgs[ 2 ] = ( SKP_float )( gains[ 2 ] * gains[ 2 ] * silk_energy_FLP( LPC_res_ptr + 0 * shift, subfr_length ) );
-        nrgs[ 3 ] = ( SKP_float )( gains[ 3 ] * gains[ 3 ] * silk_energy_FLP( LPC_res_ptr + 1 * shift, subfr_length ) );
+        nrgs[ 2 ] = ( silk_float )( gains[ 2 ] * gains[ 2 ] * silk_energy_FLP( LPC_res_ptr + 0 * shift, subfr_length ) );
+        nrgs[ 3 ] = ( silk_float )( gains[ 3 ] * gains[ 3 ] * silk_energy_FLP( LPC_res_ptr + 1 * shift, subfr_length ) );
     }
 }
index 396203c..ca6867e 100644 (file)
@@ -33,9 +33,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /* 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
 )
 {
index b8fa92c..33982eb 100644 (file)
@@ -33,8 +33,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /* 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
 )
 {
index f57ebda..d13d5cc 100644 (file)
@@ -31,15 +31,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "silk_SigProc_FLP.h"
 
-SKP_float silk_schur_FLP(           /* O    returns residual energy                     */
-    SKP_float       refl_coef[],        /* O    reflection coefficients (length order)      */
-    const SKP_float auto_corr[],        /* I    autotcorrelation 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    autotcorrelation sequence (length order+1)  */
     opus_int         order               /* I    order                                       */
 )
 {
     opus_int   k, n;
-    SKP_float C[ SILK_MAX_ORDER_LPC + 1 ][ 2 ];
-    SKP_float Ctmp1, Ctmp2, rc_tmp;
+    silk_float C[ SILK_MAX_ORDER_LPC + 1 ][ 2 ];
+    silk_float Ctmp1, Ctmp2, rc_tmp;
 
     /* Copy correlations */
     for( k = 0; k < order+1; k++ ) {
@@ -48,7 +48,7 @@ SKP_float silk_schur_FLP(           /* O    returns residual energy
 
     for( k = 0; k < order; k++ ) {
         /* Get reflection coefficient */
-        rc_tmp = -C[ k + 1 ][ 0 ] / SKP_max_float( C[ 0 ][ 1 ], 1e-9f );
+        rc_tmp = -C[ k + 1 ][ 0 ] / silk_max_float( C[ 0 ][ 1 ], 1e-9f );
 
         /* Save the output */
         refl_coef[ k ] = rc_tmp;
index a082b33..fc38c7f 100644 (file)
@@ -38,10 +38,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * the symmetric matric A is given by A = L*D*L'.
  **********************************************************************/
 void silk_LDL_FLP(
-    SKP_float           *A,      /* (I/O) Pointer to Symetric Square Matrix */
+    silk_float           *A,      /* (I/O) Pointer to Symetric Square Matrix */
     opus_int             M,       /* (I) Size of Matrix */
-    SKP_float           *L,      /* (I/O) Pointer to Square Upper triangular Matrix */
-    SKP_float           *Dinv    /* (I/O) Pointer to vector holding the inverse diagonal elements of D */
+    silk_float           *L,      /* (I/O) Pointer to Square Upper triangular Matrix */
+    silk_float           *Dinv    /* (I/O) Pointer to vector holding the inverse diagonal elements of D */
 );
 
 /**********************************************************************
@@ -49,10 +49,10 @@ void silk_LDL_FLP(
  * triangular matrix, with ones on the diagonal.
  **********************************************************************/
 void silk_SolveWithLowerTriangularWdiagOnes_FLP(
-    const SKP_float     *L,     /* (I) Pointer to Lower Triangular Matrix */
+    const silk_float     *L,     /* (I) Pointer to Lower Triangular Matrix */
     opus_int             M,      /* (I) Dim of Matrix equation */
-    const SKP_float     *b,     /* (I) b Vector */
-    SKP_float           *x      /* (O) x Vector */
+    const silk_float     *b,     /* (I) b Vector */
+    silk_float           *x      /* (O) x Vector */
 );
 
 /**********************************************************************
@@ -60,10 +60,10 @@ void silk_SolveWithLowerTriangularWdiagOnes_FLP(
  * triangular, with ones on the diagonal. (ie then A^T is upper triangular)
  **********************************************************************/
 void silk_SolveWithUpperTriangularFromLowerWdiagOnes_FLP(
-    const SKP_float     *L,     /* (I) Pointer to Lower Triangular Matrix */
+    const silk_float     *L,     /* (I) Pointer to Lower Triangular Matrix */
     opus_int             M,      /* (I) Dim of Matrix equation */
-    const SKP_float     *b,     /* (I) b Vector */
-    SKP_float           *x      /* (O) x Vector */
+    const silk_float     *b,     /* (I) b Vector */
+    silk_float           *x      /* (O) x Vector */
 );
 
 /**********************************************************************
@@ -71,18 +71,18 @@ void silk_SolveWithUpperTriangularFromLowerWdiagOnes_FLP(
  * symmetric square matrix - using LDL factorisation
  **********************************************************************/
 void silk_solve_LDL_FLP(
-          SKP_float                 *A,                 /* I/O  Symmetric square matrix, out: reg.      */
+          silk_float                 *A,                 /* I/O  Symmetric square matrix, out: reg.      */
     const opus_int                   M,                  /* I    Size of matrix                          */
-    const SKP_float                 *b,                 /* I    Pointer to b vector                     */
-          SKP_float                 *x                  /* O    Pointer to x solution vector            */
+    const silk_float                 *b,                 /* I    Pointer to b vector                     */
+          silk_float                 *x                  /* O    Pointer to x solution vector            */
 )
 {
     opus_int   i;
-    SKP_float L[    MAX_MATRIX_SIZE ][ MAX_MATRIX_SIZE ];
-    SKP_float T[    MAX_MATRIX_SIZE ];
-    SKP_float Dinv[ MAX_MATRIX_SIZE ]; /* inverse diagonal elements of D*/
+    silk_float L[    MAX_MATRIX_SIZE ][ MAX_MATRIX_SIZE ];
+    silk_float T[    MAX_MATRIX_SIZE ];
+    silk_float Dinv[ MAX_MATRIX_SIZE ]; /* inverse diagonal elements of D*/
 
-    SKP_assert( M <= MAX_MATRIX_SIZE );
+    silk_assert( M <= MAX_MATRIX_SIZE );
 
     /***************************************************
     Factorize A by LDL such that A = L*D*(L^T),
@@ -110,15 +110,15 @@ void silk_solve_LDL_FLP(
 }
 
 void silk_SolveWithUpperTriangularFromLowerWdiagOnes_FLP(
-    const SKP_float     *L,     /* (I) Pointer to Lower Triangular Matrix */
+    const silk_float     *L,     /* (I) Pointer to Lower Triangular Matrix */
     opus_int             M,      /* (I) Dim of Matrix equation */
-    const SKP_float     *b,     /* (I) b Vector */
-    SKP_float           *x      /* (O) x Vector */
+    const silk_float     *b,     /* (I) b Vector */
+    silk_float           *x      /* (O) x Vector */
 )
 {
     opus_int   i, j;
-    SKP_float temp;
-    const SKP_float *ptr1;
+    silk_float temp;
+    const silk_float *ptr1;
 
     for( i = M - 1; i >= 0; i-- ) {
         ptr1 =  matrix_adr( L, 0, i, M );
@@ -132,15 +132,15 @@ void silk_SolveWithUpperTriangularFromLowerWdiagOnes_FLP(
 }
 
 void silk_SolveWithLowerTriangularWdiagOnes_FLP(
-    const SKP_float     *L,     /* (I) Pointer to Lower Triangular Matrix */
+    const silk_float     *L,     /* (I) Pointer to Lower Triangular Matrix */
     opus_int             M,      /* (I) Dim of Matrix equation */
-    const SKP_float     *b,     /* (I) b Vector */
-    SKP_float           *x      /* (O) x Vector */
+    const silk_float     *b,     /* (I) b Vector */
+    silk_float           *x      /* (O) x Vector */
 )
 {
     opus_int   i, j;
-    SKP_float temp;
-    const SKP_float *ptr1;
+    silk_float temp;
+    const silk_float *ptr1;
 
     for( i = 0; i < M; i++ ) {
         ptr1 =  matrix_adr( L, i, 0, M );
@@ -154,18 +154,18 @@ void silk_SolveWithLowerTriangularWdiagOnes_FLP(
 }
 
 void silk_LDL_FLP(
-    SKP_float           *A,      /* (I/O) Pointer to Symetric Square Matrix */
+    silk_float           *A,      /* (I/O) Pointer to Symetric Square Matrix */
     opus_int             M,       /* (I) Size of Matrix */
-    SKP_float           *L,      /* (I/O) Pointer to Square Upper triangular Matrix */
-    SKP_float           *Dinv    /* (I/O) Pointer to vector holding the inverse diagonal elements of D */
+    silk_float           *L,      /* (I/O) Pointer to Square Upper triangular Matrix */
+    silk_float           *Dinv    /* (I/O) Pointer to vector holding the inverse diagonal elements of D */
 )
 {
     opus_int i, j, k, loop_count, err = 1;
-    SKP_float *ptr1, *ptr2;
+    silk_float *ptr1, *ptr2;
     double temp, diag_min_value;
-    SKP_float v[ MAX_MATRIX_SIZE ], D[ MAX_MATRIX_SIZE ]; /* temp arrays*/
+    silk_float v[ MAX_MATRIX_SIZE ], D[ MAX_MATRIX_SIZE ]; /* temp arrays*/
 
-    SKP_assert( M <= MAX_MATRIX_SIZE );
+    silk_assert( M <= MAX_MATRIX_SIZE );
 
     diag_min_value = FIND_LTP_COND_FAC * 0.5f * ( A[ 0 ] + A[ M * M - 1 ] );
     for( loop_count = 0; loop_count < M && err == 1; loop_count++ ) {
@@ -181,13 +181,13 @@ void silk_LDL_FLP(
                 /* Badly conditioned matrix: add white noise and run again */
                 temp = ( loop_count + 1 ) * diag_min_value - temp;
                 for( i = 0; i < M; i++ ) {
-                    matrix_ptr( A, i, i, M ) += ( SKP_float )temp;
+                    matrix_ptr( A, i, i, M ) += ( silk_float )temp;
                 }
                 err = 1;
                 break;
             }
-            D[ j ]    = ( SKP_float )temp;
-            Dinv[ j ] = ( SKP_float )( 1.0f / temp );
+            D[ j ]    = ( silk_float )temp;
+            Dinv[ j ] = ( silk_float )( 1.0f / temp );
             matrix_ptr( L, j, j, M ) = 1.0f;
 
             ptr1 = matrix_adr( A, j, 0, M );
@@ -197,11 +197,11 @@ void silk_LDL_FLP(
                 for( k = 0; k < j; k++ ) {
                     temp += ptr2[ k ] * v[ k ];
                 }
-                matrix_ptr( L, i, j, M ) = ( SKP_float )( ( ptr1[ i ] - temp ) * Dinv[ j ] );
+                matrix_ptr( L, i, j, M ) = ( silk_float )( ( ptr1[ i ] - temp ) * Dinv[ j ] );
                 ptr2 += M; /* go to next column*/
             }
         }
     }
-    SKP_assert( err == 0 );
+    silk_assert( err == 0 );
 }
 
index 62249b5..c08fb32 100644 (file)
@@ -37,19 +37,19 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "silk_SigProc_FLP.h"
 
 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    */
 )
 {
-    SKP_float value;
+    silk_float value;
     opus_int   i, j;
 
     /* Safety checks */
-    SKP_assert( K >  0 );
-    SKP_assert( L >  0 );
-    SKP_assert( L >= K );
+    silk_assert( K >  0 );
+    silk_assert( L >  0 );
+    silk_assert( L >= K );
 
     /* Write start indices in index vector */
     for( i = 0; i < K; i++ ) {
index e9c5b1a..68d358a 100644 (file)
@@ -42,21 +42,21 @@ extern "C"
 /********************************/
 typedef struct {
     opus_int8    LastGainIndex;
-    SKP_float   HarmBoost_smth;
-    SKP_float   HarmShapeGain_smth;
-    SKP_float   Tilt_smth;
+    silk_float   HarmBoost_smth;
+    silk_float   HarmShapeGain_smth;
+    silk_float   Tilt_smth;
 } silk_shape_state_FLP;
 
 /********************************/
 /* Prefilter state              */
 /********************************/
 typedef struct {
-    SKP_float   sLTP_shp[ LTP_BUF_LENGTH ];
-    SKP_float   sAR_shp[ MAX_SHAPE_LPC_ORDER + 1 ];
+    silk_float   sLTP_shp[ LTP_BUF_LENGTH ];
+    silk_float   sAR_shp[ MAX_SHAPE_LPC_ORDER + 1 ];
     opus_int     sLTP_shp_buf_idx;
-    SKP_float   sLF_AR_shp;
-    SKP_float   sLF_MA_shp;
-    SKP_float   sHarmHP;
+    silk_float   sLF_AR_shp;
+    silk_float   sLF_MA_shp;
+    silk_float   sHarmHP;
     opus_int32   rand_seed;
     opus_int     lagPrev;
 } silk_prefilter_state_FLP;
@@ -70,12 +70,12 @@ typedef struct {
     silk_prefilter_state_FLP    sPrefilt;                   /* Prefilter State */
 
     /* Buffer for find pitch and noise shape analysis */
-    SKP_float                   x_buf[ 2 * MAX_FRAME_LENGTH + LA_SHAPE_MAX ];/* Buffer for find pitch and noise shape analysis */
-    SKP_float                   LTPCorr;                    /* Normalized correlation from pitch lag estimator */
+    silk_float                   x_buf[ 2 * MAX_FRAME_LENGTH + LA_SHAPE_MAX ];/* Buffer for find pitch and noise shape analysis */
+    silk_float                   LTPCorr;                    /* Normalized correlation from pitch lag estimator */
 
     /* Parameters for LTP scaling control */
-    SKP_float                   prevLTPredCodGain;
-    SKP_float                   HPLTPredCodGain;
+    silk_float                   prevLTPredCodGain;
+    silk_float                   HPLTPredCodGain;
 } silk_encoder_state_FLP;
 
 /************************/
@@ -83,30 +83,30 @@ typedef struct {
 /************************/
 typedef struct {
     /* Prediction and coding parameters */
-    SKP_float                    Gains[ MAX_NB_SUBFR ];
-    SKP_float                    PredCoef[ 2 ][ MAX_LPC_ORDER ];        /* holds interpolated and final coefficients */
-    SKP_float                    LTPCoef[LTP_ORDER * MAX_NB_SUBFR];
-    SKP_float                    LTP_scale;
+    silk_float                    Gains[ MAX_NB_SUBFR ];
+    silk_float                    PredCoef[ 2 ][ MAX_LPC_ORDER ];        /* holds interpolated and final coefficients */
+    silk_float                    LTPCoef[LTP_ORDER * MAX_NB_SUBFR];
+    silk_float                    LTP_scale;
     opus_int                     pitchL[ MAX_NB_SUBFR ];
 
     /* Noise shaping parameters */
-    SKP_float                    AR1[ MAX_NB_SUBFR * MAX_SHAPE_LPC_ORDER ];
-    SKP_float                    AR2[ MAX_NB_SUBFR * MAX_SHAPE_LPC_ORDER ];
-    SKP_float                    LF_MA_shp[     MAX_NB_SUBFR ];
-    SKP_float                    LF_AR_shp[     MAX_NB_SUBFR ];
-    SKP_float                    GainsPre[      MAX_NB_SUBFR ];
-    SKP_float                    HarmBoost[     MAX_NB_SUBFR ];
-    SKP_float                    Tilt[          MAX_NB_SUBFR ];
-    SKP_float                    HarmShapeGain[ MAX_NB_SUBFR ];
-    SKP_float                    Lambda;
-    SKP_float                    input_quality;
-    SKP_float                    coding_quality;
+    silk_float                    AR1[ MAX_NB_SUBFR * MAX_SHAPE_LPC_ORDER ];
+    silk_float                    AR2[ MAX_NB_SUBFR * MAX_SHAPE_LPC_ORDER ];
+    silk_float                    LF_MA_shp[     MAX_NB_SUBFR ];
+    silk_float                    LF_AR_shp[     MAX_NB_SUBFR ];
+    silk_float                    GainsPre[      MAX_NB_SUBFR ];
+    silk_float                    HarmBoost[     MAX_NB_SUBFR ];
+    silk_float                    Tilt[          MAX_NB_SUBFR ];
+    silk_float                    HarmShapeGain[ MAX_NB_SUBFR ];
+    silk_float                    Lambda;
+    silk_float                    input_quality;
+    silk_float                    coding_quality;
 
     /* Measures */
-    SKP_float                    sparseness;
-    SKP_float                   predGain;
-    SKP_float                    LTPredCodGain;
-    SKP_float                    ResNrg[ MAX_NB_SUBFR ];                    /* Residual energy per subframe */
+    silk_float                    sparseness;
+    silk_float                   predGain;
+    silk_float                    LTPredCodGain;
+    silk_float                    ResNrg[ MAX_NB_SUBFR ];                    /* Residual energy per subframe */
 } silk_encoder_control_FLP;
 
 /************************/
index e997f62..de08d49 100644 (file)
@@ -33,9 +33,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /* Autocorrelations for a warped frequency axis */
 void silk_warped_autocorrelation_FLP(
-          SKP_float                 *corr,              /* O    Result [order + 1]                      */
-    const SKP_float                 *input,             /* I    Input data to correlate                 */
-    const SKP_float                 warping,            /* I    Warping coefficient                     */
+          silk_float                 *corr,              /* O  &nbs