eden-emu/opus
15
0
Fork 0
mirror of https://github.com/xiph/opus.git synced 2025-05-28 22:29:14 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Converting some silk_assert()s into hardening celt_assert()s

Browse source 
Only converted the ones that are really sure (not signal-dependent)
and that shouldn't add much run-time complexity
This commit is contained in:
Jean-Marc Valin 2018-03-24 02:16:15 -04:00
parent 69bcb28d3d
commit 7e3352ef51
No known key found for this signature in database
GPG key ID: 5E5DD9A36F9189C8
29 changed files with 96 additions and 96 deletions
Download patch file Download diff file Expand all files Collapse all files

2
silk/CNG.c
View file

@ -146,8 +146,8 @@ void silk_CNG(
/* Generate CNG signal, by synthesis filtering */ /* Generate CNG signal, by synthesis filtering */
silk_memcpy( CNG_sig_Q14, psCNG->CNG_synth_state, MAX_LPC_ORDER * sizeof( opus_int32 ) ); silk_memcpy( CNG_sig_Q14, psCNG->CNG_synth_state, MAX_LPC_ORDER * sizeof( opus_int32 ) );
celt_assert( psDec->LPC_order == 10 || psDec->LPC_order == 16 );
for( i = 0; i < length; i++ ) { for( i = 0; i < length; i++ ) {
silk_assert( psDec->LPC_order == 10 || psDec->LPC_order == 16 );
/* Avoids introducing a bias because silk_SMLAWB() always rounds to -inf */ /* Avoids introducing a bias because silk_SMLAWB() always rounds to -inf */
LPC_pred_Q10 = silk_RSHIFT( psDec->LPC_order, 1 ); LPC_pred_Q10 = silk_RSHIFT( psDec->LPC_order, 1 );
LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, CNG_sig_Q14[ MAX_LPC_ORDER + i - 1 ], A_Q12[ 0 ] ); LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, CNG_sig_Q14[ MAX_LPC_ORDER + i - 1 ], A_Q12[ 0 ] );

8
silk/LPC_analysis_filter.c
View file

@ -64,12 +64,12 @@ void silk_LPC_analysis_filter(
const opus_int16 *in_ptr; const opus_int16 *in_ptr;
#endif #endif
silk_assert( d >= 6 ); celt_assert( d >= 6 );
silk_assert( (d & 1) == 0 ); celt_assert( (d & 1) == 0 );
silk_assert( d <= len ); celt_assert( d <= len );
#if defined(FIXED_POINT) && USE_CELT_FIR #if defined(FIXED_POINT) && USE_CELT_FIR
silk_assert( d <= SILK_MAX_ORDER_LPC ); celt_assert( d <= SILK_MAX_ORDER_LPC );
for ( j = 0; j < d; j++ ) { for ( j = 0; j < d; j++ ) {
num[ j ] = -B[ j ]; num[ j ] = -B[ j ];
} }

2
silk/NLSF2A.c
View file

@ -86,7 +86,7 @@ void silk_NLSF2A(
opus_int32 a32_QA1[ SILK_MAX_ORDER_LPC ]; opus_int32 a32_QA1[ SILK_MAX_ORDER_LPC ];
silk_assert( LSF_COS_TAB_SZ_FIX == 128 ); silk_assert( LSF_COS_TAB_SZ_FIX == 128 );
silk_assert( d==10 || d==16 ); celt_assert( d==10 || d==16 );
/* convert LSFs to 2*cos(LSF), using piecewise linear curve from table */ /* convert LSFs to 2*cos(LSF), using piecewise linear curve from table */
ordering = d == 16 ? ordering16 : ordering10; ordering = d == 16 ? ordering16 : ordering10;

2
silk/NLSF_VQ.c
View file

@ -46,7 +46,7 @@ void silk_NLSF_VQ(
const opus_int16 *w_Q9_ptr; const opus_int16 *w_Q9_ptr;
const opus_uint8 *cb_Q8_ptr; const opus_uint8 *cb_Q8_ptr;
silk_assert( ( LPC_order & 1 ) == 0 ); celt_assert( ( LPC_order & 1 ) == 0 );
/* Loop over codebook */ /* Loop over codebook */
cb_Q8_ptr = pCB_Q8; cb_Q8_ptr = pCB_Q8;

4
silk/NLSF_VQ_weights_laroia.c
View file

@ -48,8 +48,8 @@ void silk_NLSF_VQ_weights_laroia(
opus_int k; opus_int k;
opus_int32 tmp1_int, tmp2_int; opus_int32 tmp1_int, tmp2_int;
silk_assert( D > 0 ); celt_assert( D > 0 );
silk_assert( ( D & 1 ) == 0 ); celt_assert( ( D & 1 ) == 0 );
/* First value */ /* First value */
tmp1_int = silk_max_int( pNLSF_Q15[ 0 ], 1 ); tmp1_int = silk_max_int( pNLSF_Q15[ 0 ], 1 );

2
silk/NLSF_encode.c
View file

@ -60,7 +60,7 @@ opus_int32 silk_NLSF_encode( /* O Returns
const opus_int16 *pCB_Wght_Q9; const opus_int16 *pCB_Wght_Q9;
SAVE_STACK; SAVE_STACK;
silk_assert( signalType >= 0 && signalType <= 2 ); celt_assert( signalType >= 0 && signalType <= 2 );
silk_assert( NLSF_mu_Q20 <= 32767 && NLSF_mu_Q20 >= 0 ); silk_assert( NLSF_mu_Q20 <= 32767 && NLSF_mu_Q20 >= 0 );
/* NLSF stabilization */ /* NLSF stabilization */

6
silk/NSQ.c
View file

@ -143,7 +143,7 @@ void silk_NSQ_c
if( ( k & ( 3 - silk_LSHIFT( LSF_interpolation_flag, 1 ) ) ) == 0 ) { if( ( k & ( 3 - silk_LSHIFT( LSF_interpolation_flag, 1 ) ) ) == 0 ) {
/* Rewhiten with new A coefs */ /* Rewhiten with new A coefs */
start_idx = psEncC->ltp_mem_length - lag - psEncC->predictLPCOrder - LTP_ORDER / 2; start_idx = psEncC->ltp_mem_length - lag - psEncC->predictLPCOrder - LTP_ORDER / 2;
silk_assert( start_idx > 0 ); celt_assert( start_idx > 0 );
silk_LPC_analysis_filter( &sLTP[ start_idx ], &NSQ->xq[ start_idx + k * psEncC->subfr_length ], silk_LPC_analysis_filter( &sLTP[ start_idx ], &NSQ->xq[ start_idx + k * psEncC->subfr_length ],
A_Q12, psEncC->ltp_mem_length - start_idx, psEncC->predictLPCOrder, psEncC->arch ); A_Q12, psEncC->ltp_mem_length - start_idx, psEncC->predictLPCOrder, psEncC->arch );
@ -247,7 +247,7 @@ void silk_noise_shape_quantizer(
} }
/* Noise shape feedback */ /* Noise shape feedback */
silk_assert( ( shapingLPCOrder & 1 ) == 0 ); /* check that order is even */ celt_assert( ( shapingLPCOrder & 1 ) == 0 ); /* check that order is even */
n_AR_Q12 = silk_NSQ_noise_shape_feedback_loop(&NSQ->sDiff_shp_Q14, NSQ->sAR2_Q14, AR_shp_Q13, shapingLPCOrder, arch); n_AR_Q12 = silk_NSQ_noise_shape_feedback_loop(&NSQ->sDiff_shp_Q14, NSQ->sAR2_Q14, AR_shp_Q13, shapingLPCOrder, arch);
n_AR_Q12 = silk_SMLAWB( n_AR_Q12, NSQ->sLF_AR_shp_Q14, Tilt_Q14 ); n_AR_Q12 = silk_SMLAWB( n_AR_Q12, NSQ->sLF_AR_shp_Q14, Tilt_Q14 );
@ -255,7 +255,7 @@ void silk_noise_shape_quantizer(
n_LF_Q12 = silk_SMULWB( NSQ->sLTP_shp_Q14[ NSQ->sLTP_shp_buf_idx - 1 ], LF_shp_Q14 ); n_LF_Q12 = silk_SMULWB( NSQ->sLTP_shp_Q14[ NSQ->sLTP_shp_buf_idx - 1 ], LF_shp_Q14 );
n_LF_Q12 = silk_SMLAWT( n_LF_Q12, NSQ->sLF_AR_shp_Q14, LF_shp_Q14 ); n_LF_Q12 = silk_SMLAWT( n_LF_Q12, NSQ->sLF_AR_shp_Q14, LF_shp_Q14 );
silk_assert( lag > 0 || signalType != TYPE_VOICED ); celt_assert( lag > 0 || signalType != TYPE_VOICED );
/* Combine prediction and noise shaping signals */ /* Combine prediction and noise shaping signals */
tmp1 = silk_SUB32( silk_LSHIFT32( LPC_pred_Q10, 2 ), n_AR_Q12 ); /* Q12 */ tmp1 = silk_SUB32( silk_LSHIFT32( LPC_pred_Q10, 2 ), n_AR_Q12 ); /* Q12 */

6
silk/NSQ_del_dec.c
View file

@ -250,7 +250,7 @@ void silk_NSQ_del_dec_c(
/* Rewhiten with new A coefs */ /* Rewhiten with new A coefs */
start_idx = psEncC->ltp_mem_length - lag - psEncC->predictLPCOrder - LTP_ORDER / 2; start_idx = psEncC->ltp_mem_length - lag - psEncC->predictLPCOrder - LTP_ORDER / 2;
silk_assert( start_idx > 0 ); celt_assert( start_idx > 0 );
silk_LPC_analysis_filter( &sLTP[ start_idx ], &NSQ->xq[ start_idx + k * psEncC->subfr_length ], silk_LPC_analysis_filter( &sLTP[ start_idx ], &NSQ->xq[ start_idx + k * psEncC->subfr_length ],
A_Q12, psEncC->ltp_mem_length - start_idx, psEncC->predictLPCOrder, psEncC->arch ); A_Q12, psEncC->ltp_mem_length - start_idx, psEncC->predictLPCOrder, psEncC->arch );
@ -361,7 +361,7 @@ static OPUS_INLINE void silk_noise_shape_quantizer_del_dec(
NSQ_sample_struct *psSS; NSQ_sample_struct *psSS;
SAVE_STACK; SAVE_STACK;
silk_assert( nStatesDelayedDecision > 0 ); celt_assert( nStatesDelayedDecision > 0 );
ALLOC( psSampleState, nStatesDelayedDecision, NSQ_sample_pair ); ALLOC( psSampleState, nStatesDelayedDecision, NSQ_sample_pair );
shp_lag_ptr = &NSQ->sLTP_shp_Q14[ NSQ->sLTP_shp_buf_idx - lag + HARM_SHAPE_FIR_TAPS / 2 ]; shp_lag_ptr = &NSQ->sLTP_shp_Q14[ NSQ->sLTP_shp_buf_idx - lag + HARM_SHAPE_FIR_TAPS / 2 ];
@ -419,7 +419,7 @@ static OPUS_INLINE void silk_noise_shape_quantizer_del_dec(
LPC_pred_Q14 = silk_LSHIFT( LPC_pred_Q14, 4 ); /* Q10 -> Q14 */ LPC_pred_Q14 = silk_LSHIFT( LPC_pred_Q14, 4 ); /* Q10 -> Q14 */
/* Noise shape feedback */ /* Noise shape feedback */
silk_assert( ( shapingLPCOrder & 1 ) == 0 ); /* check that order is even */ celt_assert( ( shapingLPCOrder & 1 ) == 0 ); /* check that order is even */
/* Output of lowpass section */ /* Output of lowpass section */
tmp2 = silk_SMLAWB( psDD->Diff_Q14, psDD->sAR2_Q14[ 0 ], warping_Q16 ); tmp2 = silk_SMLAWB( psDD->Diff_Q14, psDD->sAR2_Q14[ 0 ], warping_Q16 );
/* Output of allpass section */ /* Output of allpass section */

4
silk/PLC.c
View file

@ -291,7 +291,7 @@ static OPUS_INLINE void silk_PLC_conceal(
/* Rewhiten LTP state */ /* Rewhiten LTP state */
idx = psDec->ltp_mem_length - lag - psDec->LPC_order - LTP_ORDER / 2; idx = psDec->ltp_mem_length - lag - psDec->LPC_order - LTP_ORDER / 2;
silk_assert( idx > 0 ); celt_assert( idx > 0 );
silk_LPC_analysis_filter( &sLTP[ idx ], &psDec->outBuf[ idx ], A_Q12, psDec->ltp_mem_length - idx, psDec->LPC_order, arch ); silk_LPC_analysis_filter( &sLTP[ idx ], &psDec->outBuf[ idx ], A_Q12, psDec->ltp_mem_length - idx, psDec->LPC_order, arch );
/* Scale LTP state */ /* Scale LTP state */
inv_gain_Q30 = silk_INVERSE32_varQ( psPLC->prevGain_Q16[ 1 ], 46 ); inv_gain_Q30 = silk_INVERSE32_varQ( psPLC->prevGain_Q16[ 1 ], 46 );
@ -347,7 +347,7 @@ static OPUS_INLINE void silk_PLC_conceal(
/* Copy LPC state */ /* Copy LPC state */
silk_memcpy( sLPC_Q14_ptr, psDec->sLPC_Q14_buf, MAX_LPC_ORDER * sizeof( opus_int32 ) ); silk_memcpy( sLPC_Q14_ptr, psDec->sLPC_Q14_buf, MAX_LPC_ORDER * sizeof( opus_int32 ) );
silk_assert( psDec->LPC_order >= 10 ); /* check that unrolling works */ celt_assert( psDec->LPC_order >= 10 ); /* check that unrolling works */
for( i = 0; i < psDec->frame_length; i++ ) { for( i = 0; i < psDec->frame_length; i++ ) {
/* partly unrolled */ /* partly unrolled */
/* Avoids introducing a bias because silk_SMLAWB() always rounds to -inf */ /* Avoids introducing a bias because silk_SMLAWB() always rounds to -inf */

6
silk/VAD.c
View file

@ -101,9 +101,9 @@ opus_int silk_VAD_GetSA_Q8_c( /* O Return v
/* Safety checks */ /* Safety checks */
silk_assert( VAD_N_BANDS == 4 ); silk_assert( VAD_N_BANDS == 4 );
silk_assert( MAX_FRAME_LENGTH >= psEncC->frame_length ); celt_assert( MAX_FRAME_LENGTH >= psEncC->frame_length );
silk_assert( psEncC->frame_length <= 512 ); celt_assert( psEncC->frame_length <= 512 );
silk_assert( psEncC->frame_length == 8 * silk_RSHIFT( psEncC->frame_length, 3 ) ); celt_assert( psEncC->frame_length == 8 * silk_RSHIFT( psEncC->frame_length, 3 ) );
/***********************/ /***********************/
/* Filter and Decimate */ /* Filter and Decimate */

22
silk/check_control_input.c
View file

@ -38,7 +38,7 @@ opus_int check_control_input(
silk_EncControlStruct *encControl /* I Control structure */ silk_EncControlStruct *encControl /* I Control structure */
) )
{ {
silk_assert( encControl != NULL ); celt_assert( encControl != NULL );
if( ( ( encControl->API_sampleRate != 8000 ) && if( ( ( encControl->API_sampleRate != 8000 ) &&
( encControl->API_sampleRate != 12000 ) && ( encControl->API_sampleRate != 12000 ) &&
@ -59,46 +59,46 @@ opus_int check_control_input(
( encControl->minInternalSampleRate > encControl->desiredInternalSampleRate ) || ( encControl->minInternalSampleRate > encControl->desiredInternalSampleRate ) ||
( encControl->maxInternalSampleRate < encControl->desiredInternalSampleRate ) || ( encControl->maxInternalSampleRate < encControl->desiredInternalSampleRate ) ||
( encControl->minInternalSampleRate > encControl->maxInternalSampleRate ) ) { ( encControl->minInternalSampleRate > encControl->maxInternalSampleRate ) ) {
silk_assert( 0 ); celt_assert( 0 );
return SILK_ENC_FS_NOT_SUPPORTED; return SILK_ENC_FS_NOT_SUPPORTED;
} }
if( encControl->payloadSize_ms != 10 && if( encControl->payloadSize_ms != 10 &&
encControl->payloadSize_ms != 20 && encControl->payloadSize_ms != 20 &&
encControl->payloadSize_ms != 40 && encControl->payloadSize_ms != 40 &&
encControl->payloadSize_ms != 60 ) { encControl->payloadSize_ms != 60 ) {
silk_assert( 0 ); celt_assert( 0 );
return SILK_ENC_PACKET_SIZE_NOT_SUPPORTED; return SILK_ENC_PACKET_SIZE_NOT_SUPPORTED;
} }
if( encControl->packetLossPercentage < 0 || encControl->packetLossPercentage > 100 ) { if( encControl->packetLossPercentage < 0 || encControl->packetLossPercentage > 100 ) {
silk_assert( 0 ); celt_assert( 0 );
return SILK_ENC_INVALID_LOSS_RATE; return SILK_ENC_INVALID_LOSS_RATE;
} }
if( encControl->useDTX < 0 || encControl->useDTX > 1 ) { if( encControl->useDTX < 0 || encControl->useDTX > 1 ) {
silk_assert( 0 ); celt_assert( 0 );
return SILK_ENC_INVALID_DTX_SETTING; return SILK_ENC_INVALID_DTX_SETTING;
} }
if( encControl->useCBR < 0 || encControl->useCBR > 1 ) { if( encControl->useCBR < 0 || encControl->useCBR > 1 ) {
silk_assert( 0 ); celt_assert( 0 );
return SILK_ENC_INVALID_CBR_SETTING; return SILK_ENC_INVALID_CBR_SETTING;
} }
if( encControl->useInBandFEC < 0 || encControl->useInBandFEC > 1 ) { if( encControl->useInBandFEC < 0 || encControl->useInBandFEC > 1 ) {
silk_assert( 0 ); celt_assert( 0 );
return SILK_ENC_INVALID_INBAND_FEC_SETTING; return SILK_ENC_INVALID_INBAND_FEC_SETTING;
} }
if( encControl->nChannelsAPI < 1 || encControl->nChannelsAPI > ENCODER_NUM_CHANNELS ) { if( encControl->nChannelsAPI < 1 || encControl->nChannelsAPI > ENCODER_NUM_CHANNELS ) {
silk_assert( 0 ); celt_assert( 0 );
return SILK_ENC_INVALID_NUMBER_OF_CHANNELS_ERROR; return SILK_ENC_INVALID_NUMBER_OF_CHANNELS_ERROR;
} }
if( encControl->nChannelsInternal < 1 || encControl->nChannelsInternal > ENCODER_NUM_CHANNELS ) { if( encControl->nChannelsInternal < 1 || encControl->nChannelsInternal > ENCODER_NUM_CHANNELS ) {
silk_assert( 0 ); celt_assert( 0 );
return SILK_ENC_INVALID_NUMBER_OF_CHANNELS_ERROR; return SILK_ENC_INVALID_NUMBER_OF_CHANNELS_ERROR;
} }
if( encControl->nChannelsInternal > encControl->nChannelsAPI ) { if( encControl->nChannelsInternal > encControl->nChannelsAPI ) {
silk_assert( 0 ); celt_assert( 0 );
return SILK_ENC_INVALID_NUMBER_OF_CHANNELS_ERROR; return SILK_ENC_INVALID_NUMBER_OF_CHANNELS_ERROR;
} }
if( encControl->complexity < 0 || encControl->complexity > 10 ) { if( encControl->complexity < 0 || encControl->complexity > 10 ) {
silk_assert( 0 ); celt_assert( 0 );
return SILK_ENC_INVALID_COMPLEXITY_SETTING; return SILK_ENC_INVALID_COMPLEXITY_SETTING;
} }

20
silk/control_codec.c
View file

@ -238,8 +238,8 @@ static opus_int silk_setup_fs(
} }
/* Set internal sampling frequency */ /* Set internal sampling frequency */
silk_assert( fs_kHz == 8 || fs_kHz == 12 || fs_kHz == 16 ); celt_assert( fs_kHz == 8 || fs_kHz == 12 || fs_kHz == 16 );
silk_assert( psEnc->sCmn.nb_subfr == 2 || psEnc->sCmn.nb_subfr == 4 ); celt_assert( psEnc->sCmn.nb_subfr == 2 || psEnc->sCmn.nb_subfr == 4 );
if( psEnc->sCmn.fs_kHz != fs_kHz ) { if( psEnc->sCmn.fs_kHz != fs_kHz ) {
/* reset part of the state */ /* reset part of the state */
silk_memset( &psEnc->sShape, 0, sizeof( psEnc->sShape ) ); silk_memset( &psEnc->sShape, 0, sizeof( psEnc->sShape ) );
@ -299,7 +299,7 @@ static opus_int silk_setup_fs(
} }
/* Check that settings are valid */ /* Check that settings are valid */
silk_assert( ( psEnc->sCmn.subfr_length * psEnc->sCmn.nb_subfr ) == psEnc->sCmn.frame_length ); celt_assert( ( psEnc->sCmn.subfr_length * psEnc->sCmn.nb_subfr ) == psEnc->sCmn.frame_length );
return ret; return ret;
} }
@ -312,7 +312,7 @@ static opus_int silk_setup_complexity(
opus_int ret = 0; opus_int ret = 0;
/* Set encoding complexity */ /* Set encoding complexity */
silk_assert( Complexity >= 0 && Complexity <= 10 ); celt_assert( Complexity >= 0 && Complexity <= 10 );
if( Complexity < 1 ) { if( Complexity < 1 ) {
psEncC->pitchEstimationComplexity = SILK_PE_MIN_COMPLEX; psEncC->pitchEstimationComplexity = SILK_PE_MIN_COMPLEX;
psEncC->pitchEstimationThreshold_Q16 = SILK_FIX_CONST( 0.8, 16 ); psEncC->pitchEstimationThreshold_Q16 = SILK_FIX_CONST( 0.8, 16 );
@ -390,12 +390,12 @@ static opus_int silk_setup_complexity(
psEncC->shapeWinLength = SUB_FRAME_LENGTH_MS * psEncC->fs_kHz + 2 * psEncC->la_shape; psEncC->shapeWinLength = SUB_FRAME_LENGTH_MS * psEncC->fs_kHz + 2 * psEncC->la_shape;
psEncC->Complexity = Complexity; psEncC->Complexity = Complexity;
silk_assert( psEncC->pitchEstimationLPCOrder <= MAX_FIND_PITCH_LPC_ORDER ); celt_assert( psEncC->pitchEstimationLPCOrder <= MAX_FIND_PITCH_LPC_ORDER );
silk_assert( psEncC->shapingLPCOrder <= MAX_SHAPE_LPC_ORDER ); celt_assert( psEncC->shapingLPCOrder <= MAX_SHAPE_LPC_ORDER );
silk_assert( psEncC->nStatesDelayedDecision <= MAX_DEL_DEC_STATES ); celt_assert( psEncC->nStatesDelayedDecision <= MAX_DEL_DEC_STATES );
silk_assert( psEncC->warping_Q16 <= 32767 ); celt_assert( psEncC->warping_Q16 <= 32767 );
silk_assert( psEncC->la_shape <= LA_SHAPE_MAX ); celt_assert( psEncC->la_shape <= LA_SHAPE_MAX );
silk_assert( psEncC->shapeWinLength <= SHAPE_LPC_WIN_MAX ); celt_assert( psEncC->shapeWinLength <= SHAPE_LPC_WIN_MAX );
return ret; return ret;
} }

6
silk/dec_API.c
View file

@ -104,7 +104,7 @@ opus_int silk_Decode( /* O Returns error co
int delay_stack_alloc; int delay_stack_alloc;
SAVE_STACK; SAVE_STACK;
silk_assert( decControl->nChannelsInternal == 1 || decControl->nChannelsInternal == 2 ); celt_assert( decControl->nChannelsInternal == 1 || decControl->nChannelsInternal == 2 );
/**********************************/ /**********************************/
/* Test if first frame in payload */ /* Test if first frame in payload */
@ -143,13 +143,13 @@ opus_int silk_Decode( /* O Returns error co
channel_state[ n ].nFramesPerPacket = 3; channel_state[ n ].nFramesPerPacket = 3;
channel_state[ n ].nb_subfr = 4; channel_state[ n ].nb_subfr = 4;
} else { } else {
silk_assert( 0 ); celt_assert( 0 );
RESTORE_STACK; RESTORE_STACK;
return SILK_DEC_INVALID_FRAME_SIZE; return SILK_DEC_INVALID_FRAME_SIZE;
} }
fs_kHz_dec = ( decControl->internalSampleRate >> 10 ) + 1; fs_kHz_dec = ( decControl->internalSampleRate >> 10 ) + 1;
if( fs_kHz_dec != 8 && fs_kHz_dec != 12 && fs_kHz_dec != 16 ) { if( fs_kHz_dec != 8 && fs_kHz_dec != 12 && fs_kHz_dec != 16 ) {
silk_assert( 0 ); celt_assert( 0 );
RESTORE_STACK; RESTORE_STACK;
return SILK_DEC_INVALID_SAMPLING_FREQUENCY; return SILK_DEC_INVALID_SAMPLING_FREQUENCY;
} }

4
silk/decode_core.c
View file

@ -141,7 +141,7 @@ void silk_decode_core(
if( k == 0 || ( k == 2 && NLSF_interpolation_flag ) ) { if( k == 0 || ( k == 2 && NLSF_interpolation_flag ) ) {
/* Rewhiten with new A coefs */ /* Rewhiten with new A coefs */
start_idx = psDec->ltp_mem_length - lag - psDec->LPC_order - LTP_ORDER / 2; start_idx = psDec->ltp_mem_length - lag - psDec->LPC_order - LTP_ORDER / 2;
silk_assert( start_idx > 0 ); celt_assert( start_idx > 0 );
if( k == 2 ) { if( k == 2 ) {
silk_memcpy( &psDec->outBuf[ psDec->ltp_mem_length ], xq, 2 * psDec->subfr_length * sizeof( opus_int16 ) ); silk_memcpy( &psDec->outBuf[ psDec->ltp_mem_length ], xq, 2 * psDec->subfr_length * sizeof( opus_int16 ) );
@ -196,7 +196,7 @@ void silk_decode_core(
for( i = 0; i < psDec->subfr_length; i++ ) { for( i = 0; i < psDec->subfr_length; i++ ) {
/* Short-term prediction */ /* Short-term prediction */
silk_assert( psDec->LPC_order == 10 || psDec->LPC_order == 16 ); celt_assert( psDec->LPC_order == 10 || psDec->LPC_order == 16 );
/* Avoids introducing a bias because silk_SMLAWB() always rounds to -inf */ /* Avoids introducing a bias because silk_SMLAWB() always rounds to -inf */
LPC_pred_Q10 = silk_RSHIFT( psDec->LPC_order, 1 ); LPC_pred_Q10 = silk_RSHIFT( psDec->LPC_order, 1 );
LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, sLPC_Q14[ MAX_LPC_ORDER + i - 1 ], A_Q12_tmp[ 0 ] ); LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, sLPC_Q14[ MAX_LPC_ORDER + i - 1 ], A_Q12_tmp[ 0 ] );

6
silk/decode_frame.c
View file

@ -55,7 +55,7 @@ opus_int silk_decode_frame(
psDecCtrl->LTP_scale_Q14 = 0; psDecCtrl->LTP_scale_Q14 = 0;
/* Safety checks */ /* Safety checks */
silk_assert( L > 0 && L <= MAX_FRAME_LENGTH ); celt_assert( L > 0 && L <= MAX_FRAME_LENGTH );
if( lostFlag == FLAG_DECODE_NORMAL || if( lostFlag == FLAG_DECODE_NORMAL ||
( lostFlag == FLAG_DECODE_LBRR && psDec->LBRR_flags[ psDec->nFramesDecoded ] == 1 ) ) ( lostFlag == FLAG_DECODE_LBRR && psDec->LBRR_flags[ psDec->nFramesDecoded ] == 1 ) )
@ -91,7 +91,7 @@ opus_int silk_decode_frame(
psDec->lossCnt = 0; psDec->lossCnt = 0;
psDec->prevSignalType = psDec->indices.signalType; psDec->prevSignalType = psDec->indices.signalType;
silk_assert( psDec->prevSignalType >= 0 && psDec->prevSignalType <= 2 ); celt_assert( psDec->prevSignalType >= 0 && psDec->prevSignalType <= 2 );
/* A frame has been decoded without errors */ /* A frame has been decoded without errors */
psDec->first_frame_after_reset = 0; psDec->first_frame_after_reset = 0;
@ -104,7 +104,7 @@ opus_int silk_decode_frame(
/*************************/ /*************************/
/* Update output buffer. */ /* Update output buffer. */
/*************************/ /*************************/
silk_assert( psDec->ltp_mem_length >= psDec->frame_length ); celt_assert( psDec->ltp_mem_length >= psDec->frame_length );
mv_len = psDec->ltp_mem_length - psDec->frame_length; mv_len = psDec->ltp_mem_length - psDec->frame_length;
silk_memmove( psDec->outBuf, &psDec->outBuf[ psDec->frame_length ], mv_len * sizeof(opus_int16) ); silk_memmove( psDec->outBuf, &psDec->outBuf[ psDec->frame_length ], mv_len * sizeof(opus_int16) );
silk_memcpy( &psDec->outBuf[ mv_len ], pOut, psDec->frame_length * sizeof( opus_int16 ) ); silk_memcpy( &psDec->outBuf[ mv_len ], pOut, psDec->frame_length * sizeof( opus_int16 ) );

2
silk/decode_indices.c
View file

@ -79,7 +79,7 @@ void silk_decode_indices(
/**********************/ /**********************/
psDec->indices.NLSFIndices[ 0 ] = (opus_int8)ec_dec_icdf( psRangeDec, &psDec->psNLSF_CB->CB1_iCDF[ ( psDec->indices.signalType >> 1 ) * psDec->psNLSF_CB->nVectors ], 8 ); psDec->indices.NLSFIndices[ 0 ] = (opus_int8)ec_dec_icdf( psRangeDec, &psDec->psNLSF_CB->CB1_iCDF[ ( psDec->indices.signalType >> 1 ) * psDec->psNLSF_CB->nVectors ], 8 );
silk_NLSF_unpack( ec_ix, pred_Q8, psDec->psNLSF_CB, psDec->indices.NLSFIndices[ 0 ] ); silk_NLSF_unpack( ec_ix, pred_Q8, psDec->psNLSF_CB, psDec->indices.NLSFIndices[ 0 ] );
silk_assert( psDec->psNLSF_CB->order == psDec->LPC_order ); celt_assert( psDec->psNLSF_CB->order == psDec->LPC_order );
for( i = 0; i < psDec->psNLSF_CB->order; i++ ) { for( i = 0; i < psDec->psNLSF_CB->order; i++ ) {
Ix = ec_dec_icdf( psRangeDec, &psDec->psNLSF_CB->ec_iCDF[ ec_ix[ i ] ], 8 ); Ix = ec_dec_icdf( psRangeDec, &psDec->psNLSF_CB->ec_iCDF[ ec_ix[ i ] ], 8 );
if( Ix == 0 ) { if( Ix == 0 ) {

4
silk/decode_pitch.c
View file

@ -51,7 +51,7 @@ void silk_decode_pitch(
Lag_CB_ptr = &silk_CB_lags_stage2[ 0 ][ 0 ]; Lag_CB_ptr = &silk_CB_lags_stage2[ 0 ][ 0 ];
cbk_size = PE_NB_CBKS_STAGE2_EXT; cbk_size = PE_NB_CBKS_STAGE2_EXT;
} else { } else {
silk_assert( nb_subfr == PE_MAX_NB_SUBFR >> 1 ); celt_assert( nb_subfr == PE_MAX_NB_SUBFR >> 1 );
Lag_CB_ptr = &silk_CB_lags_stage2_10_ms[ 0 ][ 0 ]; Lag_CB_ptr = &silk_CB_lags_stage2_10_ms[ 0 ][ 0 ];
cbk_size = PE_NB_CBKS_STAGE2_10MS; cbk_size = PE_NB_CBKS_STAGE2_10MS;
} }
@ -60,7 +60,7 @@ void silk_decode_pitch(
Lag_CB_ptr = &silk_CB_lags_stage3[ 0 ][ 0 ]; Lag_CB_ptr = &silk_CB_lags_stage3[ 0 ][ 0 ];
cbk_size = PE_NB_CBKS_STAGE3_MAX; cbk_size = PE_NB_CBKS_STAGE3_MAX;
} else { } else {
silk_assert( nb_subfr == PE_MAX_NB_SUBFR >> 1 ); celt_assert( nb_subfr == PE_MAX_NB_SUBFR >> 1 );
Lag_CB_ptr = &silk_CB_lags_stage3_10_ms[ 0 ][ 0 ]; Lag_CB_ptr = &silk_CB_lags_stage3_10_ms[ 0 ][ 0 ];
cbk_size = PE_NB_CBKS_STAGE3_10MS; cbk_size = PE_NB_CBKS_STAGE3_10MS;
} }

2
silk/decode_pulses.c
View file

@ -56,7 +56,7 @@ void silk_decode_pulses(
silk_assert( 1 << LOG2_SHELL_CODEC_FRAME_LENGTH == SHELL_CODEC_FRAME_LENGTH ); silk_assert( 1 << LOG2_SHELL_CODEC_FRAME_LENGTH == SHELL_CODEC_FRAME_LENGTH );
iter = silk_RSHIFT( frame_length, LOG2_SHELL_CODEC_FRAME_LENGTH ); iter = silk_RSHIFT( frame_length, LOG2_SHELL_CODEC_FRAME_LENGTH );
if( iter * SHELL_CODEC_FRAME_LENGTH < frame_length ) { if( iter * SHELL_CODEC_FRAME_LENGTH < frame_length ) {
silk_assert( frame_length == 12 * 10 ); /* Make sure only happens for 10 ms @ 12 kHz */ celt_assert( frame_length == 12 * 10 ); /* Make sure only happens for 10 ms @ 12 kHz */
iter++; iter++;
} }

8
silk/decoder_set_fs.c
View file

@ -40,8 +40,8 @@ opus_int silk_decoder_set_fs(
{ {
opus_int frame_length, ret = 0; opus_int frame_length, ret = 0;
silk_assert( fs_kHz == 8 || fs_kHz == 12 || fs_kHz == 16 ); celt_assert( fs_kHz == 8 || fs_kHz == 12 || fs_kHz == 16 );
silk_assert( psDec->nb_subfr == MAX_NB_SUBFR || psDec->nb_subfr == MAX_NB_SUBFR/2 ); celt_assert( psDec->nb_subfr == MAX_NB_SUBFR || psDec->nb_subfr == MAX_NB_SUBFR/2 );
/* New (sub)frame length */ /* New (sub)frame length */
psDec->subfr_length = silk_SMULBB( SUB_FRAME_LENGTH_MS, fs_kHz ); psDec->subfr_length = silk_SMULBB( SUB_FRAME_LENGTH_MS, fs_kHz );
@ -86,7 +86,7 @@ opus_int silk_decoder_set_fs(
psDec->pitch_lag_low_bits_iCDF = silk_uniform4_iCDF; psDec->pitch_lag_low_bits_iCDF = silk_uniform4_iCDF;
} else { } else {
/* unsupported sampling rate */ /* unsupported sampling rate */
silk_assert( 0 ); celt_assert( 0 );
} }
psDec->first_frame_after_reset = 1; psDec->first_frame_after_reset = 1;
psDec->lagPrev = 100; psDec->lagPrev = 100;
@ -101,7 +101,7 @@ opus_int silk_decoder_set_fs(
} }
/* Check that settings are valid */ /* Check that settings are valid */
silk_assert( psDec->frame_length > 0 && psDec->frame_length <= MAX_FRAME_LENGTH ); celt_assert( psDec->frame_length > 0 && psDec->frame_length <= MAX_FRAME_LENGTH );
return ret; return ret;
} }

22
silk/enc_API.c
View file

@ -82,7 +82,7 @@ opus_int silk_InitEncoder( /* O Returns error co
silk_memset( psEnc, 0, sizeof( silk_encoder ) ); silk_memset( psEnc, 0, sizeof( silk_encoder ) );
for( n = 0; n < ENCODER_NUM_CHANNELS; n++ ) { for( n = 0; n < ENCODER_NUM_CHANNELS; n++ ) {
if( ret += silk_init_encoder( &psEnc->state_Fxx[ n ], arch ) ) { if( ret += silk_init_encoder( &psEnc->state_Fxx[ n ], arch ) ) {
silk_assert( 0 ); celt_assert( 0 );
} }
} }
@ -91,7 +91,7 @@ opus_int silk_InitEncoder( /* O Returns error co
/* Read control structure */ /* Read control structure */
if( ret += silk_QueryEncoder( encState, encStatus ) ) { if( ret += silk_QueryEncoder( encState, encStatus ) ) {
silk_assert( 0 ); celt_assert( 0 );
} }
return ret; return ret;
@ -166,7 +166,7 @@ opus_int silk_Encode( /* O Returns error co
/* Check values in encoder control structure */ /* Check values in encoder control structure */
if( ( ret = check_control_input( encControl ) ) != 0 ) { if( ( ret = check_control_input( encControl ) ) != 0 ) {
silk_assert( 0 ); celt_assert( 0 );
RESTORE_STACK; RESTORE_STACK;
return ret; return ret;
} }
@ -201,14 +201,14 @@ opus_int silk_Encode( /* O Returns error co
if( prefillFlag ) { if( prefillFlag ) {
/* Only accept input length of 10 ms */ /* Only accept input length of 10 ms */
if( nBlocksOf10ms != 1 ) { if( nBlocksOf10ms != 1 ) {
silk_assert( 0 ); celt_assert( 0 );
RESTORE_STACK; RESTORE_STACK;
return SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES; return SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES;
} }
/* Reset Encoder */ /* Reset Encoder */
for( n = 0; n < encControl->nChannelsInternal; n++ ) { for( n = 0; n < encControl->nChannelsInternal; n++ ) {
ret = silk_init_encoder( &psEnc->state_Fxx[ n ], psEnc->state_Fxx[ n ].sCmn.arch ); ret = silk_init_encoder( &psEnc->state_Fxx[ n ], psEnc->state_Fxx[ n ].sCmn.arch );
silk_assert( !ret ); celt_assert( !ret );
} }
tmp_payloadSize_ms = encControl->payloadSize_ms; tmp_payloadSize_ms = encControl->payloadSize_ms;
encControl->payloadSize_ms = 10; encControl->payloadSize_ms = 10;
@ -221,13 +221,13 @@ opus_int silk_Encode( /* O Returns error co
} else { } else {
/* Only accept input lengths that are a multiple of 10 ms */ /* Only accept input lengths that are a multiple of 10 ms */
if( nBlocksOf10ms * encControl->API_sampleRate != 100 * nSamplesIn || nSamplesIn < 0 ) { if( nBlocksOf10ms * encControl->API_sampleRate != 100 * nSamplesIn || nSamplesIn < 0 ) {
silk_assert( 0 ); celt_assert( 0 );
RESTORE_STACK; RESTORE_STACK;
return SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES; return SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES;
} }
/* Make sure no more than one packet can be produced */ /* Make sure no more than one packet can be produced */
if( 1000 * (opus_int32)nSamplesIn > encControl->payloadSize_ms * encControl->API_sampleRate ) { if( 1000 * (opus_int32)nSamplesIn > encControl->payloadSize_ms * encControl->API_sampleRate ) {
silk_assert( 0 ); celt_assert( 0 );
RESTORE_STACK; RESTORE_STACK;
return SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES; return SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES;
} }
@ -248,7 +248,7 @@ opus_int silk_Encode( /* O Returns error co
} }
psEnc->state_Fxx[ n ].sCmn.inDTX = psEnc->state_Fxx[ n ].sCmn.useDTX; psEnc->state_Fxx[ n ].sCmn.inDTX = psEnc->state_Fxx[ n ].sCmn.useDTX;
} }
silk_assert( encControl->nChannelsInternal == 1 || psEnc->state_Fxx[ 0 ].sCmn.fs_kHz == psEnc->state_Fxx[ 1 ].sCmn.fs_kHz ); celt_assert( encControl->nChannelsInternal == 1 || psEnc->state_Fxx[ 0 ].sCmn.fs_kHz == psEnc->state_Fxx[ 1 ].sCmn.fs_kHz );
/* Input buffering/resampling and encoding */ /* Input buffering/resampling and encoding */
nSamplesToBufferMax = nSamplesToBufferMax =
@ -306,7 +306,7 @@ opus_int silk_Encode( /* O Returns error co
} }
psEnc->state_Fxx[ 0 ].sCmn.inputBufIx += nSamplesToBuffer; psEnc->state_Fxx[ 0 ].sCmn.inputBufIx += nSamplesToBuffer;
} else { } else {
silk_assert( encControl->nChannelsAPI == 1 && encControl->nChannelsInternal == 1 ); celt_assert( encControl->nChannelsAPI == 1 && encControl->nChannelsInternal == 1 );
silk_memcpy(buf, samplesIn, nSamplesFromInput*sizeof(opus_int16)); silk_memcpy(buf, samplesIn, nSamplesFromInput*sizeof(opus_int16));
ret += silk_resampler( &psEnc->state_Fxx[ 0 ].sCmn.resampler_state, ret += silk_resampler( &psEnc->state_Fxx[ 0 ].sCmn.resampler_state,
&psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.inputBufIx + 2 ], buf, nSamplesFromInput ); &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.inputBufIx + 2 ], buf, nSamplesFromInput );
@ -322,8 +322,8 @@ opus_int silk_Encode( /* O Returns error co
/* Silk encoder */ /* Silk encoder */
if( psEnc->state_Fxx[ 0 ].sCmn.inputBufIx >= psEnc->state_Fxx[ 0 ].sCmn.frame_length ) { if( psEnc->state_Fxx[ 0 ].sCmn.inputBufIx >= psEnc->state_Fxx[ 0 ].sCmn.frame_length ) {
/* Enough data in input buffer, so encode */ /* Enough data in input buffer, so encode */
silk_assert( psEnc->state_Fxx[ 0 ].sCmn.inputBufIx == psEnc->state_Fxx[ 0 ].sCmn.frame_length ); celt_assert( psEnc->state_Fxx[ 0 ].sCmn.inputBufIx == psEnc->state_Fxx[ 0 ].sCmn.frame_length );
silk_assert( encControl->nChannelsInternal == 1 || psEnc->state_Fxx[ 1 ].sCmn.inputBufIx == psEnc->state_Fxx[ 1 ].sCmn.frame_length ); celt_assert( encControl->nChannelsInternal == 1 || psEnc->state_Fxx[ 1 ].sCmn.inputBufIx == psEnc->state_Fxx[ 1 ].sCmn.frame_length );
/* Deal with LBRR data */ /* Deal with LBRR data */
if( psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded == 0 && !prefillFlag ) { if( psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded == 0 && !prefillFlag ) {

6
silk/encode_indices.c
View file

@ -56,8 +56,8 @@ void silk_encode_indices(
/* Encode signal type and quantizer offset */ /* Encode signal type and quantizer offset */
/*******************************************/ /*******************************************/
typeOffset = 2 * psIndices->signalType + psIndices->quantOffsetType; typeOffset = 2 * psIndices->signalType + psIndices->quantOffsetType;
silk_assert( typeOffset >= 0 && typeOffset < 6 ); celt_assert( typeOffset >= 0 && typeOffset < 6 );
silk_assert( encode_LBRR == 0 || typeOffset >= 2 ); celt_assert( encode_LBRR == 0 || typeOffset >= 2 );
if( encode_LBRR || typeOffset >= 2 ) { if( encode_LBRR || typeOffset >= 2 ) {
ec_enc_icdf( psRangeEnc, typeOffset - 2, silk_type_offset_VAD_iCDF, 8 ); ec_enc_icdf( psRangeEnc, typeOffset - 2, silk_type_offset_VAD_iCDF, 8 );
} else { } else {
@ -90,7 +90,7 @@ void silk_encode_indices(
/****************/ /****************/
ec_enc_icdf( psRangeEnc, psIndices->NLSFIndices[ 0 ], &psEncC->psNLSF_CB->CB1_iCDF[ ( psIndices->signalType >> 1 ) * psEncC->psNLSF_CB->nVectors ], 8 ); ec_enc_icdf( psRangeEnc, psIndices->NLSFIndices[ 0 ], &psEncC->psNLSF_CB->CB1_iCDF[ ( psIndices->signalType >> 1 ) * psEncC->psNLSF_CB->nVectors ], 8 );
silk_NLSF_unpack( ec_ix, pred_Q8, psEncC->psNLSF_CB, psIndices->NLSFIndices[ 0 ] ); silk_NLSF_unpack( ec_ix, pred_Q8, psEncC->psNLSF_CB, psIndices->NLSFIndices[ 0 ] );
silk_assert( psEncC->psNLSF_CB->order == psEncC->predictLPCOrder ); celt_assert( psEncC->psNLSF_CB->order == psEncC->predictLPCOrder );
for( i = 0; i < psEncC->psNLSF_CB->order; i++ ) { for( i = 0; i < psEncC->psNLSF_CB->order; i++ ) {
if( psIndices->NLSFIndices[ i+1 ] >= NLSF_QUANT_MAX_AMPLITUDE ) { if( psIndices->NLSFIndices[ i+1 ] >= NLSF_QUANT_MAX_AMPLITUDE ) {
ec_enc_icdf( psRangeEnc, 2 * NLSF_QUANT_MAX_AMPLITUDE, &psEncC->psNLSF_CB->ec_iCDF[ ec_ix[ i ] ], 8 ); ec_enc_icdf( psRangeEnc, 2 * NLSF_QUANT_MAX_AMPLITUDE, &psEncC->psNLSF_CB->ec_iCDF[ ec_ix[ i ] ], 8 );

2
silk/encode_pulses.c
View file

@ -86,7 +86,7 @@ void silk_encode_pulses(
silk_assert( 1 << LOG2_SHELL_CODEC_FRAME_LENGTH == SHELL_CODEC_FRAME_LENGTH ); silk_assert( 1 << LOG2_SHELL_CODEC_FRAME_LENGTH == SHELL_CODEC_FRAME_LENGTH );
iter = silk_RSHIFT( frame_length, LOG2_SHELL_CODEC_FRAME_LENGTH ); iter = silk_RSHIFT( frame_length, LOG2_SHELL_CODEC_FRAME_LENGTH );
if( iter * SHELL_CODEC_FRAME_LENGTH < frame_length ) { if( iter * SHELL_CODEC_FRAME_LENGTH < frame_length ) {
silk_assert( frame_length == 12 * 10 ); /* Make sure only happens for 10 ms @ 12 kHz */ celt_assert( frame_length == 12 * 10 ); /* Make sure only happens for 10 ms @ 12 kHz */
iter++; iter++;
silk_memset( &pulses[ frame_length ], 0, SHELL_CODEC_FRAME_LENGTH * sizeof(opus_int8)); silk_memset( &pulses[ frame_length ], 0, SHELL_CODEC_FRAME_LENGTH * sizeof(opus_int8));
} }

4
silk/interpolate.c
View file

@ -42,8 +42,8 @@ void silk_interpolate(
{ {
opus_int i; opus_int i;
silk_assert( ifact_Q2 >= 0 ); celt_assert( ifact_Q2 >= 0 );
silk_assert( ifact_Q2 <= 4 ); celt_assert( ifact_Q2 <= 4 );
for( i = 0; i < d; i++ ) { for( i = 0; i < d; i++ ) {
xi[ i ] = (opus_int16)silk_ADD_RSHIFT( x0[ i ], silk_SMULBB( x1[ i ] - x0[ i ], ifact_Q2 ), 2 ); xi[ i ] = (opus_int16)silk_ADD_RSHIFT( x0[ i ], silk_SMULBB( x1[ i ] - x0[ i ], ifact_Q2 ), 2 );

6
silk/process_NLSFs.c
View file

@ -48,7 +48,7 @@ void silk_process_NLSFs(
silk_assert( psEncC->speech_activity_Q8 >= 0 ); silk_assert( psEncC->speech_activity_Q8 >= 0 );
silk_assert( psEncC->speech_activity_Q8 <= SILK_FIX_CONST( 1.0, 8 ) ); silk_assert( psEncC->speech_activity_Q8 <= SILK_FIX_CONST( 1.0, 8 ) );
silk_assert( psEncC->useInterpolatedNLSFs == 1 || psEncC->indices.NLSFInterpCoef_Q2 == ( 1 << 2 ) ); celt_assert( psEncC->useInterpolatedNLSFs == 1 || psEncC->indices.NLSFInterpCoef_Q2 == ( 1 << 2 ) );
/***********************/ /***********************/
/* Calculate mu values */ /* Calculate mu values */
@ -60,7 +60,7 @@ void silk_process_NLSFs(
NLSF_mu_Q20 = silk_ADD_RSHIFT( NLSF_mu_Q20, NLSF_mu_Q20, 1 ); NLSF_mu_Q20 = silk_ADD_RSHIFT( NLSF_mu_Q20, NLSF_mu_Q20, 1 );
} }
silk_assert( NLSF_mu_Q20 > 0 ); celt_assert( NLSF_mu_Q20 > 0 );
silk_assert( NLSF_mu_Q20 <= SILK_FIX_CONST( 0.005, 20 ) ); silk_assert( NLSF_mu_Q20 <= SILK_FIX_CONST( 0.005, 20 ) );
/* Calculate NLSF weights */ /* Calculate NLSF weights */
@ -101,7 +101,7 @@ void silk_process_NLSFs(
} else { } else {
/* Copy LPC coefficients for first half from second half */ /* Copy LPC coefficients for first half from second half */
silk_assert( psEncC->predictLPCOrder <= MAX_LPC_ORDER ); celt_assert( psEncC->predictLPCOrder <= MAX_LPC_ORDER );
silk_memcpy( PredCoef_Q12[ 0 ], PredCoef_Q12[ 1 ], psEncC->predictLPCOrder * sizeof( opus_int16 ) ); silk_memcpy( PredCoef_Q12[ 0 ], PredCoef_Q12[ 1 ], psEncC->predictLPCOrder * sizeof( opus_int16 ) );
} }
} }

10
silk/resampler.c
View file

@ -91,14 +91,14 @@ opus_int silk_resampler_init(
if( forEnc ) { if( forEnc ) {
if( ( Fs_Hz_in != 8000 && Fs_Hz_in != 12000 && Fs_Hz_in != 16000 && Fs_Hz_in != 24000 && Fs_Hz_in != 48000 ) || if( ( Fs_Hz_in != 8000 && Fs_Hz_in != 12000 && Fs_Hz_in != 16000 && Fs_Hz_in != 24000 && Fs_Hz_in != 48000 ) ||
( Fs_Hz_out != 8000 && Fs_Hz_out != 12000 && Fs_Hz_out != 16000 ) ) { ( Fs_Hz_out != 8000 && Fs_Hz_out != 12000 && Fs_Hz_out != 16000 ) ) {
silk_assert( 0 ); celt_assert( 0 );
return -1; return -1;
} }
S->inputDelay = delay_matrix_enc[ rateID( Fs_Hz_in ) ][ rateID( Fs_Hz_out ) ]; S->inputDelay = delay_matrix_enc[ rateID( Fs_Hz_in ) ][ rateID( Fs_Hz_out ) ];
} else { } else {
if( ( Fs_Hz_in != 8000 && Fs_Hz_in != 12000 && Fs_Hz_in != 16000 ) || if( ( Fs_Hz_in != 8000 && Fs_Hz_in != 12000 && Fs_Hz_in != 16000 ) ||
( Fs_Hz_out != 8000 && Fs_Hz_out != 12000 && Fs_Hz_out != 16000 && Fs_Hz_out != 24000 && Fs_Hz_out != 48000 ) ) { ( Fs_Hz_out != 8000 && Fs_Hz_out != 12000 && Fs_Hz_out != 16000 && Fs_Hz_out != 24000 && Fs_Hz_out != 48000 ) ) {
silk_assert( 0 ); celt_assert( 0 );
return -1; return -1;
} }
S->inputDelay = delay_matrix_dec[ rateID( Fs_Hz_in ) ][ rateID( Fs_Hz_out ) ]; S->inputDelay = delay_matrix_dec[ rateID( Fs_Hz_in ) ][ rateID( Fs_Hz_out ) ];
@ -151,7 +151,7 @@ opus_int silk_resampler_init(
S->Coefs = silk_Resampler_1_6_COEFS; S->Coefs = silk_Resampler_1_6_COEFS;
} else { } else {
/* None available */ /* None available */
silk_assert( 0 ); celt_assert( 0 );
return -1; return -1;
} }
} else { } else {
@ -181,9 +181,9 @@ opus_int silk_resampler(
opus_int nSamples; opus_int nSamples;
/* Need at least 1 ms of input data */ /* Need at least 1 ms of input data */
silk_assert( inLen >= S->Fs_in_kHz ); celt_assert( inLen >= S->Fs_in_kHz );
/* Delay can't exceed the 1 ms of buffering */ /* Delay can't exceed the 1 ms of buffering */
silk_assert( S->inputDelay <= S->Fs_in_kHz ); celt_assert( S->inputDelay <= S->Fs_in_kHz );
nSamples = S->Fs_in_kHz - S->inputDelay; nSamples = S->Fs_in_kHz - S->inputDelay;

4
silk/resampler_down2.c
View file

@ -43,8 +43,8 @@ void silk_resampler_down2(
opus_int32 k, len2 = silk_RSHIFT32( inLen, 1 ); opus_int32 k, len2 = silk_RSHIFT32( inLen, 1 );
opus_int32 in32, out32, Y, X; opus_int32 in32, out32, Y, X;
silk_assert( silk_resampler_down2_0 > 0 ); celt_assert( silk_resampler_down2_0 > 0 );
silk_assert( silk_resampler_down2_1 < 0 ); celt_assert( silk_resampler_down2_1 < 0 );
/* Internal variables and state are in Q10 format */ /* Internal variables and state are in Q10 format */
for( k = 0; k < len2; k++ ) { for( k = 0; k < len2; k++ ) {

2
silk/resampler_private_down_FIR.c
View file

@ -136,7 +136,7 @@ static OPUS_INLINE opus_int16 *silk_resampler_private_down_FIR_INTERPOL(
} }
break; break;
default: default:
silk_assert( 0 ); celt_assert( 0 );
} }
return out; return out;
} }

14
silk/sort.c
View file

@ -48,9 +48,9 @@ void silk_insertion_sort_increasing(
opus_int i, j; opus_int i, j;
/* Safety checks */ /* Safety checks */
silk_assert( K > 0 ); celt_assert( K > 0 );
silk_assert( L > 0 ); celt_assert( L > 0 );
silk_assert( L >= K ); celt_assert( L >= K );
/* Write start indices in index vector */ /* Write start indices in index vector */
for( i = 0; i < K; i++ ) { for( i = 0; i < K; i++ ) {
@ -96,9 +96,9 @@ void silk_insertion_sort_decreasing_int16(
opus_int value; opus_int value;
/* Safety checks */ /* Safety checks */
silk_assert( K > 0 ); celt_assert( K > 0 );
silk_assert( L > 0 ); celt_assert( L > 0 );
silk_assert( L >= K ); celt_assert( L >= K );
/* Write start indices in index vector */ /* Write start indices in index vector */
for( i = 0; i < K; i++ ) { for( i = 0; i < K; i++ ) {
@ -141,7 +141,7 @@ void silk_insertion_sort_increasing_all_values_int16(
opus_int i, j; opus_int i, j;
/* Safety checks */ /* Safety checks */
silk_assert( L > 0 ); celt_assert( L > 0 );
/* Sort vector elements by value, increasing order */ /* Sort vector elements by value, increasing order */
for( i = 1; i < L; i++ ) { for( i = 1; i < L; i++ ) {

6
silk/stereo_encode_pred.c
View file

@ -41,11 +41,11 @@ void silk_stereo_encode_pred(
/* Entropy coding */ /* Entropy coding */
n = 5 * ix[ 0 ][ 2 ] + ix[ 1 ][ 2 ]; n = 5 * ix[ 0 ][ 2 ] + ix[ 1 ][ 2 ];
silk_assert( n < 25 ); celt_assert( n < 25 );
ec_enc_icdf( psRangeEnc, n, silk_stereo_pred_joint_iCDF, 8 ); ec_enc_icdf( psRangeEnc, n, silk_stereo_pred_joint_iCDF, 8 );
for( n = 0; n < 2; n++ ) { for( n = 0; n < 2; n++ ) {
silk_assert( ix[ n ][ 0 ] < 3 ); celt_assert( ix[ n ][ 0 ] < 3 );
silk_assert( ix[ n ][ 1 ] < STEREO_QUANT_SUB_STEPS ); celt_assert( ix[ n ][ 1 ] < STEREO_QUANT_SUB_STEPS );
ec_enc_icdf( psRangeEnc, ix[ n ][ 0 ], silk_uniform3_iCDF, 8 ); ec_enc_icdf( psRangeEnc, ix[ n ][ 0 ], silk_uniform3_iCDF, 8 );
ec_enc_icdf( psRangeEnc, ix[ n ][ 1 ], silk_uniform5_iCDF, 8 ); ec_enc_icdf( psRangeEnc, ix[ n ][ 1 ], silk_uniform5_iCDF, 8 );
} }