/* Gains scalar dequantization, uniform on log scale */
void SKP_Silk_gains_dequant(
SKP_int32 gain_Q16[ MAX_NB_SUBFR ], /* O quantized gains */
const SKP_int8 ind[ MAX_NB_SUBFR ], /* I gain indices */
SKP_int8 *prev_ind, /* I/O last index in previous frame */
const SKP_int conditional, /* I first gain is delta coded if 1 */
const SKP_int nb_subfr /* I number of subframes */
)
{
SKP_int k, ind_tmp, double_step_size_threshold;
for( k = 0; k < nb_subfr; k++ ) {
if( k == 0 && conditional == 0 ) {
*prev_ind = ind[ k ];
} else {
/* Delta index */
ind_tmp = ind[ k ] + MIN_DELTA_GAIN_QUANT;
/* Accumulate deltas */
double_step_size_threshold = 2 * MAX_DELTA_GAIN_QUANT - N_LEVELS_QGAIN + *prev_ind;
if( ind_tmp > double_step_size_threshold ) {
*prev_ind += SKP_LSHIFT( ind_tmp, 1 ) - double_step_size_threshold;
} else {
*prev_ind += ind_tmp;
}
}
/* Convert to linear scale and scale */
gain_Q16[ k ] = SKP_Silk_log2lin( SKP_min_32( SKP_SMULWB( INV_SCALE_Q16, *prev_ind ) + OFFSET, 3967 ) ); /* 3967 = 31 in Q7 */
}
}
/* Gain scalar quantization with hysteresis, uniform on log scale */
void SKP_Silk_gains_quant(
SKP_int8 ind[ MAX_NB_SUBFR ], /* O gain indices */
SKP_int32 gain_Q16[ MAX_NB_SUBFR ], /* I/O gains (quantized out) */
SKP_int8 *prev_ind, /* I/O last index in previous frame */
const SKP_int conditional, /* I first gain is delta coded if 1 */
const SKP_int nb_subfr /* I number of subframes */
)
{
SKP_int k, double_step_size_threshold;
for( k = 0; k < nb_subfr; k++ ) {
/* Add half of previous quantization error, convert to log scale, scale, floor() */
ind[ k ] = SKP_SMULWB( SCALE_Q16, SKP_Silk_lin2log( gain_Q16[ k ] ) - OFFSET );
/* Round towards previous quantized gain (hysteresis) */
if( ind[ k ] < *prev_ind ) {
ind[ k ]++;
}
ind[ k ] = SKP_max_int( ind[ k ], 0 );
/* Compute delta indices and limit */
if( k == 0 && conditional == 0 ) {
/* Full index */
ind[ k ] = SKP_LIMIT_int( ind[ k ], *prev_ind + MIN_DELTA_GAIN_QUANT, N_LEVELS_QGAIN - 1 );
*prev_ind = ind[ k ];
} else {
/* Delta index */
ind[ k ] = ind[ k ] - *prev_ind;
/* Double the quantization step size for large gain increases, so that the max gain level can be reached */
double_step_size_threshold = 2 * MAX_DELTA_GAIN_QUANT - N_LEVELS_QGAIN + *prev_ind;
if( ind[ k ] > double_step_size_threshold ) {
ind[ k ] = double_step_size_threshold + SKP_RSHIFT( ind[ k ] - double_step_size_threshold + 1, 1 );
}
ind[ k ] = SKP_LIMIT_int( ind[ k ], MIN_DELTA_GAIN_QUANT, MAX_DELTA_GAIN_QUANT );
/* Accumulate deltas */
if( ind[ k ] > double_step_size_threshold ) {
*prev_ind += SKP_LSHIFT( ind[ k ], 1 ) - double_step_size_threshold;
} else {
*prev_ind += ind[ k ];
}
/* Shift to make non-negative */
ind[ k ] -= MIN_DELTA_GAIN_QUANT;
}
/* Convert to linear scale and scale */
gain_Q16[ k ] = SKP_Silk_log2lin( SKP_min_32( SKP_SMULWB( INV_SCALE_Q16, *prev_ind ) + OFFSET, 3967 ) ); /* 3967 = 31 in Q7 */
}
}
void SKP_Silk_PLC_conceal(
SKP_Silk_decoder_state *psDec, /* I/O Decoder state */
SKP_Silk_decoder_control *psDecCtrl, /* I/O Decoder control */
SKP_int16 signal[], /* O concealed signal */
SKP_int length /* I length of residual */
)
{
SKP_int i, j, k;
SKP_int16 *B_Q14, exc_buf[ MAX_FRAME_LENGTH ], *exc_buf_ptr;
SKP_int16 rand_scale_Q14, A_Q12_tmp[ MAX_LPC_ORDER ];
SKP_int32 rand_seed, harm_Gain_Q15, rand_Gain_Q15;
SKP_int lag, idx, shift1, shift2;
SKP_int32 energy1, energy2, *rand_ptr, *pred_lag_ptr, Atmp;
SKP_int32 sig_Q10[ MAX_FRAME_LENGTH ], *sig_Q10_ptr, LPC_exc_Q10, LPC_pred_Q10, LTP_pred_Q14;
SKP_Silk_PLC_struct *psPLC;
psPLC = &psDec->sPLC;
/* Update LTP buffer */
SKP_memcpy( psDec->sLTP_Q16, &psDec->sLTP_Q16[ psDec->frame_length ], psDec->frame_length * sizeof( SKP_int32 ) );
/* LPC concealment. Apply BWE to previous LPC */
SKP_Silk_bwexpander( psPLC->prevLPC_Q12, psDec->LPC_order, BWE_COEF_Q16 );
/* Find random noise component */
/* Scale previous excitation signal */
exc_buf_ptr = exc_buf;
for( k = ( NB_SUBFR >> 1 ); k < NB_SUBFR; k++ ) {
for( i = 0; i < psDec->subfr_length; i++ ) {
exc_buf_ptr[ i ] = ( SKP_int16 )SKP_RSHIFT(
SKP_SMULWW( psDec->exc_Q10[ i + k * psDec->subfr_length ], psPLC->prevGain_Q16[ k ] ), 10 );
}
exc_buf_ptr += psDec->subfr_length;
}
/* Find the subframe with lowest energy of the last two and use that as random noise generator */
SKP_Silk_sum_sqr_shift( &energy1, &shift1, exc_buf, psDec->subfr_length );
SKP_Silk_sum_sqr_shift( &energy2, &shift2, &exc_buf[ psDec->subfr_length ], psDec->subfr_length );
if( SKP_RSHIFT( energy1, shift2 ) < SKP_RSHIFT( energy1, shift2 ) ) {
/* First sub-frame has lowest energy */
rand_ptr = &psDec->exc_Q10[ SKP_max_int( 0, 3 * psDec->subfr_length - RAND_BUF_SIZE ) ];
} else {
/* Second sub-frame has lowest energy */
rand_ptr = &psDec->exc_Q10[ SKP_max_int( 0, psDec->frame_length - RAND_BUF_SIZE ) ];
}
/* Setup Gain to random noise component */
B_Q14 = psPLC->LTPCoef_Q14;
rand_scale_Q14 = psPLC->randScale_Q14;
/* Setup attenuation gains */
harm_Gain_Q15 = HARM_ATT_Q15[ SKP_min_int( NB_ATT - 1, psDec->lossCnt ) ];
if( psDec->prev_sigtype == SIG_TYPE_VOICED ) {
rand_Gain_Q15 = PLC_RAND_ATTENUATE_V_Q15[ SKP_min_int( NB_ATT - 1, psDec->lossCnt ) ];
} else {
rand_Gain_Q15 = PLC_RAND_ATTENUATE_UV_Q15[ SKP_min_int( NB_ATT - 1, psDec->lossCnt ) ];
}
/* First Lost frame */
if( psDec->lossCnt == 0 ) {
rand_scale_Q14 = (1 << 14 );
/* Reduce random noise Gain for voiced frames */
if( psDec->prev_sigtype == SIG_TYPE_VOICED ) {
for( i = 0; i < LTP_ORDER; i++ ) {
rand_scale_Q14 -= B_Q14[ i ];
}
rand_scale_Q14 = SKP_max_16( 3277, rand_scale_Q14 ); /* 0.2 */
rand_scale_Q14 = ( SKP_int16 )SKP_RSHIFT( SKP_SMULBB( rand_scale_Q14, psPLC->prevLTP_scale_Q14 ), 14 );
}
/* Reduce random noise for unvoiced frames with high LPC gain */
if( psDec->prev_sigtype == SIG_TYPE_UNVOICED ) {
SKP_int32 invGain_Q30, down_scale_Q30;
SKP_Silk_LPC_inverse_pred_gain( &invGain_Q30, psPLC->prevLPC_Q12, psDec->LPC_order );
down_scale_Q30 = SKP_min_32( SKP_RSHIFT( ( 1 << 30 ), LOG2_INV_LPC_GAIN_HIGH_THRES ), invGain_Q30 );
down_scale_Q30 = SKP_max_32( SKP_RSHIFT( ( 1 << 30 ), LOG2_INV_LPC_GAIN_LOW_THRES ), down_scale_Q30 );
down_scale_Q30 = SKP_LSHIFT( down_scale_Q30, LOG2_INV_LPC_GAIN_HIGH_THRES );
rand_Gain_Q15 = SKP_RSHIFT( SKP_SMULWB( down_scale_Q30, rand_Gain_Q15 ), 14 );
}
}
rand_seed = psPLC->rand_seed;
lag = SKP_RSHIFT_ROUND( psPLC->pitchL_Q8, 8 );
psDec->sLTP_buf_idx = psDec->frame_length;
/***************************/
/* LTP synthesis filtering */
/***************************/
sig_Q10_ptr = sig_Q10;
for( k = 0; k < NB_SUBFR; k++ ) {
/* Setup pointer */
pred_lag_ptr = &psDec->sLTP_Q16[ psDec->sLTP_buf_idx - lag + LTP_ORDER / 2 ];
for( i = 0; i < psDec->subfr_length; i++ ) {
rand_seed = SKP_RAND( rand_seed );
idx = SKP_RSHIFT( rand_seed, 25 ) & RAND_BUF_MASK;
/* Unrolled loop */
LTP_pred_Q14 = SKP_SMULWB( pred_lag_ptr[ 0 ], B_Q14[ 0 ] );
LTP_pred_Q14 = SKP_SMLAWB( LTP_pred_Q14, pred_lag_ptr[ -1 ], B_Q14[ 1 ] );
LTP_pred_Q14 = SKP_SMLAWB( LTP_pred_Q14, pred_lag_ptr[ -2 ], B_Q14[ 2 ] );
LTP_pred_Q14 = SKP_SMLAWB( LTP_pred_Q14, pred_lag_ptr[ -3 ], B_Q14[ 3 ] );
LTP_pred_Q14 = SKP_SMLAWB( LTP_pred_Q14, pred_lag_ptr[ -4 ], B_Q14[ 4 ] );
pred_lag_ptr++;
/* Generate LPC residual */
LPC_exc_Q10 = SKP_LSHIFT( SKP_SMULWB( rand_ptr[ idx ], rand_scale_Q14 ), 2 ); /* Random noise part */
LPC_exc_Q10 = SKP_ADD32( LPC_exc_Q10, SKP_RSHIFT_ROUND( LTP_pred_Q14, 4 ) ); /* Harmonic part */
/* Update states */
psDec->sLTP_Q16[ psDec->sLTP_buf_idx ] = SKP_LSHIFT( LPC_exc_Q10, 6 );
psDec->sLTP_buf_idx++;
/* Save LPC residual */
sig_Q10_ptr[ i ] = LPC_exc_Q10;
}
sig_Q10_ptr += psDec->subfr_length;
/* Gradually reduce LTP gain */
for( j = 0; j < LTP_ORDER; j++ ) {
B_Q14[ j ] = SKP_RSHIFT( SKP_SMULBB( harm_Gain_Q15, B_Q14[ j ] ), 15 );
}
/* Gradually reduce excitation gain */
rand_scale_Q14 = SKP_RSHIFT( SKP_SMULBB( rand_scale_Q14, rand_Gain_Q15 ), 15 );
/* Slowly increase pitch lag */
psPLC->pitchL_Q8 += SKP_SMULWB( psPLC->pitchL_Q8, PITCH_DRIFT_FAC_Q16 );
psPLC->pitchL_Q8 = SKP_min_32( psPLC->pitchL_Q8, SKP_LSHIFT( SKP_SMULBB( MAX_PITCH_LAG_MS, psDec->fs_kHz ), 8 ) );
lag = SKP_RSHIFT_ROUND( psPLC->pitchL_Q8, 8 );
}
/***************************/
/* LPC synthesis filtering */
/***************************/
sig_Q10_ptr = sig_Q10;
/* Preload LPC coeficients to array on stack. Gives small performance gain */
SKP_memcpy( A_Q12_tmp, psPLC->prevLPC_Q12, psDec->LPC_order * sizeof( SKP_int16 ) );
SKP_assert( psDec->LPC_order >= 10 ); /* check that unrolling works */
for( k = 0; k < NB_SUBFR; k++ ) {
for( i = 0; i < psDec->subfr_length; i++ ){
/* unrolled */
Atmp = *( ( SKP_int32* )&A_Q12_tmp[ 0 ] ); /* read two coefficients at once */
LPC_pred_Q10 = SKP_SMULWB( psDec->sLPC_Q14[ MAX_LPC_ORDER + i - 1 ], Atmp );
LPC_pred_Q10 = SKP_SMLAWT( LPC_pred_Q10, psDec->sLPC_Q14[ MAX_LPC_ORDER + i - 2 ], Atmp );
Atmp = *( ( SKP_int32* )&A_Q12_tmp[ 2 ] );
LPC_pred_Q10 = SKP_SMLAWB( LPC_pred_Q10, psDec->sLPC_Q14[ MAX_LPC_ORDER + i - 3 ], Atmp );
LPC_pred_Q10 = SKP_SMLAWT( LPC_pred_Q10, psDec->sLPC_Q14[ MAX_LPC_ORDER + i - 4 ], Atmp );
Atmp = *( ( SKP_int32* )&A_Q12_tmp[ 4 ] );
LPC_pred_Q10 = SKP_SMLAWB( LPC_pred_Q10, psDec->sLPC_Q14[ MAX_LPC_ORDER + i - 5 ], Atmp );
LPC_pred_Q10 = SKP_SMLAWT( LPC_pred_Q10, psDec->sLPC_Q14[ MAX_LPC_ORDER + i - 6 ], Atmp );
Atmp = *( ( SKP_int32* )&A_Q12_tmp[ 6 ] );
LPC_pred_Q10 = SKP_SMLAWB( LPC_pred_Q10, psDec->sLPC_Q14[ MAX_LPC_ORDER + i - 7 ], Atmp );
LPC_pred_Q10 = SKP_SMLAWT( LPC_pred_Q10, psDec->sLPC_Q14[ MAX_LPC_ORDER + i - 8 ], Atmp );
Atmp = *( ( SKP_int32* )&A_Q12_tmp[ 8 ] );
LPC_pred_Q10 = SKP_SMLAWB( LPC_pred_Q10, psDec->sLPC_Q14[ MAX_LPC_ORDER + i - 9 ], Atmp );
LPC_pred_Q10 = SKP_SMLAWT( LPC_pred_Q10, psDec->sLPC_Q14[ MAX_LPC_ORDER + i - 10 ], Atmp );
for( j = 10 ; j < psDec->LPC_order ; j+=2 ) {
Atmp = *( ( SKP_int32* )&A_Q12_tmp[ j ] );
LPC_pred_Q10 = SKP_SMLAWB( LPC_pred_Q10, psDec->sLPC_Q14[ MAX_LPC_ORDER + i - 1 - j ], Atmp );
LPC_pred_Q10 = SKP_SMLAWT( LPC_pred_Q10, psDec->sLPC_Q14[ MAX_LPC_ORDER + i - 2 - j ], Atmp );
}
/* Add prediction to LPC residual */
sig_Q10_ptr[ i ] = SKP_ADD32( sig_Q10_ptr[ i ], LPC_pred_Q10 );
/* Update states */
psDec->sLPC_Q14[ MAX_LPC_ORDER + i ] = SKP_LSHIFT( sig_Q10_ptr[ i ], 4 );
}
sig_Q10_ptr += psDec->subfr_length;
/* Update LPC filter state */
SKP_memcpy( psDec->sLPC_Q14, &psDec->sLPC_Q14[ psDec->subfr_length ], MAX_LPC_ORDER * sizeof( SKP_int32 ) );
}
/* Scale with Gain */
for( i = 0; i < psDec->frame_length; i++ ) {
signal[ i ] = ( SKP_int16 )SKP_SAT16( SKP_RSHIFT_ROUND( SKP_SMULWW( sig_Q10[ i ], psPLC->prevGain_Q16[ NB_SUBFR - 1 ] ), 10 ) );
}
/**************************************/
/* Update states */
/**************************************/
psPLC->rand_seed = rand_seed;
psPLC->randScale_Q14 = rand_scale_Q14;
for( i = 0; i < NB_SUBFR; i++ ) {
psDecCtrl->pitchL[ i ] = lag;
}
}
void SKP_Silk_NLSF_MSVQ_encode_FLP(
SKP_int *NLSFIndices, /* O Codebook path vector [ CB_STAGES ] */
SKP_float *pNLSF, /* I/O Quantized NLSF vector [ LPC_ORDER ] */
const SKP_Silk_NLSF_CB_FLP *psNLSF_CB_FLP, /* I Codebook object */
const SKP_float *pNLSF_q_prev, /* I Prev. quantized NLSF vector [LPC_ORDER] */
const SKP_float *pW, /* I NLSF weight vector [ LPC_ORDER ] */
const SKP_float NLSF_mu, /* I Rate weight for the RD optimization */
const SKP_float NLSF_mu_fluc_red, /* I Fluctuation reduction error weight */
const SKP_int NLSF_MSVQ_Survivors,/* I Max survivors from each stage */
const SKP_int LPC_order, /* I LPC order */
const SKP_int deactivate_fluc_red /* I Deactivate fluctuation reduction */
)
{
SKP_int i, s, k, cur_survivors, prev_survivors, min_survivors, input_index, cb_index, bestIndex;
SKP_float se, wsse, rateDistThreshold, bestRateDist;
#if( LOW_COMPLEXITY_ONLY == 1 )
SKP_float pRateDist[ NLSF_MSVQ_TREE_SEARCH_MAX_VECTORS_EVALUATED_LC_MODE ];
SKP_float pRate[ MAX_NLSF_MSVQ_SURVIVORS_LC_MODE ];
SKP_float pRate_new[ MAX_NLSF_MSVQ_SURVIVORS_LC_MODE ];
SKP_int pTempIndices[ MAX_NLSF_MSVQ_SURVIVORS_LC_MODE ];
SKP_int pPath[ MAX_NLSF_MSVQ_SURVIVORS_LC_MODE * NLSF_MSVQ_MAX_CB_STAGES ];
SKP_int pPath_new[ MAX_NLSF_MSVQ_SURVIVORS_LC_MODE * NLSF_MSVQ_MAX_CB_STAGES ];
SKP_float pRes[ MAX_NLSF_MSVQ_SURVIVORS_LC_MODE * MAX_LPC_ORDER ];
SKP_float pRes_new[ MAX_NLSF_MSVQ_SURVIVORS_LC_MODE * MAX_LPC_ORDER ];
#else
SKP_float pRateDist[ NLSF_MSVQ_TREE_SEARCH_MAX_VECTORS_EVALUATED ];
SKP_float pRate[ MAX_NLSF_MSVQ_SURVIVORS ];
SKP_float pRate_new[ MAX_NLSF_MSVQ_SURVIVORS ];
SKP_int pTempIndices[ MAX_NLSF_MSVQ_SURVIVORS ];
SKP_int pPath[ MAX_NLSF_MSVQ_SURVIVORS * NLSF_MSVQ_MAX_CB_STAGES ];
SKP_int pPath_new[ MAX_NLSF_MSVQ_SURVIVORS * NLSF_MSVQ_MAX_CB_STAGES ];
SKP_float pRes[ MAX_NLSF_MSVQ_SURVIVORS * MAX_LPC_ORDER ];
SKP_float pRes_new[ MAX_NLSF_MSVQ_SURVIVORS * MAX_LPC_ORDER ];
#endif
const SKP_float *pConstFloat;
SKP_float *pFloat;
const SKP_int *pConstInt;
SKP_int *pInt;
const SKP_float *pCB_element;
const SKP_Silk_NLSF_CBS_FLP *pCurrentCBStage;
#ifdef USE_UNQUANTIZED_LSFS
SKP_float NLSF_orig[ MAX_LPC_ORDER ];
SKP_memcpy( NLSF_orig, pNLSF, LPC_order * sizeof( SKP_float ) );
#endif
SKP_assert( NLSF_MSVQ_Survivors <= MAX_NLSF_MSVQ_SURVIVORS );
SKP_assert( ( LOW_COMPLEXITY_ONLY == 0 ) || ( NLSF_MSVQ_Survivors <= MAX_NLSF_MSVQ_SURVIVORS_LC_MODE ) );
cur_survivors = NLSF_MSVQ_Survivors;
/****************************************************/
/* Tree search for the multi-stage vector quantizer */
/****************************************************/
/* Clear accumulated rates */
SKP_memset( pRate, 0, NLSF_MSVQ_Survivors * sizeof( SKP_float ) );
/* Copy NLSFs into residual signal vector */
SKP_memcpy( pRes, pNLSF, LPC_order * sizeof( SKP_float ) );
/* Set first stage values */
prev_survivors = 1;
/* Minimum number of survivors */
min_survivors = NLSF_MSVQ_Survivors / 2;
/* Loop over all stages */
for( s = 0; s < psNLSF_CB_FLP->nStages; s++ ) {
/* Set a pointer to the current stage codebook */
pCurrentCBStage = &psNLSF_CB_FLP->CBStages[ s ];
/* Calculate the number of survivors in the current stage */
cur_survivors = SKP_min_32( NLSF_MSVQ_Survivors, prev_survivors * pCurrentCBStage->nVectors );
#if( NLSF_MSVQ_FLUCTUATION_REDUCTION == 0 )
/* Find a single best survivor in the last stage, if we */
/* do not need candidates for fluctuation reduction */
if( s == psNLSF_CB_FLP->nStages - 1 ) {
cur_survivors = 1;
}
#endif
/* Nearest neighbor clustering for multiple input data vectors */
SKP_Silk_NLSF_VQ_rate_distortion_FLP( pRateDist, pCurrentCBStage, pRes, pW, pRate, NLSF_mu, prev_survivors, LPC_order );
/* Sort the rate-distortion errors */
SKP_Silk_insertion_sort_increasing_FLP( pRateDist, pTempIndices, prev_survivors * pCurrentCBStage->nVectors, cur_survivors );
/* Discard survivors with rate-distortion values too far above the best one */
rateDistThreshold = ( 1.0f + NLSF_MSVQ_Survivors * NLSF_MSVQ_SURV_MAX_REL_RD ) * pRateDist[ 0 ];
while( pRateDist[ cur_survivors - 1 ] > rateDistThreshold && cur_survivors > min_survivors ) {
cur_survivors--;
}
/* Update accumulated codebook contributions for the 'cur_survivors' best codebook indices */
for( k = 0; k < cur_survivors; k++ ) {
if( s > 0 ) {
/* Find the indices of the input and the codebook vector */
if( pCurrentCBStage->nVectors == 8 ) {
input_index = SKP_RSHIFT( pTempIndices[ k ], 3 );
cb_index = pTempIndices[ k ] & 7;
} else {
input_index = pTempIndices[ k ] / pCurrentCBStage->nVectors;
cb_index = pTempIndices[ k ] - input_index * pCurrentCBStage->nVectors;
}
} else {
/* Find the indices of the input and the codebook vector */
input_index = 0;
cb_index = pTempIndices[ k ];
}
/* Subtract new contribution from the previous residual vector for each of 'cur_survivors' */
pConstFloat = &pRes[ input_index * LPC_order ];
pCB_element = &pCurrentCBStage->CB[ cb_index * LPC_order ];
pFloat = &pRes_new[ k * LPC_order ];
for( i = 0; i < LPC_order; i++ ) {
pFloat[ i ] = pConstFloat[ i ] - pCB_element[ i ];
}
/* Update accumulated rate for stage 1 to the current */
pRate_new[ k ] = pRate[ input_index ] + pCurrentCBStage->Rates[ cb_index ];
/* Copy paths from previous matrix, starting with the best path */
pConstInt = &pPath[ input_index * psNLSF_CB_FLP->nStages ];
pInt = &pPath_new[ k * psNLSF_CB_FLP->nStages ];
for( i = 0; i < s; i++ ) {
pInt[ i ] = pConstInt[ i ];
}
/* Write the current stage indices for the 'cur_survivors' to the best path matrix */
pInt[ s ] = cb_index;
}
if( s < psNLSF_CB_FLP->nStages - 1 ) {
/* Copy NLSF residual matrix for next stage */
SKP_memcpy(pRes, pRes_new, cur_survivors * LPC_order * sizeof( SKP_float ) );
/* Copy rate vector for next stage */
SKP_memcpy(pRate, pRate_new, cur_survivors * sizeof( SKP_float ) );
/* Copy best path matrix for next stage */
SKP_memcpy(pPath, pPath_new, cur_survivors * psNLSF_CB_FLP->nStages * sizeof( SKP_int ) );
}
prev_survivors = cur_survivors;
}
/* (Preliminary) index of the best survivor, later to be decoded */
bestIndex = 0;
#if( NLSF_MSVQ_FLUCTUATION_REDUCTION == 1 )
/******************************/
/* NLSF fluctuation reduction */
/******************************/
if( deactivate_fluc_red != 1 ) {
/* Search among all survivors, now taking also weighted fluctuation errors into account */
bestRateDist = SKP_float_MAX;
for( s = 0; s < cur_survivors; s++ ) {
/* Decode survivor to compare with previous quantized NLSF vector */
SKP_Silk_NLSF_MSVQ_decode_FLP( pNLSF, psNLSF_CB_FLP, &pPath_new[ s * psNLSF_CB_FLP->nStages ], LPC_order );
/* Compare decoded NLSF vector with the previously quantized vector */
wsse = 0;
for( i = 0; i < LPC_order; i += 2 ) {
/* Compute weighted squared quantization error for index i */
se = pNLSF[ i ] - pNLSF_q_prev[ i ];
wsse += pW[ i ] * se * se;
/* Compute weighted squared quantization error for index i + 1 */
se = pNLSF[ i + 1 ] - pNLSF_q_prev[ i + 1 ];
wsse += pW[ i + 1 ] * se * se;
}
/* Add the fluctuation reduction penalty to the rate distortion error */
wsse = pRateDist[s] + wsse * NLSF_mu_fluc_red;
/* Keep index of best survivor */
if( wsse < bestRateDist ) {
bestRateDist = wsse;
bestIndex = s;
}
}
}
#endif
/* Copy best path to output argument */
SKP_memcpy( NLSFIndices, &pPath_new[ bestIndex * psNLSF_CB_FLP->nStages ], psNLSF_CB_FLP->nStages * sizeof( SKP_int ) );
/* Decode and stabilize the best survivor */
SKP_Silk_NLSF_MSVQ_decode_FLP( pNLSF, psNLSF_CB_FLP, NLSFIndices, LPC_order );
#ifdef USE_UNQUANTIZED_LSFS
SKP_memcpy( pNLSF, NLSF_orig, LPC_order * sizeof( SKP_float ) );
#endif
}
void SKP_Silk_noise_shape_analysis_FIX(
SKP_Silk_encoder_state_FIX *psEnc, /* I/O Encoder state FIX */
SKP_Silk_encoder_control_FIX *psEncCtrl, /* I/O Encoder control FIX */
const SKP_int16 *pitch_res, /* I LPC residual from pitch analysis */
const SKP_int16 *x /* I Input signal [ 2 * frame_length + la_shape ]*/
)
{
SKP_Silk_shape_state_FIX *psShapeSt = &psEnc->sShape;
SKP_int k, nSamples, lz, Qnrg, b_Q14, scale = 0, sz;
SKP_int32 SNR_adj_dB_Q7, HarmBoost_Q16, HarmShapeGain_Q16, Tilt_Q16, tmp32;
SKP_int32 nrg, pre_nrg_Q30, log_energy_Q7, log_energy_prev_Q7, energy_variation_Q7;
SKP_int32 delta_Q16, BWExp1_Q16, BWExp2_Q16, gain_mult_Q16, gain_add_Q16, strength_Q16, b_Q8;
SKP_int32 auto_corr[ SHAPE_LPC_ORDER_MAX + 1 ];
SKP_int32 refl_coef_Q16[ SHAPE_LPC_ORDER_MAX ];
SKP_int32 AR_Q24[ SHAPE_LPC_ORDER_MAX ];
SKP_int16 x_windowed[ SHAPE_LPC_WIN_MAX ];
const SKP_int16 *x_ptr, *pitch_res_ptr;
SKP_int32 sqrt_nrg[ NB_SUBFR ], Qnrg_vec[ NB_SUBFR ];
/* Point to start of first LPC analysis block */
x_ptr = x + psEnc->sCmn.la_shape - SKP_SMULBB( SHAPE_LPC_WIN_MS, psEnc->sCmn.fs_kHz ) + psEnc->sCmn.frame_length / NB_SUBFR;
/****************/
/* CONTROL SNR */
/****************/
/* Reduce SNR_dB values if recent bitstream has exceeded TargetRate */
psEncCtrl->current_SNR_dB_Q7 = psEnc->SNR_dB_Q7 - SKP_SMULWB( SKP_LSHIFT( ( SKP_int32 )psEnc->BufferedInChannel_ms, 7 ), 3277 );
/* Reduce SNR_dB if inband FEC used */
if( psEnc->speech_activity_Q8 > LBRR_SPEECH_ACTIVITY_THRES_Q8 ) {
psEncCtrl->current_SNR_dB_Q7 -= SKP_RSHIFT( psEnc->inBandFEC_SNR_comp_Q8, 1 );
}
/****************/
/* GAIN CONTROL */
/****************/
/* Input quality is the average of the quality in the lowest two VAD bands */
psEncCtrl->input_quality_Q14 = ( SKP_int )SKP_RSHIFT( ( SKP_int32 )psEncCtrl->input_quality_bands_Q15[ 0 ]
+ psEncCtrl->input_quality_bands_Q15[ 1 ], 2 );
/* Coding quality level, between 0.0_Q0 and 1.0_Q0, but in Q14 */
psEncCtrl->coding_quality_Q14 = SKP_RSHIFT( SKP_Silk_sigm_Q15( SKP_RSHIFT_ROUND( psEncCtrl->current_SNR_dB_Q7 - ( 18 << 7 ), 4 ) ), 1 );
/* Reduce coding SNR during low speech activity */
b_Q8 = ( 1 << 8 ) - psEnc->speech_activity_Q8;
b_Q8 = SKP_SMULWB( SKP_LSHIFT( b_Q8, 8 ), b_Q8 );
SNR_adj_dB_Q7 = SKP_SMLAWB( psEncCtrl->current_SNR_dB_Q7,
SKP_SMULBB( -BG_SNR_DECR_dB_Q7 >> ( 4 + 1 ), b_Q8 ), // Q11
SKP_SMULWB( ( 1 << 14 ) + psEncCtrl->input_quality_Q14, psEncCtrl->coding_quality_Q14 ) ); // Q12
if( psEncCtrl->sCmn.sigtype == SIG_TYPE_VOICED ) {
/* Reduce gains for periodic signals */
SNR_adj_dB_Q7 = SKP_SMLAWB( SNR_adj_dB_Q7, HARM_SNR_INCR_dB_Q7 << 1, psEnc->LTPCorr_Q15 );
} else {
/* For unvoiced signals and low-quality input, adjust the quality slower than SNR_dB setting */
SNR_adj_dB_Q7 = SKP_SMLAWB( SNR_adj_dB_Q7,
SKP_SMLAWB( 6 << ( 7 + 2 ), -104856, psEncCtrl->current_SNR_dB_Q7 ), //-104856_Q18 = -0.4_Q0, Q9
( 1 << 14 ) - psEncCtrl->input_quality_Q14 ); // Q14
}
/*************************/
/* SPARSENESS PROCESSING */
/*************************/
/* Set quantizer offset */
if( psEncCtrl->sCmn.sigtype == SIG_TYPE_VOICED ) {
/* Initally set to 0; may be overruled in process_gains(..) */
psEncCtrl->sCmn.QuantOffsetType = 0;
psEncCtrl->sparseness_Q8 = 0;
} else {
/* Sparseness measure, based on relative fluctuations of energy per 2 milliseconds */
nSamples = SKP_LSHIFT( psEnc->sCmn.fs_kHz, 1 );
energy_variation_Q7 = 0;
log_energy_prev_Q7 = 0;
pitch_res_ptr = pitch_res;
for( k = 0; k < FRAME_LENGTH_MS / 2; k++ ) {
SKP_Silk_sum_sqr_shift( &nrg, &scale, pitch_res_ptr, nSamples );
nrg += SKP_RSHIFT( nSamples, scale ); // Q(-scale)
log_energy_Q7 = SKP_Silk_lin2log( nrg );
if( k > 0 ) {
energy_variation_Q7 += SKP_abs( log_energy_Q7 - log_energy_prev_Q7 );
}
log_energy_prev_Q7 = log_energy_Q7;
pitch_res_ptr += nSamples;
}
psEncCtrl->sparseness_Q8 = SKP_RSHIFT( SKP_Silk_sigm_Q15( SKP_SMULWB( energy_variation_Q7 - ( 5 << 7 ), 6554 ) ), 7 ); // 6554_Q16 = 0.1_Q0
/* Set quantization offset depending on sparseness measure */
if( psEncCtrl->sparseness_Q8 > SPARSENESS_THRESHOLD_QNT_OFFSET_Q8 ) {
psEncCtrl->sCmn.QuantOffsetType = 0;
} else {
psEncCtrl->sCmn.QuantOffsetType = 1;
}
/* Increase coding SNR for sparse signals */
SNR_adj_dB_Q7 = SKP_SMLAWB( SNR_adj_dB_Q7, SPARSE_SNR_INCR_dB_Q7 << 8, psEncCtrl->sparseness_Q8 - ( 1 << 7 ) );
}
/*******************************/
/* Control bandwidth expansion */
/*******************************/
delta_Q16 = SKP_SMULWB( ( 1 << 16 ) - SKP_SMULBB( 3, psEncCtrl->coding_quality_Q14 ), LOW_RATE_BANDWIDTH_EXPANSION_DELTA_Q16 );
BWExp1_Q16 = BANDWIDTH_EXPANSION_Q16 - delta_Q16;
BWExp2_Q16 = BANDWIDTH_EXPANSION_Q16 + delta_Q16;
if( psEnc->sCmn.fs_kHz == 24 ) {
/* Less bandwidth expansion for super wideband */
BWExp1_Q16 = ( 1 << 16 ) - SKP_SMULWB( SWB_BANDWIDTH_EXPANSION_REDUCTION_Q16, ( 1 << 16 ) - BWExp1_Q16 );
BWExp2_Q16 = ( 1 << 16 ) - SKP_SMULWB( SWB_BANDWIDTH_EXPANSION_REDUCTION_Q16, ( 1 << 16 ) - BWExp2_Q16 );
}
/* BWExp1 will be applied after BWExp2, so make it relative */
BWExp1_Q16 = SKP_DIV32_16( SKP_LSHIFT( BWExp1_Q16, 14 ), SKP_RSHIFT( BWExp2_Q16, 2 ) );
/********************************************/
/* Compute noise shaping AR coefs and gains */
/********************************************/
sz = ( SKP_int )SKP_SMULBB( SHAPE_LPC_WIN_MS, psEnc->sCmn.fs_kHz );
for( k = 0; k < NB_SUBFR; k++ ) {
/* Apply window */
SKP_Silk_apply_sine_window( x_windowed, x_ptr, 0, SHAPE_LPC_WIN_MS * psEnc->sCmn.fs_kHz );
/* Update pointer: next LPC analysis block */
x_ptr += psEnc->sCmn.frame_length / NB_SUBFR;
/* Calculate auto correlation */
SKP_Silk_autocorr( auto_corr, &scale, x_windowed, sz, psEnc->sCmn.shapingLPCOrder + 1 );
/* Add white noise, as a fraction of energy */
auto_corr[0] = SKP_ADD32( auto_corr[0], SKP_max_32( SKP_SMULWB( SKP_RSHIFT( auto_corr[ 0 ], 4 ), SHAPE_WHITE_NOISE_FRACTION_Q20 ), 1 ) );
/* Calculate the reflection coefficients using schur */
nrg = SKP_Silk_schur64( refl_coef_Q16, auto_corr, psEnc->sCmn.shapingLPCOrder );
/* Convert reflection coefficients to prediction coefficients */
SKP_Silk_k2a_Q16( AR_Q24, refl_coef_Q16, psEnc->sCmn.shapingLPCOrder );
/* Bandwidth expansion for synthesis filter shaping */
SKP_Silk_bwexpander_32( AR_Q24, psEnc->sCmn.shapingLPCOrder, BWExp2_Q16 );
/* Make sure to fit in Q13 SKP_int16 */
SKP_Silk_LPC_fit( &psEncCtrl->AR2_Q13[ k * SHAPE_LPC_ORDER_MAX ], AR_Q24, 13, psEnc->sCmn.shapingLPCOrder );
/* Compute noise shaping filter coefficients */
SKP_memcpy(
&psEncCtrl->AR1_Q13[ k * SHAPE_LPC_ORDER_MAX ],
&psEncCtrl->AR2_Q13[ k * SHAPE_LPC_ORDER_MAX ],
psEnc->sCmn.shapingLPCOrder * sizeof( SKP_int16 ) );
/* Bandwidth expansion for analysis filter shaping */
SKP_assert( BWExp1_Q16 <= ( 1 << 16 ) ); // If ever breaking, use LPC_stabilize() in these cases to stay within range
SKP_Silk_bwexpander( &psEncCtrl->AR1_Q13[ k * SHAPE_LPC_ORDER_MAX ], psEnc->sCmn.shapingLPCOrder, BWExp1_Q16 );
/* Increase residual energy */
nrg = SKP_SMLAWB( nrg, SKP_RSHIFT( auto_corr[ 0 ], 8 ), SHAPE_MIN_ENERGY_RATIO_Q24 );
Qnrg = -scale; // range: -12...30
SKP_assert( Qnrg >= -12 );
SKP_assert( Qnrg <= 30 );
/* Make sure that Qnrg is an even number */
if( Qnrg & 1 ) {
Qnrg -= 1;
nrg >>= 1;
}
tmp32 = SKP_Silk_SQRT_APPROX( nrg );
Qnrg >>= 1; // range: -6...15
sqrt_nrg[ k ] = tmp32;
Qnrg_vec[ k ] = Qnrg;
psEncCtrl->Gains_Q16[ k ] = SKP_LSHIFT_SAT32( tmp32, 16 - Qnrg );
/* Ratio of prediction gains, in energy domain */
SKP_Silk_LPC_inverse_pred_gain_Q13( &pre_nrg_Q30, &psEncCtrl->AR2_Q13[ k * SHAPE_LPC_ORDER_MAX ], psEnc->sCmn.shapingLPCOrder );
SKP_Silk_LPC_inverse_pred_gain_Q13( &nrg, &psEncCtrl->AR1_Q13[ k * SHAPE_LPC_ORDER_MAX ], psEnc->sCmn.shapingLPCOrder );
lz = SKP_min_32( SKP_Silk_CLZ32( pre_nrg_Q30 ) - 1, 19 );
pre_nrg_Q30 = SKP_DIV32( SKP_LSHIFT( pre_nrg_Q30, lz ), SKP_RSHIFT( nrg, 20 - lz ) + 1 ); // Q20
pre_nrg_Q30 = SKP_RSHIFT( SKP_LSHIFT_SAT32( pre_nrg_Q30, 9 ), 1 ); /* Q28 */
psEncCtrl->GainsPre_Q14[ k ] = ( SKP_int )SKP_Silk_SQRT_APPROX( pre_nrg_Q30 );
}
void SKP_Silk_NLSF_MSVQ_encode_FIX(
SKP_int *NLSFIndices, /* O Codebook path vector [ CB_STAGES ] */
SKP_int *pNLSF_Q15, /* I/O Quantized NLSF vector [ LPC_ORDER ] */
const SKP_Silk_NLSF_CB_struct *psNLSF_CB, /* I Codebook object */
const SKP_int *pNLSF_q_Q15_prev, /* I Prev. quantized NLSF vector [LPC_ORDER] */
const SKP_int *pW_Q6, /* I NLSF weight vector [ LPC_ORDER ] */
const SKP_int NLSF_mu_Q15, /* I Rate weight for the RD optimization */
const SKP_int NLSF_mu_fluc_red_Q16, /* I Fluctuation reduction error weight */
const SKP_int NLSF_MSVQ_Survivors, /* I Max survivors from each stage */
const SKP_int LPC_order, /* I LPC order */
const SKP_int deactivate_fluc_red /* I Deactivate fluctuation reduction */
)
{
SKP_int i, s, k, cur_survivors = 0, prev_survivors, input_index, cb_index, bestIndex;
SKP_int32 rateDistThreshold_Q18;
SKP_int pNLSF_in_Q15[ MAX_LPC_ORDER ];
#if( NLSF_MSVQ_FLUCTUATION_REDUCTION == 1 )
SKP_int32 se_Q15, wsse_Q20, bestRateDist_Q20;
#endif
#if( LOW_COMPLEXITY_ONLY == 1 )
SKP_int32 pRateDist_Q18[ NLSF_MSVQ_TREE_SEARCH_MAX_VECTORS_EVALUATED_LC_MODE ];
SKP_int32 pRate_Q5[ MAX_NLSF_MSVQ_SURVIVORS_LC_MODE ];
SKP_int32 pRate_new_Q5[ MAX_NLSF_MSVQ_SURVIVORS_LC_MODE ];
SKP_int pTempIndices[ MAX_NLSF_MSVQ_SURVIVORS_LC_MODE ];
SKP_int pPath[ MAX_NLSF_MSVQ_SURVIVORS_LC_MODE * NLSF_MSVQ_MAX_CB_STAGES ];
SKP_int pPath_new[ MAX_NLSF_MSVQ_SURVIVORS_LC_MODE * NLSF_MSVQ_MAX_CB_STAGES ];
SKP_int pRes_Q15[ MAX_NLSF_MSVQ_SURVIVORS_LC_MODE * MAX_LPC_ORDER ];
SKP_int pRes_new_Q15[ MAX_NLSF_MSVQ_SURVIVORS_LC_MODE * MAX_LPC_ORDER ];
#else
SKP_int32 pRateDist_Q18[ NLSF_MSVQ_TREE_SEARCH_MAX_VECTORS_EVALUATED ];
SKP_int32 pRate_Q5[ MAX_NLSF_MSVQ_SURVIVORS ];
SKP_int32 pRate_new_Q5[ MAX_NLSF_MSVQ_SURVIVORS ];
SKP_int pTempIndices[ MAX_NLSF_MSVQ_SURVIVORS ];
SKP_int pPath[ MAX_NLSF_MSVQ_SURVIVORS * NLSF_MSVQ_MAX_CB_STAGES ];
SKP_int pPath_new[ MAX_NLSF_MSVQ_SURVIVORS * NLSF_MSVQ_MAX_CB_STAGES ];
SKP_int pRes_Q15[ MAX_NLSF_MSVQ_SURVIVORS * MAX_LPC_ORDER ];
SKP_int pRes_new_Q15[ MAX_NLSF_MSVQ_SURVIVORS * MAX_LPC_ORDER ];
#endif
const SKP_int *pConstInt;
SKP_int *pInt;
const SKP_int16 *pCB_element;
const SKP_Silk_NLSF_CBS *pCurrentCBStage;
SKP_assert( NLSF_MSVQ_Survivors <= MAX_NLSF_MSVQ_SURVIVORS );
SKP_assert( ( LOW_COMPLEXITY_ONLY == 0 ) || ( NLSF_MSVQ_Survivors <= MAX_NLSF_MSVQ_SURVIVORS_LC_MODE ) );
/* Copy the input vector */
SKP_memcpy( pNLSF_in_Q15, pNLSF_Q15, LPC_order * sizeof( SKP_int ) );
/****************************************************/
/* Tree search for the multi-stage vector quantizer */
/****************************************************/
/* Clear accumulated rates */
SKP_memset( pRate_Q5, 0, NLSF_MSVQ_Survivors * sizeof( SKP_int32 ) );
/* Copy NLSFs into residual signal vector */
for( i = 0; i < LPC_order; i++ ) {
pRes_Q15[ i ] = pNLSF_Q15[ i ];
}
/* Set first stage values */
prev_survivors = 1;
/* Loop over all stages */
for( s = 0; s < psNLSF_CB->nStages; s++ ) {
/* Set a pointer to the current stage codebook */
pCurrentCBStage = &psNLSF_CB->CBStages[ s ];
/* Calculate the number of survivors in the current stage */
cur_survivors = SKP_min_32( NLSF_MSVQ_Survivors, SKP_SMULBB( prev_survivors, pCurrentCBStage->nVectors ) );
#if( NLSF_MSVQ_FLUCTUATION_REDUCTION == 0 )
/* Find a single best survivor in the last stage, if we */
/* do not need candidates for fluctuation reduction */
if( s == psNLSF_CB->nStages - 1 ) {
cur_survivors = 1;
}
#endif
/* Nearest neighbor clustering for multiple input data vectors */
SKP_Silk_NLSF_VQ_rate_distortion_FIX( pRateDist_Q18, pCurrentCBStage, pRes_Q15, pW_Q6,
pRate_Q5, NLSF_mu_Q15, prev_survivors, LPC_order );
/* Sort the rate-distortion errors */
SKP_Silk_insertion_sort_increasing( pRateDist_Q18, pTempIndices,
prev_survivors * pCurrentCBStage->nVectors, cur_survivors );
/* Discard survivors with rate-distortion values too far above the best one */
if( pRateDist_Q18[ 0 ] < SKP_int32_MAX / NLSF_MSVQ_SURV_MAX_REL_RD ) {
rateDistThreshold_Q18 = SKP_MUL( NLSF_MSVQ_SURV_MAX_REL_RD, pRateDist_Q18[ 0 ] );
while( pRateDist_Q18[ cur_survivors - 1 ] > rateDistThreshold_Q18 && cur_survivors > 1 ) {
cur_survivors--;
}
}
/* Update accumulated codebook contributions for the 'cur_survivors' best codebook indices */
for( k = 0; k < cur_survivors; k++ ) {
if( s > 0 ) {
/* Find the indices of the input and the codebook vector */
if( pCurrentCBStage->nVectors == 8 ) {
input_index = SKP_RSHIFT( pTempIndices[ k ], 3 );
cb_index = pTempIndices[ k ] & 7;
} else {
input_index = SKP_DIV32_16( pTempIndices[ k ], pCurrentCBStage->nVectors );
cb_index = pTempIndices[ k ] - SKP_SMULBB( input_index, pCurrentCBStage->nVectors );
}
} else {
/* Find the indices of the input and the codebook vector */
input_index = 0;
cb_index = pTempIndices[ k ];
}
/* Subtract new contribution from the previous residual vector for each of 'cur_survivors' */
pConstInt = &pRes_Q15[ SKP_SMULBB( input_index, LPC_order ) ];
pCB_element = &pCurrentCBStage->CB_NLSF_Q15[ SKP_SMULBB( cb_index, LPC_order ) ];
pInt = &pRes_new_Q15[ SKP_SMULBB( k, LPC_order ) ];
for( i = 0; i < LPC_order; i++ ) {
pInt[ i ] = pConstInt[ i ] - ( SKP_int )pCB_element[ i ];
}
/* Update accumulated rate for stage 1 to the current */
pRate_new_Q5[ k ] = pRate_Q5[ input_index ] + pCurrentCBStage->Rates_Q5[ cb_index ];
/* Copy paths from previous matrix, starting with the best path */
pConstInt = &pPath[ SKP_SMULBB( input_index, psNLSF_CB->nStages ) ];
pInt = &pPath_new[ SKP_SMULBB( k, psNLSF_CB->nStages ) ];
for( i = 0; i < s; i++ ) {
pInt[ i ] = pConstInt[ i ];
}
/* Write the current stage indices for the 'cur_survivors' to the best path matrix */
pInt[ s ] = cb_index;
}
if( s < psNLSF_CB->nStages - 1 ) {
/* Copy NLSF residual matrix for next stage */
SKP_memcpy( pRes_Q15, pRes_new_Q15, SKP_SMULBB( cur_survivors, LPC_order ) * sizeof( SKP_int ) );
/* Copy rate vector for next stage */
SKP_memcpy( pRate_Q5, pRate_new_Q5, cur_survivors * sizeof( SKP_int32 ) );
/* Copy best path matrix for next stage */
SKP_memcpy( pPath, pPath_new, SKP_SMULBB( cur_survivors, psNLSF_CB->nStages ) * sizeof( SKP_int ) );
}
prev_survivors = cur_survivors;
}
/* (Preliminary) index of the best survivor, later to be decoded */
bestIndex = 0;
#if( NLSF_MSVQ_FLUCTUATION_REDUCTION == 1 )
/******************************/
/* NLSF fluctuation reduction */
/******************************/
if( deactivate_fluc_red != 1 ) {
/* Search among all survivors, now taking also weighted fluctuation errors into account */
bestRateDist_Q20 = SKP_int32_MAX;
for( s = 0; s < cur_survivors; s++ ) {
/* Decode survivor to compare with previous quantized NLSF vector */
SKP_Silk_NLSF_MSVQ_decode( pNLSF_Q15, psNLSF_CB, &pPath_new[ SKP_SMULBB( s, psNLSF_CB->nStages ) ], LPC_order );
/* Compare decoded NLSF vector with the previously quantized vector */
wsse_Q20 = 0;
for( i = 0; i < LPC_order; i += 2 ) {
/* Compute weighted squared quantization error for index i */
se_Q15 = pNLSF_Q15[ i ] - pNLSF_q_Q15_prev[ i ]; // range: [ -32767 : 32767 ]
wsse_Q20 = SKP_SMLAWB( wsse_Q20, SKP_SMULBB( se_Q15, se_Q15 ), pW_Q6[ i ] );
/* Compute weighted squared quantization error for index i + 1 */
se_Q15 = pNLSF_Q15[ i + 1 ] - pNLSF_q_Q15_prev[ i + 1 ]; // range: [ -32767 : 32767 ]
wsse_Q20 = SKP_SMLAWB( wsse_Q20, SKP_SMULBB( se_Q15, se_Q15 ), pW_Q6[ i + 1 ] );
}
SKP_assert( wsse_Q20 >= 0 );
/* Add the fluctuation reduction penalty to the rate distortion error */
wsse_Q20 = SKP_ADD_POS_SAT32( pRateDist_Q18[ s ], SKP_SMULWB( wsse_Q20, NLSF_mu_fluc_red_Q16 ) );
/* Keep index of best survivor */
if( wsse_Q20 < bestRateDist_Q20 ) {
bestRateDist_Q20 = wsse_Q20;
bestIndex = s;
}
}
}
#endif
/* Copy best path to output argument */
SKP_memcpy( NLSFIndices, &pPath_new[ SKP_SMULBB( bestIndex, psNLSF_CB->nStages ) ], psNLSF_CB->nStages * sizeof( SKP_int ) );
/* Decode and stabilize the best survivor */
SKP_Silk_NLSF_MSVQ_decode( pNLSF_Q15, psNLSF_CB, NLSFIndices, LPC_order );
}
