mirror of
https://github.com/xiph/opus.git
synced 2025-05-27 21:59:12 +00:00
Converting some silk_assert()s into hardening celt_assert()s
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:
parent
69bcb28d3d
commit
7e3352ef51
29 changed files with 96 additions and 96 deletions
|
@ -146,8 +146,8 @@ void silk_CNG(
|
|||
|
||||
/* Generate CNG signal, by synthesis filtering */
|
||||
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++ ) {
|
||||
silk_assert( psDec->LPC_order == 10 || psDec->LPC_order == 16 );
|
||||
/* Avoids introducing a bias because silk_SMLAWB() always rounds to -inf */
|
||||
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 ] );
|
||||
|
|
|
@ -64,12 +64,12 @@ void silk_LPC_analysis_filter(
|
|||
const opus_int16 *in_ptr;
|
||||
#endif
|
||||
|
||||
silk_assert( d >= 6 );
|
||||
silk_assert( (d & 1) == 0 );
|
||||
silk_assert( d <= len );
|
||||
celt_assert( d >= 6 );
|
||||
celt_assert( (d & 1) == 0 );
|
||||
celt_assert( d <= len );
|
||||
|
||||
#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++ ) {
|
||||
num[ j ] = -B[ j ];
|
||||
}
|
||||
|
|
|
@ -86,7 +86,7 @@ void silk_NLSF2A(
|
|||
opus_int32 a32_QA1[ SILK_MAX_ORDER_LPC ];
|
||||
|
||||
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 */
|
||||
ordering = d == 16 ? ordering16 : ordering10;
|
||||
|
|
|
@ -46,7 +46,7 @@ void silk_NLSF_VQ(
|
|||
const opus_int16 *w_Q9_ptr;
|
||||
const opus_uint8 *cb_Q8_ptr;
|
||||
|
||||
silk_assert( ( LPC_order & 1 ) == 0 );
|
||||
celt_assert( ( LPC_order & 1 ) == 0 );
|
||||
|
||||
/* Loop over codebook */
|
||||
cb_Q8_ptr = pCB_Q8;
|
||||
|
|
|
@ -48,8 +48,8 @@ void silk_NLSF_VQ_weights_laroia(
|
|||
opus_int k;
|
||||
opus_int32 tmp1_int, tmp2_int;
|
||||
|
||||
silk_assert( D > 0 );
|
||||
silk_assert( ( D & 1 ) == 0 );
|
||||
celt_assert( D > 0 );
|
||||
celt_assert( ( D & 1 ) == 0 );
|
||||
|
||||
/* First value */
|
||||
tmp1_int = silk_max_int( pNLSF_Q15[ 0 ], 1 );
|
||||
|
|
|
@ -60,7 +60,7 @@ opus_int32 silk_NLSF_encode( /* O Returns
|
|||
const opus_int16 *pCB_Wght_Q9;
|
||||
SAVE_STACK;
|
||||
|
||||
silk_assert( signalType >= 0 && signalType <= 2 );
|
||||
celt_assert( signalType >= 0 && signalType <= 2 );
|
||||
silk_assert( NLSF_mu_Q20 <= 32767 && NLSF_mu_Q20 >= 0 );
|
||||
|
||||
/* NLSF stabilization */
|
||||
|
|
|
@ -143,7 +143,7 @@ void silk_NSQ_c
|
|||
if( ( k & ( 3 - silk_LSHIFT( LSF_interpolation_flag, 1 ) ) ) == 0 ) {
|
||||
/* Rewhiten with new A coefs */
|
||||
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 ],
|
||||
A_Q12, psEncC->ltp_mem_length - start_idx, psEncC->predictLPCOrder, psEncC->arch );
|
||||
|
@ -247,7 +247,7 @@ void silk_noise_shape_quantizer(
|
|||
}
|
||||
|
||||
/* 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_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_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 */
|
||||
tmp1 = silk_SUB32( silk_LSHIFT32( LPC_pred_Q10, 2 ), n_AR_Q12 ); /* Q12 */
|
||||
|
|
|
@ -250,7 +250,7 @@ void silk_NSQ_del_dec_c(
|
|||
|
||||
/* Rewhiten with new A coefs */
|
||||
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 ],
|
||||
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;
|
||||
SAVE_STACK;
|
||||
|
||||
silk_assert( nStatesDelayedDecision > 0 );
|
||||
celt_assert( nStatesDelayedDecision > 0 );
|
||||
ALLOC( psSampleState, nStatesDelayedDecision, NSQ_sample_pair );
|
||||
|
||||
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 */
|
||||
|
||||
/* 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 */
|
||||
tmp2 = silk_SMLAWB( psDD->Diff_Q14, psDD->sAR2_Q14[ 0 ], warping_Q16 );
|
||||
/* Output of allpass section */
|
||||
|
|
|
@ -291,7 +291,7 @@ static OPUS_INLINE void silk_PLC_conceal(
|
|||
|
||||
/* Rewhiten LTP state */
|
||||
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 );
|
||||
/* Scale LTP state */
|
||||
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 */
|
||||
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++ ) {
|
||||
/* partly unrolled */
|
||||
/* Avoids introducing a bias because silk_SMLAWB() always rounds to -inf */
|
||||
|
|
|
@ -101,9 +101,9 @@ opus_int silk_VAD_GetSA_Q8_c( /* O Return v
|
|||
|
||||
/* Safety checks */
|
||||
silk_assert( VAD_N_BANDS == 4 );
|
||||
silk_assert( MAX_FRAME_LENGTH >= psEncC->frame_length );
|
||||
silk_assert( psEncC->frame_length <= 512 );
|
||||
silk_assert( psEncC->frame_length == 8 * silk_RSHIFT( psEncC->frame_length, 3 ) );
|
||||
celt_assert( MAX_FRAME_LENGTH >= psEncC->frame_length );
|
||||
celt_assert( psEncC->frame_length <= 512 );
|
||||
celt_assert( psEncC->frame_length == 8 * silk_RSHIFT( psEncC->frame_length, 3 ) );
|
||||
|
||||
/***********************/
|
||||
/* Filter and Decimate */
|
||||
|
|
|
@ -38,7 +38,7 @@ opus_int check_control_input(
|
|||
silk_EncControlStruct *encControl /* I Control structure */
|
||||
)
|
||||
{
|
||||
silk_assert( encControl != NULL );
|
||||
celt_assert( encControl != NULL );
|
||||
|
||||
if( ( ( encControl->API_sampleRate != 8000 ) &&
|
||||
( encControl->API_sampleRate != 12000 ) &&
|
||||
|
@ -59,46 +59,46 @@ opus_int check_control_input(
|
|||
( encControl->minInternalSampleRate > encControl->desiredInternalSampleRate ) ||
|
||||
( encControl->maxInternalSampleRate < encControl->desiredInternalSampleRate ) ||
|
||||
( encControl->minInternalSampleRate > encControl->maxInternalSampleRate ) ) {
|
||||
silk_assert( 0 );
|
||||
celt_assert( 0 );
|
||||
return SILK_ENC_FS_NOT_SUPPORTED;
|
||||
}
|
||||
if( encControl->payloadSize_ms != 10 &&
|
||||
encControl->payloadSize_ms != 20 &&
|
||||
encControl->payloadSize_ms != 40 &&
|
||||
encControl->payloadSize_ms != 60 ) {
|
||||
silk_assert( 0 );
|
||||
celt_assert( 0 );
|
||||
return SILK_ENC_PACKET_SIZE_NOT_SUPPORTED;
|
||||
}
|
||||
if( encControl->packetLossPercentage < 0 || encControl->packetLossPercentage > 100 ) {
|
||||
silk_assert( 0 );
|
||||
celt_assert( 0 );
|
||||
return SILK_ENC_INVALID_LOSS_RATE;
|
||||
}
|
||||
if( encControl->useDTX < 0 || encControl->useDTX > 1 ) {
|
||||
silk_assert( 0 );
|
||||
celt_assert( 0 );
|
||||
return SILK_ENC_INVALID_DTX_SETTING;
|
||||
}
|
||||
if( encControl->useCBR < 0 || encControl->useCBR > 1 ) {
|
||||
silk_assert( 0 );
|
||||
celt_assert( 0 );
|
||||
return SILK_ENC_INVALID_CBR_SETTING;
|
||||
}
|
||||
if( encControl->useInBandFEC < 0 || encControl->useInBandFEC > 1 ) {
|
||||
silk_assert( 0 );
|
||||
celt_assert( 0 );
|
||||
return SILK_ENC_INVALID_INBAND_FEC_SETTING;
|
||||
}
|
||||
if( encControl->nChannelsAPI < 1 || encControl->nChannelsAPI > ENCODER_NUM_CHANNELS ) {
|
||||
silk_assert( 0 );
|
||||
celt_assert( 0 );
|
||||
return SILK_ENC_INVALID_NUMBER_OF_CHANNELS_ERROR;
|
||||
}
|
||||
if( encControl->nChannelsInternal < 1 || encControl->nChannelsInternal > ENCODER_NUM_CHANNELS ) {
|
||||
silk_assert( 0 );
|
||||
celt_assert( 0 );
|
||||
return SILK_ENC_INVALID_NUMBER_OF_CHANNELS_ERROR;
|
||||
}
|
||||
if( encControl->nChannelsInternal > encControl->nChannelsAPI ) {
|
||||
silk_assert( 0 );
|
||||
celt_assert( 0 );
|
||||
return SILK_ENC_INVALID_NUMBER_OF_CHANNELS_ERROR;
|
||||
}
|
||||
if( encControl->complexity < 0 || encControl->complexity > 10 ) {
|
||||
silk_assert( 0 );
|
||||
celt_assert( 0 );
|
||||
return SILK_ENC_INVALID_COMPLEXITY_SETTING;
|
||||
}
|
||||
|
||||
|
|
|
@ -238,8 +238,8 @@ static opus_int silk_setup_fs(
|
|||
}
|
||||
|
||||
/* Set internal sampling frequency */
|
||||
silk_assert( fs_kHz == 8 || fs_kHz == 12 || fs_kHz == 16 );
|
||||
silk_assert( psEnc->sCmn.nb_subfr == 2 || psEnc->sCmn.nb_subfr == 4 );
|
||||
celt_assert( fs_kHz == 8 || fs_kHz == 12 || fs_kHz == 16 );
|
||||
celt_assert( psEnc->sCmn.nb_subfr == 2 || psEnc->sCmn.nb_subfr == 4 );
|
||||
if( psEnc->sCmn.fs_kHz != fs_kHz ) {
|
||||
/* reset part of the state */
|
||||
silk_memset( &psEnc->sShape, 0, sizeof( psEnc->sShape ) );
|
||||
|
@ -299,7 +299,7 @@ static opus_int silk_setup_fs(
|
|||
}
|
||||
|
||||
/* 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;
|
||||
}
|
||||
|
@ -312,7 +312,7 @@ static opus_int silk_setup_complexity(
|
|||
opus_int ret = 0;
|
||||
|
||||
/* Set encoding complexity */
|
||||
silk_assert( Complexity >= 0 && Complexity <= 10 );
|
||||
celt_assert( Complexity >= 0 && Complexity <= 10 );
|
||||
if( Complexity < 1 ) {
|
||||
psEncC->pitchEstimationComplexity = SILK_PE_MIN_COMPLEX;
|
||||
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->Complexity = Complexity;
|
||||
|
||||
silk_assert( psEncC->pitchEstimationLPCOrder <= MAX_FIND_PITCH_LPC_ORDER );
|
||||
silk_assert( psEncC->shapingLPCOrder <= MAX_SHAPE_LPC_ORDER );
|
||||
silk_assert( psEncC->nStatesDelayedDecision <= MAX_DEL_DEC_STATES );
|
||||
silk_assert( psEncC->warping_Q16 <= 32767 );
|
||||
silk_assert( psEncC->la_shape <= LA_SHAPE_MAX );
|
||||
silk_assert( psEncC->shapeWinLength <= SHAPE_LPC_WIN_MAX );
|
||||
celt_assert( psEncC->pitchEstimationLPCOrder <= MAX_FIND_PITCH_LPC_ORDER );
|
||||
celt_assert( psEncC->shapingLPCOrder <= MAX_SHAPE_LPC_ORDER );
|
||||
celt_assert( psEncC->nStatesDelayedDecision <= MAX_DEL_DEC_STATES );
|
||||
celt_assert( psEncC->warping_Q16 <= 32767 );
|
||||
celt_assert( psEncC->la_shape <= LA_SHAPE_MAX );
|
||||
celt_assert( psEncC->shapeWinLength <= SHAPE_LPC_WIN_MAX );
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
|
@ -104,7 +104,7 @@ opus_int silk_Decode( /* O Returns error co
|
|||
int delay_stack_alloc;
|
||||
SAVE_STACK;
|
||||
|
||||
silk_assert( decControl->nChannelsInternal == 1 || decControl->nChannelsInternal == 2 );
|
||||
celt_assert( decControl->nChannelsInternal == 1 || decControl->nChannelsInternal == 2 );
|
||||
|
||||
/**********************************/
|
||||
/* 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 ].nb_subfr = 4;
|
||||
} else {
|
||||
silk_assert( 0 );
|
||||
celt_assert( 0 );
|
||||
RESTORE_STACK;
|
||||
return SILK_DEC_INVALID_FRAME_SIZE;
|
||||
}
|
||||
fs_kHz_dec = ( decControl->internalSampleRate >> 10 ) + 1;
|
||||
if( fs_kHz_dec != 8 && fs_kHz_dec != 12 && fs_kHz_dec != 16 ) {
|
||||
silk_assert( 0 );
|
||||
celt_assert( 0 );
|
||||
RESTORE_STACK;
|
||||
return SILK_DEC_INVALID_SAMPLING_FREQUENCY;
|
||||
}
|
||||
|
|
|
@ -141,7 +141,7 @@ void silk_decode_core(
|
|||
if( k == 0 || ( k == 2 && NLSF_interpolation_flag ) ) {
|
||||
/* Rewhiten with new A coefs */
|
||||
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 ) {
|
||||
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++ ) {
|
||||
/* 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 */
|
||||
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 ] );
|
||||
|
|
|
@ -55,7 +55,7 @@ opus_int silk_decode_frame(
|
|||
psDecCtrl->LTP_scale_Q14 = 0;
|
||||
|
||||
/* Safety checks */
|
||||
silk_assert( L > 0 && L <= MAX_FRAME_LENGTH );
|
||||
celt_assert( L > 0 && L <= MAX_FRAME_LENGTH );
|
||||
|
||||
if( lostFlag == FLAG_DECODE_NORMAL ||
|
||||
( lostFlag == FLAG_DECODE_LBRR && psDec->LBRR_flags[ psDec->nFramesDecoded ] == 1 ) )
|
||||
|
@ -91,7 +91,7 @@ opus_int silk_decode_frame(
|
|||
|
||||
psDec->lossCnt = 0;
|
||||
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 */
|
||||
psDec->first_frame_after_reset = 0;
|
||||
|
@ -104,7 +104,7 @@ opus_int silk_decode_frame(
|
|||
/*************************/
|
||||
/* 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;
|
||||
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 ) );
|
||||
|
|
|
@ -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 );
|
||||
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++ ) {
|
||||
Ix = ec_dec_icdf( psRangeDec, &psDec->psNLSF_CB->ec_iCDF[ ec_ix[ i ] ], 8 );
|
||||
if( Ix == 0 ) {
|
||||
|
|
|
@ -51,7 +51,7 @@ void silk_decode_pitch(
|
|||
Lag_CB_ptr = &silk_CB_lags_stage2[ 0 ][ 0 ];
|
||||
cbk_size = PE_NB_CBKS_STAGE2_EXT;
|
||||
} 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 ];
|
||||
cbk_size = PE_NB_CBKS_STAGE2_10MS;
|
||||
}
|
||||
|
@ -60,7 +60,7 @@ void silk_decode_pitch(
|
|||
Lag_CB_ptr = &silk_CB_lags_stage3[ 0 ][ 0 ];
|
||||
cbk_size = PE_NB_CBKS_STAGE3_MAX;
|
||||
} 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 ];
|
||||
cbk_size = PE_NB_CBKS_STAGE3_10MS;
|
||||
}
|
||||
|
|
|
@ -56,7 +56,7 @@ void silk_decode_pulses(
|
|||
silk_assert( 1 << LOG2_SHELL_CODEC_FRAME_LENGTH == SHELL_CODEC_FRAME_LENGTH );
|
||||
iter = silk_RSHIFT( frame_length, LOG2_SHELL_CODEC_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++;
|
||||
}
|
||||
|
||||
|
|
|
@ -40,8 +40,8 @@ opus_int silk_decoder_set_fs(
|
|||
{
|
||||
opus_int frame_length, ret = 0;
|
||||
|
||||
silk_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( fs_kHz == 8 || fs_kHz == 12 || fs_kHz == 16 );
|
||||
celt_assert( psDec->nb_subfr == MAX_NB_SUBFR || psDec->nb_subfr == MAX_NB_SUBFR/2 );
|
||||
|
||||
/* New (sub)frame length */
|
||||
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;
|
||||
} else {
|
||||
/* unsupported sampling rate */
|
||||
silk_assert( 0 );
|
||||
celt_assert( 0 );
|
||||
}
|
||||
psDec->first_frame_after_reset = 1;
|
||||
psDec->lagPrev = 100;
|
||||
|
@ -101,7 +101,7 @@ opus_int silk_decoder_set_fs(
|
|||
}
|
||||
|
||||
/* 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;
|
||||
}
|
||||
|
|
|
@ -82,7 +82,7 @@ opus_int silk_InitEncoder( /* O Returns error co
|
|||
silk_memset( psEnc, 0, sizeof( silk_encoder ) );
|
||||
for( n = 0; n < ENCODER_NUM_CHANNELS; n++ ) {
|
||||
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 */
|
||||
if( ret += silk_QueryEncoder( encState, encStatus ) ) {
|
||||
silk_assert( 0 );
|
||||
celt_assert( 0 );
|
||||
}
|
||||
|
||||
return ret;
|
||||
|
@ -166,7 +166,7 @@ opus_int silk_Encode( /* O Returns error co
|
|||
|
||||
/* Check values in encoder control structure */
|
||||
if( ( ret = check_control_input( encControl ) ) != 0 ) {
|
||||
silk_assert( 0 );
|
||||
celt_assert( 0 );
|
||||
RESTORE_STACK;
|
||||
return ret;
|
||||
}
|
||||
|
@ -201,14 +201,14 @@ opus_int silk_Encode( /* O Returns error co
|
|||
if( prefillFlag ) {
|
||||
/* Only accept input length of 10 ms */
|
||||
if( nBlocksOf10ms != 1 ) {
|
||||
silk_assert( 0 );
|
||||
celt_assert( 0 );
|
||||
RESTORE_STACK;
|
||||
return SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES;
|
||||
}
|
||||
/* Reset Encoder */
|
||||
for( n = 0; n < encControl->nChannelsInternal; n++ ) {
|
||||
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;
|
||||
encControl->payloadSize_ms = 10;
|
||||
|
@ -221,13 +221,13 @@ opus_int silk_Encode( /* O Returns error co
|
|||
} else {
|
||||
/* Only accept input lengths that are a multiple of 10 ms */
|
||||
if( nBlocksOf10ms * encControl->API_sampleRate != 100 * nSamplesIn || nSamplesIn < 0 ) {
|
||||
silk_assert( 0 );
|
||||
celt_assert( 0 );
|
||||
RESTORE_STACK;
|
||||
return SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES;
|
||||
}
|
||||
/* Make sure no more than one packet can be produced */
|
||||
if( 1000 * (opus_int32)nSamplesIn > encControl->payloadSize_ms * encControl->API_sampleRate ) {
|
||||
silk_assert( 0 );
|
||||
celt_assert( 0 );
|
||||
RESTORE_STACK;
|
||||
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;
|
||||
}
|
||||
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 */
|
||||
nSamplesToBufferMax =
|
||||
|
@ -306,7 +306,7 @@ opus_int silk_Encode( /* O Returns error co
|
|||
}
|
||||
psEnc->state_Fxx[ 0 ].sCmn.inputBufIx += nSamplesToBuffer;
|
||||
} 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));
|
||||
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 );
|
||||
|
@ -322,8 +322,8 @@ opus_int silk_Encode( /* O Returns error co
|
|||
/* Silk encoder */
|
||||
if( psEnc->state_Fxx[ 0 ].sCmn.inputBufIx >= psEnc->state_Fxx[ 0 ].sCmn.frame_length ) {
|
||||
/* Enough data in input buffer, so encode */
|
||||
silk_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( psEnc->state_Fxx[ 0 ].sCmn.inputBufIx == psEnc->state_Fxx[ 0 ].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 */
|
||||
if( psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded == 0 && !prefillFlag ) {
|
||||
|
|
|
@ -56,8 +56,8 @@ void silk_encode_indices(
|
|||
/* Encode signal type and quantizer offset */
|
||||
/*******************************************/
|
||||
typeOffset = 2 * psIndices->signalType + psIndices->quantOffsetType;
|
||||
silk_assert( typeOffset >= 0 && typeOffset < 6 );
|
||||
silk_assert( encode_LBRR == 0 || typeOffset >= 2 );
|
||||
celt_assert( typeOffset >= 0 && typeOffset < 6 );
|
||||
celt_assert( encode_LBRR == 0 || typeOffset >= 2 );
|
||||
if( encode_LBRR || typeOffset >= 2 ) {
|
||||
ec_enc_icdf( psRangeEnc, typeOffset - 2, silk_type_offset_VAD_iCDF, 8 );
|
||||
} 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 );
|
||||
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++ ) {
|
||||
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 );
|
||||
|
|
|
@ -86,7 +86,7 @@ void silk_encode_pulses(
|
|||
silk_assert( 1 << LOG2_SHELL_CODEC_FRAME_LENGTH == SHELL_CODEC_FRAME_LENGTH );
|
||||
iter = silk_RSHIFT( frame_length, LOG2_SHELL_CODEC_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++;
|
||||
silk_memset( &pulses[ frame_length ], 0, SHELL_CODEC_FRAME_LENGTH * sizeof(opus_int8));
|
||||
}
|
||||
|
|
|
@ -42,8 +42,8 @@ void silk_interpolate(
|
|||
{
|
||||
opus_int i;
|
||||
|
||||
silk_assert( ifact_Q2 >= 0 );
|
||||
silk_assert( ifact_Q2 <= 4 );
|
||||
celt_assert( ifact_Q2 >= 0 );
|
||||
celt_assert( ifact_Q2 <= 4 );
|
||||
|
||||
for( i = 0; i < d; i++ ) {
|
||||
xi[ i ] = (opus_int16)silk_ADD_RSHIFT( x0[ i ], silk_SMULBB( x1[ i ] - x0[ i ], ifact_Q2 ), 2 );
|
||||
|
|
|
@ -48,7 +48,7 @@ void silk_process_NLSFs(
|
|||
|
||||
silk_assert( psEncC->speech_activity_Q8 >= 0 );
|
||||
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 */
|
||||
|
@ -60,7 +60,7 @@ void silk_process_NLSFs(
|
|||
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 ) );
|
||||
|
||||
/* Calculate NLSF weights */
|
||||
|
@ -101,7 +101,7 @@ void silk_process_NLSFs(
|
|||
|
||||
} else {
|
||||
/* 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 ) );
|
||||
}
|
||||
}
|
||||
|
|
|
@ -91,14 +91,14 @@ opus_int silk_resampler_init(
|
|||
if( forEnc ) {
|
||||
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 ) ) {
|
||||
silk_assert( 0 );
|
||||
celt_assert( 0 );
|
||||
return -1;
|
||||
}
|
||||
S->inputDelay = delay_matrix_enc[ rateID( Fs_Hz_in ) ][ rateID( Fs_Hz_out ) ];
|
||||
} else {
|
||||
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 ) ) {
|
||||
silk_assert( 0 );
|
||||
celt_assert( 0 );
|
||||
return -1;
|
||||
}
|
||||
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;
|
||||
} else {
|
||||
/* None available */
|
||||
silk_assert( 0 );
|
||||
celt_assert( 0 );
|
||||
return -1;
|
||||
}
|
||||
} else {
|
||||
|
@ -181,9 +181,9 @@ opus_int silk_resampler(
|
|||
opus_int nSamples;
|
||||
|
||||
/* 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 */
|
||||
silk_assert( S->inputDelay <= S->Fs_in_kHz );
|
||||
celt_assert( S->inputDelay <= S->Fs_in_kHz );
|
||||
|
||||
nSamples = S->Fs_in_kHz - S->inputDelay;
|
||||
|
||||
|
|
|
@ -43,8 +43,8 @@ void silk_resampler_down2(
|
|||
opus_int32 k, len2 = silk_RSHIFT32( inLen, 1 );
|
||||
opus_int32 in32, out32, Y, X;
|
||||
|
||||
silk_assert( silk_resampler_down2_0 > 0 );
|
||||
silk_assert( silk_resampler_down2_1 < 0 );
|
||||
celt_assert( silk_resampler_down2_0 > 0 );
|
||||
celt_assert( silk_resampler_down2_1 < 0 );
|
||||
|
||||
/* Internal variables and state are in Q10 format */
|
||||
for( k = 0; k < len2; k++ ) {
|
||||
|
|
|
@ -136,7 +136,7 @@ static OPUS_INLINE opus_int16 *silk_resampler_private_down_FIR_INTERPOL(
|
|||
}
|
||||
break;
|
||||
default:
|
||||
silk_assert( 0 );
|
||||
celt_assert( 0 );
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
|
14
silk/sort.c
14
silk/sort.c
|
@ -48,9 +48,9 @@ void silk_insertion_sort_increasing(
|
|||
opus_int i, j;
|
||||
|
||||
/* Safety checks */
|
||||
silk_assert( K > 0 );
|
||||
silk_assert( L > 0 );
|
||||
silk_assert( L >= K );
|
||||
celt_assert( K > 0 );
|
||||
celt_assert( L > 0 );
|
||||
celt_assert( L >= K );
|
||||
|
||||
/* Write start indices in index vector */
|
||||
for( i = 0; i < K; i++ ) {
|
||||
|
@ -96,9 +96,9 @@ void silk_insertion_sort_decreasing_int16(
|
|||
opus_int value;
|
||||
|
||||
/* Safety checks */
|
||||
silk_assert( K > 0 );
|
||||
silk_assert( L > 0 );
|
||||
silk_assert( L >= K );
|
||||
celt_assert( K > 0 );
|
||||
celt_assert( L > 0 );
|
||||
celt_assert( L >= K );
|
||||
|
||||
/* Write start indices in index vector */
|
||||
for( i = 0; i < K; i++ ) {
|
||||
|
@ -141,7 +141,7 @@ void silk_insertion_sort_increasing_all_values_int16(
|
|||
opus_int i, j;
|
||||
|
||||
/* Safety checks */
|
||||
silk_assert( L > 0 );
|
||||
celt_assert( L > 0 );
|
||||
|
||||
/* Sort vector elements by value, increasing order */
|
||||
for( i = 1; i < L; i++ ) {
|
||||
|
|
|
@ -41,11 +41,11 @@ void silk_stereo_encode_pred(
|
|||
|
||||
/* Entropy coding */
|
||||
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 );
|
||||
for( n = 0; n < 2; n++ ) {
|
||||
silk_assert( ix[ n ][ 0 ] < 3 );
|
||||
silk_assert( ix[ n ][ 1 ] < STEREO_QUANT_SUB_STEPS );
|
||||
celt_assert( ix[ n ][ 0 ] < 3 );
|
||||
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 ][ 1 ], silk_uniform5_iCDF, 8 );
|
||||
}
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue