Renamed SKP_[u]int* to opus_[u]int*
authorJean-Marc Valin <jean-marc.valin@usherbrooke.ca>
Fri, 29 Jul 2011 22:39:57 +0000 (18:39 -0400)
committerJean-Marc Valin <jean-marc.valin@usherbrooke.ca>
Fri, 29 Jul 2011 22:39:57 +0000 (18:39 -0400)
164 files changed:
libcelt/opus_types.h
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_main_FIX.h
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_API.h
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_PLC.h
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.h
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_main.h
silk/silk_pitch_analysis_core.c
silk/silk_pitch_est_defines.h
silk/silk_pitch_est_tables.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.h
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_rom.h
silk/silk_resampler_structs.h
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_table_LSF_cos.c
silk/silk_tables.h
silk/silk_tables_LTP.c
silk/silk_tables_NLSF_CB_NB_MB.c
silk/silk_tables_NLSF_CB_WB.c
silk/silk_tables_gain.c
silk/silk_tables_other.c
silk/silk_tables_pitch_lag.c
silk/silk_tables_pulses_per_block.c
silk/silk_typedef.h
src/opus_decoder.c

index a676b61..1ec6d7e 100644 (file)
 
 #endif
 
+#define opus_int         int                     /* used for counters etc; at least 16 bits */
+#define opus_int64       long long
+#define opus_int8        signed char
+
+#define opus_uint        unsigned int            /* used for counters etc; at least 16 bits */
+#define opus_uint64      unsigned long long
+#define opus_uint8       unsigned char
+
+
 #endif  /* _OPUS_TYPES_H */
index 2e864a4..e4664de 100644 (file)
@@ -28,21 +28,21 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "silk_main_FIX.h"\r
 \r
 void silk_LTP_analysis_filter_FIX(\r
-    SKP_int16       *LTP_res,                               /* O:   LTP residual signal of length MAX_NB_SUBFR * ( pre_length + subfr_length )  */\r
-    const SKP_int16 *x,                                     /* I:   Pointer to input signal with at least max( pitchL ) preceeding samples      */\r
-    const SKP_int16 LTPCoef_Q14[ LTP_ORDER * MAX_NB_SUBFR ],/* I:   LTP_ORDER LTP coefficients for each MAX_NB_SUBFR subframe                   */\r
-    const SKP_int   pitchL[ MAX_NB_SUBFR ],                 /* I:   Pitch lag, one for each subframe                                            */\r
-    const SKP_int32 invGains_Q16[ MAX_NB_SUBFR ],           /* I:   Inverse quantization gains, one for each subframe                           */\r
-    const SKP_int   subfr_length,                           /* I:   Length of each subframe                                                     */\r
-    const SKP_int   nb_subfr,                               /* I:   Number of subframes                                                         */\r
-    const SKP_int   pre_length                              /* I:   Length of the preceeding samples starting at &x[0] for each subframe        */\r
+    opus_int16       *LTP_res,                               /* O:   LTP residual signal of length MAX_NB_SUBFR * ( pre_length + subfr_length )  */\r
+    const opus_int16 *x,                                     /* I:   Pointer to input signal with at least max( pitchL ) preceeding samples      */\r
+    const opus_int16 LTPCoef_Q14[ LTP_ORDER * MAX_NB_SUBFR ],/* I:   LTP_ORDER LTP coefficients for each MAX_NB_SUBFR subframe                   */\r
+    const opus_int   pitchL[ MAX_NB_SUBFR ],                 /* I:   Pitch lag, one for each subframe                                            */\r
+    const opus_int32 invGains_Q16[ MAX_NB_SUBFR ],           /* I:   Inverse quantization gains, one for each subframe                           */\r
+    const opus_int   subfr_length,                           /* I:   Length of each subframe                                                     */\r
+    const opus_int   nb_subfr,                               /* I:   Number of subframes                                                         */\r
+    const opus_int   pre_length                              /* I:   Length of the preceeding samples starting at &x[0] for each subframe        */\r
 )\r
 {\r
-    const SKP_int16 *x_ptr, *x_lag_ptr;\r
-    SKP_int16   Btmp_Q14[ LTP_ORDER ];\r
-    SKP_int16   *LTP_res_ptr;\r
-    SKP_int     k, i, j;\r
-    SKP_int32   LTP_est;\r
+    const opus_int16 *x_ptr, *x_lag_ptr;\r
+    opus_int16   Btmp_Q14[ LTP_ORDER ];\r
+    opus_int16   *LTP_res_ptr;\r
+    opus_int     k, i, j;\r
+    opus_int32   LTP_est;\r
 \r
     x_ptr = x;\r
     LTP_res_ptr = LTP_res;\r
@@ -65,7 +65,7 @@ void silk_LTP_analysis_filter_FIX(
             LTP_est = SKP_RSHIFT_ROUND( LTP_est, 14 ); // round and -> Q0\r
 \r
             /* Subtract long-term prediction */\r
-            LTP_res_ptr[ i ] = ( SKP_int16 )SKP_SAT16( ( SKP_int32 )x_ptr[ i ] - LTP_est );\r
+            LTP_res_ptr[ i ] = ( opus_int16 )SKP_SAT16( ( opus_int32 )x_ptr[ i ] - LTP_est );\r
 \r
             /* Scale residual */\r
             LTP_res_ptr[ i ] = SKP_SMULWB( invGains_Q16[ k ], LTP_res_ptr[ i ] );\r
index 946d24c..d3535c7 100644 (file)
@@ -32,7 +32,7 @@ void silk_LTP_scale_ctrl_FIX(
     silk_encoder_control_FIX    *psEncCtrl  /* I/O  encoder control FIX                         */\r
 )\r
 {\r
-    SKP_int round_loss;\r
+    opus_int round_loss;\r
 \r
     /* 1st order high-pass filter */\r
     psEnc->HPLTPredCodGain_Q7 = SKP_max_int( psEncCtrl->LTPredCodGain_Q7 - SKP_RSHIFT( psEnc->prevLTPredCodGain_Q7, 1 ), 0 ) \r
@@ -42,7 +42,7 @@ void silk_LTP_scale_ctrl_FIX(
     /* Only scale if first frame in packet */\r
     if( psEnc->sCmn.nFramesEncoded == 0 ) {\r
         round_loss = psEnc->sCmn.PacketLoss_perc + psEnc->sCmn.nFramesPerPacket - 1;\r
-        psEnc->sCmn.indices.LTP_scaleIndex = (SKP_int8)SKP_LIMIT( \r
+        psEnc->sCmn.indices.LTP_scaleIndex = (opus_int8)SKP_LIMIT( \r
             SKP_SMULWB( SKP_SMULBB( round_loss, psEnc->HPLTPredCodGain_Q7 ), SILK_FIX_CONST( 0.1, 9 ) ), 0, 2 );\r
     } else {\r
         /* Default is minimum scaling */\r
index 453cac8..619546f 100644 (file)
@@ -33,17 +33,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 \r
 /* Calculates correlation vector X'*t */\r
 void silk_corrVector_FIX(\r
-    const SKP_int16                 *x,         /* I    x vector [L + order - 1] used to form data matrix X */\r
-    const SKP_int16                 *t,         /* I    target vector [L]                                   */\r
-    const SKP_int                   L,          /* I    Length of vectors                                   */\r
-    const SKP_int                   order,      /* I    Max lag for correlation                             */\r
-    SKP_int32                       *Xt,        /* O    Pointer to X'*t correlation vector [order]          */\r
-    const SKP_int                   rshifts     /* I    Right shifts of correlations                        */\r
+    const opus_int16                 *x,         /* I    x vector [L + order - 1] used to form data matrix X */\r
+    const opus_int16                 *t,         /* I    target vector [L]                                   */\r
+    const opus_int                   L,          /* I    Length of vectors                                   */\r
+    const opus_int                   order,      /* I    Max lag for correlation                             */\r
+    opus_int32                       *Xt,        /* O    Pointer to X'*t correlation vector [order]          */\r
+    const opus_int                   rshifts     /* I    Right shifts of correlations                        */\r
 )\r
 {\r
-    SKP_int         lag, i;\r
-    const SKP_int16 *ptr1, *ptr2;\r
-    SKP_int32       inner_prod;\r
+    opus_int         lag, i;\r
+    const opus_int16 *ptr1, *ptr2;\r
+    opus_int32       inner_prod;\r
 \r
     ptr1 = &x[ order - 1 ]; /* Points to first sample of column 0 of X: X[:,0] */\r
     ptr2 = t;\r
@@ -69,17 +69,17 @@ void silk_corrVector_FIX(
 \r
 /* Calculates correlation matrix X'*X */\r
 void silk_corrMatrix_FIX(\r
-    const SKP_int16                 *x,         /* I    x vector [L + order - 1] used to form data matrix X */\r
-    const SKP_int                   L,          /* I    Length of vectors                                   */\r
-    const SKP_int                   order,      /* I    Max lag for correlation                             */\r
-    const SKP_int                   head_room,  /* I    Desired headroom                                    */\r
-    SKP_int32                       *XX,        /* O    Pointer to X'*X correlation matrix [ order x order ]*/\r
-    SKP_int                         *rshifts    /* I/O  Right shifts of correlations                        */\r
+    const opus_int16                 *x,         /* I    x vector [L + order - 1] used to form data matrix X */\r
+    const opus_int                   L,          /* I    Length of vectors                                   */\r
+    const opus_int                   order,      /* I    Max lag for correlation                             */\r
+    const opus_int                   head_room,  /* I    Desired headroom                                    */\r
+    opus_int32                       *XX,        /* O    Pointer to X'*X correlation matrix [ order x order ]*/\r
+    opus_int                         *rshifts    /* I/O  Right shifts of correlations                        */\r
 )\r
 {\r
-    SKP_int         i, j, lag, rshifts_local, head_room_rshifts;\r
-    SKP_int32       energy;\r
-    const SKP_int16 *ptr1, *ptr2;\r
+    opus_int         i, j, lag, rshifts_local, head_room_rshifts;\r
+    opus_int32       energy;\r
+    const opus_int16 *ptr1, *ptr2;\r
 \r
     /* Calculate energy to find shift used to fit in 32 bits */\r
     silk_sum_sqr_shift( &energy, &rshifts_local, x, L + order - 1 );\r
index 06d1d32..ea05aa7 100644 (file)
@@ -31,17 +31,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /****************/\r
 /* Encode frame */\r
 /****************/\r
-SKP_int silk_encode_frame_FIX( \r
+opus_int silk_encode_frame_FIX( \r
     silk_encoder_state_FIX          *psEnc,             /* I/O  Encoder state FIX                       */\r
-    SKP_int32                       *pnBytesOut,        /*   O  Number of payload bytes                 */\r
+    opus_int32                       *pnBytesOut,        /*   O  Number of payload bytes                 */\r
     ec_enc                          *psRangeEnc         /* I/O  compressor data structure               */\r
 )\r
 {\r
     silk_encoder_control_FIX sEncCtrl;\r
-    SKP_int     ret = 0;\r
-    SKP_int16   *x_frame, *res_pitch_frame;\r
-    SKP_int16   xfw[ MAX_FRAME_LENGTH ];\r
-    SKP_int16   res_pitch[ 2 * MAX_FRAME_LENGTH + LA_PITCH_MAX ];\r
+    opus_int     ret = 0;\r
+    opus_int16   *x_frame, *res_pitch_frame;\r
+    opus_int16   xfw[ MAX_FRAME_LENGTH ];\r
+    opus_int16   res_pitch[ 2 * MAX_FRAME_LENGTH + LA_PITCH_MAX ];\r
 \r
 TIC(ENCODE_FRAME)\r
 \r
@@ -92,7 +92,7 @@ TOC(VAD)
     /*******************************************/\r
     /* Copy new frame to front of input buffer */\r
     /*******************************************/\r
-    SKP_memcpy( x_frame + LA_SHAPE_MS * psEnc->sCmn.fs_kHz, psEnc->sCmn.inputBuf - 1, psEnc->sCmn.frame_length * sizeof( SKP_int16 ) );\r
+    SKP_memcpy( x_frame + LA_SHAPE_MS * psEnc->sCmn.fs_kHz, psEnc->sCmn.inputBuf - 1, psEnc->sCmn.frame_length * sizeof( opus_int16 ) );\r
 \r
     /*****************************************/\r
     /* Find pitch lags, initial LPC analysis */\r
@@ -153,7 +153,7 @@ TOC(NSQ)
 \r
     /* Update input buffer */\r
     SKP_memmove( psEnc->x_buf, &psEnc->x_buf[ psEnc->sCmn.frame_length ], \r
-        ( psEnc->sCmn.ltp_mem_length + LA_SHAPE_MS * psEnc->sCmn.fs_kHz ) * sizeof( SKP_int16 ) );\r
+        ( psEnc->sCmn.ltp_mem_length + LA_SHAPE_MS * psEnc->sCmn.fs_kHz ) * sizeof( opus_int16 ) );\r
 \r
     /* Parameters needed for next frame */\r
     psEnc->sCmn.prevLag        = sEncCtrl.pitchL[ psEnc->sCmn.nb_subfr - 1 ];\r
@@ -201,9 +201,9 @@ TOC(ENCODE_FRAME)
     {\r
         SKP_float tmp[ MAX_NB_SUBFR * LTP_ORDER ];\r
         int i;\r
-        DEBUG_STORE_DATA( xf.dat,                   x_frame + LA_SHAPE_MS * psEnc->sCmn.fs_kHz, psEnc->sCmn.frame_length * sizeof( SKP_int16 ) );\r
-        DEBUG_STORE_DATA( xfw.dat,                  xfw,                            psEnc->sCmn.frame_length    * sizeof( SKP_int16 ) );\r
-        DEBUG_STORE_DATA( pitchL.dat,               sEncCtrl.pitchL,                psEnc->sCmn.nb_subfr        * sizeof( SKP_int ) );\r
+        DEBUG_STORE_DATA( xf.dat,                   x_frame + LA_SHAPE_MS * psEnc->sCmn.fs_kHz, psEnc->sCmn.frame_length * sizeof( opus_int16 ) );\r
+        DEBUG_STORE_DATA( xfw.dat,                  xfw,                            psEnc->sCmn.frame_length    * sizeof( opus_int16 ) );\r
+        DEBUG_STORE_DATA( pitchL.dat,               sEncCtrl.pitchL,                psEnc->sCmn.nb_subfr        * sizeof( opus_int ) );\r
         for( i = 0; i < psEnc->sCmn.nb_subfr * LTP_ORDER; i++ ) {\r
             tmp[ i ] = (SKP_float)sEncCtrl.LTPCoef_Q14[ i ] / 16384.0f;\r
         }\r
@@ -223,20 +223,20 @@ TOC(ENCODE_FRAME)
             tmp[ i ] = (SKP_float)sEncCtrl.Gains_Q16[ i ] / 65536.0f;\r
         }\r
         DEBUG_STORE_DATA( gains.dat,                tmp,                            psEnc->sCmn.nb_subfr * sizeof( SKP_float ) );\r
-        DEBUG_STORE_DATA( gains_indices.dat,        &psEnc->sCmn.indices.GainsIndices, psEnc->sCmn.nb_subfr * sizeof( SKP_int ) );\r
+        DEBUG_STORE_DATA( gains_indices.dat,        &psEnc->sCmn.indices.GainsIndices, psEnc->sCmn.nb_subfr * sizeof( opus_int ) );\r
         tmp[ 0 ] = (SKP_float)sEncCtrl.current_SNR_dB_Q7 / 128.0f;\r
         DEBUG_STORE_DATA( current_SNR_db.dat,       tmp,                            sizeof( SKP_float ) );\r
-        DEBUG_STORE_DATA( quantOffsetType.dat,      &psEnc->sCmn.indices.quantOffsetType, sizeof( SKP_int ) );\r
+        DEBUG_STORE_DATA( quantOffsetType.dat,      &psEnc->sCmn.indices.quantOffsetType, sizeof( opus_int ) );\r
         tmp[ 0 ] = (SKP_float)psEnc->sCmn.speech_activity_Q8 / 256.0f;\r
         DEBUG_STORE_DATA( speech_activity.dat,      tmp,                            sizeof( SKP_float ) );\r
         for( i = 0; i < VAD_N_BANDS; i++ ) {\r
             tmp[ i ] = (SKP_float)psEnc->sCmn.input_quality_bands_Q15[ i ] / 32768.0f;\r
         }\r
         DEBUG_STORE_DATA( input_quality_bands.dat,  tmp,                       VAD_N_BANDS * sizeof( SKP_float ) );\r
-        DEBUG_STORE_DATA( signalType.dat,           &psEnc->sCmn.indices.signalType,         sizeof( SKP_int8) ); \r
-        DEBUG_STORE_DATA( lag_index.dat,            &psEnc->sCmn.indices.lagIndex,           sizeof( SKP_int16 ) ); \r
-        DEBUG_STORE_DATA( contour_index.dat,        &psEnc->sCmn.indices.contourIndex,       sizeof( SKP_int8 ) ); \r
-        DEBUG_STORE_DATA( per_index.dat,            &psEnc->sCmn.indices.PERIndex,           sizeof( SKP_int8) ); \r
+        DEBUG_STORE_DATA( signalType.dat,           &psEnc->sCmn.indices.signalType,         sizeof( opus_int8) ); \r
+        DEBUG_STORE_DATA( lag_index.dat,            &psEnc->sCmn.indices.lagIndex,           sizeof( opus_int16 ) ); \r
+        DEBUG_STORE_DATA( contour_index.dat,        &psEnc->sCmn.indices.contourIndex,       sizeof( opus_int8 ) ); \r
+        DEBUG_STORE_DATA( per_index.dat,            &psEnc->sCmn.indices.PERIndex,           sizeof( opus_int8) ); \r
     }\r
 #endif\r
     return ret;\r
@@ -246,10 +246,10 @@ TOC(ENCODE_FRAME)
 void silk_LBRR_encode_FIX(\r
     silk_encoder_state_FIX          *psEnc,         /* I/O  Pointer to Silk FIX encoder state           */\r
     silk_encoder_control_FIX        *psEncCtrl,     /* I/O  Pointer to Silk FIX encoder control struct  */\r
-    const SKP_int16                 xfw[]           /* I    Input signal                                */\r
+    const opus_int16                 xfw[]           /* I    Input signal                                */\r
 )\r
 {\r
-    SKP_int32   TempGains_Q16[ MAX_NB_SUBFR ];\r
+    opus_int32   TempGains_Q16[ MAX_NB_SUBFR ];\r
     SideInfoIndices *psIndices_LBRR = &psEnc->sCmn.indices_LBRR[ psEnc->sCmn.nFramesEncoded ];\r
     silk_nsq_state sNSQ_LBRR;\r
 \r
@@ -264,7 +264,7 @@ void silk_LBRR_encode_FIX(
         SKP_memcpy( psIndices_LBRR, &psEnc->sCmn.indices, sizeof( SideInfoIndices ) );\r
 \r
         /* Save original gains */\r
-        SKP_memcpy( TempGains_Q16, psEncCtrl->Gains_Q16, psEnc->sCmn.nb_subfr * sizeof( SKP_int32 ) );\r
+        SKP_memcpy( TempGains_Q16, psEncCtrl->Gains_Q16, psEnc->sCmn.nb_subfr * sizeof( opus_int32 ) );\r
 \r
         if( psEnc->sCmn.nFramesEncoded == 0 || psEnc->sCmn.LBRR_flags[ psEnc->sCmn.nFramesEncoded - 1 ] == 0 ) {\r
             /* First frame in packet or previous frame not LBRR coded */\r
@@ -296,6 +296,6 @@ void silk_LBRR_encode_FIX(
         }\r
 \r
         /* Restore original gains */\r
-        SKP_memcpy( psEncCtrl->Gains_Q16, TempGains_Q16, psEnc->sCmn.nb_subfr * sizeof( SKP_int32 ) );\r
+        SKP_memcpy( psEncCtrl->Gains_Q16, TempGains_Q16, psEnc->sCmn.nb_subfr * sizeof( opus_int32 ) );\r
     }\r
 }\r
index 97bf1c9..f1a0434 100644 (file)
@@ -30,29 +30,29 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 \r
 /* Finds LPC vector from correlations, and converts to NLSF */\r
 void silk_find_LPC_FIX(\r
-    SKP_int16                       NLSF_Q15[],             /* O    NLSFs                                                           */\r
-    SKP_int8                        *interpIndex,           /* O    NLSF interpolation index, only used for NLSF interpolation      */\r
-    const SKP_int16                 prev_NLSFq_Q15[],       /* I    previous NLSFs, only used for NLSF interpolation                */\r
-    const SKP_int                   useInterpNLSFs,         /* I    Flag                                                            */\r
-    const SKP_int                   firstFrameAfterReset,   /* I    Flag                                                            */\r
-    const SKP_int                   LPC_order,              /* I    LPC order                                                       */\r
-    const SKP_int16                 x[],                    /* I    Input signal                                                    */\r
-    const SKP_int                   subfr_length,           /* I    Input signal subframe length including preceeding samples       */\r
-    const SKP_int                   nb_subfr                /* I:   Number of subframes                                             */\r
+    opus_int16                       NLSF_Q15[],             /* O    NLSFs                                                           */\r
+    opus_int8                        *interpIndex,           /* O    NLSF interpolation index, only used for NLSF interpolation      */\r
+    const opus_int16                 prev_NLSFq_Q15[],       /* I    previous NLSFs, only used for NLSF interpolation                */\r
+    const opus_int                   useInterpNLSFs,         /* I    Flag                                                            */\r
+    const opus_int                   firstFrameAfterReset,   /* I    Flag                                                            */\r
+    const opus_int                   LPC_order,              /* I    LPC order                                                       */\r
+    const opus_int16                 x[],                    /* I    Input signal                                                    */\r
+    const opus_int                   subfr_length,           /* I    Input signal subframe length including preceeding samples       */\r
+    const opus_int                   nb_subfr                /* I:   Number of subframes                                             */\r
 )\r
 {\r
-    SKP_int     k;\r
-    SKP_int32   a_Q16[ MAX_LPC_ORDER ];\r
-    SKP_int     isInterpLower, shift;\r
-    SKP_int32   res_nrg0, res_nrg1;\r
-    SKP_int     rshift0, rshift1; \r
+    opus_int     k;\r
+    opus_int32   a_Q16[ MAX_LPC_ORDER ];\r
+    opus_int     isInterpLower, shift;\r
+    opus_int32   res_nrg0, res_nrg1;\r
+    opus_int     rshift0, rshift1; \r
 \r
     /* Used only for LSF interpolation */\r
-    SKP_int32   a_tmp_Q16[ MAX_LPC_ORDER ], res_nrg_interp, res_nrg, res_tmp_nrg, res_nrg_2nd;\r
-    SKP_int     res_nrg_interp_Q, res_nrg_Q, res_tmp_nrg_Q, res_nrg_2nd_Q;\r
-    SKP_int16   a_tmp_Q12[ MAX_LPC_ORDER ];\r
-    SKP_int16   NLSF0_Q15[ MAX_LPC_ORDER ];\r
-    SKP_int16   LPC_res[ ( MAX_FRAME_LENGTH + MAX_NB_SUBFR * MAX_LPC_ORDER ) / 2 ];\r
+    opus_int32   a_tmp_Q16[ MAX_LPC_ORDER ], res_nrg_interp, res_nrg, res_tmp_nrg, res_nrg_2nd;\r
+    opus_int     res_nrg_interp_Q, res_nrg_Q, res_tmp_nrg_Q, res_nrg_2nd_Q;\r
+    opus_int16   a_tmp_Q12[ MAX_LPC_ORDER ];\r
+    opus_int16   NLSF0_Q15[ MAX_LPC_ORDER ];\r
+    opus_int16   LPC_res[ ( MAX_FRAME_LENGTH + MAX_NB_SUBFR * MAX_LPC_ORDER ) / 2 ];\r
 \r
     /* Default: no interpolation */\r
     *interpIndex = 4;\r
@@ -141,7 +141,7 @@ void silk_find_LPC_FIX(
                 /* Interpolation has lower residual energy */\r
                 res_nrg   = res_nrg_interp;\r
                 res_nrg_Q = res_nrg_interp_Q;\r
-                *interpIndex = (SKP_int8)k;\r
+                *interpIndex = (opus_int8)k;\r
             }\r
             res_nrg_2nd   = res_nrg_interp;\r
             res_nrg_2nd_Q = res_nrg_interp_Q;\r
index 21b28d3..e88dda4 100644 (file)
@@ -32,38 +32,38 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define LTP_CORRS_HEAD_ROOM                             2\r
 \r
 void silk_fit_LTP(\r
-    SKP_int32 LTP_coefs_Q16[ LTP_ORDER ],\r
-    SKP_int16 LTP_coefs_Q14[ LTP_ORDER ]\r
+    opus_int32 LTP_coefs_Q16[ LTP_ORDER ],\r
+    opus_int16 LTP_coefs_Q14[ LTP_ORDER ]\r
 );\r
 \r
 void silk_find_LTP_FIX(\r
-    SKP_int16           b_Q14[ MAX_NB_SUBFR * LTP_ORDER ],              /* O    LTP coefs                                                   */\r
-    SKP_int32           WLTP[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ],   /* O    Weight for LTP quantization                                 */\r
-    SKP_int             *LTPredCodGain_Q7,                              /* O    LTP coding gain                                             */\r
-    const SKP_int16     r_lpc[]  ,                                      /* I    residual signal after LPC signal + state for first 10 ms    */\r
-    const SKP_int       lag[ MAX_NB_SUBFR ],                            /* I    LTP lags                                                    */\r
-    const SKP_int32     Wght_Q15[ MAX_NB_SUBFR ],                       /* I    weights                                                     */\r
-    const SKP_int       subfr_length,                                   /* I    subframe length                                             */\r
-    const SKP_int       nb_subfr,                                       /* I    number of subframes                                         */\r
-    const SKP_int       mem_offset,                                     /* I    number of samples in LTP memory                             */\r
-    SKP_int             corr_rshifts[ MAX_NB_SUBFR ]                    /* O    right shifts applied to correlations                        */\r
+    opus_int16           b_Q14[ MAX_NB_SUBFR * LTP_ORDER ],              /* O    LTP coefs                                                   */\r
+    opus_int32           WLTP[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ],   /* O    Weight for LTP quantization                                 */\r
+    opus_int             *LTPredCodGain_Q7,                              /* O    LTP coding gain                                             */\r
+    const opus_int16     r_lpc[]  ,                                      /* I    residual signal after LPC signal + state for first 10 ms    */\r
+    const opus_int       lag[ MAX_NB_SUBFR ],                            /* I    LTP lags                                                    */\r
+    const opus_int32     Wght_Q15[ MAX_NB_SUBFR ],                       /* I    weights                                                     */\r
+    const opus_int       subfr_length,                                   /* I    subframe length                                             */\r
+    const opus_int       nb_subfr,                                       /* I    number of subframes                                         */\r
+    const opus_int       mem_offset,                                     /* I    number of samples in LTP memory                             */\r
+    opus_int             corr_rshifts[ MAX_NB_SUBFR ]                    /* O    right shifts applied to correlations                        */\r
 )\r
 {\r
-    SKP_int   i, k, lshift;\r
-    const SKP_int16 *r_ptr, *lag_ptr;\r
-    SKP_int16 *b_Q14_ptr;\r
-\r
-    SKP_int32 regu;\r
-    SKP_int32 *WLTP_ptr;\r
-    SKP_int32 b_Q16[ LTP_ORDER ], delta_b_Q14[ LTP_ORDER ], d_Q14[ MAX_NB_SUBFR ], nrg[ MAX_NB_SUBFR ], g_Q26;\r
-    SKP_int32 w[ MAX_NB_SUBFR ], WLTP_max, max_abs_d_Q14, max_w_bits;\r
-\r
-    SKP_int32 temp32, denom32;\r
-    SKP_int   extra_shifts;\r
-    SKP_int   rr_shifts, maxRshifts, maxRshifts_wxtra, LZs;\r
-    SKP_int32 LPC_res_nrg, LPC_LTP_res_nrg, div_Q16;\r
-    SKP_int32 Rr[ LTP_ORDER ], rr[ MAX_NB_SUBFR ];\r
-    SKP_int32 wd, m_Q12;\r
+    opus_int   i, k, lshift;\r
+    const opus_int16 *r_ptr, *lag_ptr;\r
+    opus_int16 *b_Q14_ptr;\r
+\r
+    opus_int32 regu;\r
+    opus_int32 *WLTP_ptr;\r
+    opus_int32 b_Q16[ LTP_ORDER ], delta_b_Q14[ LTP_ORDER ], d_Q14[ MAX_NB_SUBFR ], nrg[ MAX_NB_SUBFR ], g_Q26;\r
+    opus_int32 w[ MAX_NB_SUBFR ], WLTP_max, max_abs_d_Q14, max_w_bits;\r
+\r
+    opus_int32 temp32, denom32;\r
+    opus_int   extra_shifts;\r
+    opus_int   rr_shifts, maxRshifts, maxRshifts_wxtra, LZs;\r
+    opus_int32 LPC_res_nrg, LPC_LTP_res_nrg, div_Q16;\r
+    opus_int32 Rr[ LTP_ORDER ], rr[ MAX_NB_SUBFR ];\r
+    opus_int32 wd, m_Q12;\r
     \r
     b_Q14_ptr = b_Q14;\r
     WLTP_ptr  = WLTP;\r
@@ -108,8 +108,8 @@ void silk_find_LTP_FIX(
         denom32 = SKP_LSHIFT_SAT32( SKP_SMULWB( nrg[ k ], Wght_Q15[ k ] ), 1 + extra_shifts ) + /* Q( -corr_rshifts[ k ] + extra_shifts ) */\r
             SKP_RSHIFT( SKP_SMULWB( subfr_length, 655 ), corr_rshifts[ k ] - extra_shifts );    /* Q( -corr_rshifts[ k ] + extra_shifts ) */\r
         denom32 = SKP_max( denom32, 1 );\r
-        SKP_assert( ((SKP_int64)Wght_Q15[ k ] << 16 ) < SKP_int32_MAX );                        /* Wght always < 0.5 in Q0 */\r
-        temp32 = SKP_DIV32( SKP_LSHIFT( ( SKP_int32 )Wght_Q15[ k ], 16 ), denom32 );            /* Q( 15 + 16 + corr_rshifts[k] - extra_shifts ) */\r
+        SKP_assert( ((opus_int64)Wght_Q15[ k ] << 16 ) < SKP_int32_MAX );                        /* Wght always < 0.5 in Q0 */\r
+        temp32 = SKP_DIV32( SKP_LSHIFT( ( opus_int32 )Wght_Q15[ k ], 16 ), denom32 );            /* Q( 15 + 16 + corr_rshifts[k] - extra_shifts ) */\r
         temp32 = SKP_RSHIFT( temp32, 31 + corr_rshifts[ k ] - extra_shifts - 26 );              /* Q26 */\r
         \r
         /* Limit temp such that the below scaling never wraps around */\r
@@ -120,7 +120,7 @@ void silk_find_LTP_FIX(
         lshift = silk_CLZ32( WLTP_max ) - 1 - 3; /* keep 3 bits free for vq_nearest_neighbor_fix */\r
         SKP_assert( 26 - 18 + lshift >= 0 );\r
         if( 26 - 18 + lshift < 31 ) {\r
-            temp32 = SKP_min_32( temp32, SKP_LSHIFT( ( SKP_int32 )1, 26 - 18 + lshift ) );\r
+            temp32 = SKP_min_32( temp32, SKP_LSHIFT( ( opus_int32 )1, 26 - 18 + lshift ) );\r
         }\r
 \r
         silk_scale_vector32_Q26_lshift_18( WLTP_ptr, temp32, LTP_ORDER * LTP_ORDER ); /* WLTP_ptr in Q( 18 - corr_rshifts[ k ] ) */\r
@@ -150,9 +150,9 @@ void silk_find_LTP_FIX(
         LPC_LTP_res_nrg = SKP_max( LPC_LTP_res_nrg, 1 ); /* avoid division by zero */\r
 \r
         div_Q16 = silk_DIV32_varQ( LPC_res_nrg, LPC_LTP_res_nrg, 16 );\r
-        *LTPredCodGain_Q7 = ( SKP_int )SKP_SMULBB( 3, silk_lin2log( div_Q16 ) - ( 16 << 7 ) );\r
+        *LTPredCodGain_Q7 = ( opus_int )SKP_SMULBB( 3, silk_lin2log( div_Q16 ) - ( 16 << 7 ) );\r
 \r
-        SKP_assert( *LTPredCodGain_Q7 == ( SKP_int )SKP_SAT16( SKP_MUL( 3, silk_lin2log( div_Q16 ) - ( 16 << 7 ) ) ) );\r
+        SKP_assert( *LTPredCodGain_Q7 == ( opus_int )SKP_SAT16( SKP_MUL( 3, silk_lin2log( div_Q16 ) - ( 16 << 7 ) ) ) );\r
     }\r
 \r
     /* smoothing */\r
@@ -212,7 +212,7 @@ void silk_find_LTP_FIX(
             SKP_DIV32( \r
                 SILK_FIX_CONST( LTP_SMOOTHING, 26 ), \r
                 SKP_RSHIFT( SILK_FIX_CONST( LTP_SMOOTHING, 26 ), 10 ) + temp32 ),                                       /* Q10 */ \r
-            SKP_LSHIFT_SAT32( SKP_SUB_SAT32( ( SKP_int32 )m_Q12, SKP_RSHIFT( d_Q14[ k ], 2 ) ), 4 ) );  /* Q16 */\r
+            SKP_LSHIFT_SAT32( SKP_SUB_SAT32( ( opus_int32 )m_Q12, SKP_RSHIFT( d_Q14[ k ], 2 ) ), 4 ) );  /* Q16 */\r
 \r
         temp32 = 0;\r
         for( i = 0; i < LTP_ORDER; i++ ) {\r
@@ -221,7 +221,7 @@ void silk_find_LTP_FIX(
         }\r
         temp32 = SKP_DIV32( g_Q26, temp32 ); /* Q14->Q12 */\r
         for( i = 0; i < LTP_ORDER; i++ ) {\r
-            b_Q14_ptr[ i ] = SKP_LIMIT_32( ( SKP_int32 )b_Q14_ptr[ i ] + SKP_SMULWB( SKP_LSHIFT_SAT32( temp32, 4 ), delta_b_Q14[ i ] ), -16000, 28000 );\r
+            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 );\r
         }\r
         b_Q14_ptr += LTP_ORDER;\r
     }\r
@@ -229,13 +229,13 @@ TOC(find_LTP_FIX)
 }\r
 \r
 void silk_fit_LTP(\r
-    SKP_int32 LTP_coefs_Q16[ LTP_ORDER ],\r
-    SKP_int16 LTP_coefs_Q14[ LTP_ORDER ]\r
+    opus_int32 LTP_coefs_Q16[ LTP_ORDER ],\r
+    opus_int16 LTP_coefs_Q14[ LTP_ORDER ]\r
 )\r
 {\r
-    SKP_int i;\r
+    opus_int i;\r
 \r
     for( i = 0; i < LTP_ORDER; i++ ) {\r
-        LTP_coefs_Q14[ i ] = ( SKP_int16 )SKP_SAT16( SKP_RSHIFT_ROUND( LTP_coefs_Q16[ i ], 2 ) );\r
+        LTP_coefs_Q14[ i ] = ( opus_int16 )SKP_SAT16( SKP_RSHIFT_ROUND( LTP_coefs_Q16[ i ], 2 ) );\r
     }\r
 }\r
index d6c4ee8..866f1d7 100644 (file)
@@ -32,18 +32,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 void silk_find_pitch_lags_FIX(\r
     silk_encoder_state_FIX          *psEnc,         /* I/O  encoder state                               */\r
     silk_encoder_control_FIX        *psEncCtrl,     /* I/O  encoder control                             */\r
-    SKP_int16                       res[],          /* O    residual                                    */\r
-    const SKP_int16                 x[]             /* I    Speech signal                               */\r
+    opus_int16                       res[],          /* O    residual                                    */\r
+    const opus_int16                 x[]             /* I    Speech signal                               */\r
 )\r
 {\r
-    SKP_int   buf_len, i, scale;\r
-    SKP_int32 thrhld_Q15, res_nrg;\r
-    const SKP_int16 *x_buf, *x_buf_ptr;\r
-    SKP_int16 Wsig[      FIND_PITCH_LPC_WIN_MAX ], *Wsig_ptr;\r
-    SKP_int32 auto_corr[ MAX_FIND_PITCH_LPC_ORDER + 1 ];\r
-    SKP_int16 rc_Q15[    MAX_FIND_PITCH_LPC_ORDER ];\r
-    SKP_int32 A_Q24[     MAX_FIND_PITCH_LPC_ORDER ];\r
-    SKP_int16 A_Q12[     MAX_FIND_PITCH_LPC_ORDER ];\r
+    opus_int   buf_len, i, scale;\r
+    opus_int32 thrhld_Q15, res_nrg;\r
+    const opus_int16 *x_buf, *x_buf_ptr;\r
+    opus_int16 Wsig[      FIND_PITCH_LPC_WIN_MAX ], *Wsig_ptr;\r
+    opus_int32 auto_corr[ MAX_FIND_PITCH_LPC_ORDER + 1 ];\r
+    opus_int16 rc_Q15[    MAX_FIND_PITCH_LPC_ORDER ];\r
+    opus_int32 A_Q24[     MAX_FIND_PITCH_LPC_ORDER ];\r
+    opus_int16 A_Q12[     MAX_FIND_PITCH_LPC_ORDER ];\r
 \r
     /******************************************/\r
     /* Setup buffer lengths etc based on Fs   */\r
@@ -69,7 +69,7 @@ void silk_find_pitch_lags_FIX(
     /* Middle un - windowed samples */\r
     Wsig_ptr  += psEnc->sCmn.la_pitch;\r
     x_buf_ptr += psEnc->sCmn.la_pitch;\r
-    SKP_memcpy( Wsig_ptr, x_buf_ptr, ( psEnc->sCmn.pitch_LPC_win_length - SKP_LSHIFT( psEnc->sCmn.la_pitch, 1 ) ) * sizeof( SKP_int16 ) );\r
+    SKP_memcpy( Wsig_ptr, x_buf_ptr, ( psEnc->sCmn.pitch_LPC_win_length - SKP_LSHIFT( psEnc->sCmn.la_pitch, 1 ) ) * sizeof( opus_int16 ) );\r
 \r
     /* Last LA_LTP samples */\r
     Wsig_ptr  += psEnc->sCmn.pitch_LPC_win_length - SKP_LSHIFT( psEnc->sCmn.la_pitch, 1 );\r
@@ -93,7 +93,7 @@ void silk_find_pitch_lags_FIX(
     \r
     /* Convert From 32 bit Q24 to 16 bit Q12 coefs */\r
     for( i = 0; i < psEnc->sCmn.pitchEstimationLPCOrder; i++ ) {\r
-        A_Q12[ i ] = ( SKP_int16 )SKP_SAT16( SKP_RSHIFT( A_Q24[ i ], 12 ) );\r
+        A_Q12[ i ] = ( opus_int16 )SKP_SAT16( SKP_RSHIFT( A_Q24[ i ], 12 ) );\r
     }\r
 \r
     /* Do BWE */\r
@@ -118,7 +118,7 @@ void silk_find_pitch_lags_FIX(
         /*****************************************/\r
         if( silk_pitch_analysis_core( res, psEncCtrl->pitchL, &psEnc->sCmn.indices.lagIndex, &psEnc->sCmn.indices.contourIndex, \r
                 &psEnc->LTPCorr_Q15, psEnc->sCmn.prevLag, psEnc->sCmn.pitchEstimationThreshold_Q16, \r
-                ( SKP_int16 )thrhld_Q15, psEnc->sCmn.fs_kHz, psEnc->sCmn.pitchEstimationComplexity, psEnc->sCmn.nb_subfr ) == 0 ) \r
+                ( opus_int16 )thrhld_Q15, psEnc->sCmn.fs_kHz, psEnc->sCmn.pitchEstimationComplexity, psEnc->sCmn.nb_subfr ) == 0 ) \r
         {\r
             psEnc->sCmn.indices.signalType = TYPE_VOICED;\r
         } else {\r
index 21885b4..ae95372 100644 (file)
@@ -30,18 +30,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 void silk_find_pred_coefs_FIX(\r
     silk_encoder_state_FIX          *psEnc,         /* I/O  encoder state                               */\r
     silk_encoder_control_FIX        *psEncCtrl,     /* I/O  encoder control                             */\r
-    const SKP_int16                 res_pitch[],    /* I    Residual from pitch analysis                */\r
-    const SKP_int16                 x[]             /* I    Speech signal                               */\r
+    const opus_int16                 res_pitch[],    /* I    Residual from pitch analysis                */\r
+    const opus_int16                 x[]             /* I    Speech signal                               */\r
 )\r
 {\r
-    SKP_int         i;\r
-    SKP_int32       WLTP[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ];\r
-    SKP_int32       invGains_Q16[ MAX_NB_SUBFR ], local_gains[ MAX_NB_SUBFR ], Wght_Q15[ MAX_NB_SUBFR ];\r
-    SKP_int16       NLSF_Q15[ MAX_LPC_ORDER ];\r
-    const SKP_int16 *x_ptr;\r
-    SKP_int16       *x_pre_ptr, LPC_in_pre[ MAX_NB_SUBFR * MAX_LPC_ORDER + MAX_FRAME_LENGTH ];\r
-    SKP_int32       tmp, min_gain_Q16;\r
-    SKP_int         LTP_corrs_rshift[ MAX_NB_SUBFR ];\r
+    opus_int         i;\r
+    opus_int32       WLTP[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ];\r
+    opus_int32       invGains_Q16[ MAX_NB_SUBFR ], local_gains[ MAX_NB_SUBFR ], Wght_Q15[ MAX_NB_SUBFR ];\r
+    opus_int16       NLSF_Q15[ MAX_LPC_ORDER ];\r
+    const opus_int16 *x_ptr;\r
+    opus_int16       *x_pre_ptr, LPC_in_pre[ MAX_NB_SUBFR * MAX_LPC_ORDER + MAX_FRAME_LENGTH ];\r
+    opus_int32       tmp, min_gain_Q16;\r
+    opus_int         LTP_corrs_rshift[ MAX_NB_SUBFR ];\r
 \r
     /* weighting for weighted least squares */\r
     min_gain_Q16 = SKP_int32_MAX >> 6;\r
@@ -102,7 +102,7 @@ void silk_find_pred_coefs_FIX(
             x_ptr     += psEnc->sCmn.subfr_length;\r
         }\r
 \r
-        SKP_memset( psEncCtrl->LTPCoef_Q14, 0, psEnc->sCmn.nb_subfr * LTP_ORDER * sizeof( SKP_int16 ) );\r
+        SKP_memset( psEncCtrl->LTPCoef_Q14, 0, psEnc->sCmn.nb_subfr * LTP_ORDER * sizeof( opus_int16 ) );\r
         psEncCtrl->LTPredCodGain_Q7 = 0;\r
     }\r
 \r
index cc3be26..fb31ae6 100644 (file)
@@ -53,13 +53,13 @@ extern "C"
 /* High-pass filter with cutoff frequency adaptation based on pitch lag statistics */\r
 void silk_HP_variable_cutoff(\r
     silk_encoder_state_Fxx          state_Fxx[],    /* I/O  Encoder states                              */\r
-    const SKP_int                   nChannels       /* I    Number of channels                          */\r
+    const opus_int                   nChannels       /* I    Number of channels                          */\r
 );\r
 \r
 /* Encoder main function */\r
-SKP_int silk_encode_frame_FIX( \r
+opus_int silk_encode_frame_FIX( \r
     silk_encoder_state_FIX          *psEnc,             /* I/O  Pointer to Silk FIX encoder state       */\r
-    SKP_int32                       *pnBytesOut,        /*   O  Pointer to number of payload bytes;     */\r
+    opus_int32                       *pnBytesOut,        /*   O  Pointer to number of payload bytes;     */\r
     ec_enc                          *psRangeEnc         /* I/O  compressor data structure               */\r
 );\r
 \r
@@ -67,21 +67,21 @@ SKP_int silk_encode_frame_FIX(
 void silk_LBRR_encode_FIX(\r
     silk_encoder_state_FIX          *psEnc,             /* I/O  Pointer to Silk FIX encoder state           */\r
     silk_encoder_control_FIX        *psEncCtrl,         /* I/O  Pointer to Silk FIX encoder control struct  */\r
-    const SKP_int16                 xfw[]               /* I    Input signal                                */\r
+    const opus_int16                 xfw[]               /* I    Input signal                                */\r
 );\r
 \r
 /* Initializes the Silk encoder state */\r
-SKP_int silk_init_encoder(\r
+opus_int silk_init_encoder(\r
     silk_encoder_state_FIX          *psEnc              /* I/O  Pointer to Silk FIX encoder state           */\r
 );\r
 \r
 /* Control the Silk encoder */\r
-SKP_int silk_control_encoder( \r
+opus_int silk_control_encoder( \r
     silk_encoder_state_FIX          *psEnc,             /* I/O  Pointer to Silk encoder state           */\r
     silk_EncControlStruct           *encControl,        /* I:   Control structure                       */\r
-    const SKP_int32                 TargetRate_bps,     /* I    Target max bitrate (bps)                */\r
-    const SKP_int                   allow_bw_switch,    /* I    Flag to allow switching audio bandwidth */\r
-    const SKP_int                   channelNb           /* I    Channel number                          */\r
+    const opus_int32                 TargetRate_bps,     /* I    Target max bitrate (bps)                */\r
+    const opus_int                   allow_bw_switch,    /* I    Flag to allow switching audio bandwidth */\r
+    const opus_int                   channelNb           /* I    Channel number                          */\r
 );\r
 \r
 /****************/\r
@@ -90,8 +90,8 @@ SKP_int silk_control_encoder(
 void silk_prefilter_FIX(\r
     silk_encoder_state_FIX              *psEnc,         /* I/O  Encoder state                               */\r
     const silk_encoder_control_FIX      *psEncCtrl,     /* I    Encoder control                             */\r
-    SKP_int16                           xw[],           /* O    Weighted signal                             */\r
-    const SKP_int16                     x[]             /* I    Speech signal                               */\r
+    opus_int16                           xw[],           /* O    Weighted signal                             */\r
+    const opus_int16                     x[]             /* I    Speech signal                               */\r
 );\r
 \r
 /**************************/\r
@@ -101,18 +101,18 @@ void silk_prefilter_FIX(
 void silk_noise_shape_analysis_FIX(\r
     silk_encoder_state_FIX          *psEnc,         /* I/O  Encoder state FIX                           */\r
     silk_encoder_control_FIX        *psEncCtrl,     /* I/O  Encoder control FIX                         */\r
-    const SKP_int16                 *pitch_res,     /* I    LPC residual from pitch analysis            */\r
-    const SKP_int16                 *x              /* I    Input signal [ frame_length + la_shape ]    */\r
+    const opus_int16                 *pitch_res,     /* I    LPC residual from pitch analysis            */\r
+    const opus_int16                 *x              /* I    Input signal [ frame_length + la_shape ]    */\r
 );\r
 \r
 /* Autocorrelations for a warped frequency axis */\r
 void silk_warped_autocorrelation_FIX(\r
-          SKP_int32                 *corr,              /* O    Result [order + 1]                      */\r
-          SKP_int                   *scale,             /* O    Scaling of the correlation vector       */\r
-    const SKP_int16                 *input,             /* I    Input data to correlate                 */\r
-    const SKP_int                   warping_Q16,        /* I    Warping coefficient                     */\r
-    const SKP_int                   length,             /* I    Length of input                         */\r
-    const SKP_int                   order               /* I    Correlation order (even)                */\r
+          opus_int32                 *corr,              /* O    Result [order + 1]                      */\r
+          opus_int                   *scale,             /* O    Scaling of the correlation vector       */\r
+    const opus_int16                 *input,             /* I    Input data to correlate                 */\r
+    const opus_int                   warping_Q16,        /* I    Warping coefficient                     */\r
+    const opus_int                   length,             /* I    Length of input                         */\r
+    const opus_int                   order               /* I    Correlation order (even)                */\r
 );\r
 \r
 /* Calculation of LTP state scaling */\r
@@ -128,77 +128,77 @@ void silk_LTP_scale_ctrl_FIX(
 void silk_find_pitch_lags_FIX(\r
     silk_encoder_state_FIX          *psEnc,         /* I/O  encoder state                               */\r
     silk_encoder_control_FIX        *psEncCtrl,     /* I/O  encoder control                             */\r
-    SKP_int16                       res[],          /* O    residual                                    */\r
-    const SKP_int16                 x[]             /* I    Speech signal                               */\r
+    opus_int16                       res[],          /* O    residual                                    */\r
+    const opus_int16                 x[]             /* I    Speech signal                               */\r
 );\r
 \r
 /* Find LPC and LTP coefficients */\r
 void silk_find_pred_coefs_FIX(\r
     silk_encoder_state_FIX          *psEnc,         /* I/O  encoder state                               */\r
     silk_encoder_control_FIX        *psEncCtrl,     /* I/O  encoder control                             */\r
-    const SKP_int16                 res_pitch[],    /* I    Residual from pitch analysis                */\r
-    const SKP_int16                 x[]             /* I    Speech signal                               */\r
+    const opus_int16                 res_pitch[],    /* I    Residual from pitch analysis                */\r
+    const opus_int16                 x[]             /* I    Speech signal                               */\r
 );\r
 \r
 /* LPC analysis */\r
 void silk_find_LPC_FIX(\r
-    SKP_int16                       NLSF_Q15[],             /* O    NLSFs                                                           */\r
-    SKP_int8                        *interpIndex,           /* O    NLSF interpolation index, only used for NLSF interpolation      */\r
-    const SKP_int16                 prev_NLSFq_Q15[],       /* I    previous NLSFs, only used for NLSF interpolation                */\r
-    const SKP_int                   useInterpNLSFs,         /* I    Flag                                                            */\r
-    const SKP_int                   firstFrameAfterReset,   /* I    Flag                                                            */\r
-    const SKP_int                   LPC_order,              /* I    LPC order                                                       */\r
-    const SKP_int16                 x[],                    /* I    Input signal                                                    */\r
-    const SKP_int                   subfr_length,           /* I    Input signal subframe length including preceeding samples       */\r
-    const SKP_int                   nb_subfr                /* I:   Number of subframes                                             */\r
+    opus_int16                       NLSF_Q15[],             /* O    NLSFs                                                           */\r
+    opus_int8                        *interpIndex,           /* O    NLSF interpolation index, only used for NLSF interpolation      */\r
+    const opus_int16                 prev_NLSFq_Q15[],       /* I    previous NLSFs, only used for NLSF interpolation                */\r
+    const opus_int                   useInterpNLSFs,         /* I    Flag                                                            */\r
+    const opus_int                   firstFrameAfterReset,   /* I    Flag                                                            */\r
+    const opus_int                   LPC_order,              /* I    LPC order                                                       */\r
+    const opus_int16                 x[],                    /* I    Input signal                                                    */\r
+    const opus_int                   subfr_length,           /* I    Input signal subframe length including preceeding samples       */\r
+    const opus_int                   nb_subfr                /* I:   Number of subframes                                             */\r
 );\r
 \r
 /* LTP analysis */\r
 void silk_find_LTP_FIX(\r
-    SKP_int16           b_Q14[ MAX_NB_SUBFR * LTP_ORDER ],              /* O    LTP coefs                                                   */\r
-    SKP_int32           WLTP[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ],   /* O    Weight for LTP quantization                                 */\r
-    SKP_int             *LTPredCodGain_Q7,                              /* O    LTP coding gain                                             */\r
-    const SKP_int16     r_lpc[],                                        /* I    residual signal after LPC signal + state for first 10 ms    */\r
-    const SKP_int       lag[ MAX_NB_SUBFR ],                            /* I    LTP lags                                                    */\r
-    const SKP_int32     Wght_Q15[ MAX_NB_SUBFR ],                       /* I    weights                                                     */\r
-    const SKP_int       subfr_length,                                   /* I    subframe length                                             */\r
-    const SKP_int       nb_subfr,                                       /* I    number of subframes                                         */\r
-    const SKP_int       mem_offset,                                     /* I    number of samples in LTP memory                             */\r
-    SKP_int             corr_rshifts[ MAX_NB_SUBFR ]                    /* O    right shifts applied to correlations                        */\r
+    opus_int16           b_Q14[ MAX_NB_SUBFR * LTP_ORDER ],              /* O    LTP coefs                                                   */\r
+    opus_int32           WLTP[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ],   /* O    Weight for LTP quantization                                 */\r
+    opus_int             *LTPredCodGain_Q7,                              /* O    LTP coding gain                                             */\r
+    const opus_int16     r_lpc[],                                        /* I    residual signal after LPC signal + state for first 10 ms    */\r
+    const opus_int       lag[ MAX_NB_SUBFR ],                            /* I    LTP lags                                                    */\r
+    const opus_int32     Wght_Q15[ MAX_NB_SUBFR ],                       /* I    weights                                                     */\r
+    const opus_int       subfr_length,                                   /* I    subframe length                                             */\r
+    const opus_int       nb_subfr,                                       /* I    number of subframes                                         */\r
+    const opus_int       mem_offset,                                     /* I    number of samples in LTP memory                             */\r
+    opus_int             corr_rshifts[ MAX_NB_SUBFR ]                    /* O    right shifts applied to correlations                        */\r
 );\r
 \r
 void silk_LTP_analysis_filter_FIX(\r
-    SKP_int16           *LTP_res,                               /* O:   LTP residual signal of length MAX_NB_SUBFR * ( pre_length + subfr_length )  */\r
-    const SKP_int16     *x,                                     /* I:   Pointer to input signal with at least max( pitchL ) preceeding samples      */\r
-    const SKP_int16     LTPCoef_Q14[ LTP_ORDER * MAX_NB_SUBFR ],/* I:   LTP_ORDER LTP coefficients for each MAX_NB_SUBFR subframe                   */\r
-    const SKP_int       pitchL[ MAX_NB_SUBFR ],                 /* I:   Pitch lag, one for each subframe                                            */\r
-    const SKP_int32     invGains_Q16[ MAX_NB_SUBFR ],           /* I:   Inverse quantization gains, one for each subframe                           */\r
-    const SKP_int       subfr_length,                           /* I:   Length of each subframe                                                     */\r
-    const SKP_int       nb_subfr,                               /* I:   Number of subframes                                                         */\r
-    const SKP_int       pre_length                              /* I:   Length of the preceeding samples starting at &x[0] for each subframe        */\r
+    opus_int16           *LTP_res,                               /* O:   LTP residual signal of length MAX_NB_SUBFR * ( pre_length + subfr_length )  */\r
+    const opus_int16     *x,                                     /* I:   Pointer to input signal with at least max( pitchL ) preceeding samples      */\r
+    const opus_int16     LTPCoef_Q14[ LTP_ORDER * MAX_NB_SUBFR ],/* I:   LTP_ORDER LTP coefficients for each MAX_NB_SUBFR subframe                   */\r
+    const opus_int       pitchL[ MAX_NB_SUBFR ],                 /* I:   Pitch lag, one for each subframe                                            */\r
+    const opus_int32     invGains_Q16[ MAX_NB_SUBFR ],           /* I:   Inverse quantization gains, one for each subframe                           */\r
+    const opus_int       subfr_length,                           /* I:   Length of each subframe                                                     */\r
+    const opus_int       nb_subfr,                               /* I:   Number of subframes                                                         */\r
+    const opus_int       pre_length                              /* I:   Length of the preceeding samples starting at &x[0] for each subframe        */\r
 );\r
 \r
 /* Calculates residual energies of input subframes where all subframes have LPC_order   */\r
 /* of preceeding samples                                                                */\r
 void silk_residual_energy_FIX(\r
-          SKP_int32 nrgs[ MAX_NB_SUBFR ],           /* O    Residual energy per subframe    */\r
-          SKP_int   nrgsQ[ MAX_NB_SUBFR ],          /* O    Q value per subframe            */\r
-    const SKP_int16 x[],                            /* I    Input signal                    */\r
-          SKP_int16 a_Q12[ 2 ][ MAX_LPC_ORDER ],    /* I    AR coefs for each frame half    */\r
-    const SKP_int32 gains[ MAX_NB_SUBFR ],          /* I    Quantization gains              */\r
-    const SKP_int   subfr_length,                   /* I    Subframe length                 */\r
-    const SKP_int   nb_subfr,                       /* I    Number of subframes             */\r
-    const SKP_int   LPC_order                       /* I    LPC order                       */\r
+          opus_int32 nrgs[ MAX_NB_SUBFR ],           /* O    Residual energy per subframe    */\r
+          opus_int   nrgsQ[ MAX_NB_SUBFR ],          /* O    Q value per subframe            */\r
+    const opus_int16 x[],                            /* I    Input signal                    */\r
+          opus_int16 a_Q12[ 2 ][ MAX_LPC_ORDER ],    /* I    AR coefs for each frame half    */\r
+    const opus_int32 gains[ MAX_NB_SUBFR ],          /* I    Quantization gains              */\r
+    const opus_int   subfr_length,                   /* I    Subframe length                 */\r
+    const opus_int   nb_subfr,                       /* I    Number of subframes             */\r
+    const opus_int   LPC_order                       /* I    LPC order                       */\r
 );\r
 \r
 /* Residual energy: nrg = wxx - 2 * wXx * c + c' * wXX * c */\r
-SKP_int32 silk_residual_energy16_covar_FIX(\r
-    const SKP_int16                 *c,                 /* I    Prediction vector                           */\r
-    const SKP_int32                 *wXX,               /* I    Correlation matrix                          */\r
-    const SKP_int32                 *wXx,               /* I    Correlation vector                          */\r
-    SKP_int32                       wxx,                /* I    Signal energy                               */\r
-    SKP_int                         D,                  /* I    Dimension                                   */\r
-    SKP_int                         cQ                  /* I    Q value for c vector 0 - 15                 */\r
+opus_int32 silk_residual_energy16_covar_FIX(\r
+    const opus_int16                 *c,                 /* I    Prediction vector                           */\r
+    const opus_int32                 *wXX,               /* I    Correlation matrix                          */\r
+    const opus_int32                 *wXx,               /* I    Correlation vector                          */\r
+    opus_int32                       wxx,                /* I    Signal energy                               */\r
+    opus_int                         D,                  /* I    Dimension                                   */\r
+    opus_int                         cQ                  /* I    Q value for c vector 0 - 15                 */\r
 );\r
 \r
 /* Processing of gains */\r
@@ -212,38 +212,38 @@ void silk_process_gains_FIX(
 /******************/\r
 /* Calculates correlation matrix X'*X */\r
 void silk_corrMatrix_FIX(\r
-    const SKP_int16                 *x,         /* I    x vector [L + order - 1] used to form data matrix X */\r
-    const SKP_int                   L,          /* I    Length of vectors                                   */\r
-    const SKP_int                   order,      /* I    Max lag for correlation                             */\r
-    const SKP_int                   head_room,  /* I    Desired headroom                                    */\r
-    SKP_int32                       *XX,        /* O    Pointer to X'*X correlation matrix [ order x order ]*/\r
-    SKP_int                         *rshifts    /* I/O  Right shifts of correlations                        */\r
+    const opus_int16                 *x,         /* I    x vector [L + order - 1] used to form data matrix X */\r
+    const opus_int                   L,          /* I    Length of vectors                                   */\r
+    const opus_int                   order,      /* I    Max lag for correlation                             */\r
+    const opus_int                   head_room,  /* I    Desired headroom                                    */\r
+    opus_int32                       *XX,        /* O    Pointer to X'*X correlation matrix [ order x order ]*/\r
+    opus_int                         *rshifts    /* I/O  Right shifts of correlations                        */\r
 );\r
 \r
 /* Calculates correlation vector X'*t */\r
 void silk_corrVector_FIX(\r
-    const SKP_int16                 *x,         /* I    x vector [L + order - 1] used to form data matrix X */\r
-    const SKP_int16                 *t,         /* I    Target vector [L]                                   */\r
-    const SKP_int                   L,          /* I    Length of vectors                                   */\r
-    const SKP_int                   order,      /* I    Max lag for correlation                             */\r
-    SKP_int32                       *Xt,        /* O    Pointer to X'*t correlation vector [order]          */\r
-    const SKP_int                   rshifts     /* I    Right shifts of correlations                        */\r
+    const opus_int16                 *x,         /* I    x vector [L + order - 1] used to form data matrix X */\r
+    const opus_int16                 *t,         /* I    Target vector [L]                                   */\r
+    const opus_int                   L,          /* I    Length of vectors                                   */\r
+    const opus_int                   order,      /* I    Max lag for correlation                             */\r
+    opus_int32                       *Xt,        /* O    Pointer to X'*t correlation vector [order]          */\r
+    const opus_int                   rshifts     /* I    Right shifts of correlations                        */\r
 );\r
 \r
 /* Add noise to matrix diagonal */\r
 void silk_regularize_correlations_FIX(\r
-    SKP_int32                       *XX,                /* I/O  Correlation matrices                        */\r
-    SKP_int32                       *xx,                /* I/O  Correlation values                          */\r
-    SKP_int32                       noise,              /* I    Noise to add                                */\r
-    SKP_int                         D                   /* I    Dimension of XX                             */\r
+    opus_int32                       *XX,                /* I/O  Correlation matrices                        */\r
+    opus_int32                       *xx,                /* I/O  Correlation values                          */\r
+    opus_int32                       noise,              /* I    Noise to add                                */\r
+    opus_int                         D                   /* I    Dimension of XX                             */\r
 );\r
 \r
 /* Solves Ax = b, assuming A is symmetric */\r
 void silk_solve_LDL_FIX(\r
-    SKP_int32                       *A,                 /* I    Pointer to symetric square matrix A         */\r
-    SKP_int                         M,                  /* I    Size of matrix                              */\r
-    const SKP_int32                 *b,                 /* I    Pointer to b vector                         */\r
-    SKP_int32                       *x_Q16              /* O    Pointer to x solution vector                */\r
+    opus_int32                       *A,                 /* I    Pointer to symetric square matrix A         */\r
+    opus_int                         M,                  /* I    Size of matrix                              */\r
+    const opus_int32                 *b,                 /* I    Pointer to b vector                         */\r
+    opus_int32                       *x_Q16              /* O    Pointer to x solution vector                */\r
 );\r
 \r
 #ifndef FORCE_CPP_BUILD\r
index 7ded610..fb2bcc9 100644 (file)
@@ -30,13 +30,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 \r
 /* Compute gain to make warped filter coefficients have a zero mean log frequency response on a     */\r
 /* non-warped frequency scale. (So that it can be implemented with a minimum-phase monic filter.)   */\r
-SKP_INLINE SKP_int32 warped_gain( // gain in Q16\r
-    const SKP_int32     *coefs_Q24, \r
-    SKP_int             lambda_Q16, \r
-    SKP_int             order \r
+SKP_INLINE opus_int32 warped_gain( // gain in Q16\r
+    const opus_int32     *coefs_Q24, \r
+    opus_int             lambda_Q16, \r
+    opus_int             order \r
 ) {\r
-    SKP_int   i;\r
-    SKP_int32 gain_Q24;\r
+    opus_int   i;\r
+    opus_int32 gain_Q24;\r
 \r
     lambda_Q16 = -lambda_Q16;\r
     gain_Q24 = coefs_Q24[ order - 1 ];\r
@@ -50,15 +50,15 @@ SKP_INLINE SKP_int32 warped_gain( // gain in Q16
 /* Convert warped filter coefficients to monic pseudo-warped coefficients and limit maximum     */\r
 /* amplitude of monic warped coefficients by using bandwidth expansion on the true coefficients */\r
 SKP_INLINE void limit_warped_coefs( \r
-    SKP_int32           *coefs_syn_Q24,\r
-    SKP_int32           *coefs_ana_Q24,\r
-    SKP_int             lambda_Q16,\r
-    SKP_int32           limit_Q24,\r
-    SKP_int             order\r
+    opus_int32           *coefs_syn_Q24,\r
+    opus_int32           *coefs_ana_Q24,\r
+    opus_int             lambda_Q16,\r
+    opus_int32           limit_Q24,\r
+    opus_int             order\r
 ) {\r
-    SKP_int   i, iter, ind = 0;\r
-    SKP_int32 tmp, maxabs_Q24, chirp_Q16, gain_syn_Q16, gain_ana_Q16;\r
-    SKP_int32 nom_Q16, den_Q24;\r
+    opus_int   i, iter, ind = 0;\r
+    opus_int32 tmp, maxabs_Q24, chirp_Q16, gain_syn_Q16, gain_ana_Q16;\r
+    opus_int32 nom_Q16, den_Q24;\r
 \r
     /* Convert to monic coefficients */\r
     lambda_Q16 = -lambda_Q16;\r
@@ -137,22 +137,22 @@ SKP_INLINE void limit_warped_coefs(
 void silk_noise_shape_analysis_FIX(\r
     silk_encoder_state_FIX          *psEnc,         /* I/O  Encoder state FIX                           */\r
     silk_encoder_control_FIX        *psEncCtrl,     /* I/O  Encoder control FIX                         */\r
-    const SKP_int16                 *pitch_res,     /* I    LPC residual from pitch analysis            */\r
-    const SKP_int16                 *x              /* I    Input signal [ frame_length + la_shape ]    */\r
+    const opus_int16                 *pitch_res,     /* I    LPC residual from pitch analysis            */\r
+    const opus_int16                 *x              /* I    Input signal [ frame_length + la_shape ]    */\r
 )\r
 {\r
     silk_shape_state_FIX *psShapeSt = &psEnc->sShape;\r
-    SKP_int     k, i, nSamples, Qnrg, b_Q14, warping_Q16, scale = 0;\r
-    SKP_int32   SNR_adj_dB_Q7, HarmBoost_Q16, HarmShapeGain_Q16, Tilt_Q16, tmp32;\r
-    SKP_int32   nrg, pre_nrg_Q30, log_energy_Q7, log_energy_prev_Q7, energy_variation_Q7;\r
-    SKP_int32   delta_Q16, BWExp1_Q16, BWExp2_Q16, gain_mult_Q16, gain_add_Q16, strength_Q16, b_Q8;\r
-    SKP_int32   auto_corr[     MAX_SHAPE_LPC_ORDER + 1 ];\r
-    SKP_int32   refl_coef_Q16[ MAX_SHAPE_LPC_ORDER ];\r
-    SKP_int32   AR1_Q24[       MAX_SHAPE_LPC_ORDER ];\r
-    SKP_int32   AR2_Q24[       MAX_SHAPE_LPC_ORDER ];\r
-    SKP_int16   x_windowed[    SHAPE_LPC_WIN_MAX ];\r
-    SKP_int32   sqrt_nrg[ MAX_NB_SUBFR ], Qnrg_vec[ MAX_NB_SUBFR ];\r
-    const SKP_int16 *x_ptr, *pitch_res_ptr;\r
+    opus_int     k, i, nSamples, Qnrg, b_Q14, warping_Q16, scale = 0;\r
+    opus_int32   SNR_adj_dB_Q7, HarmBoost_Q16, HarmShapeGain_Q16, Tilt_Q16, tmp32;\r
+    opus_int32   nrg, pre_nrg_Q30, log_energy_Q7, log_energy_prev_Q7, energy_variation_Q7;\r
+    opus_int32   delta_Q16, BWExp1_Q16, BWExp2_Q16, gain_mult_Q16, gain_add_Q16, strength_Q16, b_Q8;\r
+    opus_int32   auto_corr[     MAX_SHAPE_LPC_ORDER + 1 ];\r
+    opus_int32   refl_coef_Q16[ MAX_SHAPE_LPC_ORDER ];\r
+    opus_int32   AR1_Q24[       MAX_SHAPE_LPC_ORDER ];\r
+    opus_int32   AR2_Q24[       MAX_SHAPE_LPC_ORDER ];\r
+    opus_int16   x_windowed[    SHAPE_LPC_WIN_MAX ];\r
+    opus_int32   sqrt_nrg[ MAX_NB_SUBFR ], Qnrg_vec[ MAX_NB_SUBFR ];\r
+    const opus_int16 *x_ptr, *pitch_res_ptr;\r
 \r
     /* Point to start of first LPC analysis block */\r
     x_ptr = x - psEnc->sCmn.la_shape;\r
@@ -163,7 +163,7 @@ void silk_noise_shape_analysis_FIX(
     SNR_adj_dB_Q7 = psEnc->sCmn.SNR_dB_Q7;\r
 \r
     /* Input quality is the average of the quality in the lowest two VAD bands */\r
-    psEncCtrl->input_quality_Q14 = ( SKP_int )SKP_RSHIFT( ( SKP_int32 )psEnc->sCmn.input_quality_bands_Q15[ 0 ] \r
+    psEncCtrl->input_quality_Q14 = ( opus_int )SKP_RSHIFT( ( opus_int32 )psEnc->sCmn.input_quality_bands_Q15[ 0 ] \r
         + psEnc->sCmn.input_quality_bands_Q15[ 1 ], 2 );\r
 \r
     /* Coding quality level, between 0.0_Q0 and 1.0_Q0, but in Q14 */\r
@@ -255,13 +255,13 @@ void silk_noise_shape_analysis_FIX(
     /********************************************/\r
     for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) {\r
         /* Apply window: sine slope followed by flat part followed by cosine slope */\r
-        SKP_int shift, slope_part, flat_part;\r
+        opus_int shift, slope_part, flat_part;\r
         flat_part = psEnc->sCmn.fs_kHz * 3;\r
         slope_part = SKP_RSHIFT( psEnc->sCmn.shapeWinLength - flat_part, 1 );\r
 \r
         silk_apply_sine_window( x_windowed, x_ptr, 1, slope_part );\r
         shift = slope_part;\r
-        SKP_memcpy( x_windowed + shift, x_ptr + shift, flat_part * sizeof(SKP_int16) );\r
+        SKP_memcpy( x_windowed + shift, x_ptr + shift, flat_part * sizeof(opus_int16) );\r
         shift += flat_part;\r
         silk_apply_sine_window( x_windowed + shift, x_ptr + shift, 2, slope_part );\r
 \r
@@ -319,7 +319,7 @@ void silk_noise_shape_analysis_FIX(
         silk_bwexpander_32( AR2_Q24, psEnc->sCmn.shapingLPCOrder, BWExp2_Q16 );\r
 \r
         /* Compute noise shaping filter coefficients */\r
-        SKP_memcpy( AR1_Q24, AR2_Q24, psEnc->sCmn.shapingLPCOrder * sizeof( SKP_int32 ) );\r
+        SKP_memcpy( AR1_Q24, AR2_Q24, psEnc->sCmn.shapingLPCOrder * sizeof( opus_int32 ) );\r
 \r
         /* Bandwidth expansion for analysis filter shaping */\r
         SKP_assert( BWExp1_Q16 <= SILK_FIX_CONST( 1.0, 16 ) );\r
@@ -331,15 +331,15 @@ void silk_noise_shape_analysis_FIX(
 \r
         //psEncCtrl->GainsPre[ k ] = 1.0f - 0.7f * ( 1.0f - pre_nrg / nrg ) = 0.3f + 0.7f * pre_nrg / nrg;\r
         pre_nrg_Q30 = SKP_LSHIFT32( SKP_SMULWB( pre_nrg_Q30, SILK_FIX_CONST( 0.7, 15 ) ), 1 );\r
-        psEncCtrl->GainsPre_Q14[ k ] = ( SKP_int ) SILK_FIX_CONST( 0.3, 14 ) + silk_DIV32_varQ( pre_nrg_Q30, nrg, 14 );\r
+        psEncCtrl->GainsPre_Q14[ k ] = ( opus_int ) SILK_FIX_CONST( 0.3, 14 ) + silk_DIV32_varQ( pre_nrg_Q30, nrg, 14 );\r
 \r
         /* Convert to monic warped prediction coefficients and limit absolute values */\r
         limit_warped_coefs( AR2_Q24, AR1_Q24, warping_Q16, SILK_FIX_CONST( 3.999, 24 ), psEnc->sCmn.shapingLPCOrder );\r
 \r
         /* Convert from Q24 to Q13 and store in int16 */\r
         for( i = 0; i < psEnc->sCmn.shapingLPCOrder; i++ ) {\r
-            psEncCtrl->AR1_Q13[ k * MAX_SHAPE_LPC_ORDER + i ] = (SKP_int16)SKP_SAT16( SKP_RSHIFT_ROUND( AR1_Q24[ i ], 11 ) );\r
-            psEncCtrl->AR2_Q13[ k * MAX_SHAPE_LPC_ORDER + i ] = (SKP_int16)SKP_SAT16( SKP_RSHIFT_ROUND( AR2_Q24[ i ], 11 ) );\r
+            psEncCtrl->AR1_Q13[ k * MAX_SHAPE_LPC_ORDER + i ] = (opus_int16)SKP_SAT16( SKP_RSHIFT_ROUND( AR1_Q24[ i ], 11 ) );\r
+            psEncCtrl->AR2_Q13[ k * MAX_SHAPE_LPC_ORDER + i ] = (opus_int16)SKP_SAT16( SKP_RSHIFT_ROUND( AR2_Q24[ i ], 11 ) );\r
         }\r
     }\r
 \r
@@ -372,14 +372,14 @@ void silk_noise_shape_analysis_FIX(
     if( psEnc->sCmn.indices.signalType == TYPE_VOICED ) {\r
         /* Reduce low frequencies quantization noise for periodic signals, depending on pitch lag */\r
         /*f = 400; freqz([1, -0.98 + 2e-4 * f], [1, -0.97 + 7e-4 * f], 2^12, Fs); axis([0, 1000, -10, 1])*/\r
-        SKP_int fs_kHz_inv = SKP_DIV32_16( SILK_FIX_CONST( 0.2, 14 ), psEnc->sCmn.fs_kHz );\r
+        opus_int fs_kHz_inv = SKP_DIV32_16( SILK_FIX_CONST( 0.2, 14 ), psEnc->sCmn.fs_kHz );\r
         for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) {\r
             b_Q14 = fs_kHz_inv + SKP_DIV32_16( SILK_FIX_CONST( 3.0, 14 ), psEncCtrl->pitchL[ k ] ); \r
             /* Pack two coefficients in one int32 */\r
             psEncCtrl->LF_shp_Q14[ k ]  = SKP_LSHIFT( SILK_FIX_CONST( 1.0, 14 ) - b_Q14 - SKP_SMULWB( strength_Q16, b_Q14 ), 16 );\r
-            psEncCtrl->LF_shp_Q14[ k ] |= (SKP_uint16)( b_Q14 - SILK_FIX_CONST( 1.0, 14 ) );\r
+            psEncCtrl->LF_shp_Q14[ k ] |= (opus_uint16)( b_Q14 - SILK_FIX_CONST( 1.0, 14 ) );\r
         }\r
-        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 SKP_int16\r
+        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\r
         Tilt_Q16 = - SILK_FIX_CONST( HP_NOISE_COEF, 16 ) - \r
             SKP_SMULWB( SILK_FIX_CONST( 1.0, 16 ) - SILK_FIX_CONST( HP_NOISE_COEF, 16 ), \r
                 SKP_SMULWB( SILK_FIX_CONST( HARM_HP_NOISE_COEF, 24 ), psEnc->sCmn.speech_activity_Q8 ) );\r
@@ -388,7 +388,7 @@ void silk_noise_shape_analysis_FIX(
         /* Pack two coefficients in one int32 */\r
         psEncCtrl->LF_shp_Q14[ 0 ]  = SKP_LSHIFT( SILK_FIX_CONST( 1.0, 14 ) - b_Q14 - \r
             SKP_SMULWB( strength_Q16, SKP_SMULWB( SILK_FIX_CONST( 0.6, 16 ), b_Q14 ) ), 16 );\r
-        psEncCtrl->LF_shp_Q14[ 0 ] |= (SKP_uint16)( b_Q14 - SILK_FIX_CONST( 1.0, 14 ) );\r
+        psEncCtrl->LF_shp_Q14[ 0 ] |= (opus_uint16)( b_Q14 - SILK_FIX_CONST( 1.0, 14 ) );\r
         for( k = 1; k < psEnc->sCmn.nb_subfr; k++ ) {\r
             psEncCtrl->LF_shp_Q14[ k ] = psEncCtrl->LF_shp_Q14[ 0 ];\r
         }\r
@@ -430,8 +430,8 @@ void silk_noise_shape_analysis_FIX(
         psShapeSt->Tilt_smth_Q16 =\r
             SKP_SMLAWB( psShapeSt->Tilt_smth_Q16,          Tilt_Q16          - psShapeSt->Tilt_smth_Q16,          SILK_FIX_CONST( SUBFR_SMTH_COEF, 16 ) );\r
 \r
-        psEncCtrl->HarmBoost_Q14[ k ]     = ( SKP_int )SKP_RSHIFT_ROUND( psShapeSt->HarmBoost_smth_Q16,     2 );\r
-        psEncCtrl->HarmShapeGain_Q14[ k ] = ( SKP_int )SKP_RSHIFT_ROUND( psShapeSt->HarmShapeGain_smth_Q16, 2 );\r
-        psEncCtrl->Tilt_Q14[ k ]          = ( SKP_int )SKP_RSHIFT_ROUND( psShapeSt->Tilt_smth_Q16,          2 );\r
+        psEncCtrl->HarmBoost_Q14[ k ]     = ( opus_int )SKP_RSHIFT_ROUND( psShapeSt->HarmBoost_smth_Q16,     2 );\r
+        psEncCtrl->HarmShapeGain_Q14[ k ] = ( opus_int )SKP_RSHIFT_ROUND( psShapeSt->HarmShapeGain_smth_Q16, 2 );\r
+        psEncCtrl->Tilt_Q14[ k ]          = ( opus_int )SKP_RSHIFT_ROUND( psShapeSt->Tilt_smth_Q16,          2 );\r
     }\r
 }\r
index 44e6034..368aeda 100644 (file)
@@ -31,27 +31,27 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /* silk_prefilter. Prefilter for finding Quantizer input signal */\r
 SKP_INLINE void silk_prefilt_FIX(\r
     silk_prefilter_state_FIX *P,                    /* I/O state                          */\r
-    SKP_int32   st_res_Q12[],                           /* I short term residual signal       */\r
-    SKP_int16   xw[],                                   /* O prefiltered signal               */\r
-    SKP_int32   HarmShapeFIRPacked_Q12,                 /* I Harmonic shaping coeficients     */\r
-    SKP_int     Tilt_Q14,                               /* I Tilt shaping coeficient          */\r
-    SKP_int32   LF_shp_Q14,                             /* I Low-frequancy shaping coeficients*/\r
-    SKP_int     lag,                                    /* I Lag for harmonic shaping         */\r
-    SKP_int     length                                  /* I Length of signals                */\r
+    opus_int32   st_res_Q12[],                           /* I short term residual signal       */\r
+    opus_int16   xw[],                                   /* O prefiltered signal               */\r
+    opus_int32   HarmShapeFIRPacked_Q12,                 /* I Harmonic shaping coeficients     */\r
+    opus_int     Tilt_Q14,                               /* I Tilt shaping coeficient          */\r
+    opus_int32   LF_shp_Q14,                             /* I Low-frequancy shaping coeficients*/\r
+    opus_int     lag,                                    /* I Lag for harmonic shaping         */\r
+    opus_int     length                                  /* I Length of signals                */\r
 );\r
 \r
 void silk_warped_LPC_analysis_filter_FIX(\r
-          SKP_int32                 state[],            /* I/O  State [order + 1]                       */\r
-          SKP_int16                 res[],              /* O    Residual signal [length]                */\r
-    const SKP_int16                 coef_Q13[],         /* I    Coefficients [order]                    */\r
-    const SKP_int16                 input[],            /* I    Input signal [length]                   */\r
-    const SKP_int16                 lambda_Q16,         /* I    Warping factor                          */\r
-    const SKP_int                   length,             /* I    Length of input signal                  */\r
-    const SKP_int                   order               /* I    Filter order (even)                     */\r
+          opus_int32                 state[],            /* I/O  State [order + 1]                       */\r
+          opus_int16                 res[],              /* O    Residual signal [length]                */\r
+    const opus_int16                 coef_Q13[],         /* I    Coefficients [order]                    */\r
+    const opus_int16                 input[],            /* I    Input signal [length]                   */\r
+    const opus_int16                 lambda_Q16,         /* I    Warping factor                          */\r
+    const opus_int                   length,             /* I    Length of input signal                  */\r
+    const opus_int                   order               /* I    Filter order (even)                     */\r
 )\r
 {\r
-    SKP_int     n, i;\r
-    SKP_int32   acc_Q11, tmp1, tmp2;\r
+    opus_int     n, i;\r
+    opus_int32   acc_Q11, tmp1, tmp2;\r
 \r
     /* Order must be even */\r
     SKP_assert( ( order & 1 ) == 0 );\r
@@ -77,28 +77,28 @@ void silk_warped_LPC_analysis_filter_FIX(
         }\r
         state[ order ] = tmp1;\r
         acc_Q11 = SKP_SMLAWB( acc_Q11, tmp1, coef_Q13[ order - 1 ] );\r
-        res[ n ] = ( SKP_int16 )SKP_SAT16( ( SKP_int32 )input[ n ] - SKP_RSHIFT_ROUND( acc_Q11, 11 ) );\r
+        res[ n ] = ( opus_int16 )SKP_SAT16( ( opus_int32 )input[ n ] - SKP_RSHIFT_ROUND( acc_Q11, 11 ) );\r
     }\r
 }\r
 \r
 void silk_prefilter_FIX(\r
     silk_encoder_state_FIX              *psEnc,         /* I/O  Encoder state FIX                           */\r
     const silk_encoder_control_FIX      *psEncCtrl,     /* I    Encoder control FIX                         */\r
-    SKP_int16                           xw[],           /* O    Weighted signal                             */\r
-    const SKP_int16                     x[]             /* I    Speech signal                               */\r
+    opus_int16                           xw[],           /* O    Weighted signal                             */\r
+    const opus_int16                     x[]             /* I    Speech signal                               */\r
 )\r
 {\r
     silk_prefilter_state_FIX *P = &psEnc->sPrefilt;\r
-    SKP_int   j, k, lag;\r
-    SKP_int32 tmp_32;\r
-    const SKP_int16 *AR1_shp_Q13;\r
-    const SKP_int16 *px;\r
-    SKP_int16 *pxw;\r
-    SKP_int   HarmShapeGain_Q12, Tilt_Q14;\r
-    SKP_int32 HarmShapeFIRPacked_Q12, LF_shp_Q14;\r
-    SKP_int32 x_filt_Q12[ MAX_FRAME_LENGTH / MAX_NB_SUBFR ];\r
-    SKP_int16 st_res[ ( MAX_FRAME_LENGTH / MAX_NB_SUBFR ) + MAX_LPC_ORDER ];\r
-    SKP_int16 B_Q12[ 2 ];\r
+    opus_int   j, k, lag;\r
+    opus_int32 tmp_32;\r
+    const opus_int16 *AR1_shp_Q13;\r
+    const opus_int16 *px;\r
+    opus_int16 *pxw;\r
+    opus_int   HarmShapeGain_Q12, Tilt_Q14;\r
+    opus_int32 HarmShapeFIRPacked_Q12, LF_shp_Q14;\r
+    opus_int32 x_filt_Q12[ MAX_FRAME_LENGTH / MAX_NB_SUBFR ];\r
+    opus_int16 st_res[ ( MAX_FRAME_LENGTH / MAX_NB_SUBFR ) + MAX_LPC_ORDER ];\r
+    opus_int16 B_Q12[ 2 ];\r
 \r
     /* Setup pointers */\r
     px  = x;\r
@@ -114,7 +114,7 @@ void silk_prefilter_FIX(
         HarmShapeGain_Q12 = SKP_SMULWB( psEncCtrl->HarmShapeGain_Q14[ k ], 16384 - psEncCtrl->HarmBoost_Q14[ k ] );\r
         SKP_assert( HarmShapeGain_Q12 >= 0 );\r
         HarmShapeFIRPacked_Q12  =                          SKP_RSHIFT( HarmShapeGain_Q12, 2 );\r
-        HarmShapeFIRPacked_Q12 |= SKP_LSHIFT( ( SKP_int32 )SKP_RSHIFT( HarmShapeGain_Q12, 1 ), 16 );\r
+        HarmShapeFIRPacked_Q12 |= SKP_LSHIFT( ( opus_int32 )SKP_RSHIFT( HarmShapeGain_Q12, 1 ), 16 );\r
         Tilt_Q14    = psEncCtrl->Tilt_Q14[   k ];\r
         LF_shp_Q14  = psEncCtrl->LF_shp_Q14[ k ];\r
         AR1_shp_Q13 = &psEncCtrl->AR1_Q13[   k * MAX_SHAPE_LPC_ORDER ];\r
@@ -150,19 +150,19 @@ void silk_prefilter_FIX(
 /* silk_prefilter. Prefilter for finding Quantizer input signal                           */\r
 SKP_INLINE void silk_prefilt_FIX(\r
     silk_prefilter_state_FIX *P,                    /* I/O state                          */\r
-    SKP_int32   st_res_Q12[],                           /* I short term residual signal       */\r
-    SKP_int16   xw[],                                   /* O prefiltered signal               */\r
-    SKP_int32   HarmShapeFIRPacked_Q12,                 /* I Harmonic shaping coeficients     */\r
-    SKP_int     Tilt_Q14,                               /* I Tilt shaping coeficient          */\r
-    SKP_int32   LF_shp_Q14,                             /* I Low-frequancy shaping coeficients*/\r
-    SKP_int     lag,                                    /* I Lag for harmonic shaping         */\r
-    SKP_int     length                                  /* I Length of signals                */\r
+    opus_int32   st_res_Q12[],                           /* I short term residual signal       */\r
+    opus_int16   xw[],                                   /* O prefiltered signal               */\r
+    opus_int32   HarmShapeFIRPacked_Q12,                 /* I Harmonic shaping coeficients     */\r
+    opus_int     Tilt_Q14,                               /* I Tilt shaping coeficient          */\r
+    opus_int32   LF_shp_Q14,                             /* I Low-frequancy shaping coeficients*/\r
+    opus_int     lag,                                    /* I Lag for harmonic shaping         */\r
+    opus_int     length                                  /* I Length of signals                */\r
 )\r
 {\r
-    SKP_int   i, idx, LTP_shp_buf_idx;\r
-    SKP_int32 n_LTP_Q12, n_Tilt_Q10, n_LF_Q10;\r
-    SKP_int32 sLF_MA_shp_Q12, sLF_AR_shp_Q12;\r
-    SKP_int16 *LTP_shp_buf;\r
+    opus_int   i, idx, LTP_shp_buf_idx;\r
+    opus_int32 n_LTP_Q12, n_Tilt_Q10, n_LF_Q10;\r
+    opus_int32 sLF_MA_shp_Q12, sLF_AR_shp_Q12;\r
+    opus_int16 *LTP_shp_buf;\r
 \r
     /* To speed up use temp variables instead of using the struct */\r
     LTP_shp_buf     = P->sLTP_shp;\r
@@ -189,9 +189,9 @@ SKP_INLINE void silk_prefilt_FIX(
         sLF_MA_shp_Q12 = SKP_SUB32( sLF_AR_shp_Q12,  SKP_LSHIFT( n_LF_Q10,   2 ) );\r
 \r
         LTP_shp_buf_idx = ( LTP_shp_buf_idx - 1 ) & LTP_MASK;\r
-        LTP_shp_buf[ LTP_shp_buf_idx ] = ( SKP_int16 )SKP_SAT16( SKP_RSHIFT_ROUND( sLF_MA_shp_Q12, 12 ) );\r
+        LTP_shp_buf[ LTP_shp_buf_idx ] = ( opus_int16 )SKP_SAT16( SKP_RSHIFT_ROUND( sLF_MA_shp_Q12, 12 ) );\r
 \r
-        xw[i] = ( SKP_int16 )SKP_SAT16( SKP_RSHIFT_ROUND( SKP_SUB32( sLF_MA_shp_Q12, n_LTP_Q12 ), 12 ) );\r
+        xw[i] = ( opus_int16 )SKP_SAT16( SKP_RSHIFT_ROUND( SKP_SUB32( sLF_MA_shp_Q12, n_LTP_Q12 ), 12 ) );\r
     }\r
 \r
     /* Copy temp variable back to state */\r
index b884129..4341ac0 100644 (file)
@@ -35,8 +35,8 @@ void silk_process_gains_FIX(
 )\r
 {\r
     silk_shape_state_FIX    *psShapeSt = &psEnc->sShape;\r
-    SKP_int     k;\r
-    SKP_int32   s_Q16, InvMaxSqrVal_Q16, gain, gain_squared, ResNrg, ResNrgPart, quant_offset_Q10;\r
+    opus_int     k;\r
+    opus_int32   s_Q16, InvMaxSqrVal_Q16, gain, gain_squared, ResNrg, ResNrgPart, quant_offset_Q10;\r
 \r
     /* Gain reduction when LTP coding gain is high */\r
     if( psEnc->sCmn.indices.signalType == TYPE_VOICED ) {\r
index b0737d4..8cca332 100644 (file)
@@ -29,13 +29,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 \r
 /* Add noise to matrix diagonal */\r
 void silk_regularize_correlations_FIX(\r
-    SKP_int32                       *XX,                /* I/O  Correlation matrices                        */\r
-    SKP_int32                       *xx,                /* I/O  Correlation values                          */\r
-    SKP_int32                       noise,              /* I    Noise to add                                */\r
-    SKP_int                         D                   /* I    Dimension of XX                             */\r
+    opus_int32                       *XX,                /* I/O  Correlation matrices                        */\r
+    opus_int32                       *xx,                /* I/O  Correlation values                          */\r
+    opus_int32                       noise,              /* I    Noise to add                                */\r
+    opus_int                         D                   /* I    Dimension of XX                             */\r
 )\r
 {\r
-    SKP_int i;\r
+    opus_int i;\r
     for( i = 0; i < D; i++ ) {\r
         matrix_ptr( &XX[ 0 ], i, i, D ) = SKP_ADD32( matrix_ptr( &XX[ 0 ], i, i, D ), noise );\r
     }\r
index f651160..c3b571c 100644 (file)
@@ -28,19 +28,19 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "silk_main_FIX.h"\r
 \r
 /* Residual energy: nrg = wxx - 2 * wXx * c + c' * wXX * c */\r
-SKP_int32 silk_residual_energy16_covar_FIX(\r
-    const SKP_int16                 *c,                 /* I    Prediction vector                           */\r
-    const SKP_int32                 *wXX,               /* I    Correlation matrix                          */\r
-    const SKP_int32                 *wXx,               /* I    Correlation vector                          */\r
-    SKP_int32                       wxx,                /* I    Signal energy                               */\r
-    SKP_int                         D,                  /* I    Dimension                                   */\r
-    SKP_int                         cQ                  /* I    Q value for c vector 0 - 15                 */\r
+opus_int32 silk_residual_energy16_covar_FIX(\r
+    const opus_int16                 *c,                 /* I    Prediction vector                           */\r
+    const opus_int32                 *wXX,               /* I    Correlation matrix                          */\r
+    const opus_int32                 *wXx,               /* I    Correlation vector                          */\r
+    opus_int32                       wxx,                /* I    Signal energy                               */\r
+    opus_int                         D,                  /* I    Dimension                                   */\r
+    opus_int                         cQ                  /* I    Q value for c vector 0 - 15                 */\r
 )\r
 {\r
-    SKP_int   i, j, lshifts, Qxtra;\r
-    SKP_int32 c_max, w_max, tmp, tmp2, nrg;\r
-    SKP_int   cn[ MAX_MATRIX_SIZE ]; \r
-    const SKP_int32 *pRow;\r
+    opus_int   i, j, lshifts, Qxtra;\r
+    opus_int32 c_max, w_max, tmp, tmp2, nrg;\r
+    opus_int   cn[ MAX_MATRIX_SIZE ]; \r
+    const opus_int32 *pRow;\r
 \r
     /* Safety checks */\r
     SKP_assert( D >=  0 );\r
@@ -53,7 +53,7 @@ SKP_int32 silk_residual_energy16_covar_FIX(
 \r
     c_max = 0;\r
     for( i = 0; i < D; i++ ) {\r
-        c_max = SKP_max_32( c_max, SKP_abs( ( SKP_int32 )c[ i ] ) );\r
+        c_max = SKP_max_32( c_max, SKP_abs( ( opus_int32 )c[ i ] ) );\r
     }\r
     Qxtra = SKP_min_int( Qxtra, silk_CLZ32( c_max ) - 17 );\r
 \r
@@ -61,7 +61,7 @@ SKP_int32 silk_residual_energy16_covar_FIX(
     Qxtra = SKP_min_int( Qxtra, silk_CLZ32( SKP_MUL( D, SKP_RSHIFT( SKP_SMULWB( w_max, c_max ), 4 ) ) ) - 5 );\r
     Qxtra = SKP_max_int( Qxtra, 0 );\r
     for( i = 0; i < D; i++ ) {\r
-        cn[ i ] = SKP_LSHIFT( ( SKP_int )c[ i ], Qxtra );\r
+        cn[ i ] = SKP_LSHIFT( ( opus_int )c[ i ], Qxtra );\r
         SKP_assert( SKP_abs(cn[i]) <= ( SKP_int16_MAX + 1 ) ); /* Check that SKP_SMLAWB can be used */\r
     }\r
     lshifts -= Qxtra;\r
index c161bb2..e156b36 100644 (file)
@@ -30,20 +30,20 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /* Calculates residual energies of input subframes where all subframes have LPC_order   */\r
 /* of preceeding samples                                                                */\r
 void silk_residual_energy_FIX(\r
-          SKP_int32 nrgs[ MAX_NB_SUBFR ],           /* O    Residual energy per subframe    */\r
-          SKP_int   nrgsQ[ MAX_NB_SUBFR ],          /* O    Q value per subframe            */\r
-    const SKP_int16 x[],                            /* I    Input signal                    */\r
-          SKP_int16 a_Q12[ 2 ][ MAX_LPC_ORDER ],    /* I    AR coefs for each frame half    */\r
-    const SKP_int32 gains[ MAX_NB_SUBFR ],          /* I    Quantization gains              */\r
-    const SKP_int   subfr_length,                   /* I    Subframe length                 */\r
-    const SKP_int   nb_subfr,                       /* I    Number of subframes             */\r
-    const SKP_int   LPC_order                       /* I    LPC order                       */\r
+          opus_int32 nrgs[ MAX_NB_SUBFR ],           /* O    Residual energy per subframe    */\r
+          opus_int   nrgsQ[ MAX_NB_SUBFR ],          /* O    Q value per subframe            */\r
+    const opus_int16 x[],                            /* I    Input signal                    */\r
+          opus_int16 a_Q12[ 2 ][ MAX_LPC_ORDER ],    /* I    AR coefs for each frame half    */\r
+    const opus_int32 gains[ MAX_NB_SUBFR ],          /* I    Quantization gains              */\r
+    const opus_int   subfr_length,                   /* I    Subframe length                 */\r
+    const opus_int   nb_subfr,                       /* I    Number of subframes             */\r
+    const opus_int   LPC_order                       /* I    LPC order                       */\r
 )\r
 {\r
-    SKP_int         offset, i, j, rshift, lz1, lz2;\r
-    SKP_int16       *LPC_res_ptr, LPC_res[ ( MAX_FRAME_LENGTH + MAX_NB_SUBFR * MAX_LPC_ORDER ) / 2 ];\r
-    const SKP_int16 *x_ptr;\r
-    SKP_int32       tmp32;\r
+    opus_int         offset, i, j, rshift, lz1, lz2;\r
+    opus_int16       *LPC_res_ptr, LPC_res[ ( MAX_FRAME_LENGTH + MAX_NB_SUBFR * MAX_LPC_ORDER ) / 2 ];\r
+    const opus_int16 *x_ptr;\r
+    opus_int32       tmp32;\r
 \r
     x_ptr  = x;\r
     offset = LPC_order + subfr_length;\r
index a287a29..ef69fb4 100644 (file)
@@ -33,50 +33,50 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /*****************************/\r
 \r
 typedef struct {\r
-    SKP_int32 Q36_part;\r
-    SKP_int32 Q48_part;\r
+    opus_int32 Q36_part;\r
+    opus_int32 Q48_part;\r
 } inv_D_t;\r
 \r
 /* Factorize square matrix A into LDL form */\r
 SKP_INLINE void silk_LDL_factorize_FIX(\r
-    SKP_int32           *A,         /* I/O Pointer to Symetric Square Matrix */\r
-    SKP_int             M,          /* I   Size of Matrix */\r
-    SKP_int32           *L_Q16,     /* I/O Pointer to Square Upper triangular Matrix */\r
+    opus_int32           *A,         /* I/O Pointer to Symetric Square Matrix */\r
+    opus_int             M,          /* I   Size of Matrix */\r
+    opus_int32           *L_Q16,     /* I/O Pointer to Square Upper triangular Matrix */\r
     inv_D_t             *inv_D      /* I/O Pointer to vector holding inverted diagonal elements of D */\r
 );\r
 \r
 /* Solve Lx = b, when L is lower triangular and has ones on the diagonal */\r
 SKP_INLINE void silk_LS_SolveFirst_FIX(\r
-    const SKP_int32     *L_Q16,     /* I Pointer to Lower Triangular Matrix */\r
-    SKP_int             M,          /* I Dim of Matrix equation */\r
-    const SKP_int32     *b,         /* I b Vector */\r
-    SKP_int32           *x_Q16      /* O x Vector */  \r
+    const opus_int32     *L_Q16,     /* I Pointer to Lower Triangular Matrix */\r
+    opus_int             M,          /* I Dim of Matrix equation */\r
+    const opus_int32     *b,         /* I b Vector */\r
+    opus_int32           *x_Q16      /* O x Vector */  \r
 );\r
 \r
 /* Solve L^t*x = b, where L is lower triangular with ones on the diagonal */\r
 SKP_INLINE void silk_LS_SolveLast_FIX(\r
-    const SKP_int32     *L_Q16,     /* I Pointer to Lower Triangular Matrix */\r
-    const SKP_int       M,          /* I Dim of Matrix equation */\r
-    const SKP_int32     *b,         /* I b Vector */\r
-    SKP_int32           *x_Q16      /* O x Vector */  \r
+    const opus_int32     *L_Q16,     /* I Pointer to Lower Triangular Matrix */\r
+    const opus_int       M,          /* I Dim of Matrix equation */\r
+    const opus_int32     *b,         /* I b Vector */\r
+    opus_int32           *x_Q16      /* O x Vector */  \r
 );\r
 \r
 SKP_INLINE void silk_LS_divide_Q16_FIX(\r
-    SKP_int32           T[],    /* I/O Numenator vector */\r
+    opus_int32           T[],    /* I/O Numenator vector */\r
     inv_D_t             *inv_D, /* I   1 / D vector     */\r
-    SKP_int             M       /* I   dimension        */\r
+    opus_int             M       /* I   dimension        */\r
 );\r
 \r
 /* Solves Ax = b, assuming A is symmetric */\r
 void silk_solve_LDL_FIX(\r
-    SKP_int32                       *A,                 /* I    Pointer to symetric square matrix A         */\r
-    SKP_int                         M,                  /* I    Size of matrix                              */\r
-    const SKP_int32                 *b,                 /* I    Pointer to b vector                         */\r
-    SKP_int32                       *x_Q16              /* O    Pointer to x solution vector                */\r
+    opus_int32                       *A,                 /* I    Pointer to symetric square matrix A         */\r
+    opus_int                         M,                  /* I    Size of matrix                              */\r
+    const opus_int32                 *b,                 /* I    Pointer to b vector                         */\r
+    opus_int32                       *x_Q16              /* O    Pointer to x solution vector                */\r
 )\r
 {\r
-    SKP_int32 L_Q16[  MAX_MATRIX_SIZE * MAX_MATRIX_SIZE ]; \r
-    SKP_int32 Y[      MAX_MATRIX_SIZE ];\r
+    opus_int32 L_Q16[  MAX_MATRIX_SIZE * MAX_MATRIX_SIZE ]; \r
+    opus_int32 Y[      MAX_MATRIX_SIZE ];\r
     inv_D_t   inv_D[  MAX_MATRIX_SIZE ];\r
 \r
     SKP_assert( M <= MAX_MATRIX_SIZE );\r
@@ -106,17 +106,17 @@ void silk_solve_LDL_FIX(
 }\r
 \r
 SKP_INLINE void silk_LDL_factorize_FIX(\r
-    SKP_int32           *A,         /* I   Pointer to Symetric Square Matrix */\r
-    SKP_int             M,          /* I   Size of Matrix */\r
-    SKP_int32           *L_Q16,     /* I/O Pointer to Square Upper triangular Matrix */\r
+    opus_int32           *A,         /* I   Pointer to Symetric Square Matrix */\r
+    opus_int             M,          /* I   Size of Matrix */\r
+    opus_int32           *L_Q16,     /* I/O Pointer to Square Upper triangular Matrix */\r
     inv_D_t             *inv_D      /* I/O Pointer to vector holding inverted diagonal elements of D */\r
 )\r
 {\r
-    SKP_int   i, j, k, status, loop_count;\r
-    const SKP_int32 *ptr1, *ptr2;\r
-    SKP_int32 diag_min_value, tmp_32, err;\r
-    SKP_int32 v_Q0[ MAX_MATRIX_SIZE ], D_Q0[ MAX_MATRIX_SIZE ];\r
-    SKP_int32 one_div_diag_Q36, one_div_diag_Q40, one_div_diag_Q48;\r
+    opus_int   i, j, k, status, loop_count;\r
+    const opus_int32 *ptr1, *ptr2;\r
+    opus_int32 diag_min_value, tmp_32, err;\r
+    opus_int32 v_Q0[ MAX_MATRIX_SIZE ], D_Q0[ MAX_MATRIX_SIZE ];\r
+    opus_int32 one_div_diag_Q36, one_div_diag_Q40, one_div_diag_Q48;\r
 \r
     SKP_assert( M <= MAX_MATRIX_SIZE );\r
 \r
@@ -178,14 +178,14 @@ SKP_INLINE void silk_LDL_factorize_FIX(
 }\r
 \r
 SKP_INLINE void silk_LS_divide_Q16_FIX(\r
-    SKP_int32 T[],      /* I/O Numenator vector */\r
+    opus_int32 T[],      /* I/O Numenator vector */\r
     inv_D_t *inv_D,     /* I   1 / D vector     */\r
-    SKP_int M           /* I   Order */\r
+    opus_int M           /* I   Order */\r
 )\r
 {\r
-    SKP_int   i;\r
-    SKP_int32 tmp_32;\r
-    SKP_int32 one_div_diag_Q36, one_div_diag_Q48;\r
+    opus_int   i;\r
+    opus_int32 tmp_32;\r
+    opus_int32 one_div_diag_Q36, one_div_diag_Q48;\r
 \r
     for( i = 0; i < M; i++ ) {\r
         one_div_diag_Q36 = inv_D[ i ].Q36_part;\r
@@ -198,15 +198,15 @@ SKP_INLINE void silk_LS_divide_Q16_FIX(
 \r
 /* Solve Lx = b, when L is lower triangular and has ones on the diagonal */\r
 SKP_INLINE void silk_LS_SolveFirst_FIX(\r
-    const SKP_int32     *L_Q16, /* I Pointer to Lower Triangular Matrix */\r
-    SKP_int             M,      /* I Dim of Matrix equation */\r
-    const SKP_int32     *b,     /* I b Vector */\r
-    SKP_int32           *x_Q16  /* O x Vector */  \r
+    const opus_int32     *L_Q16, /* I Pointer to Lower Triangular Matrix */\r
+    opus_int             M,      /* I Dim of Matrix equation */\r
+    const opus_int32     *b,     /* I b Vector */\r
+    opus_int32           *x_Q16  /* O x Vector */  \r
 )\r
 {\r
-    SKP_int i, j;\r
-    const SKP_int32 *ptr32;\r
-    SKP_int32 tmp_32;\r
+    opus_int i, j;\r
+    const opus_int32 *ptr32;\r
+    opus_int32 tmp_32;\r
 \r
     for( i = 0; i < M; i++ ) {\r
         ptr32 = matrix_adr( L_Q16, i, 0, M );\r
@@ -220,15 +220,15 @@ SKP_INLINE void silk_LS_SolveFirst_FIX(
 \r
 /* Solve L^t*x = b, where L is lower triangular with ones on the diagonal */\r
 SKP_INLINE void silk_LS_SolveLast_FIX(\r
-    const SKP_int32     *L_Q16,     /* I Pointer to Lower Triangular Matrix */\r
-    const SKP_int       M,          /* I Dim of Matrix equation */\r
-    const SKP_int32     *b,         /* I b Vector */\r
-    SKP_int32           *x_Q16      /* O x Vector */  \r
+    const opus_int32     *L_Q16,     /* I Pointer to Lower Triangular Matrix */\r
+    const opus_int       M,          /* I Dim of Matrix equation */\r
+    const opus_int32     *b,         /* I b Vector */\r
+    opus_int32           *x_Q16      /* O x Vector */  \r
 )\r
 {\r
-    SKP_int i, j;\r
-    const SKP_int32 *ptr32;\r
-    SKP_int32 tmp_32;\r
+    opus_int i, j;\r
+    const opus_int32 *ptr32;\r
+    opus_int32 tmp_32;\r
 \r
     for( i = M - 1; i >= 0; i-- ) {\r
         ptr32 = matrix_adr( L_Q16, 0, i, M );\r
index d60eb92..d7d5d87 100644 (file)
@@ -41,24 +41,24 @@ extern "C"
 /* Noise shaping analysis state */\r
 /********************************/\r
 typedef struct {\r
-    SKP_int8    LastGainIndex;\r
-    SKP_int32   HarmBoost_smth_Q16;\r
-    SKP_int32   HarmShapeGain_smth_Q16;\r
-    SKP_int32   Tilt_smth_Q16;\r
+    opus_int8    LastGainIndex;\r
+    opus_int32   HarmBoost_smth_Q16;\r
+    opus_int32   HarmShapeGain_smth_Q16;\r
+    opus_int32   Tilt_smth_Q16;\r
 } silk_shape_state_FIX;\r
 \r
 /********************************/\r
 /* Prefilter state              */\r
 /********************************/\r
 typedef struct {\r
-    SKP_int16   sLTP_shp[ LTP_BUF_LENGTH ];\r
-    SKP_int32   sAR_shp[ MAX_SHAPE_LPC_ORDER + 1 ];\r
-    SKP_int     sLTP_shp_buf_idx;\r
-    SKP_int32   sLF_AR_shp_Q12;\r
-    SKP_int32   sLF_MA_shp_Q12;\r
-    SKP_int     sHarmHP;\r
-    SKP_int32   rand_seed;\r
-    SKP_int     lagPrev;\r
+    opus_int16   sLTP_shp[ LTP_BUF_LENGTH ];\r
+    opus_int32   sAR_shp[ MAX_SHAPE_LPC_ORDER + 1 ];\r
+    opus_int     sLTP_shp_buf_idx;\r
+    opus_int32   sLF_AR_shp_Q12;\r
+    opus_int32   sLF_MA_shp_Q12;\r
+    opus_int     sHarmHP;\r
+    opus_int32   rand_seed;\r
+    opus_int     lagPrev;\r
 } silk_prefilter_state_FIX;\r
 \r
 /********************************/\r
@@ -70,12 +70,12 @@ typedef struct {
     silk_prefilter_state_FIX    sPrefilt;                   /* Prefilter State                                                  */\r
 \r
     /* Buffer for find pitch and noise shape analysis */\r
-    SKP_DWORD_ALIGN SKP_int16   x_buf[ 2 * MAX_FRAME_LENGTH + LA_SHAPE_MAX ];/* Buffer for find pitch and noise shape analysis  */\r
-    SKP_int                     LTPCorr_Q15;                /* Normalized correlation from pitch lag estimator                  */\r
+    SKP_DWORD_ALIGN opus_int16   x_buf[ 2 * MAX_FRAME_LENGTH + LA_SHAPE_MAX ];/* Buffer for find pitch and noise shape analysis  */\r
+    opus_int                     LTPCorr_Q15;                /* Normalized correlation from pitch lag estimator                  */\r
  \r
     /* Parameters For LTP scaling Control */\r
-    SKP_int                     prevLTPredCodGain_Q7;\r
-    SKP_int                     HPLTPredCodGain_Q7;\r
+    opus_int                     prevLTPredCodGain_Q7;\r
+    opus_int                     HPLTPredCodGain_Q7;\r
 } silk_encoder_state_FIX;\r
 \r
 /************************/\r
@@ -83,31 +83,31 @@ typedef struct {
 /************************/\r
 typedef struct {\r
     /* Prediction and coding parameters */\r
-    SKP_int32                   Gains_Q16[ MAX_NB_SUBFR ];\r
-    SKP_DWORD_ALIGN SKP_int16   PredCoef_Q12[ 2 ][ MAX_LPC_ORDER ];\r
-    SKP_int16                   LTPCoef_Q14[ LTP_ORDER * MAX_NB_SUBFR ];\r
-    SKP_int                     LTP_scale_Q14;\r
-    SKP_int                     pitchL[ MAX_NB_SUBFR ];\r
+    opus_int32                   Gains_Q16[ MAX_NB_SUBFR ];\r
+    SKP_DWORD_ALIGN opus_int16   PredCoef_Q12[ 2 ][ MAX_LPC_ORDER ];\r
+    opus_int16                   LTPCoef_Q14[ LTP_ORDER * MAX_NB_SUBFR ];\r
+    opus_int                     LTP_scale_Q14;\r
+    opus_int                     pitchL[ MAX_NB_SUBFR ];\r
 \r
     /* Noise shaping parameters */\r
     /* Testing */\r
-    SKP_DWORD_ALIGN SKP_int16 AR1_Q13[ MAX_NB_SUBFR * MAX_SHAPE_LPC_ORDER ];\r
-    SKP_DWORD_ALIGN SKP_int16 AR2_Q13[ MAX_NB_SUBFR * MAX_SHAPE_LPC_ORDER ];\r
-    SKP_int32   LF_shp_Q14[        MAX_NB_SUBFR ];          /* Packs two int16 coefficients per int32 value             */\r
-    SKP_int     GainsPre_Q14[      MAX_NB_SUBFR ];\r
-    SKP_int     HarmBoost_Q14[     MAX_NB_SUBFR ];\r
-    SKP_int     Tilt_Q14[          MAX_NB_SUBFR ];\r
-    SKP_int     HarmShapeGain_Q14[ MAX_NB_SUBFR ];\r
-    SKP_int     Lambda_Q10;\r
-    SKP_int     input_quality_Q14;\r
-    SKP_int     coding_quality_Q14;\r
+    SKP_DWORD_ALIGN opus_int16 AR1_Q13[ MAX_NB_SUBFR * MAX_SHAPE_LPC_ORDER ];\r
+    SKP_DWORD_ALIGN opus_int16 AR2_Q13[ MAX_NB_SUBFR * MAX_SHAPE_LPC_ORDER ];\r
+    opus_int32   LF_shp_Q14[        MAX_NB_SUBFR ];          /* Packs two int16 coefficients per int32 value             */\r
+    opus_int     GainsPre_Q14[      MAX_NB_SUBFR ];\r
+    opus_int     HarmBoost_Q14[     MAX_NB_SUBFR ];\r
+    opus_int     Tilt_Q14[          MAX_NB_SUBFR ];\r
+    opus_int     HarmShapeGain_Q14[ MAX_NB_SUBFR ];\r
+    opus_int     Lambda_Q10;\r
+    opus_int     input_quality_Q14;\r
+    opus_int     coding_quality_Q14;\r
 \r
     /* measures */\r
-    SKP_int     sparseness_Q8;\r
-    SKP_int32   predGain_Q16;\r
-    SKP_int     LTPredCodGain_Q7;\r
-    SKP_int32   ResNrg[ MAX_NB_SUBFR ];             /* Residual energy per subframe                             */\r
-    SKP_int     ResNrgQ[ MAX_NB_SUBFR ];            /* Q domain for the residual energy > 0                     */\r
+    opus_int     sparseness_Q8;\r
+    opus_int32   predGain_Q16;\r
+    opus_int     LTPredCodGain_Q7;\r
+    opus_int32   ResNrg[ MAX_NB_SUBFR ];             /* Residual energy per subframe                             */\r
+    opus_int     ResNrgQ[ MAX_NB_SUBFR ];            /* Q domain for the residual energy > 0                     */\r
     \r
 } silk_encoder_control_FIX;\r
 \r
@@ -117,11 +117,11 @@ typedef struct {
 typedef struct {\r
     silk_encoder_state_FIX  state_Fxx[ ENCODER_NUM_CHANNELS ];\r
     stereo_enc_state        sStereo;\r
-    SKP_int32               nBitsExceeded;\r
-    SKP_int                 nChannelsAPI;\r
-    SKP_int                 nChannelsInternal;\r
-    SKP_int                 timeSinceSwitchAllowed_ms;\r
-    SKP_int                 allowBandwidthSwitch;\r
+    opus_int32               nBitsExceeded;\r
+    opus_int                 nChannelsAPI;\r
+    opus_int                 nChannelsInternal;\r
+    opus_int                 timeSinceSwitchAllowed_ms;\r
+    opus_int                 allowBandwidthSwitch;\r
 } silk_encoder;\r
 \r
 \r
index 18a3cad..2f34cb9 100644 (file)
@@ -32,18 +32,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 \r
 /* Autocorrelations for a warped frequency axis */\r
 void silk_warped_autocorrelation_FIX(\r
-          SKP_int32                 *corr,              /* O    Result [order + 1]                      */\r
-          SKP_int                   *scale,             /* O    Scaling of the correlation vector       */\r
-    const SKP_int16                 *input,             /* I    Input data to correlate                 */\r
-    const SKP_int                   warping_Q16,        /* I    Warping coefficient                     */\r
-    const SKP_int                   length,             /* I    Length of input                         */\r
-    const SKP_int                   order               /* I    Correlation order (even)                */\r
+          opus_int32                 *corr,              /* O    Result [order + 1]                      */\r
+          opus_int                   *scale,             /* O    Scaling of the correlation vector       */\r
+    const opus_int16                 *input,             /* I    Input data to correlate                 */\r
+    const opus_int                   warping_Q16,        /* I    Warping coefficient                     */\r
+    const opus_int                   length,             /* I    Length of input                         */\r
+    const opus_int                   order               /* I    Correlation order (even)                */\r
 )\r
 {\r
-    SKP_int   n, i, lsh;\r
-    SKP_int32 tmp1_QS, tmp2_QS;\r
-    SKP_int32 state_QS[ MAX_SHAPE_LPC_ORDER + 1 ] = { 0 };\r
-    SKP_int64 corr_QC[  MAX_SHAPE_LPC_ORDER + 1 ] = { 0 };\r
+    opus_int   n, i, lsh;\r
+    opus_int32 tmp1_QS, tmp2_QS;\r
+    opus_int32 state_QS[ MAX_SHAPE_LPC_ORDER + 1 ] = { 0 };\r
+    opus_int64 corr_QC[  MAX_SHAPE_LPC_ORDER + 1 ] = { 0 };\r
 \r
     /* Order must be even */\r
     SKP_assert( ( order & 1 ) == 0 );\r
@@ -51,7 +51,7 @@ void silk_warped_autocorrelation_FIX(
 \r
     /* Loop over samples */\r
     for( n = 0; n < length; n++ ) {\r
-        tmp1_QS = SKP_LSHIFT32( ( SKP_int32 )input[ n ], QS );\r
+        tmp1_QS = SKP_LSHIFT32( ( opus_int32 )input[ n ], QS );\r
         /* Loop over allpass sections */\r
         for( i = 0; i < order; i += 2 ) {\r
             /* Output of allpass section */\r
@@ -73,11 +73,11 @@ void silk_warped_autocorrelation_FIX(
     SKP_assert( *scale >= -30 && *scale <= 12 );\r
     if( lsh >= 0 ) {\r
         for( i = 0; i < order + 1; i++ ) {\r
-            corr[ i ] = ( SKP_int32 )SKP_CHECK_FIT32( SKP_LSHIFT64( corr_QC[ i ], lsh ) );\r
+            corr[ i ] = ( opus_int32 )SKP_CHECK_FIT32( SKP_LSHIFT64( corr_QC[ i ], lsh ) );\r
         }\r
     } else {\r
         for( i = 0; i < order + 1; i++ ) {\r
-            corr[ i ] = ( SKP_int32 )SKP_CHECK_FIT32( SKP_RSHIFT64( corr_QC[ i ], -lsh ) );\r
+            corr[ i ] = ( opus_int32 )SKP_CHECK_FIT32( SKP_RSHIFT64( corr_QC[ i ], -lsh ) );\r
         }    \r
     }\r
     SKP_assert( corr_QC[ 0 ] >= 0 ); // If breaking, decrease QC\r
index 7f506c4..645a645 100644 (file)
@@ -40,10 +40,10 @@ void silk_LPC_analysis_filter16_FLP(
           SKP_float                 r_LPC[],            /* O    LPC residual signal                     */\r
     const SKP_float                 PredCoef[],         /* I    LPC coefficients                        */\r
     const SKP_float                 s[],                /* I    Input signal                            */\r
-    const SKP_int                   length              /* I    Length of input signal                  */\r
+    const opus_int                   length              /* I    Length of input signal                  */\r
 )\r
 {\r
-    SKP_int   ix;\r
+    opus_int   ix;\r
     SKP_float LPC_pred;\r
     const SKP_float *s_ptr;\r
 \r
@@ -78,10 +78,10 @@ void silk_LPC_analysis_filter14_FLP(
           SKP_float                 r_LPC[],            /* O    LPC residual signal                     */\r
     const SKP_float                 PredCoef[],         /* I    LPC coefficients                        */\r
     const SKP_float                 s[],                /* I    Input signal                            */\r
-    const SKP_int                   length              /* I    Length of input signal                  */\r
+    const opus_int                   length              /* I    Length of input signal                  */\r
 )\r
 {\r
-    SKP_int   ix;\r
+    opus_int   ix;\r
     SKP_float LPC_pred;\r
     const SKP_float *s_ptr;\r
 \r
@@ -114,10 +114,10 @@ void silk_LPC_analysis_filter12_FLP(
           SKP_float                 r_LPC[],            /* O    LPC residual signal                     */\r
     const SKP_float                 PredCoef[],         /* I    LPC coefficients                        */\r
     const SKP_float                 s[],                /* I    Input signal                            */\r
-    const SKP_int                   length              /* I    Length of input signal                  */\r
+    const opus_int                   length              /* I    Length of input signal                  */\r
 )\r
 {\r
-    SKP_int   ix;\r
+    opus_int   ix;\r
     SKP_float LPC_pred;\r
     const SKP_float *s_ptr;\r
 \r
@@ -148,10 +148,10 @@ void silk_LPC_analysis_filter10_FLP(
           SKP_float                 r_LPC[],            /* O    LPC residual signal                     */\r
     const SKP_float                 PredCoef[],         /* I    LPC coefficients                        */\r
     const SKP_float                 s[],                /* I    Input signal                            */\r
-    const SKP_int                   length              /* I    Length of input signal                  */\r
+    const opus_int                   length              /* I    Length of input signal                  */\r
 )\r
 {\r
-    SKP_int   ix;\r
+    opus_int   ix;\r
     SKP_float LPC_pred;\r
     const SKP_float *s_ptr;\r
 \r
@@ -180,10 +180,10 @@ void silk_LPC_analysis_filter8_FLP(
           SKP_float                 r_LPC[],            /* O    LPC residual signal                     */\r
     const SKP_float                 PredCoef[],         /* I    LPC coefficients                        */\r
     const SKP_float                 s[],                /* I    Input signal                            */\r
-    const SKP_int                   length              /* I    Length of input signal                  */\r
+    const opus_int                   length              /* I    Length of input signal                  */\r
 )\r
 {\r
-    SKP_int   ix;\r
+    opus_int   ix;\r
     SKP_float LPC_pred;\r
     const SKP_float *s_ptr;\r
 \r
@@ -210,10 +210,10 @@ void silk_LPC_analysis_filter6_FLP(
           SKP_float                 r_LPC[],            /* O    LPC residual signal                     */\r
     const SKP_float                 PredCoef[],         /* I    LPC coefficients                        */\r
     const SKP_float                 s[],                /* I    Input signal                            */\r
-    const SKP_int                   length              /* I    Length of input signal                  */\r
+    const opus_int                   length              /* I    Length of input signal                  */\r
 )\r
 {\r
-    SKP_int   ix;\r
+    opus_int   ix;\r
     SKP_float LPC_pred;\r
     const SKP_float *s_ptr;\r
 \r
@@ -244,8 +244,8 @@ void silk_LPC_analysis_filter_FLP(
           SKP_float                 r_LPC[],            /* O    LPC residual signal                     */\r
     const SKP_float                 PredCoef[],         /* I    LPC coefficients                        */\r
     const SKP_float                 s[],                /* I    Input signal                            */\r
-    const SKP_int                   length,             /* I    Length of input signal                  */\r
-    const SKP_int                   Order               /* I    LPC order                               */\r
+    const opus_int                   length,             /* I    Length of input signal                  */\r
+    const opus_int                   Order               /* I    LPC order                               */\r
 )\r
 {\r
     SKP_assert( Order <= length );\r
index 512ae5d..9e5a3c8 100644 (file)
@@ -33,13 +33,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /* compute inverse of LPC prediction gain, and                          */\r
 /* test if LPC coefficients are stable (all poles within unit circle)   */\r
 /* this code is based on silk_a2k_FLP()                               */\r
-SKP_int silk_LPC_inverse_pred_gain_FLP(   /* O:   returns 1 if unstable, otherwise 0      */\r
+opus_int silk_LPC_inverse_pred_gain_FLP(   /* O:   returns 1 if unstable, otherwise 0      */\r
     SKP_float       *invGain,               /* O:   inverse prediction gain, energy domain  */\r
     const SKP_float *A,                     /* I:   prediction coefficients [order]         */\r
-    SKP_int32       order                   /* I:   prediction order                        */\r
+    opus_int32       order                   /* I:   prediction order                        */\r
 )\r
 {\r
-    SKP_int   k, n;\r
+    opus_int   k, n;\r
     double    rc, rc_mult1, rc_mult2;\r
     SKP_float Atmp[ 2 ][ SILK_MAX_ORDER_LPC ];\r
     SKP_float *Aold, *Anew;\r
index 3bf6169..60d04ee 100644 (file)
@@ -31,18 +31,18 @@ void silk_LTP_analysis_filter_FLP(
           SKP_float         *LTP_res,                       /* O    LTP res MAX_NB_SUBFR*(pre_lgth+subfr_lngth) */\r
     const SKP_float         *x,                             /* I    Input signal, with preceeding samples       */\r
     const SKP_float         B[ LTP_ORDER * MAX_NB_SUBFR ],  /* I    LTP coefficients for each subframe          */\r
-    const SKP_int           pitchL[   MAX_NB_SUBFR ],       /* I    Pitch lags                                  */\r
+    const opus_int           pitchL[   MAX_NB_SUBFR ],       /* I    Pitch lags                                  */\r
     const SKP_float         invGains[ MAX_NB_SUBFR ],       /* I    Inverse quantization gains                  */\r
-    const SKP_int           subfr_length,                   /* I    Length of each subframe                     */\r
-    const SKP_int           nb_subfr,                       /* I    number of subframes                         */\r
-    const SKP_int           pre_length                      /* I    Preceeding samples for each subframe        */\r
+    const opus_int           subfr_length,                   /* I    Length of each subframe                     */\r
+    const opus_int           nb_subfr,                       /* I    number of subframes                         */\r
+    const opus_int           pre_length                      /* I    Preceeding samples for each subframe        */\r
 )\r
 {\r
     const SKP_float *x_ptr, *x_lag_ptr;\r
     SKP_float   Btmp[ LTP_ORDER ];\r
     SKP_float   *LTP_res_ptr;\r
     SKP_float   inv_gain;\r
-    SKP_int     k, i, j;\r
+    opus_int     k, i, j;\r
 \r
     x_ptr = x;\r
     LTP_res_ptr = LTP_res;\r
index 437c524..6babea3 100644 (file)
@@ -32,7 +32,7 @@ void silk_LTP_scale_ctrl_FLP(
     silk_encoder_control_FLP    *psEncCtrl          /* I/O  Encoder control FLP                     */\r
 )\r
 {\r
-    SKP_int   round_loss;\r
+    opus_int   round_loss;\r
 \r
     /* 1st order high-pass filter */\r
     //g_HP(n) = g(n) - 0.5 * g(n-1) + 0.5 * g_HP(n-1);\r
@@ -43,7 +43,7 @@ void silk_LTP_scale_ctrl_FLP(
     /* Only scale if first frame in packet */\r
     if( psEnc->sCmn.nFramesEncoded == 0 ) {\r
         round_loss = psEnc->sCmn.PacketLoss_perc + psEnc->sCmn.nFramesPerPacket;\r
-        psEnc->sCmn.indices.LTP_scaleIndex = (SKP_int8)SKP_LIMIT( round_loss * psEnc->HPLTPredCodGain * 0.1f, 0.0f, 2.0f );\r
+        psEnc->sCmn.indices.LTP_scaleIndex = (opus_int8)SKP_LIMIT( round_loss * psEnc->HPLTPredCodGain * 0.1f, 0.0f, 2.0f );\r
     } else {\r
         /* Default is minimum scaling */\r
         psEnc->sCmn.indices.LTP_scaleIndex = 0;\r
index b20bcfd..ece5af2 100644 (file)
@@ -43,44 +43,44 @@ extern "C"
 /* Chirp (bw expand) LP AR filter */\r
 void silk_bwexpander_FLP( \r
     SKP_float *ar,                     /* io   AR filter to be expanded (without leading 1)    */\r
-    const SKP_int d,                   /* i    length of ar                                       */\r
+    const opus_int d,                   /* i   length of ar                                       */\r
     const SKP_float chirp              /* i    chirp factor (typically in range (0..1) )          */\r
 );\r
 \r
 /* compute inverse of LPC prediction gain, and                                                 */\r
 /* test if LPC coefficients are stable (all poles within unit circle)  */\r
 /* this code is based on silk_FLP_a2k()                                                                    */\r
-SKP_int silk_LPC_inverse_pred_gain_FLP( /* O:   returns 1 if unstable, otherwise 0    */\r
+opus_int silk_LPC_inverse_pred_gain_FLP( /* O:   returns 1 if unstable, otherwise 0    */\r
     SKP_float            *invGain,      /* O:   inverse prediction gain, energy domain   */\r
     const SKP_float      *A,            /* I:   prediction coefficients [order]           */\r
-    SKP_int32            order          /* I:   prediction order                          */\r
+    opus_int32            order          /* I:   prediction order                          */\r
 );\r
 \r
 SKP_float silk_schur_FLP(               /* O    returns residual energy                     */\r
     SKP_float       refl_coef[],        /* O    reflection coefficients (length order)      */\r
     const SKP_float auto_corr[],        /* I    autocorrelation sequence (length order+1)   */\r
-    SKP_int         order               /* I    order                                       */\r
+    opus_int         order               /* I    order                                       */\r
 );\r
 \r
 void silk_k2a_FLP(\r
     SKP_float           *A,             /* O:  prediction coefficients [order]           */\r
     const SKP_float     *rc,            /* I:  reflection coefficients [order]           */\r
-    SKP_int32           order           /* I:  prediction order                          */\r
+    opus_int32           order           /* I: prediction order                          */\r
 );\r
 \r
 /* Solve the normal equations using the Levinson-Durbin recursion */\r
 SKP_float silk_levinsondurbin_FLP(         /* O        prediction error energy                                         */\r
        SKP_float               A[],                            /* O    prediction coefficients [order]                         */\r
        const SKP_float corr[],                         /* I    input auto-correlations [order + 1]                     */\r
-       const SKP_int   order                           /* I    prediction order                                                        */\r
+       const opus_int  order                           /* I    prediction order                                                        */\r
 );\r
 \r
 /* compute autocorrelation */\r
 void silk_autocorrelation_FLP( \r
     SKP_float *results,                 /* o    result (length correlationCount)            */\r
     const SKP_float *inputData,         /* i    input data to correlate                     */\r
-    SKP_int inputDataSize,              /* i    length of input                             */\r
-    SKP_int correlationCount            /* i    number of correlation taps to compute       */\r
+    opus_int inputDataSize,              /* i    length of input                             */\r
+    opus_int correlationCount            /* i    number of correlation taps to compute       */\r
 );\r
 \r
 /* Pitch estimator */\r
@@ -88,44 +88,44 @@ void silk_autocorrelation_FLP(
 #define SigProc_PE_MID_COMPLEX        1\r
 #define SigProc_PE_MAX_COMPLEX        2\r
 \r
-SKP_int silk_pitch_analysis_core_FLP(   /* O voicing estimate: 0 voiced, 1 unvoiced                         */\r
+opus_int silk_pitch_analysis_core_FLP(   /* O voicing estimate: 0 voiced, 1 unvoiced                         */\r
     const SKP_float *signal,            /* I signal of length PE_FRAME_LENGTH_MS*Fs_kHz                     */\r
-    SKP_int         *pitch_out,         /* O 4 pitch lag values                                             */\r
-    SKP_int16       *lagIndex,          /* O lag Index                                                      */\r
-    SKP_int8        *contourIndex,      /* O pitch contour Index                                            */\r
+    opus_int         *pitch_out,         /* O 4 pitch lag values                                             */\r
+    opus_int16       *lagIndex,          /* O lag Index                                                      */\r
+    opus_int8        *contourIndex,      /* O pitch contour Index                                            */\r
     SKP_float       *LTPCorr,           /* I/O normalized correlation; input: value from previous frame     */\r
-    SKP_int         prevLag,            /* I last lag of previous frame; set to zero is unvoiced            */\r
+    opus_int         prevLag,            /* I last lag of previous frame; set to zero is unvoiced            */\r
     const SKP_float search_thres1,      /* I first stage threshold for lag candidates 0 - 1                 */\r
     const SKP_float search_thres2,      /* I final threshold for lag candidates 0 - 1                       */\r
-    const SKP_int   Fs_kHz,             /* I sample frequency (kHz)                                         */\r
-    const SKP_int   complexity,         /* I Complexity setting, 0-2, where 2 is highest                    */\r
-    const SKP_int   nb_subfr            /* I    number of 5 ms subframes                                    */\r
+    const opus_int   Fs_kHz,             /* I sample frequency (kHz)                                         */\r
+    const opus_int   complexity,         /* I Complexity setting, 0-2, where 2 is highest                    */\r
+    const opus_int   nb_subfr            /* I    number of 5 ms subframes                                    */\r
 );\r
 \r
 #define PI               (3.1415926536f)\r
 \r
 void silk_insertion_sort_decreasing_FLP(\r
     SKP_float            *a,            /* I/O:  Unsorted / Sorted vector                */\r
-    SKP_int              *idx,          /* O:    Index vector for the sorted elements    */\r
-    const SKP_int        L,             /* I:    Vector length                           */\r
-    const SKP_int        K              /* I:    Number of correctly sorted positions    */\r
+    opus_int              *idx,          /* O:    Index vector for the sorted elements    */\r
+    const opus_int        L,             /* I:    Vector length                           */\r
+    const opus_int        K              /* I:    Number of correctly sorted positions    */\r
 );\r
 \r
 /* Compute reflection coefficients from input signal */\r
 SKP_float silk_burg_modified_FLP(           /* O    returns residual energy                                         */\r
     SKP_float           A[],                /* O    prediction coefficients (length order)                          */\r
     const SKP_float     x[],                /* I    input signal, length: nb_subfr*(D+L_sub)                        */\r
-    const SKP_int       subfr_length,       /* I    input signal subframe length (including D preceeding samples)   */\r
-    const SKP_int       nb_subfr,           /* I    number of subframes stacked in x                                */\r
+    const opus_int       subfr_length,       /* I    input signal subframe length (including D preceeding samples)   */\r
+    const opus_int       nb_subfr,           /* I    number of subframes stacked in x                                */\r
     const SKP_float     WhiteNoiseFrac,     /* I    fraction added to zero-lag autocorrelation                      */\r
-    const SKP_int       D                   /* I    order                                                           */\r
+    const opus_int       D                   /* I    order                                                           */\r
 );\r
 \r
 /* multiply a vector by a constant */\r
 void silk_scale_vector_FLP( \r
     SKP_float           *data1,\r
     SKP_float           gain, \r
-    SKP_int             dataSize\r
+    opus_int             dataSize\r
 );\r
 \r
 /* copy and multiply a vector by a constant */\r
@@ -133,20 +133,20 @@ void silk_scale_copy_vector_FLP(
     SKP_float           *data_out, \r
     const SKP_float     *data_in, \r
     SKP_float           gain, \r
-    SKP_int             dataSize\r
+    opus_int             dataSize\r
 );\r
 \r
 /* inner product of two SKP_float arrays, with result as double */\r
 double silk_inner_product_FLP( \r
     const SKP_float     *data1, \r
     const SKP_float     *data2, \r
-    SKP_int             dataSize\r
+    opus_int             dataSize\r
 );\r
 \r
 /* sum of squares of a SKP_float array, with result as double */\r
 double silk_energy_FLP( \r
     const SKP_float     *data, \r
-    SKP_int             dataSize\r
+    opus_int             dataSize\r
 );\r
 \r
 /********************************************************************/\r
@@ -167,31 +167,31 @@ SKP_INLINE SKP_float SKP_sigmoid(SKP_float x)
 }\r
 \r
 /* floating-point to integer conversion (rounding) */\r
-SKP_INLINE SKP_int32 SKP_float2int(double x) \r
+SKP_INLINE opus_int32 SKP_float2int(double x) \r
 {\r
 #ifdef _WIN32\r
        double t = x + 6755399441055744.0;\r
-       return *((SKP_int32 *)( &t ));\r
+       return *((opus_int32 *)( &t ));\r
 #else\r
-       return (SKP_int32)( ( x > 0 ) ? x + 0.5 : x - 0.5 );\r
+       return (opus_int32)( ( x > 0 ) ? x + 0.5 : x - 0.5 );\r
 #endif\r
 }\r
 \r
 /* floating-point to integer conversion (rounding) */\r
 SKP_INLINE void SKP_float2short_array(\r
-    SKP_int16       *out, \r
+    opus_int16       *out, \r
     const SKP_float *in, \r
-    SKP_int32       length\r
+    opus_int32       length\r
 ) \r
 {\r
-    SKP_int32 k;\r
+    opus_int32 k;\r
     for (k = length-1; k >= 0; k--) {\r
 #ifdef _WIN32\r
                double t = in[k] + 6755399441055744.0;\r
-               out[k] = (SKP_int16)SKP_SAT16(*(( SKP_int32 * )( &t )));\r
+               out[k] = (opus_int16)SKP_SAT16(*(( opus_int32 * )( &t )));\r
 #else\r
                double x = in[k];\r
-               out[k] = (SKP_int16)SKP_SAT16( ( x > 0 ) ? x + 0.5 : x - 0.5 );\r
+               out[k] = (opus_int16)SKP_SAT16( ( x > 0 ) ? x + 0.5 : x - 0.5 );\r
 #endif\r
     }\r
 }\r
@@ -199,11 +199,11 @@ SKP_INLINE void SKP_float2short_array(
 /* integer to floating-point conversion */\r
 SKP_INLINE void SKP_short2float_array(\r
     SKP_float       *out, \r
-    const SKP_int16 *in, \r
-    SKP_int32       length\r
+    const opus_int16 *in, \r
+    opus_int32       length\r
 ) \r
 {\r
-    SKP_int32 k;\r
+    opus_int32 k;\r
     for (k = length-1; k >= 0; k--) {\r
         out[k] = (SKP_float)in[k];\r
     }\r
index 450be05..e52075c 100644 (file)
@@ -34,11 +34,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 void silk_apply_sine_window_FLP(\r
           SKP_float                 px_win[],           /* O    Pointer to windowed signal              */\r
     const SKP_float                 px[],               /* I    Pointer to input signal                 */\r
-    const SKP_int                   win_type,           /* I    Selects a window type                   */\r
-    const SKP_int                   length              /* I    Window length, multiple of 4            */\r
+    const opus_int                   win_type,           /* I    Selects a window type                   */\r
+    const opus_int                   length              /* I    Window length, multiple of 4            */\r
 )\r
 {\r
-    SKP_int   k;\r
+    opus_int   k;\r
     SKP_float freq, c, S0, S1;\r
 \r
     SKP_assert( win_type == 1 || win_type == 2 );\r
index 7cbf871..991513c 100644 (file)
@@ -32,11 +32,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 void silk_autocorrelation_FLP( \r
     SKP_float       *results,           /* O    result (length correlationCount)            */\r
     const SKP_float *inputData,         /* I    input data to correlate                     */\r
-    SKP_int         inputDataSize,      /* I    length of input                             */\r
-    SKP_int         correlationCount    /* I    number of correlation taps to compute       */\r
+    opus_int         inputDataSize,      /* I    length of input                             */\r
+    opus_int         correlationCount    /* I    number of correlation taps to compute       */\r
 )\r
 {\r
-    SKP_int i;\r
+    opus_int i;\r
 \r
     if ( correlationCount > inputDataSize ) {\r
         correlationCount = inputDataSize;\r
index 563216a..622f061 100644 (file)
@@ -34,13 +34,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 SKP_float silk_burg_modified_FLP(   /* O    returns residual energy                                         */\r
     SKP_float       A[],                /* O    prediction coefficients (length order)                          */\r
     const SKP_float x[],                /* I    input signal, length: nb_subfr*(D+L_sub)                        */\r
-    const SKP_int   subfr_length,       /* I    input signal subframe length (including D preceeding samples)   */\r
-    const SKP_int   nb_subfr,           /* I    number of subframes stacked in x                                */\r
+    const opus_int   subfr_length,       /* I    input signal subframe length (including D preceeding samples)   */\r
+    const opus_int   nb_subfr,           /* I    number of subframes stacked in x                                */\r
     const SKP_float WhiteNoiseFrac,     /* I    fraction added to zero-lag autocorrelation                      */\r
-    const SKP_int   D                   /* I    order                                                           */\r
+    const opus_int   D                   /* I    order                                                           */\r
 )\r
 {\r
-    SKP_int         k, n, s;\r
+    opus_int         k, n, s;\r
     double          C0, num, nrg_f, nrg_b, rc, Atmp, tmp1, tmp2;\r
     const SKP_float *x_ptr;\r
     double          C_first_row[ SILK_MAX_ORDER_LPC ], C_last_row[ SILK_MAX_ORDER_LPC ];\r
index d97328e..55d1fdd 100644 (file)
@@ -32,11 +32,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /* Chirp (bw expand) LP AR filter */\r
 void silk_bwexpander_FLP( \r
     SKP_float           *ar,        /* I/O  AR filter to be expanded (without leading 1)    */\r
-    const SKP_int       d,          /* I    length of ar                                    */\r
+    const opus_int       d,          /* I    length of ar                                    */\r
     const SKP_float     chirp       /* I    chirp factor (typically in range (0..1) )       */\r
 )\r
 {\r
-    SKP_int   i;\r
+    opus_int   i;\r
     SKP_float cfac = chirp;\r
 \r
     for( i = 0; i < d - 1; i++ ) {\r
index 4a25971..2b396ee 100644 (file)
@@ -35,12 +35,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 void silk_corrVector_FLP(\r
     const SKP_float                 *x,                 /* I    x vector [L+order-1] used to create X   */\r
     const SKP_float                 *t,                 /* I    Target vector [L]                       */\r
-    const SKP_int                   L,                  /* I    Length of vecors                        */\r
-    const SKP_int                   Order,              /* I    Max lag for correlation                 */\r
+    const opus_int                   L,                  /* I    Length of vecors                        */\r
+    const opus_int                   Order,              /* I    Max lag for correlation                 */\r
           SKP_float                 *Xt                 /* O    X'*t correlation vector [order]         */\r
 )\r
 {\r
-    SKP_int lag;\r
+    opus_int lag;\r
     const SKP_float *ptr1;\r
     \r
     ptr1 = &x[ Order - 1 ];                     /* Points to first sample of column 0 of X: X[:,0] */\r
@@ -54,12 +54,12 @@ void silk_corrVector_FLP(
 /* Calculates correlation matrix X'*X */\r
 void silk_corrMatrix_FLP(\r
     const SKP_float                 *x,                 /* I    x vector [ L+order-1 ] used to create X */\r
-    const SKP_int                   L,                  /* I    Length of vectors                       */\r
-    const SKP_int                   Order,              /* I    Max lag for correlation                 */\r
+    const opus_int                   L,                  /* I    Length of vectors                       */\r
+    const opus_int                   Order,              /* I    Max lag for correlation                 */\r
           SKP_float                 *XX                 /* O    X'*X correlation matrix [order x order] */\r
 )\r
 {\r
-    SKP_int j, lag;\r
+    opus_int j, lag;\r
     double  energy;\r
     const SKP_float *ptr1, *ptr2;\r
 \r
index d18f22b..b2e73f7 100644 (file)
@@ -31,14 +31,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /****************/\r
 /* Encode frame */\r
 /****************/\r
-SKP_int silk_encode_frame_FLP( \r
+opus_int silk_encode_frame_FLP( \r
     silk_encoder_state_FLP          *psEnc,             /* I/O  Encoder state FLP                       */\r
-    SKP_int32                       *pnBytesOut,        /*   O  Number of payload bytes                 */\r
+    opus_int32                       *pnBytesOut,        /*   O  Number of payload bytes                 */\r
     ec_enc                          *psRangeEnc         /* I/O  compressor data structure               */\r
 )\r
 {\r
     silk_encoder_control_FLP sEncCtrl;\r
-    SKP_int     i, ret = 0;\r
+    opus_int     i, ret = 0;\r
     SKP_float   *x_frame, *res_pitch_frame;\r
     SKP_float   xfw[ MAX_FRAME_LENGTH ];\r
     SKP_float   res_pitch[ 2 * MAX_FRAME_LENGTH + LA_PITCH_MAX ];\r
@@ -195,21 +195,21 @@ TOC(ENCODE_PULSES)
 TOC(ENCODE_FRAME)\r
 \r
 #ifdef SAVE_ALL_INTERNAL_DATA\r
-    //DEBUG_STORE_DATA( xf.dat,                   pIn_HP_LP,                           psEnc->sCmn.frame_length * sizeof( SKP_int16 ) );\r
+    //DEBUG_STORE_DATA( xf.dat,                   pIn_HP_LP,                           psEnc->sCmn.frame_length * sizeof( opus_int16 ) );\r
     //DEBUG_STORE_DATA( xfw.dat,                  xfw,                                 psEnc->sCmn.frame_length * sizeof( SKP_float ) );\r
-    DEBUG_STORE_DATA( pitchL.dat,               sEncCtrl.pitchL,                                 MAX_NB_SUBFR * sizeof( SKP_int   ) );\r
+    DEBUG_STORE_DATA( pitchL.dat,               sEncCtrl.pitchL,                                 MAX_NB_SUBFR * sizeof( opus_int   ) );\r
     DEBUG_STORE_DATA( pitchG_quantized.dat,     sEncCtrl.LTPCoef,            psEnc->sCmn.nb_subfr * LTP_ORDER * sizeof( SKP_float ) );\r
     DEBUG_STORE_DATA( LTPcorr.dat,              &psEnc->LTPCorr,                                                sizeof( SKP_float ) );\r
     DEBUG_STORE_DATA( gains.dat,                sEncCtrl.Gains,                          psEnc->sCmn.nb_subfr * sizeof( SKP_float ) );\r
-    DEBUG_STORE_DATA( gains_indices.dat,        &psEnc->sCmn.indices.GainsIndices,       psEnc->sCmn.nb_subfr * sizeof( SKP_int8  ) );\r
-    DEBUG_STORE_DATA( quantOffsetType.dat,      &psEnc->sCmn.indices.quantOffsetType,                           sizeof( SKP_int8  ) );\r
-    DEBUG_STORE_DATA( speech_activity_q8.dat,   &psEnc->sCmn.speech_activity_Q8,                                sizeof( SKP_int   ) );\r
-    DEBUG_STORE_DATA( signalType.dat,           &psEnc->sCmn.indices.signalType,                                sizeof( SKP_int8  ) ); \r
-    DEBUG_STORE_DATA( lag_index.dat,            &psEnc->sCmn.indices.lagIndex,                                  sizeof( SKP_int16 ) ); \r
-    DEBUG_STORE_DATA( contour_index.dat,        &psEnc->sCmn.indices.contourIndex,                              sizeof( SKP_int8  ) ); \r
-    DEBUG_STORE_DATA( per_index.dat,            &psEnc->sCmn.indices.PERIndex,                                  sizeof( SKP_int8  ) );\r
+    DEBUG_STORE_DATA( gains_indices.dat,        &psEnc->sCmn.indices.GainsIndices,       psEnc->sCmn.nb_subfr * sizeof( opus_int8  ) );\r
+    DEBUG_STORE_DATA( quantOffsetType.dat,      &psEnc->sCmn.indices.quantOffsetType,                           sizeof( opus_int8  ) );\r
+    DEBUG_STORE_DATA( speech_activity_q8.dat,   &psEnc->sCmn.speech_activity_Q8,                                sizeof( opus_int   ) );\r
+    DEBUG_STORE_DATA( signalType.dat,           &psEnc->sCmn.indices.signalType,                                sizeof( opus_int8  ) ); \r
+    DEBUG_STORE_DATA( lag_index.dat,            &psEnc->sCmn.indices.lagIndex,                                  sizeof( opus_int16 ) ); \r
+    DEBUG_STORE_DATA( contour_index.dat,        &psEnc->sCmn.indices.contourIndex,                              sizeof( opus_int8  ) ); \r
+    DEBUG_STORE_DATA( per_index.dat,            &psEnc->sCmn.indices.PERIndex,                                  sizeof( opus_int8  ) );\r
     DEBUG_STORE_DATA( PredCoef.dat,             &sEncCtrl.PredCoef[ 1 ],          psEnc->sCmn.predictLPCOrder * sizeof( SKP_float ) );\r
-    DEBUG_STORE_DATA( ltp_scale_idx.dat,        &psEnc->sCmn.indices.LTP_scaleIndex,                            sizeof( SKP_int8   ) );\r
+    DEBUG_STORE_DATA( ltp_scale_idx.dat,        &psEnc->sCmn.indices.LTP_scaleIndex,                            sizeof( opus_int8   ) );\r
 //  DEBUG_STORE_DATA( xq.dat,                   psEnc->sCmn.sNSQ.xqBuf,                psEnc->sCmn.frame_length * sizeof( SKP_float ) );\r
 #endif\r
     return ret;\r
@@ -222,8 +222,8 @@ void silk_LBRR_encode_FLP(
     const SKP_float                 xfw[]               /* I    Input signal                            */\r
 )\r
 {\r
-    SKP_int     k;\r
-    SKP_int32   Gains_Q16[ MAX_NB_SUBFR ];\r
+    opus_int     k;\r
+    opus_int32   Gains_Q16[ MAX_NB_SUBFR ];\r
     SKP_float   TempGains[ MAX_NB_SUBFR ];\r
     SideInfoIndices *psIndices_LBRR = &psEnc->sCmn.indices_LBRR[ psEnc->sCmn.nFramesEncoded ];\r
     silk_nsq_state sNSQ_LBRR;\r
index 87cbb9e..86b6341 100644 (file)
@@ -30,10 +30,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /* sum of squares of a SKP_float array, with result as double */\r
 double silk_energy_FLP( \r
     const SKP_float     *data, \r
-    SKP_int             dataSize\r
+    opus_int             dataSize\r
 )\r
 {\r
-    SKP_int  i, dataSize4;\r
+    opus_int  i, dataSize4;\r
     double   result;\r
 \r
     /* 4x unrolled loop */\r
index 1ad3c1c..23657e5 100644 (file)
@@ -29,23 +29,23 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "silk_tuning_parameters.h"\r
 \r
 void silk_find_LPC_FLP(\r
-          SKP_int16                 NLSF_Q15[],             /* O    NLSFs                                   */\r
-          SKP_int8                  *interpIndex,           /* O    NLSF interp. index for NLSF interp.     */\r
-    const SKP_int16                 prev_NLSFq_Q15[],       /* I    Previous NLSFs, for NLSF interpolation  */\r
-    const SKP_int                   useInterpNLSFs,         /* I    Flag                                    */\r
-    const SKP_int                   firstFrameAfterReset,   /* I    Flag                                    */\r
-    const SKP_int                   LPC_order,              /* I    LPC order                               */\r
+          opus_int16                 NLSF_Q15[],             /* O    NLSFs                                   */\r
+          opus_int8                  *interpIndex,           /* O    NLSF interp. index for NLSF interp.     */\r
+    const opus_int16                 prev_NLSFq_Q15[],       /* I    Previous NLSFs, for NLSF interpolation  */\r
+    const opus_int                   useInterpNLSFs,         /* I    Flag                                    */\r
+    const opus_int                   firstFrameAfterReset,   /* I    Flag                                    */\r
+    const opus_int                   LPC_order,              /* I    LPC order                               */\r
     const SKP_float                 x[],                    /* I    Input signal                            */\r
-    const SKP_int                   subfr_length,           /* I    Subframe length incl preceeding samples */\r
-    const SKP_int                   nb_subfr                /* I:   Number of subframes                     */\r
+    const opus_int                   subfr_length,           /* I    Subframe length incl preceeding samples */\r
+    const opus_int                   nb_subfr                /* I:   Number of subframes                     */\r
 )\r
 {\r
-    SKP_int     k;\r
+    opus_int     k;\r
     SKP_float   a[ MAX_LPC_ORDER ];\r
 \r
     /* Used only for NLSF interpolation */\r
     double      res_nrg, res_nrg_2nd, res_nrg_interp;\r
-    SKP_int16   NLSF0_Q15[ MAX_LPC_ORDER ];\r
+    opus_int16   NLSF0_Q15[ MAX_LPC_ORDER ];\r
     SKP_float   a_tmp[ MAX_LPC_ORDER ];\r
     SKP_float   LPC_res[ ( MAX_FRAME_LENGTH + MAX_NB_SUBFR * MAX_LPC_ORDER ) / 2 ];\r
 \r
@@ -91,7 +91,7 @@ void silk_find_LPC_FLP(
             if( res_nrg_interp < res_nrg ) {\r
                 /* Interpolation has lower residual energy */\r
                 res_nrg = res_nrg_interp;\r
-                *interpIndex = (SKP_int8)k;\r
+                *interpIndex = (opus_int8)k;\r
             } else if( res_nrg_interp > res_nrg_2nd ) {\r
                 /* No reason to continue iterating - residual energies will continue to climb */\r
                 break;\r
index e8fe1e7..97ab20b 100644 (file)
@@ -33,14 +33,14 @@ void silk_find_LTP_FLP(
           SKP_float WLTP[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ], /* O    Weight for LTP quantization       */\r
           SKP_float *LTPredCodGain,                         /* O    LTP coding gain                         */\r
     const SKP_float r_lpc[],                                /* I    LPC residual                            */\r
-    const SKP_int   lag[  MAX_NB_SUBFR ],                   /* I    LTP lags                                */\r
+    const opus_int   lag[  MAX_NB_SUBFR ],                   /* I    LTP lags                                */\r
     const SKP_float Wght[ MAX_NB_SUBFR ],                   /* I    Weights                                 */\r
-    const SKP_int   subfr_length,                           /* I    Subframe length                         */\r
-    const SKP_int   nb_subfr,                               /* I    number of subframes                     */\r
-    const SKP_int   mem_offset                              /* I    Number of samples in LTP memory         */\r
+    const opus_int   subfr_length,                           /* I    Subframe length                         */\r
+    const opus_int   nb_subfr,                               /* I    number of subframes                     */\r
+    const opus_int   mem_offset                              /* I    Number of samples in LTP memory         */\r
 )\r
 {\r
-    SKP_int   i, k;\r
+    opus_int   i, k;\r
     SKP_float *b_ptr, temp, *WLTP_ptr;\r
     SKP_float LPC_res_nrg, LPC_LTP_res_nrg;\r
     SKP_float d[ MAX_NB_SUBFR ], m, g, delta_b[ LTP_ORDER ];\r
index 8f213ca..873c7e0 100644 (file)
@@ -36,7 +36,7 @@ void silk_find_pitch_lags_FLP(
     const SKP_float                 x[]                 /* I    Speech signal                           */\r
 )\r
 {\r
-    SKP_int   buf_len;\r
+    opus_int   buf_len;\r
     SKP_float thrhld, res_nrg;\r
     const SKP_float *x_buf_ptr, *x_buf;\r
     SKP_float auto_corr[ MAX_FIND_PITCH_LPC_ORDER + 1 ];\r
index 200c78c..e4be48e 100644 (file)
@@ -35,10 +35,10 @@ void silk_find_pred_coefs_FLP(
     const SKP_float                 x[]                 /* I    Speech signal                           */\r
 )\r
 {\r
-    SKP_int         i;\r
+    opus_int         i;\r
     SKP_float       WLTP[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ];\r
     SKP_float       invGains[ MAX_NB_SUBFR ], Wght[ MAX_NB_SUBFR ];\r
-    SKP_int16       NLSF_Q15[ MAX_LPC_ORDER ];\r
+    opus_int16       NLSF_Q15[ MAX_LPC_ORDER ];\r
     const SKP_float *x_ptr;\r
     SKP_float       *x_pre_ptr, LPC_in_pre[ MAX_NB_SUBFR * MAX_LPC_ORDER + MAX_FRAME_LENGTH ];\r
 \r
index 80ad1f5..55fbcf4 100644 (file)
@@ -31,10 +31,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 double silk_inner_product_FLP(      /* O    result              */\r
     const SKP_float     *data1,         /* I    vector 1            */\r
     const SKP_float     *data2,         /* I    vector 2            */\r
-    SKP_int             dataSize        /* I    length of vectors   */\r
+    opus_int             dataSize        /* I    length of vectors   */\r
 )\r
 {\r
-    SKP_int  i, dataSize4;\r
+    opus_int  i, dataSize4;\r
     double   result;\r
 \r
     /* 4x unrolled loop */\r
index 8aec7da..eedcae4 100644 (file)
@@ -31,10 +31,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 void silk_k2a_FLP(\r
     SKP_float       *A,                 /* O:   prediction coefficients [order]             */\r
     const SKP_float *rc,                /* I:   reflection coefficients [order]             */\r
-    SKP_int32       order               /* I:   prediction order                            */\r
+    opus_int32       order               /* I:   prediction order                            */\r
 )\r
 {\r
-    SKP_int   k, n;\r
+    opus_int   k, n;\r
     SKP_float Atmp[ SILK_MAX_ORDER_LPC ];\r
 \r
     for( k = 0; k < order; k++ ){\r
index b58a48a..b0bf862 100644 (file)
@@ -31,10 +31,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 SKP_float silk_levinsondurbin_FLP(    /* O    prediction error energy                     */\r
     SKP_float       A[],                /* O    prediction coefficients [order]             */\r
     const SKP_float corr[],             /* I    input auto-correlations [order + 1]         */\r
-    const SKP_int   order               /* I    prediction order                            */\r
+    const opus_int   order               /* I    prediction order                            */\r
 )\r
 {\r
-    SKP_int   i, mHalf, m;\r
+    opus_int   i, mHalf, m;\r
     SKP_float min_nrg, nrg, t, km, Atmp1, Atmp2;\r
     \r
     min_nrg = 1e-12f * corr[ 0 ] + 1e-9f;\r
index d1f7021..ccc552c 100644 (file)
@@ -51,13 +51,13 @@ extern "C"
 /* High-pass filter with cutoff frequency adaptation based on pitch lag statistics */\r
 void silk_HP_variable_cutoff(\r
     silk_encoder_state_Fxx          state_Fxx[],        /* I/O  Encoder states                          */\r
-    const SKP_int                   nChannels           /* I    Number of channels                      */\r
+    const opus_int                   nChannels           /* I    Number of channels                      */\r
 );\r
 \r
 /* Encoder main function */\r
-SKP_int silk_encode_frame_FLP( \r
+opus_int silk_encode_frame_FLP( \r
     silk_encoder_state_FLP          *psEnc,             /* I/O  Encoder state FLP                       */\r
-    SKP_int32                       *pnBytesOut,        /*   O  Number of payload bytes;                */\r
+    opus_int32                       *pnBytesOut,        /*   O  Number of payload bytes;                */\r
     ec_enc                          *psRangeEnc         /* I/O  compressor data structure               */\r
 );\r
 \r
@@ -69,17 +69,17 @@ void silk_LBRR_encode_FLP(
 );\r
 \r
 /* Initializes the Silk encoder state */\r
-SKP_int silk_init_encoder(\r
+opus_int silk_init_encoder(\r
     silk_encoder_state_FLP          *psEnc              /* I/O  Encoder state FLP                       */\r
 );\r
 \r
 /* Control the Silk encoder */\r
-SKP_int silk_control_encoder( \r
+opus_int silk_control_encoder( \r
     silk_encoder_state_FLP          *psEnc,             /* I/O  Pointer to Silk encoder state FLP       */\r
     silk_EncControlStruct           *encControl,        /* I:   Control structure                       */\r
-    const SKP_int32                 TargetRate_bps,     /* I    Target max bitrate (bps)                */\r
-    const SKP_int                   allow_bw_switch,    /* I    Flag to allow switching audio bandwidth */\r
-    const SKP_int                   channelNb           /* I    Channel number                          */\r
+    const opus_int32                 TargetRate_bps,     /* I    Target max bitrate (bps)                */\r
+    const opus_int                   allow_bw_switch,    /* I    Flag to allow switching audio bandwidth */\r
+    const opus_int                   channelNb           /* I    Channel number                          */\r
 );\r
 \r
 /****************/\r
@@ -108,8 +108,8 @@ void silk_warped_autocorrelation_FLP(
           SKP_float                 *corr,              /* O    Result [order + 1]                      */\r
     const SKP_float                 *input,             /* I    Input data to correlate                 */\r
     const SKP_float                 warping,            /* I    Warping coefficient                     */\r
-    const SKP_int                   length,             /* I    Length of input                         */\r
-    const SKP_int                   order               /* I    Correlation order (even)                */\r
+    const opus_int                   length,             /* I    Length of input                         */\r
+    const opus_int                   order               /* I    Correlation order (even)                */\r
 );\r
 \r
 /* Calculation of LTP state scaling */\r
@@ -139,15 +139,15 @@ void silk_find_pred_coefs_FLP(
 \r
 /* LPC analysis */\r
 void silk_find_LPC_FLP(\r
-          SKP_int16                 NLSF_Q15[],             /* O    NLSFs                                   */\r
-          SKP_int8                  *interpIndex,           /* O    NLSF interp. index for NLSF interp.     */\r
-    const SKP_int16                 prev_NLSFq_Q15[],       /* I    Previous NLSFs, for NLSF interpolation  */\r
-    const SKP_int                   useInterpNLSFs,         /* I    Flag                                    */\r
-    const SKP_int                   firstFrameAfterReset,   /* I    Flag                                    */\r
-    const SKP_int                   LPC_order,              /* I    LPC order                               */\r
+          opus_int16                 NLSF_Q15[],             /* O    NLSFs                                   */\r
+          opus_int8                  *interpIndex,           /* O    NLSF interp. index for NLSF interp.     */\r
+    const opus_int16                 prev_NLSFq_Q15[],       /* I    Previous NLSFs, for NLSF interpolation  */\r
+    const opus_int                   useInterpNLSFs,         /* I    Flag                                    */\r
+    const opus_int                   firstFrameAfterReset,   /* I    Flag                                    */\r
+    const opus_int                   LPC_order,              /* I    LPC order                               */\r
     const SKP_float                 x[],                    /* I    Input signal                            */\r
-    const SKP_int                   subfr_length,           /* I    Subframe length incl preceeding samples */\r
-    const SKP_int                   nb_subfr                /* I:   Number of subframes                     */\r
+    const opus_int                   subfr_length,           /* I    Subframe length incl preceeding samples */\r
+    const opus_int                   nb_subfr                /* I:   Number of subframes                     */\r
 );\r
 \r
 /* LTP analysis */\r
@@ -156,22 +156,22 @@ void silk_find_LTP_FLP(
           SKP_float WLTP[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ], /* O    Weight for LTP quantization       */\r
           SKP_float *LTPredCodGain,                         /* O    LTP coding gain                         */\r
     const SKP_float r_lpc[],                                /* I    LPC residual                            */\r
-    const SKP_int   lag[  MAX_NB_SUBFR ],                   /* I    LTP lags                                */\r
+    const opus_int   lag[  MAX_NB_SUBFR ],                   /* I    LTP lags                                */\r
     const SKP_float Wght[ MAX_NB_SUBFR ],                   /* I    Weights                                 */\r
-    const SKP_int   subfr_length,                           /* I    Subframe length                         */\r
-    const SKP_int   nb_subfr,                               /* I    number of subframes                     */\r
-    const SKP_int   mem_offset                              /* I    Number of samples in LTP memory         */\r
+    const opus_int   subfr_length,                           /* I    Subframe length                         */\r
+    const opus_int   nb_subfr,                               /* I    number of subframes                     */\r
+    const opus_int   mem_offset                              /* I    Number of samples in LTP memory         */\r
 );\r
 \r
 void silk_LTP_analysis_filter_FLP(\r
           SKP_float         *LTP_res,                   /* O    LTP res MAX_NB_SUBFR*(pre_lgth+subfr_lngth) */\r
     const SKP_float         *x,                         /* I    Input signal, with preceeding samples       */\r
     const SKP_float         B[ LTP_ORDER * MAX_NB_SUBFR ],  /* I    LTP coefficients for each subframe      */\r
-    const SKP_int           pitchL[   MAX_NB_SUBFR ],   /* I    Pitch lags                                  */\r
+    const opus_int           pitchL[   MAX_NB_SUBFR ],   /* I    Pitch lags                                  */\r
     const SKP_float         invGains[ MAX_NB_SUBFR ],   /* I    Inverse quantization gains                  */\r
-    const SKP_int           subfr_length,               /* I    Length of each subframe                     */\r
-    const SKP_int           nb_subfr,                   /* I    number of subframes                         */\r
-    const SKP_int           pre_length                  /* I    Preceeding samples for each subframe        */\r
+    const opus_int           subfr_length,               /* I    Length of each subframe                     */\r
+    const opus_int           nb_subfr,                   /* I    number of subframes                         */\r
+    const opus_int           pre_length                  /* I    Preceeding samples for each subframe        */\r
 );\r
 \r
 /* Calculates residual energies of input subframes where all subframes have LPC_order   */\r
@@ -181,9 +181,9 @@ void silk_residual_energy_FLP(
     const SKP_float             x[],                    /* I    Input signal                            */\r
           SKP_float             a[ 2 ][ MAX_LPC_ORDER ],/* I    AR coefs for each frame half            */\r
     const SKP_float             gains[],                /* I    Quantization gains                      */\r
-    const SKP_int               subfr_length,           /* I    Subframe length                         */\r
-    const SKP_int               nb_subfr,               /* I    number of subframes                     */\r
-    const SKP_int               LPC_order               /* I    LPC order                               */\r
+    const opus_int               subfr_length,           /* I    Subframe length                         */\r
+    const opus_int               nb_subfr,               /* I    number of subframes                     */\r
+    const opus_int               LPC_order               /* I    LPC order                               */\r
 );\r
 \r
 /* 16th order LPC analysis filter */\r
@@ -191,19 +191,19 @@ void silk_LPC_analysis_filter_FLP(
           SKP_float                 r_LPC[],            /* O    LPC residual signal                     */\r
     const SKP_float                 PredCoef[],         /* I    LPC coefficients                        */\r
     const SKP_float                 s[],                /* I    Input signal                            */\r
-    const SKP_int                   length,             /* I    Length of input signal                  */\r
-    const SKP_int                   Order               /* I    LPC order                               */\r
+    const opus_int                   length,             /* I    Length of input signal                  */\r
+    const opus_int                   Order               /* I    LPC order                               */\r
 );\r
 \r
 /* LTP tap quantizer */\r
 void silk_quant_LTP_gains_FLP(\r
           SKP_float B[ MAX_NB_SUBFR * LTP_ORDER ],              /* I/O  (Un-)quantized LTP gains                */\r
-          SKP_int8  cbk_index[ MAX_NB_SUBFR ],                  /* O    Codebook index                          */\r
-          SKP_int8  *periodicity_index,                         /* O    Periodicity index                       */\r
+          opus_int8  cbk_index[ MAX_NB_SUBFR ],                  /* O    Codebook index                          */\r
+          opus_int8  *periodicity_index,                         /* O    Periodicity index                       */\r
     const SKP_float W[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ],  /* I    Error weights                           */\r
-    const SKP_int   mu_Q10,                                     /* I    Mu value (R/D tradeoff)                 */\r
-    const SKP_int   lowComplexity,                              /* I    Flag for low complexity                 */\r
-    const SKP_int   nb_subfr                                    /* I    number of subframes                     */\r
+    const opus_int   mu_Q10,                                     /* I    Mu value (R/D tradeoff)                 */\r
+    const opus_int   lowComplexity,                              /* I    Flag for low complexity                 */\r
+    const opus_int   nb_subfr                                    /* I    number of subframes                     */\r
 );\r
 \r
 /******************/\r
@@ -213,8 +213,8 @@ void silk_quant_LTP_gains_FLP(
 void silk_process_NLSFs_FLP(\r
     silk_encoder_state              *psEncC,                            /* I/O  Encoder state                               */\r
     SKP_float                       PredCoef[ 2 ][ MAX_LPC_ORDER ],     /* O    Prediction coefficients                     */\r
-    SKP_int16                       NLSF_Q15[      MAX_LPC_ORDER ],     /* I/O  Normalized LSFs (quant out) (0 - (2^15-1))  */\r
-    const SKP_int16                 prev_NLSF_Q15[ MAX_LPC_ORDER ]      /* I    Previous Normalized LSFs (0 - (2^15-1))     */\r
+    opus_int16                       NLSF_Q15[      MAX_LPC_ORDER ],     /* I/O  Normalized LSFs (quant out) (0 - (2^15-1))  */\r
+    const opus_int16                 prev_NLSF_Q15[ MAX_LPC_ORDER ]      /* I    Previous Normalized LSFs (0 - (2^15-1))     */\r
 );\r
 \r
 /* Residual energy: nrg = wxx - 2 * wXx * c + c' * wXX * c */\r
@@ -223,19 +223,19 @@ SKP_float silk_residual_energy_covar_FLP(           /* O    Weighted residual en
           SKP_float                 *wXX,               /* I/O  Weighted correlation matrix, reg. out   */\r
     const SKP_float                 *wXx,               /* I    Weighted correlation vector             */\r
     const SKP_float                 wxx,                /* I    Weighted correlation value              */\r
-    const SKP_int                   D                   /* I    Dimension                               */\r
+    const opus_int                   D                   /* I    Dimension                               */\r
 );\r
 \r
 /* Entropy constrained MATRIX-weighted VQ, for a single input data vector */\r
 void silk_VQ_WMat_EC_FLP(\r
-          SKP_int                   *ind,               /* O    Index of best codebook vector           */\r
+          opus_int                   *ind,               /* O    Index of best codebook vector           */\r
           SKP_float                 *rate_dist,         /* O    Best weighted quant. error + mu * rate  */\r
     const SKP_float                 *in,                /* I    Input vector to be quantized            */\r
     const SKP_float                 *W,                 /* I    Weighting matrix                        */\r
-    const SKP_int16                 *cb,                /* I    Codebook                                */\r
-    const SKP_int16                 *cl_Q6,             /* I    Code length for each codebook vector    */\r
+    const opus_int16                 *cb,                /* I    Codebook                                */\r
+    const opus_int16                 *cl_Q6,             /* I    Code length for each codebook vector    */\r
     const SKP_float                 mu,                 /* I    Tradeoff between WSSE and rate          */\r
-    const SKP_int                   L                   /* I    Number of vectors in codebook           */\r
+    const opus_int                   L                   /* I    Number of vectors in codebook           */\r
 );\r
 \r
 /* Processing of gains */\r
@@ -250,8 +250,8 @@ void silk_process_gains_FLP(
 /* Calculates correlation matrix X'*X */\r
 void silk_corrMatrix_FLP(\r
     const SKP_float                 *x,                 /* I    x vector [ L+order-1 ] used to create X */\r
-    const SKP_int                   L,                  /* I    Length of vectors                       */\r
-    const SKP_int                   Order,              /* I    Max lag for correlation                 */\r
+    const opus_int                   L,                  /* I    Length of vectors                       */\r
+    const opus_int                   Order,              /* I    Max lag for correlation                 */\r
           SKP_float                 *XX                 /* O    X'*X correlation matrix [order x order] */\r
 );\r
 \r
@@ -259,8 +259,8 @@ void silk_corrMatrix_FLP(
 void silk_corrVector_FLP(\r
     const SKP_float                 *x,                 /* I    x vector [L+order-1] used to create X   */\r
     const SKP_float                 *t,                 /* I    Target vector [L]                       */\r
-    const SKP_int                   L,                  /* I    Length of vecors                        */\r
-    const SKP_int                   Order,              /* I    Max lag for correlation                 */\r
+    const opus_int                   L,                  /* I    Length of vecors                        */\r
+    const opus_int                   Order,              /* I    Max lag for correlation                 */\r
           SKP_float                 *Xt                 /* O    X'*t correlation vector [order]         */\r
 );\r
 \r
@@ -269,13 +269,13 @@ void silk_regularize_correlations_FLP(
           SKP_float                 *XX,                /* I/O  Correlation matrices                    */\r
           SKP_float                 *xx,                /* I/O  Correlation values                      */\r
     const SKP_float                 noise,              /* I    Noise energy to add                     */\r
-    const SKP_int                   D                   /* I    Dimension of XX                         */\r
+    const opus_int                   D                   /* I    Dimension of XX                         */\r
 );\r
 \r
 /* Function to solve linear equation Ax = b, where A is an MxM symmetric matrix */\r
 void silk_solve_LDL_FLP(\r
           SKP_float                 *A,                 /* I/O  Symmetric square matrix, out: reg.      */\r
-    const SKP_int                   M,                  /* I    Size of matrix                          */\r
+    const opus_int                   M,                  /* I    Size of matrix                          */\r
     const SKP_float                 *b,                 /* I    Pointer to b vector                     */\r
           SKP_float                 *x                  /* O    Pointer to x solution vector            */\r
 );\r
@@ -287,24 +287,24 @@ void silk_solve_LDL_FLP(
 void silk_apply_sine_window_FLP(\r
           SKP_float                 px_win[],           /* O    Pointer to windowed signal              */\r
     const SKP_float                 px[],               /* I    Pointer to input signal                 */\r
-    const SKP_int                   win_type,           /* I    Selects a window type                   */\r
-    const SKP_int                   length              /* I    Window length, multiple of 4            */\r
+    const opus_int                   win_type,           /* I    Selects a window type                   */\r
+    const opus_int                   length              /* I    Window length, multiple of 4            */\r
 );\r
 \r
 /* Wrapper functions. Call flp / fix code */\r
 \r
 /* Convert AR filter coefficients to NLSF parameters */\r
 void silk_A2NLSF_FLP( \r
-          SKP_int16                 *NLSF_Q15,          /* O    NLSF vector      [ LPC_order ]          */\r
+          opus_int16                 *NLSF_Q15,          /* O    NLSF vector      [ LPC_order ]          */\r
     const SKP_float                 *pAR,               /* I    LPC coefficients [ LPC_order ]          */\r
-    const SKP_int                   LPC_order           /* I    LPC order                               */\r
+    const opus_int                   LPC_order           /* I    LPC order                               */\r
 );\r
 \r
 /* Convert NLSF parameters to AR prediction filter coefficients */\r
 void silk_NLSF2A_FLP( \r
           SKP_float                 *pAR,               /* O    LPC coefficients [ LPC_order ]          */\r
-    const SKP_int16                 *NLSF_Q15,          /* I    NLSF vector      [ LPC_order ]          */\r
-    const SKP_int                   LPC_order           /* I    LPC order                               */\r
+    const opus_int16                 *NLSF_Q15,          /* I    NLSF vector      [ LPC_order ]          */\r
+    const opus_int                   LPC_order           /* I    LPC order                               */\r
 );\r
 \r
 /****************************************/\r
@@ -315,7 +315,7 @@ void silk_NSQ_wrapper_FLP(
     silk_encoder_control_FLP        *psEncCtrl,     /* I/O  Encoder control FLP                         */\r
     SideInfoIndices                 *psIndices,     /* I/O  Quantization indices                        */\r
     silk_nsq_state                  *psNSQ,         /* I/O  Noise Shaping Quantzation state             */\r
-          SKP_int8                  pulses[],       /* O    Quantized pulse signal                      */\r
+          opus_int8                  pulses[],       /* O    Quantized pulse signal                      */\r
     const SKP_float                 x[]             /* I    Prefiltered input signal                    */\r
 );\r
 \r
index 4ff41c6..271ee51 100644 (file)
@@ -33,9 +33,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 SKP_INLINE SKP_float warped_gain( \r
     const SKP_float     *coefs, \r
     SKP_float           lambda, \r
-    SKP_int             order \r
+    opus_int             order \r
 ) {\r
-    SKP_int   i;\r
+    opus_int   i;\r
     SKP_float gain;\r
 \r
     lambda = -lambda;\r
@@ -53,9 +53,9 @@ SKP_INLINE void warped_true2monic_coefs(
     SKP_float           *coefs_ana,\r
     SKP_float           lambda,\r
     SKP_float           limit,\r
-    SKP_int             order\r
+    opus_int             order\r
 ) {\r
-    SKP_int   i, iter, ind = 0;\r
+    opus_int   i, iter, ind = 0;\r
     SKP_float tmp, maxabs, chirp, gain_syn, gain_ana;\r
 \r
     /* Convert to monic coefficients */\r
@@ -127,7 +127,7 @@ void silk_noise_shape_analysis_FLP(
 )\r
 {\r
     silk_shape_state_FLP *psShapeSt = &psEnc->sShape;\r
-    SKP_int     k, nSamples;\r
+    opus_int     k, nSamples;\r
     SKP_float   SNR_adj_dB, HarmBoost, HarmShapeGain, Tilt;\r
     SKP_float   nrg, pre_nrg, log_energy, log_energy_prev, energy_variation;\r
     SKP_float   delta, BWExp1, BWExp2, gain_mult, gain_add, strength, b, warping;\r
@@ -223,7 +223,7 @@ void silk_noise_shape_analysis_FLP(
     /********************************************/\r
     for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) {\r
         /* Apply window: sine slope followed by flat part followed by cosine slope */\r
-        SKP_int shift, slope_part, flat_part;\r
+        opus_int shift, slope_part, flat_part;\r
         flat_part = psEnc->sCmn.fs_kHz * 3;\r
         slope_part = ( psEnc->sCmn.shapeWinLength - flat_part ) / 2;\r
 \r
index abcdfe2..cc74866 100644 (file)
@@ -47,65 +47,65 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 static void silk_P_Ana_calc_corr_st3(\r
     SKP_float cross_corr_st3[ PE_MAX_NB_SUBFR ][ PE_NB_CBKS_STAGE3_MAX ][ PE_NB_STAGE3_LAGS ], /* O 3 DIM correlation array */\r
     const SKP_float signal[],           /* I vector to correlate                                            */\r
-    SKP_int         start_lag,          /* I start lag                                                      */\r
-    SKP_int         sf_length,          /* I sub frame length                                               */\r
-    SKP_int         nb_subfr,           /* I number of subframes                                            */\r
-    SKP_int         complexity          /* I Complexity setting                                             */\r
+    opus_int         start_lag,          /* I start lag                                                      */\r
+    opus_int         sf_length,          /* I sub frame length                                               */\r
+    opus_int         nb_subfr,           /* I number of subframes                                            */\r
+    opus_int         complexity          /* I Complexity setting                                             */\r
 );\r
 \r
 static void silk_P_Ana_calc_energy_st3(\r
     SKP_float energies_st3[ PE_MAX_NB_SUBFR ][ PE_NB_CBKS_STAGE3_MAX ][ PE_NB_STAGE3_LAGS ], /* O 3 DIM correlation array */\r
     const SKP_float signal[],           /* I vector to correlate                                            */\r
-    SKP_int         start_lag,          /* I start lag                                                      */\r
-    SKP_int         sf_length,          /* I sub frame length                                               */\r
-    SKP_int         nb_subfr,           /* I number of subframes                                            */\r
-    SKP_int         complexity          /* I Complexity setting                                             */\r
+    opus_int         start_lag,          /* I start lag                                                      */\r
+    opus_int         sf_length,          /* I sub frame length                                               */\r
+    opus_int         nb_subfr,           /* I number of subframes                                            */\r
+    opus_int         complexity          /* I Complexity setting                                             */\r
 );\r
 \r
 //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
 //%             CORE PITCH ANALYSIS FUNCTION                %\r
 //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
-SKP_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoiced                       */\r
+opus_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoiced                       */\r
     const SKP_float *signal,            /* I signal of length PE_FRAME_LENGTH_MS*Fs_kHz                     */\r
-    SKP_int         *pitch_out,         /* O 4 pitch lag values                                             */\r
-    SKP_int16        *lagIndex,         /* O lag Index                                                      */\r
-    SKP_int8        *contourIndex,      /* O pitch contour Index                                            */\r
+    opus_int         *pitch_out,         /* O 4 pitch lag values                                             */\r
+    opus_int16        *lagIndex,         /* O lag Index                                                      */\r
+    opus_int8        *contourIndex,      /* O pitch contour Index                                            */\r
     SKP_float       *LTPCorr,           /* I/O normalized correlation; input: value from previous frame     */\r
-    SKP_int         prevLag,            /* I last lag of previous frame; set to zero is unvoiced            */\r
+    opus_int         prevLag,            /* I last lag of previous frame; set to zero is unvoiced            */\r
     const SKP_float search_thres1,      /* I first stage threshold for lag candidates 0 - 1                 */\r
     const SKP_float search_thres2,      /* I final threshold for lag candidates 0 - 1                       */\r
-    const SKP_int   Fs_kHz,             /* I sample frequency (kHz)                                         */\r
-    const SKP_int   complexity,         /* I Complexity setting, 0-2, where 2 is highest                    */\r
-    const SKP_int   nb_subfr            /* I    number of 5 ms subframes                                    */\r
+    const opus_int   Fs_kHz,             /* I sample frequency (kHz)                                         */\r
+    const opus_int   complexity,         /* I Complexity setting, 0-2, where 2 is highest                    */\r
+    const opus_int   nb_subfr            /* I    number of 5 ms subframes                                    */\r
 )\r
 {\r
-    SKP_int   i, k, d, j;\r
+    opus_int   i, k, d, j;\r
     SKP_float signal_8kHz[  PE_MAX_FRAME_LENGTH_MS * 8 ];\r
     SKP_float signal_4kHz[  PE_MAX_FRAME_LENGTH_MS * 4 ];\r
-    SKP_int16 signal_8_FIX[ PE_MAX_FRAME_LENGTH_MS * 8 ];\r
-    SKP_int16 signal_4_FIX[ PE_MAX_FRAME_LENGTH_MS * 4 ];\r
-    SKP_int32 filt_state[ 6 ];\r
+    opus_int16 signal_8_FIX[ PE_MAX_FRAME_LENGTH_MS * 8 ];\r
+    opus_int16 signal_4_FIX[ PE_MAX_FRAME_LENGTH_MS * 4 ];\r
+    opus_int32 filt_state[ 6 ];\r
     SKP_float threshold, contour_bias;\r
     SKP_float C[ PE_MAX_NB_SUBFR][ (PE_MAX_LAG >> 1) + 5 ];\r
     SKP_float CC[ PE_NB_CBKS_STAGE2_EXT ];\r
     const SKP_float *target_ptr, *basis_ptr;\r
     double    cross_corr, normalizer, energy, energy_tmp;\r
-    SKP_int   d_srch[ PE_D_SRCH_LENGTH ];\r
-    SKP_int16 d_comp[ (PE_MAX_LAG >> 1) + 5 ];\r
-    SKP_int   length_d_srch, length_d_comp;\r
+    opus_int   d_srch[ PE_D_SRCH_LENGTH ];\r
+    opus_int16 d_comp[ (PE_MAX_LAG >> 1) + 5 ];\r
+    opus_int   length_d_srch, length_d_comp;\r
     SKP_float Cmax, CCmax, CCmax_b, CCmax_new_b, CCmax_new;\r
-    SKP_int   CBimax, CBimax_new, lag, start_lag, end_lag, lag_new;\r
-    SKP_int   cbk_size;\r
+    opus_int   CBimax, CBimax_new, lag, start_lag, end_lag, lag_new;\r
+    opus_int   cbk_size;\r
     SKP_float lag_log2, prevLag_log2, delta_lag_log2_sqr;\r
     SKP_float energies_st3[ PE_MAX_NB_SUBFR ][ PE_NB_CBKS_STAGE3_MAX ][ PE_NB_STAGE3_LAGS ];\r
     SKP_float cross_corr_st3[ PE_MAX_NB_SUBFR ][ PE_NB_CBKS_STAGE3_MAX ][ PE_NB_STAGE3_LAGS ];\r
-    SKP_int   lag_counter;\r
-    SKP_int   frame_length, frame_length_8kHz, frame_length_4kHz;\r
-    SKP_int   sf_length, sf_length_8kHz, sf_length_4kHz;\r
-    SKP_int   min_lag, min_lag_8kHz, min_lag_4kHz;\r
-    SKP_int   max_lag, max_lag_8kHz, max_lag_4kHz;\r
-    SKP_int   nb_cbk_search;\r
-    const SKP_int8 *Lag_CB_ptr;\r
+    opus_int   lag_counter;\r
+    opus_int   frame_length, frame_length_8kHz, frame_length_4kHz;\r
+    opus_int   sf_length, sf_length_8kHz, sf_length_4kHz;\r
+    opus_int   min_lag, min_lag_8kHz, min_lag_4kHz;\r
+    opus_int   max_lag, max_lag_8kHz, max_lag_4kHz;\r
+    opus_int   nb_cbk_search;\r
+    const opus_int8 *Lag_CB_ptr;\r
 \r
     /* Check for valid sampling frequency */\r
     SKP_assert( Fs_kHz == 8 || Fs_kHz == 12 || Fs_kHz == 16 );\r
@@ -136,16 +136,16 @@ SKP_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoice
     /* Resample from input sampled at Fs_kHz to 8 kHz */\r
     if( Fs_kHz == 16 ) {\r
         /* Resample to 16 -> 8 khz */\r
-        SKP_int16 signal_16_FIX[ 16 * PE_MAX_FRAME_LENGTH_MS ];\r
+        opus_int16 signal_16_FIX[ 16 * PE_MAX_FRAME_LENGTH_MS ];\r
         SKP_float2short_array( signal_16_FIX, signal, frame_length );\r
-        SKP_memset( filt_state, 0, 2 * sizeof( SKP_int32 ) );\r
+        SKP_memset( filt_state, 0, 2 * sizeof( opus_int32 ) );\r
         silk_resampler_down2( filt_state, signal_8_FIX, signal_16_FIX, frame_length );\r
         SKP_short2float_array( signal_8kHz, signal_8_FIX, frame_length_8kHz );\r
     } else if( Fs_kHz == 12 ) {\r
         /* Resample to 12 -> 8 khz */\r
-        SKP_int16 signal_12_FIX[ 12 * PE_MAX_FRAME_LENGTH_MS ];\r
+        opus_int16 signal_12_FIX[ 12 * PE_MAX_FRAME_LENGTH_MS ];\r
         SKP_float2short_array( signal_12_FIX, signal, frame_length );\r
-        SKP_memset( filt_state, 0, 6 * sizeof( SKP_int32 ) );\r
+        SKP_memset( filt_state, 0, 6 * sizeof( opus_int32 ) );\r
         silk_resampler_down2_3( filt_state, signal_8_FIX, signal_12_FIX, frame_length );\r
         SKP_short2float_array( signal_8kHz, signal_8_FIX, frame_length_8kHz );\r
     } else {\r
@@ -154,7 +154,7 @@ SKP_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoice
     }\r
 \r
     /* Decimate again to 4 kHz */\r
-    SKP_memset( filt_state, 0, 2 * sizeof( SKP_int32 ) );\r
+    SKP_memset( filt_state, 0, 2 * sizeof( opus_int32 ) );\r
     silk_resampler_down2( filt_state, signal_4_FIX, signal_8_FIX, frame_length_8kHz );\r
     SKP_short2float_array( signal_4kHz, signal_4_FIX, frame_length_4kHz );\r
 \r
@@ -223,7 +223,7 @@ SKP_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoice
     }\r
     threshold = Cmax * Cmax; \r
     if( energy / 16.0f > threshold ) {\r
-        SKP_memset( pitch_out, 0, nb_subfr * sizeof( SKP_int ) );\r
+        SKP_memset( pitch_out, 0, nb_subfr * sizeof( opus_int ) );\r
         *LTPCorr      = 0.0f;\r
         *lagIndex     = 0;\r
         *contourIndex = 0;\r
@@ -270,7 +270,7 @@ SKP_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoice
     length_d_comp = 0;\r
     for( i = min_lag_8kHz; i < max_lag_8kHz + 4; i++ ) {    \r
         if( d_comp[ i ] > 0 ) {\r
-            d_comp[ length_d_comp ] = (SKP_int16)( i - 2 );\r
+            d_comp[ length_d_comp ] = (opus_int16)( i - 2 );\r
             length_d_comp++;\r
         }\r
     }\r
@@ -385,7 +385,7 @@ SKP_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoice
 \r
     if( lag == -1 ) {\r
         /* No suitable candidate found */\r
-        SKP_memset( pitch_out, 0, PE_MAX_NB_SUBFR * sizeof(SKP_int) );\r
+        SKP_memset( pitch_out, 0, PE_MAX_NB_SUBFR * sizeof(opus_int) );\r
         *LTPCorr      = 0.0f;\r
         *lagIndex     = 0;\r
         *contourIndex = 0;\r
@@ -425,7 +425,7 @@ SKP_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoice
 \r
         /* Setup cbk parameters acording to complexity setting and frame length */\r
         if( nb_subfr == PE_MAX_NB_SUBFR ) {\r
-            nb_cbk_search = (SKP_int)silk_nb_cbk_searchs_stage3[ complexity ];\r
+            nb_cbk_search = (opus_int)silk_nb_cbk_searchs_stage3[ complexity ];\r
             cbk_size      = PE_NB_CBKS_STAGE3_MAX;\r
             Lag_CB_ptr    = &silk_CB_lags_stage3[ 0 ][ 0 ];\r
         } else {\r
@@ -451,7 +451,7 @@ SKP_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoice
                 }\r
 \r
                 if( CCmax_new > CCmax &&\r
-                   ( d + (SKP_int)silk_CB_lags_stage3[ 0 ][ j ] ) <= max_lag  \r
+                   ( d + (opus_int)silk_CB_lags_stage3[ 0 ][ j ] ) <= max_lag  \r
                    ) {\r
                     CCmax   = CCmax_new;\r
                     lag_new = d;\r
@@ -464,8 +464,8 @@ SKP_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoice
         for( k = 0; k < nb_subfr; k++ ) {\r
             pitch_out[ k ] = lag_new + matrix_ptr( Lag_CB_ptr, k, CBimax, cbk_size );\r
         }\r
-        *lagIndex = (SKP_int16)( lag_new - min_lag );\r
-        *contourIndex = (SKP_int8)CBimax;\r
+        *lagIndex = (opus_int16)( lag_new - min_lag );\r
+        *contourIndex = (opus_int8)CBimax;\r
     } else {\r
         /* Save Lags and correlation */\r
         SKP_assert( CCmax >= 0.0f );\r
@@ -473,8 +473,8 @@ SKP_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoice
         for( k = 0; k < nb_subfr; k++ ) {\r
             pitch_out[ k ] = lag + matrix_ptr( Lag_CB_ptr, k, CBimax, cbk_size );\r
         }\r
-        *lagIndex = (SKP_int16)( lag - min_lag );\r
-        *contourIndex = (SKP_int8)CBimax;\r
+        *lagIndex = (opus_int16)( lag - min_lag );\r
+        *contourIndex = (opus_int8)CBimax;\r
     }\r
     SKP_assert( *lagIndex >= 0 );\r
     /* return as voiced */\r
@@ -484,10 +484,10 @@ SKP_int silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoice
 static void silk_P_Ana_calc_corr_st3(\r
     SKP_float cross_corr_st3[ PE_MAX_NB_SUBFR ][ PE_NB_CBKS_STAGE3_MAX ][ PE_NB_STAGE3_LAGS ], /* O 3 DIM correlation array */\r
     const SKP_float signal[],           /* I vector to correlate                                            */\r
-    SKP_int         start_lag,          /* I start lag                                                      */\r
-    SKP_int         sf_length,          /* I sub frame length                                               */\r
-    SKP_int         nb_subfr,           /* I number of subframes                                            */\r
-    SKP_int         complexity          /* I Complexity setting                                             */\r
+    opus_int         start_lag,          /* I start lag                                                      */\r
+    opus_int         sf_length,          /* I sub frame length                                               */\r
+    opus_int         nb_subfr,           /* I number of subframes                                            */\r
+    opus_int         complexity          /* I Complexity setting                                             */\r
 )\r
     /***********************************************************************\r
      Calculates the correlations used in stage 3 search. In order to cover \r
@@ -504,10 +504,10 @@ static void silk_P_Ana_calc_corr_st3(
      **********************************************************************/\r
 {\r
     const SKP_float *target_ptr, *basis_ptr;\r
-    SKP_int   i, j, k, lag_counter, lag_low, lag_high;\r
-    SKP_int   nb_cbk_search, delta, idx, cbk_size;\r
+    opus_int   i, j, k, lag_counter, lag_low, lag_high;\r
+    opus_int   nb_cbk_search, delta, idx, cbk_size;\r
     SKP_float scratch_mem[ SCRATCH_SIZE ];\r
-    const SKP_int8 *Lag_range_ptr, *Lag_CB_ptr;\r
+    const opus_int8 *Lag_range_ptr, *Lag_CB_ptr;\r
 \r
     SKP_assert( complexity >= SigProc_PE_MIN_COMPLEX );\r
     SKP_assert( complexity <= SigProc_PE_MAX_COMPLEX );\r
@@ -557,10 +557,10 @@ static void silk_P_Ana_calc_corr_st3(
 static void silk_P_Ana_calc_energy_st3(\r
     SKP_float energies_st3[ PE_MAX_NB_SUBFR ][ PE_NB_CBKS_STAGE3_MAX ][ PE_NB_STAGE3_LAGS ], /* O 3 DIM correlation array */\r
     const SKP_float signal[],           /* I vector to correlate                                            */\r
-    SKP_int         start_lag,          /* I start lag                                                      */\r
-    SKP_int         sf_length,          /* I sub frame length                                               */\r
-    SKP_int         nb_subfr,           /* I number of subframes                                            */\r
-    SKP_int         complexity          /* I Complexity setting                                             */\r
+    opus_int         start_lag,          /* I start lag                                                      */\r
+    opus_int         sf_length,          /* I sub frame length                                               */\r
+    opus_int         nb_subfr,           /* I number of subframes                                            */\r
+    opus_int         complexity          /* I Complexity setting                                             */\r
 )\r
 /****************************************************************\r
 Calculate the energies for first two subframes. The energies are\r
@@ -569,10 +569,10 @@ calculated recursively.
 {\r
     const SKP_float *target_ptr, *basis_ptr;\r
     double    energy;\r
-    SKP_int   k, i, j, lag_counter;\r
-    SKP_int   nb_cbk_search, delta, idx, cbk_size, lag_diff;\r
+    opus_int   k, i, j, lag_counter;\r
+    opus_int   nb_cbk_search, delta, idx, cbk_size, lag_diff;\r
     SKP_float scratch_mem[ SCRATCH_SIZE ];\r
-    const SKP_int8 *Lag_range_ptr, *Lag_CB_ptr;\r
+    const opus_int8 *Lag_range_ptr, *Lag_CB_ptr;\r
 \r
     SKP_assert( complexity >= SigProc_PE_MIN_COMPLEX );\r
     SKP_assert( complexity <= SigProc_PE_MAX_COMPLEX );\r
index 3a61c71..e2534c2 100644 (file)
@@ -39,8 +39,8 @@ SKP_INLINE void silk_prefilt_FLP(
     SKP_float Tilt,                 /* I */\r
     SKP_float LF_MA_shp,            /* I */\r
     SKP_float LF_AR_shp,            /* I */\r
-    SKP_int   lag,                  /* I */\r
-    SKP_int   length                /* I */\r
+    opus_int   lag,                  /* I */\r
+    opus_int   length                /* I */\r
 );\r
 \r
 void silk_warped_LPC_analysis_filter_FLP(\r
@@ -49,11 +49,11 @@ void silk_warped_LPC_analysis_filter_FLP(
     const SKP_float                 coef[],             /* I    Coefficients [order]                    */\r
     const SKP_float                 input[],            /* I    Input signal [length]                   */\r
     const SKP_float                 lambda,             /* I    Warping factor                          */\r
-    const SKP_int                   length,             /* I    Length of input signal                  */\r
-    const SKP_int                   order               /* I    Filter order (even)                     */\r
+    const opus_int                   length,             /* I    Length of input signal                  */\r
+    const opus_int                   order               /* I    Filter order (even)                     */\r
 )\r
 {\r
-    SKP_int     n, i;\r
+    opus_int     n, i;\r
     SKP_float   acc, tmp1, tmp2;\r
 \r
     /* Order must be even */\r
@@ -95,7 +95,7 @@ void silk_prefilter_FLP(
 )\r
 {\r
     silk_prefilter_state_FLP *P = &psEnc->sPrefilt;\r
-    SKP_int   j, k, lag;\r
+    opus_int   j, k, lag;\r
     SKP_float HarmShapeGain, Tilt, LF_MA_shp, LF_AR_shp;\r
     SKP_float B[ 2 ];\r
     const SKP_float *AR1_shp;\r
@@ -157,12 +157,12 @@ SKP_INLINE void silk_prefilt_FLP(
     SKP_float Tilt,                                    /* I */\r
     SKP_float LF_MA_shp,                       /* I */\r
     SKP_float LF_AR_shp,                       /* I */\r
-    SKP_int   lag,                                     /* I */\r
-    SKP_int   length                           /* I */\r
+    opus_int   lag,                                    /* I */\r
+    opus_int   length                          /* I */\r
 )\r
 {\r
-    SKP_int   i;\r
-    SKP_int   idx, LTP_shp_buf_idx;\r
+    opus_int   i;\r
+    opus_int   idx, LTP_shp_buf_idx;\r
     SKP_float n_Tilt, n_LF, n_LTP; \r
     SKP_float sLF_AR_shp, sLF_MA_shp;\r
     SKP_float *LTP_shp_buf;\r
index 8f517df..e29721d 100644 (file)
@@ -35,8 +35,8 @@ void silk_process_gains_FLP(
 )\r
 {\r
     silk_shape_state_FLP *psShapeSt = &psEnc->sShape;\r
-    SKP_int     k;\r
-    SKP_int32   pGains_Q16[ MAX_NB_SUBFR ];\r
+    opus_int     k;\r
+    opus_int32   pGains_Q16[ MAX_NB_SUBFR ];\r
     SKP_float   s, InvMaxSqrVal, gain, quant_offset;\r
 \r
     /* Gain reduction when LTP coding gain is high */\r
@@ -59,7 +59,7 @@ void silk_process_gains_FLP(
 \r
     /* Prepare gains for noise shaping quantization */\r
     for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) {\r
-        pGains_Q16[ k ] = ( SKP_int32 ) ( psEncCtrl->Gains[ k ] * 65536.0f ); \r
+        pGains_Q16[ k ] = ( opus_int32 ) ( psEncCtrl->Gains[ k ] * 65536.0f ); \r
     }\r
 \r
     /* Noise shaping quantization */\r
index dd5d036..111b1ca 100644 (file)
@@ -31,10 +31,10 @@ void silk_regularize_correlations_FLP(
           SKP_float                 *XX,                /* I/O  Correlation matrices                    */\r
           SKP_float                 *xx,                /* I/O  Correlation values                      */\r
     const SKP_float                 noise,              /* I    Noise energy to add                     */\r
-    const SKP_int                   D                   /* I    Dimension of XX                         */\r
+    const opus_int                   D                   /* I    Dimension of XX                         */\r
 )\r
 {\r
-    SKP_int i;\r
+    opus_int i;\r
 \r
     for( i = 0; i < D; i++ ) {\r
         matrix_ptr( &XX[ 0 ], i, i, D ) += noise;\r
index 192e570..312a4c3 100644 (file)
@@ -36,10 +36,10 @@ SKP_float silk_residual_energy_covar_FLP(           /* O    Weighted residual en
           SKP_float                 *wXX,               /* I/O  Weighted correlation matrix, reg. out   */\r
     const SKP_float                 *wXx,               /* I    Weighted correlation vector             */\r
     const SKP_float                 wxx,                /* I    Weighted correlation value              */\r
-    const SKP_int                   D                   /* I    Dimension                               */\r
+    const opus_int                   D                   /* I    Dimension                               */\r
 )\r
 {\r
-    SKP_int   i, j, k;\r
+    opus_int   i, j, k;\r
     SKP_float tmp, nrg = 0.0f, regularization;\r
 \r
     /* Safety checks */\r
@@ -89,12 +89,12 @@ void silk_residual_energy_FLP(
     const SKP_float x[],                        /* I    Input signal                    */\r
           SKP_float a[ 2 ][ MAX_LPC_ORDER ],    /* I    AR coefs for each frame half    */\r
     const SKP_float gains[],                    /* I    Quantization gains              */\r
-    const SKP_int   subfr_length,               /* I    Subframe length                 */\r
-    const SKP_int   nb_subfr,                   /* I    number of subframes             */\r
-    const SKP_int   LPC_order                   /* I    LPC order                       */\r
+    const opus_int   subfr_length,               /* I    Subframe length                 */\r
+    const opus_int   nb_subfr,                   /* I    number of subframes             */\r
+    const opus_int   LPC_order                   /* I    LPC order                       */\r
 )\r
 {\r
-    SKP_int     shift;\r
+    opus_int     shift;\r
     SKP_float   *LPC_res_ptr, LPC_res[ ( MAX_FRAME_LENGTH + MAX_NB_SUBFR * MAX_LPC_ORDER ) / 2 ];\r
 \r
     LPC_res_ptr = LPC_res + LPC_order;\r
index 3a9487a..89f86c0 100644 (file)
@@ -32,10 +32,10 @@ void silk_scale_copy_vector_FLP(
     SKP_float           *data_out, \r
     const SKP_float     *data_in, \r
     SKP_float           gain, \r
-    SKP_int             dataSize\r
+    opus_int             dataSize\r
 )\r
 {\r
-    SKP_int  i, dataSize4;\r
+    opus_int  i, dataSize4;\r
 \r
     /* 4x unrolled loop */\r
     dataSize4 = dataSize & 0xFFFC;\r
index 457d738..83dba68 100644 (file)
@@ -31,10 +31,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 void silk_scale_vector_FLP( \r
     SKP_float           *data1, \r
     SKP_float           gain, \r
-    SKP_int             dataSize\r
+    opus_int             dataSize\r
 )\r
 {\r
-    SKP_int  i, dataSize4;\r
+    opus_int  i, dataSize4;\r
 \r
     /* 4x unrolled loop */\r
     dataSize4 = dataSize & 0xFFFC;\r
index 651e50d..887cc17 100644 (file)
@@ -30,10 +30,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 SKP_float silk_schur_FLP(           /* O    returns residual energy                     */\r
     SKP_float       refl_coef[],        /* O    reflection coefficients (length order)      */\r
     const SKP_float auto_corr[],        /* I    autotcorrelation sequence (length order+1)  */\r
-    SKP_int         order               /* I    order                                       */\r
+    opus_int         order               /* I    order                                       */\r
 )\r
 {\r
-    SKP_int   k, n;\r
+    opus_int   k, n;\r
     SKP_float C[ SILK_MAX_ORDER_LPC + 1 ][ 2 ];\r
     SKP_float Ctmp1, Ctmp2, rc_tmp;\r
     \r
index 296d2ff..f9ac62e 100644 (file)
@@ -35,7 +35,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  **********************************************************************/\r
 void silk_LDL_FLP(\r
     SKP_float           *A,      /* (I/O) Pointer to Symetric Square Matrix */\r
-    SKP_int             M,       /* (I) Size of Matrix */\r
+    opus_int             M,       /* (I) Size of Matrix */\r
     SKP_float           *L,      /* (I/O) Pointer to Square Upper triangular Matrix */\r
     SKP_float           *Dinv    /* (I/O) Pointer to vector holding the inverse diagonal elements of D */\r
 );\r
@@ -46,7 +46,7 @@ void silk_LDL_FLP(
  **********************************************************************/\r
 void silk_SolveWithLowerTriangularWdiagOnes_FLP(\r
     const SKP_float     *L,     /* (I) Pointer to Lower Triangular Matrix */\r
-    SKP_int             M,      /* (I) Dim of Matrix equation */\r
+    opus_int             M,      /* (I) Dim of Matrix equation */\r
     const SKP_float     *b,     /* (I) b Vector */\r
     SKP_float           *x      /* (O) x Vector */  \r
 );\r
@@ -57,7 +57,7 @@ void silk_SolveWithLowerTriangularWdiagOnes_FLP(
  **********************************************************************/\r
 void silk_SolveWithUpperTriangularFromLowerWdiagOnes_FLP(\r
     const SKP_float     *L,     /* (I) Pointer to Lower Triangular Matrix */\r
-    SKP_int             M,      /* (I) Dim of Matrix equation */\r
+    opus_int             M,      /* (I) Dim of Matrix equation */\r
     const SKP_float     *b,     /* (I) b Vector */\r
     SKP_float           *x      /* (O) x Vector */  \r
 );\r
@@ -68,12 +68,12 @@ void silk_SolveWithUpperTriangularFromLowerWdiagOnes_FLP(
  **********************************************************************/\r
 void silk_solve_LDL_FLP(\r
           SKP_float                 *A,                 /* I/O  Symmetric square matrix, out: reg.      */\r
-    const SKP_int                   M,                  /* I    Size of matrix                          */\r
+    const opus_int                   M,                  /* I    Size of matrix                          */\r
     const SKP_float                 *b,                 /* I    Pointer to b vector                     */\r
           SKP_float                 *x                  /* O    Pointer to x solution vector            */\r
 )\r
 {\r
-    SKP_int   i;\r
+    opus_int   i;\r
     SKP_float L[    MAX_MATRIX_SIZE ][ MAX_MATRIX_SIZE ];\r
     SKP_float T[    MAX_MATRIX_SIZE ];\r
     SKP_float Dinv[ MAX_MATRIX_SIZE ]; // inverse diagonal elements of D\r
@@ -107,12 +107,12 @@ void silk_solve_LDL_FLP(
 \r
 void silk_SolveWithUpperTriangularFromLowerWdiagOnes_FLP(\r
     const SKP_float     *L,     /* (I) Pointer to Lower Triangular Matrix */\r
-    SKP_int             M,      /* (I) Dim of Matrix equation */\r
+    opus_int             M,      /* (I) Dim of Matrix equation */\r
     const SKP_float     *b,     /* (I) b Vector */\r
     SKP_float           *x      /* (O) x Vector */  \r
 )\r
 {\r
-    SKP_int   i, j;\r
+    opus_int   i, j;\r
     SKP_float temp;\r
     const SKP_float *ptr1;\r
     \r
@@ -129,12 +129,12 @@ void silk_SolveWithUpperTriangularFromLowerWdiagOnes_FLP(
 \r
 void silk_SolveWithLowerTriangularWdiagOnes_FLP(\r
     const SKP_float     *L,     /* (I) Pointer to Lower Triangular Matrix */\r
-    SKP_int             M,      /* (I) Dim of Matrix equation */\r
+    opus_int             M,      /* (I) Dim of Matrix equation */\r
     const SKP_float     *b,     /* (I) b Vector */\r
     SKP_float           *x      /* (O) x Vector */  \r
 )\r
 {\r
-    SKP_int   i, j;\r
+    opus_int   i, j;\r
     SKP_float temp;\r
     const SKP_float *ptr1;\r
     \r
@@ -151,12 +151,12 @@ void silk_SolveWithLowerTriangularWdiagOnes_FLP(
 \r
 void silk_LDL_FLP(\r
     SKP_float           *A,      /* (I/O) Pointer to Symetric Square Matrix */\r
-    SKP_int             M,       /* (I) Size of Matrix */\r
+    opus_int             M,       /* (I) Size of Matrix */\r
     SKP_float           *L,      /* (I/O) Pointer to Square Upper triangular Matrix */\r
     SKP_float           *Dinv    /* (I/O) Pointer to vector holding the inverse diagonal elements of D */\r
 )\r
 {\r
-    SKP_int i, j, k, loop_count, err = 1;\r
+    opus_int i, j, k, loop_count, err = 1;\r
     SKP_float *ptr1, *ptr2;\r
     double temp, diag_min_value;\r
     SKP_float v[ MAX_MATRIX_SIZE ], D[ MAX_MATRIX_SIZE ]; // temp arrays\r
index 7872fe2..fc791a9 100644 (file)
@@ -34,13 +34,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 \r
 void silk_insertion_sort_decreasing_FLP(\r
     SKP_float            *a,          /* I/O:  Unsorted / Sorted vector                */\r
-    SKP_int              *idx,      /* O:    Index vector for the sorted elements    */\r
-    const SKP_int        L,           /* I:    Vector length                           */\r
-    const SKP_int        K            /* I:    Number of correctly sorted positions    */\r
+    opus_int              *idx,      /* O:    Index vector for the sorted elements    */\r
+    const opus_int        L,           /* I:    Vector length                           */\r
+    const opus_int        K            /* I:    Number of correctly sorted positions    */\r
 )\r
 {\r
     SKP_float value;\r
-    SKP_int   i, j;\r
+    opus_int   i, j;\r
 \r
     /* Safety checks */\r
     SKP_assert( K >  0 );\r
index db72bba..aa47ed1 100644 (file)
@@ -41,7 +41,7 @@ extern "C"
 /* Noise shaping analysis state */\r
 /********************************/\r
 typedef struct {\r
-    SKP_int8    LastGainIndex;\r
+    opus_int8    LastGainIndex;\r
     SKP_float   HarmBoost_smth;\r
     SKP_float   HarmShapeGain_smth;\r
     SKP_float   Tilt_smth;\r
@@ -53,12 +53,12 @@ typedef struct {
 typedef struct {\r
     SKP_float   sLTP_shp[ LTP_BUF_LENGTH ];\r
     SKP_float   sAR_shp[ MAX_SHAPE_LPC_ORDER + 1 ];\r
-    SKP_int     sLTP_shp_buf_idx;\r
+    opus_int     sLTP_shp_buf_idx;\r
     SKP_float   sLF_AR_shp;\r
     SKP_float   sLF_MA_shp;\r
     SKP_float   sHarmHP;\r
-    SKP_int32   rand_seed;\r
-    SKP_int     lagPrev;\r
+    opus_int32   rand_seed;\r
+    opus_int     lagPrev;\r
 } silk_prefilter_state_FLP;\r
 \r
 /********************************/\r
@@ -87,7 +87,7 @@ typedef struct {
        SKP_float                                       PredCoef[ 2 ][ MAX_LPC_ORDER ];         /* holds interpolated and final coefficients */\r
        SKP_float                                       LTPCoef[LTP_ORDER * MAX_NB_SUBFR];\r
        SKP_float                                       LTP_scale;\r
-    SKP_int                     pitchL[ MAX_NB_SUBFR ];\r
+    opus_int                     pitchL[ MAX_NB_SUBFR ];\r
 \r
     /* Noise shaping parameters */\r
        SKP_float                                       AR1[ MAX_NB_SUBFR * MAX_SHAPE_LPC_ORDER ];\r
@@ -115,11 +115,11 @@ typedef struct {
 typedef struct {\r
     silk_encoder_state_FLP      state_Fxx[ ENCODER_NUM_CHANNELS ];\r
     stereo_enc_state            sStereo;\r
-    SKP_int32                   nBitsExceeded;\r
-    SKP_int                     nChannelsAPI;\r
-    SKP_int                     nChannelsInternal;\r
-    SKP_int                     timeSinceSwitchAllowed_ms;\r
-    SKP_int                     allowBandwidthSwitch;\r
+    opus_int32                   nBitsExceeded;\r
+    opus_int                     nChannelsAPI;\r
+    opus_int                     nChannelsInternal;\r
+    opus_int                     timeSinceSwitchAllowed_ms;\r
+    opus_int                     allowBandwidthSwitch;\r
 } silk_encoder;\r
 \r
 #ifdef __cplusplus\r
index 402e2ec..92296c5 100644 (file)
@@ -32,11 +32,11 @@ void silk_warped_autocorrelation_FLP(
           SKP_float                 *corr,              /* O    Result [order + 1]                      */\r
     const SKP_float                 *input,             /* I    Input data to correlate                 */\r
     const SKP_float                 warping,            /* I    Warping coefficient                     */\r
-    const SKP_int                   length,             /* I    Length of input                         */\r
-    const SKP_int                   order               /* I    Correlation order (even)                */\r
+    const opus_int                   length,             /* I    Length of input                         */\r
+    const opus_int                   order               /* I    Correlation order (even)                */\r
 )\r
 {\r
-    SKP_int   n, i;\r
+    opus_int   n, i;\r
     double tmp1, tmp2;\r
     double state[ MAX_SHAPE_LPC_ORDER + 1 ] = { 0 };\r
     double C[ MAX_SHAPE_LPC_ORDER + 1 ] = { 0 };\r
index 040d5d9..f000e9d 100644 (file)
@@ -31,13 +31,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 \r
 /* Convert AR filter coefficients to NLSF parameters */\r
 void silk_A2NLSF_FLP( \r
-          SKP_int16                 *NLSF_Q15,          /* O    NLSF vector      [ LPC_order ]          */\r
+          opus_int16                 *NLSF_Q15,          /* O    NLSF vector      [ LPC_order ]          */\r
     const SKP_float                 *pAR,               /* I    LPC coefficients [ LPC_order ]          */\r
-    const SKP_int                   LPC_order           /* I    LPC order                               */\r
+    const opus_int                   LPC_order           /* I    LPC order                               */\r
 )\r
 {\r
-    SKP_int   i;\r
-    SKP_int32 a_fix_Q16[ MAX_LPC_ORDER ];\r
+    opus_int   i;\r
+    opus_int32 a_fix_Q16[ MAX_LPC_ORDER ];\r
 \r
     for( i = 0; i < LPC_order; i++ ) {\r
         a_fix_Q16[ i ] = SKP_float2int( pAR[ i ] * 65536.0f );\r
@@ -49,12 +49,12 @@ void silk_A2NLSF_FLP(
 /* Convert LSF parameters to AR prediction filter coefficients */\r
 void silk_NLSF2A_FLP( \r
           SKP_float                 *pAR,               /* O    LPC coefficients [ LPC_order ]          */\r
-    const SKP_int16                 *NLSF_Q15,          /* I    NLSF vector      [ LPC_order ]          */\r
-    const SKP_int                   LPC_order           /* I    LPC order                               */\r
+    const opus_int16                 *NLSF_Q15,          /* I    NLSF vector      [ LPC_order ]          */\r
+    const opus_int                   LPC_order           /* I    LPC order                               */\r
 )\r
 {\r
-    SKP_int   i;\r
-    SKP_int16 a_fix_Q12[ MAX_LPC_ORDER ];\r
+    opus_int   i;\r
+    opus_int16 a_fix_Q12[ MAX_LPC_ORDER ];\r
 \r
     silk_NLSF2A( a_fix_Q12, NLSF_Q15, LPC_order );\r
 \r
@@ -69,12 +69,12 @@ void silk_NLSF2A_FLP(
 void silk_process_NLSFs_FLP(\r
     silk_encoder_state              *psEncC,                            /* I/O  Encoder state                               */\r
     SKP_float                       PredCoef[ 2 ][ MAX_LPC_ORDER ],     /* O    Prediction coefficients                     */\r
-    SKP_int16                       NLSF_Q15[      MAX_LPC_ORDER ],     /* I/O  Normalized LSFs (quant out) (0 - (2^15-1))  */\r
-    const SKP_int16                 prev_NLSF_Q15[ MAX_LPC_ORDER ]      /* I    Previous Normalized LSFs (0 - (2^15-1))     */\r
+    opus_int16                       NLSF_Q15[      MAX_LPC_ORDER ],     /* I/O  Normalized LSFs (quant out) (0 - (2^15-1))  */\r
+    const opus_int16                 prev_NLSF_Q15[ MAX_LPC_ORDER ]      /* I    Previous Normalized LSFs (0 - (2^15-1))     */\r
 )\r
 {\r
-    SKP_int     i, j;\r
-    SKP_int16   PredCoef_Q12[ 2 ][ MAX_LPC_ORDER ];\r
+    opus_int     i, j;\r
+    opus_int16   PredCoef_Q12[ 2 ][ MAX_LPC_ORDER ];\r
 \r
     silk_process_NLSFs( psEncC, PredCoef_Q12, NLSF_Q15, prev_NLSF_Q15);\r
 \r
@@ -93,23 +93,23 @@ void silk_NSQ_wrapper_FLP(
     silk_encoder_control_FLP        *psEncCtrl,     /* I/O  Encoder control FLP                         */\r
     SideInfoIndices                 *psIndices,     /* I/O  Quantization indices                        */\r
     silk_nsq_state                  *psNSQ,         /* I/O  Noise Shaping Quantzation state             */\r
-          SKP_int8                  pulses[],       /* O    Quantized pulse signal                      */\r
+          opus_int8                  pulses[],       /* O &nb