/* Set decoder sampling rate */
void SKP_Silk_decoder_set_fs(SKP_Silk_decoder_state * psDec, /* I/O Decoder state pointer */
int fs_kHz /* I Sampling frequency (kHz) */
)
{
if (psDec->fs_kHz != fs_kHz) {
psDec->fs_kHz = fs_kHz;
psDec->frame_length = SKP_SMULBB(FRAME_LENGTH_MS, fs_kHz);
psDec->subfr_length =
SKP_SMULBB(FRAME_LENGTH_MS / NB_SUBFR, fs_kHz);
if (psDec->fs_kHz == 8) {
psDec->LPC_order = MIN_LPC_ORDER;
psDec->psNLSF_CB[0] = &SKP_Silk_NLSF_CB0_10;
psDec->psNLSF_CB[1] = &SKP_Silk_NLSF_CB1_10;
} else {
psDec->LPC_order = MAX_LPC_ORDER;
psDec->psNLSF_CB[0] = &SKP_Silk_NLSF_CB0_16;
psDec->psNLSF_CB[1] = &SKP_Silk_NLSF_CB1_16;
}
/* Reset part of the decoder state */
SKP_memset(psDec->sLPC_Q14, 0, MAX_LPC_ORDER * sizeof(int32_t));
SKP_memset(psDec->outBuf, 0,
MAX_FRAME_LENGTH * sizeof(int16_t));
SKP_memset(psDec->prevNLSF_Q15, 0, MAX_LPC_ORDER * sizeof(int));
psDec->sLTP_buf_idx = 0;
psDec->lagPrev = 100;
psDec->LastGainIndex = 1;
psDec->prev_sigtype = 0;
psDec->first_frame_after_reset = 1;
if (fs_kHz == 24) {
psDec->HP_A = SKP_Silk_Dec_A_HP_24;
psDec->HP_B = SKP_Silk_Dec_B_HP_24;
} else if (fs_kHz == 16) {
psDec->HP_A = SKP_Silk_Dec_A_HP_16;
psDec->HP_B = SKP_Silk_Dec_B_HP_16;
} else if (fs_kHz == 12) {
psDec->HP_A = SKP_Silk_Dec_A_HP_12;
psDec->HP_B = SKP_Silk_Dec_B_HP_12;
} else if (fs_kHz == 8) {
psDec->HP_A = SKP_Silk_Dec_A_HP_8;
psDec->HP_B = SKP_Silk_Dec_B_HP_8;
} else {
/* unsupported sampling rate */
assert(0);
}
}
/* Check that settings are valid */
assert(psDec->frame_length > 0
&& psDec->frame_length <= MAX_FRAME_LENGTH);
}
SKP_int SKP_Silk_init_encoder_FLP(
SKP_Silk_encoder_state_FLP *psEnc /* I/O Encoder state FLP */
) {
SKP_int ret = 0;
/* Clear the entire encoder state */
SKP_memset( psEnc, 0, sizeof( SKP_Silk_encoder_state_FLP ) );
#if HIGH_PASS_INPUT
psEnc->variable_HP_smth1 = SKP_Silk_log2( 70.0 );
psEnc->variable_HP_smth2 = SKP_Silk_log2( 70.0 );
#endif
/* Used to deactivate e.g. LSF interpolation and fluctuation reduction */
psEnc->sCmn.first_frame_after_reset = 1;
/* Initialize Silk VAD */
ret += SKP_Silk_VAD_Init( &psEnc->sCmn.sVAD );
/* Initialize NSQ */
psEnc->sCmn.sNSQ.prev_inv_gain_Q16 = 65536;
psEnc->sCmn.sNSQ_LBRR.prev_inv_gain_Q16 = 65536;
return( ret );
}
SKP_int SKP_Silk_VAD_Init( /* O Return value, 0 if success */
SKP_Silk_VAD_state *psSilk_VAD /* I/O Pointer to Silk VAD state */
)
{
SKP_int b, ret = 0;
/* reset state memory */
SKP_memset( psSilk_VAD, 0, sizeof( SKP_Silk_VAD_state ) );
/* init noise levels */
/* Initialize array with approx pink noise levels (psd proportional to inverse of frequency) */
for( b = 0; b < VAD_N_BANDS; b++ ) {
psSilk_VAD->NoiseLevelBias[ b ] = SKP_max_32( SKP_DIV32_16( VAD_NOISE_LEVELS_BIAS, b + 1 ), 1 );
}
/* Initialize state */
for( b = 0; b < VAD_N_BANDS; b++ ) {
psSilk_VAD->NL[ b ] = SKP_MUL( 100, psSilk_VAD->NoiseLevelBias[ b ] );
psSilk_VAD->inv_NL[ b ] = SKP_DIV32( SKP_int32_MAX, psSilk_VAD->NL[ b ] );
}
psSilk_VAD->counter = 15;
/* init smoothed energy-to-noise ratio*/
for( b = 0; b < VAD_N_BANDS; b++ ) {
psSilk_VAD->NrgRatioSmth_Q8[ b ] = 100 * 256; /* 100 * 256 --> 20 dB SNR */
}
return( ret );
}
/* Getting type of content for a packet */
void SKP_Silk_SDK_get_TOC(
const SKP_uint8 *inData, /* I: Encoded input vector */
const SKP_int nBytesIn, /* I: Number of input bytes */
SKP_Silk_TOC_struct *Silk_TOC /* O: Type of content */
)
{
SKP_Silk_decoder_state sDec; // Local Decoder state to avoid interfering with running decoder */
SKP_Silk_decoder_control sDecCtrl;
SKP_int TempQ[ MAX_FRAME_LENGTH ];
sDec.nFramesDecoded = 0;
sDec.fs_kHz = 0; /* Force update parameters LPC_order etc */
SKP_Silk_range_dec_init( &sDec.sRC, inData, ( SKP_int32 )nBytesIn );
Silk_TOC->corrupt = 0;
while( 1 ) {
SKP_Silk_decode_parameters( &sDec, &sDecCtrl, TempQ, 0 );
Silk_TOC->vadFlags[ sDec.nFramesDecoded ] = sDec.vadFlag;
Silk_TOC->sigtypeFlags[ sDec.nFramesDecoded ] = sDecCtrl.sigtype;
if( sDec.sRC.error ) {
/* Corrupt stream */
Silk_TOC->corrupt = 1;
break;
};
if( sDec.nBytesLeft > 0 && sDec.FrameTermination == SKP_SILK_MORE_FRAMES ) {
sDec.nFramesDecoded++;
} else {
break;
}
}
if( Silk_TOC->corrupt || sDec.FrameTermination == SKP_SILK_MORE_FRAMES ||
sDec.nFramesInPacket > SILK_MAX_FRAMES_PER_PACKET ) {
/* Corrupt packet */
SKP_memset( Silk_TOC, 0, sizeof( SKP_Silk_TOC_struct ) );
Silk_TOC->corrupt = 1;
} else {
Silk_TOC->framesInPacket = sDec.nFramesDecoded + 1;
Silk_TOC->fs_kHz = sDec.fs_kHz;
if( sDec.FrameTermination == SKP_SILK_LAST_FRAME ) {
Silk_TOC->inbandLBRR = sDec.FrameTermination;
} else {
Silk_TOC->inbandLBRR = sDec.FrameTermination - 1;
}
}
}
/* Function to find LBRR information in a packet */
void SKP_Silk_SDK_search_for_LBRR(
const SKP_uint8 *inData, /* I: Encoded input vector */
const SKP_int nBytesIn, /* I: Number of input Bytes */
SKP_int lost_offset, /* I: Offset from lost packet */
SKP_uint8 *LBRRData, /* O: LBRR payload */
SKP_int16 *nLBRRBytes /* O: Number of LBRR Bytes */
)
{
SKP_Silk_decoder_state sDec; // Local decoder state to avoid interfering with running decoder */
SKP_Silk_decoder_control sDecCtrl;
SKP_int TempQ[ MAX_FRAME_LENGTH ];
if( lost_offset < 1 || lost_offset > MAX_LBRR_DELAY ) {
/* No useful FEC in this packet */
*nLBRRBytes = 0;
return;
}
sDec.nFramesDecoded = 0;
sDec.fs_kHz = 0; /* Force update parameters LPC_order etc */
sDec.lossCnt = 0; /* Avoid running bw expansion of the LPC parameters when searching for LBRR data */
SKP_memset( sDec.prevNLSF_Q15, 0, MAX_LPC_ORDER * sizeof( SKP_int ) );
SKP_Silk_range_dec_init( &sDec.sRC, inData, ( SKP_int32 )nBytesIn );
while(1) {
SKP_Silk_decode_parameters( &sDec, &sDecCtrl, TempQ, 0 );
if( sDec.sRC.error ) {
/* Corrupt stream */
*nLBRRBytes = 0;
return;
};
if( ( sDec.FrameTermination - 1 ) & lost_offset && sDec.FrameTermination > 0 && sDec.nBytesLeft >= 0 ) {
/* The wanted FEC is present in the packet */
*nLBRRBytes = sDec.nBytesLeft;
SKP_memcpy( LBRRData, &inData[ nBytesIn - sDec.nBytesLeft ], sDec.nBytesLeft * sizeof( SKP_uint8 ) );
break;
}
if( sDec.nBytesLeft > 0 && sDec.FrameTermination == SKP_SILK_MORE_FRAMES ) {
sDec.nFramesDecoded++;
} else {
LBRRData = NULL;
*nLBRRBytes = 0;
break;
}
}
}
opus_int silk_init_decoder(
silk_decoder_state *psDec /* I/O Decoder state pointer */
)
{
/* Clear the entire encoder state, except anything copied */
SKP_memset( psDec, 0, sizeof( silk_decoder_state ) );
/* Used to deactivate e.g. LSF interpolation and fluctuation reduction */
psDec->first_frame_after_reset = 1;
psDec->prev_inv_gain_Q16 = 65536;
/* Reset CNG state */
silk_CNG_Reset( psDec );
/* Reset PLC state */
silk_PLC_Reset( psDec );
return(0);
}
SKP_int SKP_Silk_init_decoder(
SKP_Silk_decoder_state *psDec /* I/O Decoder state pointer */
)
{
SKP_memset( psDec, 0, sizeof( SKP_Silk_decoder_state ) );
/* Set sampling rate to 24 kHz, and init non-zero values */
SKP_Silk_decoder_set_fs( psDec, 24 );
/* Used to deactivate e.g. LSF interpolation and fluctuation reduction */
psDec->first_frame_after_reset = 1;
psDec->prev_inv_gain_Q16 = 65536;
/* Reset CNG state */
SKP_Silk_CNG_Reset( psDec );
SKP_Silk_PLC_Reset( psDec );
return(0);
}
void silk_LPC_analysis_filter_FLP(
SKP_float r_LPC[], /* O LPC residual signal */
const SKP_float PredCoef[], /* I LPC coefficients */
const SKP_float s[], /* I Input signal */
const opus_int length, /* I Length of input signal */
const opus_int Order /* I LPC order */
)
{
SKP_assert( Order <= length );
switch( Order ) {
case 6:
silk_LPC_analysis_filter6_FLP( r_LPC, PredCoef, s, length );
break;
case 8:
silk_LPC_analysis_filter8_FLP( r_LPC, PredCoef, s, length );
break;
case 10:
silk_LPC_analysis_filter10_FLP( r_LPC, PredCoef, s, length );
break;
case 12:
silk_LPC_analysis_filter12_FLP( r_LPC, PredCoef, s, length );
break;
case 14:
silk_LPC_analysis_filter14_FLP( r_LPC, PredCoef, s, length );
break;
case 16:
silk_LPC_analysis_filter16_FLP( r_LPC, PredCoef, s, length );
break;
default:
SKP_assert( 0 );
break;
}
/* Set first Order output samples to zero */
SKP_memset( r_LPC, 0, Order * sizeof( SKP_float ) );
}
SKP_int silk_init_encoder(
silk_encoder_state_Fxx *psEnc /* I/O Pointer to Silk encoder state */
) {
SKP_int ret = 0;
/* Clear the entire encoder state */
SKP_memset( psEnc, 0, sizeof( silk_encoder_state_Fxx ) );
psEnc->sCmn.inputBuf = &psEnc->sCmn.inputBuf__[ 2 ];
psEnc->sCmn.variable_HP_smth1_Q15 = SKP_LSHIFT( silk_lin2log( SILK_FIX_CONST( VARIABLE_HP_MIN_CUTOFF_HZ, 16 ) ) - ( 16 << 7 ), 8 );
psEnc->sCmn.variable_HP_smth2_Q15 = psEnc->sCmn.variable_HP_smth1_Q15;
/* Used to deactivate LSF interpolation, fluctuation reduction, pitch prediction */
psEnc->sCmn.first_frame_after_reset = 1;
/* Initialize Silk VAD */
ret += silk_VAD_Init( &psEnc->sCmn.sVAD );
return( ret );
}
/* Uses SMULL(), available on armv4 */
SKP_int32 SKP_Silk_schur64( /* O: Returns residual energy */
SKP_int32 rc_Q16[], /* O: Reflection coefficients [order] Q16 */
const SKP_int32 c[], /* I: Correlations [order+1] */
SKP_int32 order /* I: Prediction order */
)
{
SKP_int k, n;
SKP_int32 C[ SKP_Silk_MAX_ORDER_LPC + 1 ][ 2 ];
SKP_int32 Ctmp1_Q30, Ctmp2_Q30, rc_tmp_Q31;
/* Check for invalid input */
if( c[ 0 ] <= 0 ) {
SKP_memset( rc_Q16, 0, order * sizeof( SKP_int32 ) );
return 0;
}
for( k = 0; k < order + 1; k++ ) {
C[ k ][ 0 ] = C[ k ][ 1 ] = c[ k ];
}
for( k = 0; k < order; k++ ) {
/* Get reflection coefficient: divide two Q30 values and get result in Q31 */
rc_tmp_Q31 = SKP_DIV32_varQ( -C[ k + 1 ][ 0 ], C[ 0 ][ 1 ], 31 );
/* Save the output */
rc_Q16[ k ] = SKP_RSHIFT_ROUND( rc_tmp_Q31, 15 );
/* Update correlations */
for( n = 0; n < order - k; n++ ) {
Ctmp1_Q30 = C[ n + k + 1 ][ 0 ];
Ctmp2_Q30 = C[ n ][ 1 ];
/* Multiply and add the highest int32 */
C[ n + k + 1 ][ 0 ] = Ctmp1_Q30 + SKP_SMMUL( SKP_LSHIFT( Ctmp2_Q30, 1 ), rc_tmp_Q31 );
C[ n ][ 1 ] = Ctmp2_Q30 + SKP_SMMUL( SKP_LSHIFT( Ctmp1_Q30, 1 ), rc_tmp_Q31 );
}
}
return( C[ 0 ][ 1 ] );
}
/* Control encoder SNR */
SKP_int SKP_Silk_control_encoder_FIX(
SKP_Silk_encoder_state_FIX *psEnc, /* I/O Pointer to Silk encoder state */
const SKP_int API_fs_kHz, /* I External (API) sampling rate (kHz) */
const SKP_int PacketSize_ms, /* I Packet length (ms) */
SKP_int32 TargetRate_bps, /* I Target max bitrate (bps) (used if SNR_dB == 0) */
const SKP_int PacketLoss_perc, /* I Packet loss rate (in percent) */
const SKP_int INBandFec_enabled, /* I Enable (1) / disable (0) inband FEC */
const SKP_int DTX_enabled, /* I Enable / disable DTX */
const SKP_int InputFramesize_ms, /* I Inputframe in ms */
const SKP_int Complexity /* I Complexity (0->low; 1->medium; 2->high) */
)
{
SKP_int32 LBRRRate_thres_bps;
SKP_int k, fs_kHz, ret = 0;
SKP_int32 frac_Q6;
const SKP_int32 *rateTable;
/* State machine for the SWB/WB switching */
fs_kHz = psEnc->sCmn.fs_kHz;
/* Only switch during low speech activity, when no frames are sitting in the payload buffer */
if( API_fs_kHz == 8 || fs_kHz == 0 || API_fs_kHz < fs_kHz ) {
// Switching is not possible, encoder just initialized, or internal mode higher than external
fs_kHz = API_fs_kHz;
} else {
/* Resample all valid data in x_buf. Resampling the last part gets rid of a click, 5ms after switching */
/* this is because the same state is used when downsampling in API.c and is then up to date */
/* the click immidiatly after switching is most of the time still there */
if( psEnc->sCmn.fs_kHz == 24 ) {
/* Accumulate the difference between the target rate and limit */
if( psEnc->sCmn.fs_kHz_changed == 0 ) {
psEnc->sCmn.bitrateDiff += SKP_MUL( InputFramesize_ms, TargetRate_bps - SWB2WB_BITRATE_BPS_INITIAL );
} else {
psEnc->sCmn.bitrateDiff += SKP_MUL( InputFramesize_ms, TargetRate_bps - SWB2WB_BITRATE_BPS );
}
psEnc->sCmn.bitrateDiff = SKP_min( psEnc->sCmn.bitrateDiff, 0 );
/* Check if we should switch from 24 to 16 kHz */
#if SWITCH_TRANSITION_FILTERING
if( ( psEnc->sCmn.sLP.transition_frame_no == 0 ) && /* Transition phase not active */
( psEnc->sCmn.bitrateDiff <= -ACCUM_BITS_DIFF_THRESHOLD || psEnc->sCmn.sSWBdetect.WB_detected == 1 ) &&
( psEnc->speech_activity_Q8 < 128 && psEnc->sCmn.nFramesInPayloadBuf == 0 ) ) {
psEnc->sCmn.sLP.transition_frame_no = 1; /* Begin transition phase */
psEnc->sCmn.sLP.mode = 0; /* Switch down */
}
if( ( psEnc->sCmn.sLP.transition_frame_no >= TRANSITION_FRAMES_DOWN ) && ( psEnc->sCmn.sLP.mode == 0 ) && /* Transition phase complete, ready to switch */
#else
if( ( psEnc->sCmn.bitrateDiff <= -ACCUM_BITS_DIFF_THRESHOLD || psEnc->sCmn.sSWBdetect.WB_detected == 1 ) &&
#endif
( psEnc->speech_activity_Q8 < 128 && psEnc->sCmn.nFramesInPayloadBuf == 0 ) ) {
SKP_int16 x_buf[ 2 * MAX_FRAME_LENGTH + LA_SHAPE_MAX ];
SKP_int16 x_bufout[ 2 * MAX_FRAME_LENGTH + LA_SHAPE_MAX ];
psEnc->sCmn.bitrateDiff = 0;
fs_kHz = 16;
SKP_memcpy( x_buf, psEnc->x_buf, ( 2 * MAX_FRAME_LENGTH + LA_SHAPE_MAX ) * sizeof( SKP_int16 ) );
SKP_memset( psEnc->sCmn.resample24To16state, 0, sizeof( psEnc->sCmn.resample24To16state ) );
#if LOW_COMPLEXITY_ONLY
{
SKP_int16 scratch[ ( 2 * MAX_FRAME_LENGTH + LA_SHAPE_MAX ) + SigProc_Resample_2_3_coarse_NUM_FIR_COEFS - 1 ];
SKP_Silk_resample_2_3_coarse( &x_bufout[ 0 ], psEnc->sCmn.resample24To16state, &x_buf[ 0 ], SKP_LSHIFT( psEnc->sCmn.frame_length, 1 ) + psEnc->sCmn.la_shape, (SKP_int16*)scratch );
}
#else
SKP_Silk_resample_2_3( &x_bufout[ 0 ], psEnc->sCmn.resample24To16state, &x_buf[ 0 ], SKP_LSHIFT( psEnc->sCmn.frame_length, 1 ) + psEnc->sCmn.la_shape );
#endif
/* set the first frame to zero, no performance difference was noticed though */
SKP_memset( x_bufout, 0, 320 * sizeof( SKP_int16 ) );
SKP_memcpy( psEnc->x_buf, x_bufout, ( 2 * MAX_FRAME_LENGTH + LA_SHAPE_MAX ) * sizeof( SKP_int16 ) );
#if SWITCH_TRANSITION_FILTERING
psEnc->sCmn.sLP.transition_frame_no = 0; /* Transition phase complete */
#endif
}
} else if( psEnc->sCmn.fs_kHz == 16 ) {
/* Check if we should switch from 16 to 24 kHz */
#if SWITCH_TRANSITION_FILTERING
if( ( psEnc->sCmn.sLP.transition_frame_no == 0 ) && /* No transition phase running, ready to switch */
#else
if(
#endif
( API_fs_kHz > psEnc->sCmn.fs_kHz && TargetRate_bps >= WB2SWB_BITRATE_BPS && psEnc->sCmn.sSWBdetect.WB_detected == 0 ) &&
( psEnc->speech_activity_Q8 < 128 && psEnc->sCmn.nFramesInPayloadBuf == 0 ) ) {
SKP_int16 x_buf[ 2 * MAX_FRAME_LENGTH + LA_SHAPE_MAX ];
SKP_int16 x_bufout[ 3 * ( 2 * MAX_FRAME_LENGTH + LA_SHAPE_MAX ) / 2 ];
SKP_int32 resample16To24state[ 11 ];
psEnc->sCmn.bitrateDiff = 0;
fs_kHz = 24;
SKP_memcpy( x_buf, psEnc->x_buf, ( 2 * MAX_FRAME_LENGTH + LA_SHAPE_MAX ) * sizeof( SKP_int16 ) );
SKP_memset( resample16To24state, 0, sizeof(resample16To24state) );
SKP_Silk_resample_3_2( &x_bufout[ 0 ], resample16To24state, &x_buf[ 0 ], SKP_LSHIFT( psEnc->sCmn.frame_length, 1 ) + psEnc->sCmn.la_shape );
/* set the first frame to zero, no performance difference was noticed though */
SKP_memset( x_bufout, 0, 480 * sizeof( SKP_int16 ) );
SKP_memcpy( psEnc->x_buf, x_bufout, ( 2 * MAX_FRAME_LENGTH + LA_SHAPE_MAX ) * sizeof( SKP_int16 ) );
#if SWITCH_TRANSITION_FILTERING
psEnc->sCmn.sLP.mode = 1; /* Switch up */
#endif
} else {
/* accumulate the difference between the target rate and limit */
psEnc->sCmn.bitrateDiff += SKP_MUL( InputFramesize_ms, TargetRate_bps - WB2MB_BITRATE_BPS );
psEnc->sCmn.bitrateDiff = SKP_min( psEnc->sCmn.bitrateDiff, 0 );
/* Check if we should switch from 16 to 12 kHz */
#if SWITCH_TRANSITION_FILTERING
if( ( psEnc->sCmn.sLP.transition_frame_no == 0 ) && /* Transition phase not active */
( psEnc->sCmn.bitrateDiff <= -ACCUM_BITS_DIFF_THRESHOLD ) &&
( psEnc->speech_activity_Q8 < 128 && psEnc->sCmn.nFramesInPayloadBuf == 0 ) ) {
psEnc->sCmn.sLP.transition_frame_no = 1; /* Begin transition phase */
psEnc->sCmn.sLP.mode = 0; /* Switch down */
}
if( ( psEnc->sCmn.sLP.transition_frame_no >= TRANSITION_FRAMES_DOWN ) && ( psEnc->sCmn.sLP.mode == 0 ) && /* Transition phase complete, ready to switch */
#else
if( ( psEnc->sCmn.bitrateDiff <= -ACCUM_BITS_DIFF_THRESHOLD ) &&
#endif
( psEnc->speech_activity_Q8 < 128 && psEnc->sCmn.nFramesInPayloadBuf == 0 ) ) {
SKP_int16 x_buf[ 2 * MAX_FRAME_LENGTH + LA_SHAPE_MAX ];
SKP_memcpy( x_buf, psEnc->x_buf, ( 2 * MAX_FRAME_LENGTH + LA_SHAPE_MAX ) * sizeof( SKP_int16 ) );
psEnc->sCmn.bitrateDiff = 0;
fs_kHz = 12;
if( API_fs_kHz == 24 ) {
/* Intermediate upsampling of x_bufFIX from 16 to 24 kHz */
SKP_int16 x_buf24[ 3 * ( 2 * MAX_FRAME_LENGTH + LA_SHAPE_MAX ) / 2 ];
SKP_int32 scratch[ 3 * ( 2 * MAX_FRAME_LENGTH + LA_SHAPE_MAX ) ];
SKP_int32 resample16To24state[ 11 ];
SKP_memset( resample16To24state, 0, sizeof( resample16To24state ) );
SKP_Silk_resample_3_2( &x_buf24[ 0 ], resample16To24state, &x_buf[ 0 ], SKP_LSHIFT( psEnc->sCmn.frame_length, 1 ) + psEnc->sCmn.la_shape );
/* Update the state of the resampler used in API.c, from 24 to 12 kHz */
SKP_memset( psEnc->sCmn.resample24To12state, 0, sizeof( psEnc->sCmn.resample24To12state ) );
SKP_Silk_resample_1_2_coarse( &x_buf24[ 0 ], psEnc->sCmn.resample24To12state, &x_buf[ 0 ], scratch, SKP_RSHIFT( SKP_SMULBB( 3, SKP_LSHIFT( psEnc->sCmn.frame_length, 1 ) + psEnc->sCmn.la_shape ), 2 ) );
/* set the first frame to zero, no performance difference was noticed though */
SKP_memset( x_buf, 0, 240 * sizeof( SKP_int16 ) );
SKP_memcpy( psEnc->x_buf, x_buf, ( 2 * MAX_FRAME_LENGTH + LA_SHAPE_MAX ) * sizeof( SKP_int16 ) );
} else if( API_fs_kHz == 16 ) {
SKP_int16 x_bufout[ 3 * ( 2 * MAX_FRAME_LENGTH + LA_SHAPE_MAX ) / 4 ];
SKP_memset( psEnc->sCmn.resample16To12state, 0, sizeof( psEnc->sCmn.resample16To12state ) );
SKP_Silk_resample_3_4( &x_bufout[ 0 ], psEnc->sCmn.resample16To12state, &x_buf[ 0 ], SKP_LSHIFT( psEnc->sCmn.frame_length, 1 ) + psEnc->sCmn.la_shape );
/* set the first frame to zero, no performance difference was noticed though */
SKP_memset( x_bufout, 0, 240 * sizeof( SKP_int16 ) );
SKP_memcpy( psEnc->x_buf, x_bufout, ( 2 * MAX_FRAME_LENGTH + LA_SHAPE_MAX ) * sizeof( SKP_int16 ) );
}
#if SWITCH_TRANSITION_FILTERING
psEnc->sCmn.sLP.transition_frame_no = 0; /* Transition phase complete */
#endif
}
}
} else if( psEnc->sCmn.fs_kHz == 12 ) {
/* Find pitch lags */
void SKP_Silk_find_pitch_lags_FIX(
SKP_Silk_encoder_state_FIX *psEnc, /* I/O encoder state */
SKP_Silk_encoder_control_FIX *psEncCtrl, /* I/O encoder control */
SKP_int16 res[], /* O residual */
const SKP_int16 x[] /* I Speech signal */
)
{
SKP_Silk_predict_state_FIX *psPredSt = &psEnc->sPred;
SKP_int buf_len, i;
SKP_int32 scale;
SKP_int32 thrhld_Q15;
const SKP_int16 *x_buf, *x_buf_ptr;
SKP_int16 Wsig[ FIND_PITCH_LPC_WIN_MAX ], *Wsig_ptr;
SKP_int32 auto_corr[ FIND_PITCH_LPC_ORDER_MAX + 1 ];
SKP_int16 rc_Q15[ FIND_PITCH_LPC_ORDER_MAX ];
SKP_int32 A_Q24[ FIND_PITCH_LPC_ORDER_MAX ];
SKP_int32 FiltState[ FIND_PITCH_LPC_ORDER_MAX ];
SKP_int16 A_Q12[ FIND_PITCH_LPC_ORDER_MAX ];
/******************************************/
/* Setup buffer lengths etc based of Fs. */
/******************************************/
buf_len = SKP_ADD_LSHIFT( psEnc->sCmn.la_pitch, psEnc->sCmn.frame_length, 1 );
/* Safty check */
SKP_assert( buf_len >= psPredSt->pitch_LPC_win_length );
x_buf = x - psEnc->sCmn.frame_length;
/*************************************/
/* Estimate LPC AR coeficients */
/*************************************/
/* Calculate windowed signal */
/* First LA_LTP samples */
x_buf_ptr = x_buf + buf_len - psPredSt->pitch_LPC_win_length;
Wsig_ptr = Wsig;
SKP_Silk_apply_sine_window( Wsig_ptr, x_buf_ptr, 1, psEnc->sCmn.la_pitch );
/* Middle un - windowed samples */
Wsig_ptr += psEnc->sCmn.la_pitch;
x_buf_ptr += psEnc->sCmn.la_pitch;
SKP_memcpy( Wsig_ptr, x_buf_ptr, ( psPredSt->pitch_LPC_win_length - SKP_LSHIFT( psEnc->sCmn.la_pitch, 1 ) ) * sizeof( SKP_int16 ) );
/* Last LA_LTP samples */
Wsig_ptr += psPredSt->pitch_LPC_win_length - SKP_LSHIFT( psEnc->sCmn.la_pitch, 1 );
x_buf_ptr += psPredSt->pitch_LPC_win_length - SKP_LSHIFT( psEnc->sCmn.la_pitch, 1 );
SKP_Silk_apply_sine_window( Wsig_ptr, x_buf_ptr, 2, psEnc->sCmn.la_pitch );
/* Calculate autocorrelation sequence */
SKP_Silk_autocorr( auto_corr, &scale, Wsig, psPredSt->pitch_LPC_win_length, psEnc->sCmn.pitchEstimationLPCOrder + 1 );
/* add white noise, as fraction of energy */
auto_corr[ 0 ] = SKP_SMLAWB( auto_corr[ 0 ], auto_corr[ 0 ], FIND_PITCH_WHITE_NOISE_FRACTION_Q16 );
/* calculate the reflection coefficients using schur */
SKP_Silk_schur( rc_Q15, auto_corr, psEnc->sCmn.pitchEstimationLPCOrder );
/* convert reflection coefficients to prediction coefficients */
SKP_Silk_k2a( A_Q24, rc_Q15, psEnc->sCmn.pitchEstimationLPCOrder );
/* Convert From 32 bit Q24 to 16 bit Q12 coefs */
for( i = 0; i < psEnc->sCmn.pitchEstimationLPCOrder; i++ ) {
A_Q12[ i ] = ( SKP_int16 )SKP_SAT16( SKP_RSHIFT( A_Q24[ i ], 12 ) );
}
/* Do BWE */
SKP_Silk_bwexpander( A_Q12, psEnc->sCmn.pitchEstimationLPCOrder, FIND_PITCH_BANDWITH_EXPANSION_Q16 );
/*****************************************/
/* LPC analysis filtering */
/*****************************************/
SKP_memset( FiltState, 0, psEnc->sCmn.pitchEstimationLPCOrder * sizeof( SKP_int16 ) );
SKP_Silk_MA_Prediction( x_buf, A_Q12, FiltState, res, buf_len, psEnc->sCmn.pitchEstimationLPCOrder );
SKP_memset( res, 0, psEnc->sCmn.pitchEstimationLPCOrder * sizeof( SKP_int16 ) );
/* Threshold for pitch estimator */
thrhld_Q15 = ( 1 << 14 ); // 0.5f in Q15
thrhld_Q15 = SKP_SMLABB( thrhld_Q15, -131, psEnc->sCmn.pitchEstimationLPCOrder );
thrhld_Q15 = SKP_SMLABB( thrhld_Q15, -13, ( SKP_int16 )SKP_Silk_SQRT_APPROX( SKP_LSHIFT( ( SKP_int32 )psEnc->speech_activity_Q8, 8 ) ) );
thrhld_Q15 = SKP_SMLABB( thrhld_Q15, 4587, psEnc->sCmn.prev_sigtype );
thrhld_Q15 = SKP_MLA( thrhld_Q15, -31, SKP_RSHIFT( psEncCtrl->input_tilt_Q15, 8 ) );
thrhld_Q15 = SKP_SAT16( thrhld_Q15 );
/*****************************************/
/* Call Pitch estimator */
/*****************************************/
psEncCtrl->sCmn.sigtype = SKP_Silk_pitch_analysis_core( res, psEncCtrl->sCmn.pitchL, &psEncCtrl->sCmn.lagIndex,
&psEncCtrl->sCmn.contourIndex, &psEnc->LTPCorr_Q15, psEnc->sCmn.prevLag, psEnc->pitchEstimationThreshold_Q16,
( SKP_int16 )thrhld_Q15, psEnc->sCmn.fs_kHz, psEnc->sCmn.pitchEstimationComplexity );
}
/* Low Bitrate Redundancy (LBRR) encoding. Reuse all parameters but encode with lower bitrate */
void SKP_Silk_LBRR_encode_FLP(
SKP_Silk_encoder_state_FLP *psEnc, /* I/O Encoder state FLP */
SKP_Silk_encoder_control_FLP *psEncCtrl, /* I/O Encoder control FLP */
SKP_uint8 *pCode, /* O Payload */
SKP_int16 *pnBytesOut, /* I/O Payload bytes; in: max; out: used */
const SKP_float xfw[] /* I Input signal */
)
{
SKP_int32 Gains_Q16[ NB_SUBFR ];
SKP_int k, TempGainsIndices[ NB_SUBFR ], frame_terminator;
SKP_int nBytes, nFramesInPayloadBuf;
SKP_float TempGains[ NB_SUBFR ];
SKP_int typeOffset, LTP_scaleIndex, Rate_only_parameters = 0;
/* Control use of inband LBRR */
SKP_Silk_LBRR_ctrl_FLP( psEnc, &psEncCtrl->sCmn );
if( psEnc->sCmn.LBRR_enabled ) {
/* Save original gains */
SKP_memcpy( TempGainsIndices, psEncCtrl->sCmn.GainsIndices, NB_SUBFR * sizeof( SKP_int ) );
SKP_memcpy( TempGains, psEncCtrl->Gains, NB_SUBFR * sizeof( SKP_float ) );
typeOffset = psEnc->sCmn.typeOffsetPrev; // Temp save as cannot be overwritten
LTP_scaleIndex = psEncCtrl->sCmn.LTP_scaleIndex;
/* Set max rate where quant signal is encoded */
if( psEnc->sCmn.fs_kHz == 8 ) {
Rate_only_parameters = 13500;
} else if( psEnc->sCmn.fs_kHz == 12 ) {
Rate_only_parameters = 15500;
} else if( psEnc->sCmn.fs_kHz == 16 ) {
Rate_only_parameters = 17500;
} else if( psEnc->sCmn.fs_kHz == 24 ) {
Rate_only_parameters = 19500;
} else {
SKP_assert( 0 );
}
if( psEnc->sCmn.Complexity > 0 && psEnc->sCmn.TargetRate_bps > Rate_only_parameters ) {
if( psEnc->sCmn.nFramesInPayloadBuf == 0 ) {
/* First frame in packet copy everything */
SKP_memcpy( &psEnc->sCmn.sNSQ_LBRR, &psEnc->sCmn.sNSQ, sizeof( SKP_Silk_nsq_state ) );
psEnc->sCmn.LBRRprevLastGainIndex = psEnc->sShape.LastGainIndex;
/* Increase Gains to get target LBRR rate */
psEncCtrl->sCmn.GainsIndices[ 0 ] += psEnc->sCmn.LBRR_GainIncreases;
psEncCtrl->sCmn.GainsIndices[ 0 ] = SKP_LIMIT_int( psEncCtrl->sCmn.GainsIndices[ 0 ], 0, N_LEVELS_QGAIN - 1 );
}
/* Decode to get gains in sync with decoder */
SKP_Silk_gains_dequant( Gains_Q16, psEncCtrl->sCmn.GainsIndices,
&psEnc->sCmn.LBRRprevLastGainIndex, psEnc->sCmn.nFramesInPayloadBuf );
/* Overwrite unquantized gains with quantized gains and convert back to Q0 from Q16 */
for( k = 0; k < NB_SUBFR; k++ ) {
psEncCtrl->Gains[ k ] = Gains_Q16[ k ] / 65536.0f;
}
/*****************************************/
/* Noise shaping quantization */
/*****************************************/
SKP_Silk_NSQ_wrapper_FLP( psEnc, psEncCtrl, xfw, psEnc->sCmn.q_LBRR, 1 );
} else {
SKP_memset( psEnc->sCmn.q_LBRR, 0, psEnc->sCmn.frame_length * sizeof( SKP_int8 ) );
psEncCtrl->sCmn.LTP_scaleIndex = 0;
}
/****************************************/
/* Initialize arithmetic coder */
/****************************************/
if( psEnc->sCmn.nFramesInPayloadBuf == 0 ) {
SKP_Silk_range_enc_init( &psEnc->sCmn.sRC_LBRR );
psEnc->sCmn.nBytesInPayloadBuf = 0;
}
/****************************************/
/* Encode Parameters */
/****************************************/
SKP_Silk_encode_parameters( &psEnc->sCmn, &psEncCtrl->sCmn, &psEnc->sCmn.sRC_LBRR, psEnc->sCmn.q_LBRR );
if( psEnc->sCmn.sRC_LBRR.error ) {
/* Encoder returned error: Clear payload buffer */
nFramesInPayloadBuf = 0;
} else {
nFramesInPayloadBuf = psEnc->sCmn.nFramesInPayloadBuf + 1;
}
/****************************************/
/* Finalize payload and copy to output */
/****************************************/
if( nFramesInPayloadBuf * FRAME_LENGTH_MS >= psEnc->sCmn.PacketSize_ms ) {
/* Check if FEC information should be added */
frame_terminator = SKP_SILK_LAST_FRAME;
/* Add the frame termination info to stream */
SKP_Silk_range_encoder( &psEnc->sCmn.sRC_LBRR, frame_terminator, SKP_Silk_FrameTermination_CDF );
/* Payload length so far */
SKP_Silk_range_coder_get_length( &psEnc->sCmn.sRC_LBRR, &nBytes );
/* Check that there is enough space in external output buffer and move data */
if( *pnBytesOut >= nBytes ) {
SKP_Silk_range_enc_wrap_up( &psEnc->sCmn.sRC_LBRR );
SKP_memcpy( pCode, psEnc->sCmn.sRC_LBRR.buffer, nBytes * sizeof( SKP_uint8 ) );
*pnBytesOut = nBytes;
} else {
/* Not enough space: Payload will be discarded */
*pnBytesOut = 0;
SKP_assert( 0 );
}
} else {
/* No payload this time */
*pnBytesOut = 0;
/* Encode that more frames follows */
frame_terminator = SKP_SILK_MORE_FRAMES;
SKP_Silk_range_encoder( &psEnc->sCmn.sRC_LBRR, frame_terminator, SKP_Silk_FrameTermination_CDF );
}
/* Restore original Gains */
SKP_memcpy( psEncCtrl->sCmn.GainsIndices, TempGainsIndices, NB_SUBFR * sizeof( SKP_int ) );
SKP_memcpy( psEncCtrl->Gains, TempGains, NB_SUBFR * sizeof( SKP_float ) );
/* Restore LTP scale index and typeoffset */
psEncCtrl->sCmn.LTP_scaleIndex = LTP_scaleIndex;
psEnc->sCmn.typeOffsetPrev = typeOffset;
}
}
/* Low BitRate Redundancy encoding functionality. Reuse all parameters but encode residual with lower bitrate */
void SKP_Silk_LBRR_encode_FIX(SKP_Silk_encoder_state_FIX * psEnc, /* I/O Pointer to Silk encoder state */
SKP_Silk_encoder_control_FIX * psEncCtrl, /* I/O Pointer to Silk encoder control struct */
uint8_t * pCode, /* O Pointer to payload */
int16_t * pnBytesOut, /* I/O Pointer to number of payload bytes */
int16_t xfw[] /* I Input signal */
)
{
int i, TempGainsIndices[NB_SUBFR], frame_terminator;
int nBytes, nFramesInPayloadBuf;
int32_t TempGains_Q16[NB_SUBFR];
int typeOffset, LTP_scaleIndex, Rate_only_parameters = 0;
/*******************************************/
/* Control use of inband LBRR */
/*******************************************/
SKP_Silk_LBRR_ctrl_FIX(psEnc, psEncCtrl);
if (psEnc->sCmn.LBRR_enabled) {
/* Save original Gains */
SKP_memcpy(TempGainsIndices, psEncCtrl->sCmn.GainsIndices,
NB_SUBFR * sizeof(int));
SKP_memcpy(TempGains_Q16, psEncCtrl->Gains_Q16,
NB_SUBFR * sizeof(int32_t));
typeOffset = psEnc->sCmn.typeOffsetPrev; // Temp save as cannot be overwritten
LTP_scaleIndex = psEncCtrl->sCmn.LTP_scaleIndex;
/* Set max rate where quant signal is encoded */
if (psEnc->sCmn.fs_kHz == 8) {
Rate_only_parameters = 13500;
} else if (psEnc->sCmn.fs_kHz == 12) {
Rate_only_parameters = 15500;
} else if (psEnc->sCmn.fs_kHz == 16) {
Rate_only_parameters = 17500;
} else if (psEnc->sCmn.fs_kHz == 24) {
Rate_only_parameters = 19500;
} else {
assert(0);
}
if (psEnc->sCmn.Complexity > 0
&& psEnc->sCmn.TargetRate_bps > Rate_only_parameters) {
if (psEnc->sCmn.nFramesInPayloadBuf == 0) {
/* First frame in packet copy Everything */
SKP_memcpy(&psEnc->sNSQ_LBRR, &psEnc->sNSQ,
sizeof(SKP_Silk_nsq_state));
psEnc->sCmn.LBRRprevLastGainIndex =
psEnc->sShape.LastGainIndex;
/* Increase Gains to get target LBRR rate */
psEncCtrl->sCmn.GainsIndices[0] =
psEncCtrl->sCmn.GainsIndices[0] +
psEnc->sCmn.LBRR_GainIncreases;
psEncCtrl->sCmn.GainsIndices[0] =
SKP_LIMIT(psEncCtrl->sCmn.GainsIndices[0],
0, N_LEVELS_QGAIN - 1);
}
/* Decode to get Gains in sync with decoder */
/* Overwrite unquantized gains with quantized gains */
SKP_Silk_gains_dequant(psEncCtrl->Gains_Q16,
psEncCtrl->sCmn.GainsIndices,
&psEnc->sCmn.
LBRRprevLastGainIndex,
psEnc->sCmn.nFramesInPayloadBuf);
/*****************************************/
/* Noise shaping quantization */
/*****************************************/
psEnc->NoiseShapingQuantizer(&psEnc->sCmn,
&psEncCtrl->sCmn,
&psEnc->sNSQ_LBRR, xfw,
&psEnc->sCmn.q_LBRR[psEnc->
sCmn.
nFramesInPayloadBuf
*
psEnc->
sCmn.
frame_length],
psEncCtrl->sCmn.
NLSFInterpCoef_Q2,
psEncCtrl->PredCoef_Q12[0],
psEncCtrl->LTPCoef_Q14,
psEncCtrl->AR2_Q13,
psEncCtrl->
HarmShapeGain_Q14,
psEncCtrl->Tilt_Q14,
psEncCtrl->LF_shp_Q14,
psEncCtrl->Gains_Q16,
psEncCtrl->Lambda_Q10,
psEncCtrl->LTP_scale_Q14);
} else {
SKP_memset(&psEnc->sCmn.
q_LBRR[psEnc->sCmn.nFramesInPayloadBuf *
psEnc->sCmn.frame_length], 0,
psEnc->sCmn.frame_length * sizeof(int));
psEncCtrl->sCmn.LTP_scaleIndex = 0;
}
/****************************************/
/* Initialize arithmetic coder */
/****************************************/
if (psEnc->sCmn.nFramesInPayloadBuf == 0) {
SKP_Silk_range_enc_init(&psEnc->sCmn.sRC_LBRR);
psEnc->sCmn.nBytesInPayloadBuf = 0;
}
/****************************************/
/* Encode Parameters */
/****************************************/
if (psEnc->sCmn.bitstream_v == BIT_STREAM_V4) {
SKP_Silk_encode_parameters_v4(&psEnc->sCmn,
&psEncCtrl->sCmn,
&psEnc->sCmn.sRC_LBRR);
} else {
SKP_Silk_encode_parameters(&psEnc->sCmn,
&psEncCtrl->sCmn,
&psEnc->sCmn.sRC_LBRR,
&psEnc->sCmn.q_LBRR[psEnc->
sCmn.
nFramesInPayloadBuf
*
psEnc->
sCmn.
frame_length]);
}
if (psEnc->sCmn.sRC_LBRR.error) {
/* encoder returned error: clear payload buffer */
nFramesInPayloadBuf = 0;
} else {
nFramesInPayloadBuf =
psEnc->sCmn.nFramesInPayloadBuf + 1;
}
/****************************************/
/* finalize payload and copy to output */
/****************************************/
if (SKP_SMULBB(nFramesInPayloadBuf, FRAME_LENGTH_MS) >=
psEnc->sCmn.PacketSize_ms) {
/* Check if FEC information should be added */
frame_terminator = SKP_SILK_LAST_FRAME;
/* Add the frame termination info to stream */
SKP_Silk_range_encoder(&psEnc->sCmn.sRC_LBRR,
frame_terminator,
SKP_Silk_FrameTermination_CDF);
if (psEnc->sCmn.bitstream_v == BIT_STREAM_V4) {
/*********************************************/
/* Encode quantization indices of excitation */
/*********************************************/
for (i = 0; i < nFramesInPayloadBuf; i++) {
SKP_Silk_encode_pulses(&psEnc->sCmn.
sRC_LBRR,
psEnc->sCmn.
sigtype[i],
psEnc->sCmn.
QuantOffsetType
[i],
&psEnc->sCmn.
q_LBRR[i *
psEnc->
sCmn.
frame_length],
psEnc->sCmn.
frame_length);
}
}
/* payload length so far */
SKP_Silk_range_coder_get_length(&psEnc->sCmn.sRC_LBRR,
&nBytes);
/* check that there is enough space in external output buffer, and move data */
if (*pnBytesOut >= nBytes) {
SKP_Silk_range_enc_wrap_up(&psEnc->sCmn.
sRC_LBRR);
SKP_memcpy(pCode, psEnc->sCmn.sRC_LBRR.buffer,
nBytes * sizeof(uint8_t));
*pnBytesOut = nBytes;
} else {
/* not enough space: payload will be discarded */
*pnBytesOut = 0;
assert(0);
}
} else {
/* no payload for you this time */
*pnBytesOut = 0;
/* Encode that more frames follows */
frame_terminator = SKP_SILK_MORE_FRAMES;
SKP_Silk_range_encoder(&psEnc->sCmn.sRC_LBRR,
frame_terminator,
SKP_Silk_FrameTermination_CDF);
}
/* Restore original Gains */
SKP_memcpy(psEncCtrl->sCmn.GainsIndices, TempGainsIndices,
NB_SUBFR * sizeof(int));
SKP_memcpy(psEncCtrl->Gains_Q16, TempGains_Q16,
NB_SUBFR * sizeof(int32_t));
/* Restore LTP scale index and typeoffset */
psEncCtrl->sCmn.LTP_scaleIndex = LTP_scaleIndex;
psEnc->sCmn.typeOffsetPrev = typeOffset;
}
}
/* Decode parameters from payload */
void silk_decode_parameters(
silk_decoder_state *psDec, /* I/O State */
silk_decoder_control *psDecCtrl /* I/O Decoder control */
)
{
SKP_int i, k, Ix;
SKP_int16 pNLSF_Q15[ MAX_LPC_ORDER ], pNLSF0_Q15[ MAX_LPC_ORDER ];
const SKP_int8 *cbk_ptr_Q7;
/* Dequant Gains */
silk_gains_dequant( psDecCtrl->Gains_Q16, psDec->indices.GainsIndices,
&psDec->LastGainIndex, psDec->nFramesDecoded, psDec->nb_subfr );
/****************/
/* Decode NLSFs */
/****************/
silk_NLSF_decode( pNLSF_Q15, psDec->indices.NLSFIndices, psDec->psNLSF_CB );
/* Convert NLSF parameters to AR prediction filter coefficients */
silk_NLSF2A_stable( psDecCtrl->PredCoef_Q12[ 1 ], pNLSF_Q15, psDec->LPC_order );
/* If just reset, e.g., because internal Fs changed, do not allow interpolation */
/* improves the case of packet loss in the first frame after a switch */
if( psDec->first_frame_after_reset == 1 ) {
psDec->indices.NLSFInterpCoef_Q2 = 4;
}
if( psDec->indices.NLSFInterpCoef_Q2 < 4 ) {
/* Calculation of the interpolated NLSF0 vector from the interpolation factor, */
/* the previous NLSF1, and the current NLSF1 */
for( i = 0; i < psDec->LPC_order; i++ ) {
pNLSF0_Q15[ i ] = psDec->prevNLSF_Q15[ i ] + SKP_RSHIFT( SKP_MUL( psDec->indices.NLSFInterpCoef_Q2,
pNLSF_Q15[ i ] - psDec->prevNLSF_Q15[ i ] ), 2 );
}
/* Convert NLSF parameters to AR prediction filter coefficients */
silk_NLSF2A_stable( psDecCtrl->PredCoef_Q12[ 0 ], pNLSF0_Q15, psDec->LPC_order );
} else {
/* Copy LPC coefficients for first half from second half */
SKP_memcpy( psDecCtrl->PredCoef_Q12[ 0 ], psDecCtrl->PredCoef_Q12[ 1 ],
psDec->LPC_order * sizeof( SKP_int16 ) );
}
SKP_memcpy( psDec->prevNLSF_Q15, pNLSF_Q15, psDec->LPC_order * sizeof( SKP_int16 ) );
/* After a packet loss do BWE of LPC coefs */
if( psDec->lossCnt ) {
silk_bwexpander( psDecCtrl->PredCoef_Q12[ 0 ], psDec->LPC_order, BWE_AFTER_LOSS_Q16 );
silk_bwexpander( psDecCtrl->PredCoef_Q12[ 1 ], psDec->LPC_order, BWE_AFTER_LOSS_Q16 );
}
if( psDec->indices.signalType == TYPE_VOICED ) {
/*********************/
/* Decode pitch lags */
/*********************/
/* Decode pitch values */
silk_decode_pitch( psDec->indices.lagIndex, psDec->indices.contourIndex, psDecCtrl->pitchL, psDec->fs_kHz, psDec->nb_subfr );
/* Decode Codebook Index */
cbk_ptr_Q7 = silk_LTP_vq_ptrs_Q7[ psDec->indices.PERIndex ]; /* set pointer to start of codebook */
for( k = 0; k < psDec->nb_subfr; k++ ) {
Ix = psDec->indices.LTPIndex[ k ];
for( i = 0; i < LTP_ORDER; i++ ) {
psDecCtrl->LTPCoef_Q14[ k * LTP_ORDER + i ] = SKP_LSHIFT( cbk_ptr_Q7[ Ix * LTP_ORDER + i ], 7 );
}
}
/**********************/
/* Decode LTP scaling */
/**********************/
Ix = psDec->indices.LTP_scaleIndex;
psDecCtrl->LTP_scale_Q14 = silk_LTPScales_table_Q14[ Ix ];
} else {
SKP_memset( psDecCtrl->pitchL, 0, psDec->nb_subfr * sizeof( SKP_int ) );
SKP_memset( psDecCtrl->LTPCoef_Q14, 0, LTP_ORDER * psDec->nb_subfr * sizeof( SKP_int16 ) );
psDec->indices.PERIndex = 0;
psDecCtrl->LTP_scale_Q14 = 0;
}
}
/* Find pitch lags */
void SKP_Silk_find_pitch_lags_FIX(
SKP_Silk_encoder_state_FIX *psEnc, /* I/O encoder state */
SKP_Silk_encoder_control_FIX *psEncCtrl, /* I/O encoder control */
SKP_int16 res[], /* O residual */
const SKP_int16 x[] /* I Speech signal */
)
{
SKP_Silk_predict_state_FIX *psPredSt = &psEnc->sPred;
SKP_int buf_len, i, scale;
SKP_int32 thrhld_Q15, res_nrg;
const SKP_int16 *x_buf, *x_buf_ptr;
SKP_int16 Wsig[ FIND_PITCH_LPC_WIN_MAX ], *Wsig_ptr;
SKP_int32 auto_corr[ MAX_FIND_PITCH_LPC_ORDER + 1 ];
SKP_int16 rc_Q15[ MAX_FIND_PITCH_LPC_ORDER ];
SKP_int32 A_Q24[ MAX_FIND_PITCH_LPC_ORDER ];
SKP_int32 FiltState[ MAX_FIND_PITCH_LPC_ORDER ];
SKP_int16 A_Q12[ MAX_FIND_PITCH_LPC_ORDER ];
/******************************************/
/* Setup buffer lengths etc based on Fs */
/******************************************/
buf_len = SKP_ADD_LSHIFT( psEnc->sCmn.la_pitch, psEnc->sCmn.frame_length, 1 );
/* Safty check */
SKP_assert( buf_len >= psPredSt->pitch_LPC_win_length );
x_buf = x - psEnc->sCmn.frame_length;
/*************************************/
/* Estimate LPC AR coefficients */
/*************************************/
/* Calculate windowed signal */
/* First LA_LTP samples */
x_buf_ptr = x_buf + buf_len - psPredSt->pitch_LPC_win_length;
Wsig_ptr = Wsig;
SKP_Silk_apply_sine_window_new( Wsig_ptr, x_buf_ptr, 1, psEnc->sCmn.la_pitch );
/* Middle un - windowed samples */
Wsig_ptr += psEnc->sCmn.la_pitch;
x_buf_ptr += psEnc->sCmn.la_pitch;
SKP_memcpy( Wsig_ptr, x_buf_ptr, ( psPredSt->pitch_LPC_win_length - SKP_LSHIFT( psEnc->sCmn.la_pitch, 1 ) ) * sizeof( SKP_int16 ) );
/* Last LA_LTP samples */
Wsig_ptr += psPredSt->pitch_LPC_win_length - SKP_LSHIFT( psEnc->sCmn.la_pitch, 1 );
x_buf_ptr += psPredSt->pitch_LPC_win_length - SKP_LSHIFT( psEnc->sCmn.la_pitch, 1 );
SKP_Silk_apply_sine_window_new( Wsig_ptr, x_buf_ptr, 2, psEnc->sCmn.la_pitch );
/* Calculate autocorrelation sequence */
SKP_Silk_autocorr( auto_corr, &scale, Wsig, psPredSt->pitch_LPC_win_length, psEnc->sCmn.pitchEstimationLPCOrder + 1 );
/* Add white noise, as fraction of energy */
auto_corr[ 0 ] = SKP_SMLAWB( auto_corr[ 0 ], auto_corr[ 0 ], SKP_FIX_CONST( FIND_PITCH_WHITE_NOISE_FRACTION, 16 ) );
/* Calculate the reflection coefficients using schur */
res_nrg = SKP_Silk_schur( rc_Q15, auto_corr, psEnc->sCmn.pitchEstimationLPCOrder );
/* Prediction gain */
psEncCtrl->predGain_Q16 = SKP_DIV32_varQ( auto_corr[ 0 ], SKP_max_int( res_nrg, 1 ), 16 );
/* Convert reflection coefficients to prediction coefficients */
SKP_Silk_k2a( A_Q24, rc_Q15, psEnc->sCmn.pitchEstimationLPCOrder );
/* Convert From 32 bit Q24 to 16 bit Q12 coefs */
for( i = 0; i < psEnc->sCmn.pitchEstimationLPCOrder; i++ ) {
A_Q12[ i ] = ( SKP_int16 )SKP_SAT16( SKP_RSHIFT( A_Q24[ i ], 12 ) );
}
/* Do BWE */
SKP_Silk_bwexpander( A_Q12, psEnc->sCmn.pitchEstimationLPCOrder, SKP_FIX_CONST( FIND_PITCH_BANDWITH_EXPANSION, 16 ) );
/*****************************************/
/* LPC analysis filtering */
/*****************************************/
SKP_memset( FiltState, 0, psEnc->sCmn.pitchEstimationLPCOrder * sizeof( SKP_int32 ) ); /* Not really necessary, but Valgrind will complain otherwise */
SKP_Silk_MA_Prediction( x_buf, A_Q12, FiltState, res, buf_len, psEnc->sCmn.pitchEstimationLPCOrder );
SKP_memset( res, 0, psEnc->sCmn.pitchEstimationLPCOrder * sizeof( SKP_int16 ) );
/* Threshold for pitch estimator */
thrhld_Q15 = SKP_FIX_CONST( 0.45, 15 );
thrhld_Q15 = SKP_SMLABB( thrhld_Q15, SKP_FIX_CONST( -0.004, 15 ), psEnc->sCmn.pitchEstimationLPCOrder );
thrhld_Q15 = SKP_SMLABB( thrhld_Q15, SKP_FIX_CONST( -0.1, 7 ), psEnc->speech_activity_Q8 );
thrhld_Q15 = SKP_SMLABB( thrhld_Q15, SKP_FIX_CONST( 0.15, 15 ), psEnc->sCmn.prev_sigtype );
thrhld_Q15 = SKP_SMLAWB( thrhld_Q15, SKP_FIX_CONST( -0.1, 16 ), psEncCtrl->input_tilt_Q15 );
thrhld_Q15 = SKP_SAT16( thrhld_Q15 );
/*****************************************/
/* Call pitch estimator */
/*****************************************/
psEncCtrl->sCmn.sigtype = SKP_Silk_pitch_analysis_core( res, psEncCtrl->sCmn.pitchL, &psEncCtrl->sCmn.lagIndex,
&psEncCtrl->sCmn.contourIndex, &psEnc->LTPCorr_Q15, psEnc->sCmn.prevLag, psEnc->sCmn.pitchEstimationThreshold_Q16,
( SKP_int16 )thrhld_Q15, psEnc->sCmn.fs_kHz, psEnc->sCmn.pitchEstimationComplexity, SKP_FALSE );
}
/* Control internal sampling rate */
SKP_int SKP_Silk_control_audio_bandwidth(
SKP_Silk_encoder_state *psEncC, /* I/O Pointer to Silk encoder state */
SKP_int32 TargetRate_bps /* I Target max bitrate (bps) */
)
{
SKP_int fs_kHz;
fs_kHz = psEncC->fs_kHz;
/* Reduce bitrate for 10 ms modes in these calculations */
if( psEncC->nb_subfr == 2 ) {
TargetRate_bps -= REDUCE_BITRATE_10_MS_BPS;
}
if( fs_kHz == 0 ) {
/* Encoder has just been initialized */
if( TargetRate_bps >= WB2MB_BITRATE_BPS ) {
fs_kHz = 16;
} else if( TargetRate_bps >= MB2NB_BITRATE_BPS ) {
fs_kHz = 12;
} else {
fs_kHz = 8;
}
/* Make sure internal rate is not higher than external rate or maximum allowed, or lower than minimum allowed */
fs_kHz = SKP_min( fs_kHz, SKP_DIV32_16( psEncC->API_fs_Hz, 1000 ) );
fs_kHz = SKP_min( fs_kHz, psEncC->maxInternal_fs_kHz );
fs_kHz = SKP_max( fs_kHz, psEncC->minInternal_fs_kHz );
} else if( SKP_SMULBB( fs_kHz, 1000 ) > psEncC->API_fs_Hz || fs_kHz > psEncC->maxInternal_fs_kHz || fs_kHz < psEncC->minInternal_fs_kHz ) {
/* Make sure internal rate is not higher than external rate or maximum allowed, or lower than minimum allowed */
fs_kHz = SKP_DIV32_16( psEncC->API_fs_Hz, 1000 );
fs_kHz = SKP_min( fs_kHz, psEncC->maxInternal_fs_kHz );
fs_kHz = SKP_max( fs_kHz, psEncC->minInternal_fs_kHz );
} else {
/* State machine for the internal sampling rate switching */
if( psEncC->API_fs_Hz > 8000 && psEncC->prevSignalType == TYPE_NO_VOICE_ACTIVITY ) { /* Low speech activity */
/* Check if we should switch down */
if( ( psEncC->fs_kHz == 12 && TargetRate_bps < MB2NB_BITRATE_BPS && psEncC->minInternal_fs_kHz <= 8 ) ||
( psEncC->fs_kHz == 16 && TargetRate_bps < WB2MB_BITRATE_BPS && psEncC->minInternal_fs_kHz <= 12 ) )
{
/* Switch down */
if( SWITCH_TRANSITION_FILTERING && psEncC->sLP.mode == 0 ) {
/* New transition */
psEncC->sLP.transition_frame_no = TRANSITION_FRAMES;
/* Reset transition filter state */
SKP_memset( psEncC->sLP.In_LP_State, 0, sizeof( psEncC->sLP.In_LP_State ) );
}
if( psEncC->sLP.transition_frame_no <= 0 ) {
/* Stop transition phase */
psEncC->sLP.mode = 0;
/* Switch to a lower sample frequency */
fs_kHz = psEncC->fs_kHz == 16 ? 12 : 8;
} else {
/* Direction: down (at double speed) */
psEncC->sLP.mode = -2;
}
}
else
if( ( psEncC->fs_kHz == 8 && TargetRate_bps > NB2MB_BITRATE_BPS && psEncC->maxInternal_fs_kHz >= 12 && psEncC->API_fs_Hz >= 12000 ) ||
( psEncC->fs_kHz == 12 && TargetRate_bps > MB2WB_BITRATE_BPS && psEncC->maxInternal_fs_kHz >= 16 && psEncC->API_fs_Hz >= 16000 ) )
{
/* Switch up */
if( SWITCH_TRANSITION_FILTERING && psEncC->sLP.mode == 0 ) {
/* Switch to a higher sample frequency */
fs_kHz = psEncC->fs_kHz == 8 ? 12 : 16;
/* New transition */
psEncC->sLP.transition_frame_no = 0;
}
if( psEncC->sLP.transition_frame_no >= TRANSITION_FRAMES ) {
/* Stop transition phase */
psEncC->sLP.mode = 0;
} else {
/* Direction: up */
psEncC->sLP.mode = 1;
}
}
}
}
#ifdef FORCE_INTERNAL_FS_KHZ
fs_kHz = FORCE_INTERNAL_FS_KHZ;
#endif
return fs_kHz;
}
/* Updates CNG estimate, and applies the CNG when packet was lost */
void SKP_Silk_CNG(
SKP_Silk_decoder_state *psDec, /* I/O Decoder state */
SKP_Silk_decoder_control *psDecCtrl, /* I/O Decoder control */
SKP_int16 signal[], /* I/O Signal */
SKP_int length /* I Length of residual */
)
{
SKP_int i, subfr;
SKP_int32 tmp_32, Gain_Q26, max_Gain_Q16;
SKP_int16 LPC_buf[ MAX_LPC_ORDER ];
SKP_int16 CNG_sig[ MAX_FRAME_LENGTH ];
SKP_Silk_CNG_struct *psCNG;
psCNG = &psDec->sCNG;
if( psDec->fs_kHz != psCNG->fs_kHz ) {
/* Reset state */
SKP_Silk_CNG_Reset( psDec );
psCNG->fs_kHz = psDec->fs_kHz;
}
if( psDec->lossCnt == 0 && psDec->vadFlag == NO_VOICE_ACTIVITY ) {
/* Update CNG parameters */
/* Smoothing of LSF's */
for( i = 0; i < psDec->LPC_order; i++ ) {
psCNG->CNG_smth_NLSF_Q15[ i ] += SKP_SMULWB( psDec->prevNLSF_Q15[ i ] - psCNG->CNG_smth_NLSF_Q15[ i ], CNG_NLSF_SMTH_Q16 );
}
/* Find the subframe with the highest gain */
max_Gain_Q16 = 0;
subfr = 0;
for( i = 0; i < NB_SUBFR; i++ ) {
if( psDecCtrl->Gains_Q16[ i ] > max_Gain_Q16 ) {
max_Gain_Q16 = psDecCtrl->Gains_Q16[ i ];
subfr = i;
}
}
/* Update CNG excitation buffer with excitation from this subframe */
SKP_memmove( &psCNG->CNG_exc_buf_Q10[ psDec->subfr_length ], psCNG->CNG_exc_buf_Q10, ( NB_SUBFR - 1 ) * psDec->subfr_length * sizeof( SKP_int32 ) );
SKP_memcpy( psCNG->CNG_exc_buf_Q10, &psDec->exc_Q10[ subfr * psDec->subfr_length ], psDec->subfr_length * sizeof( SKP_int32 ) );
/* Smooth gains */
for( i = 0; i < NB_SUBFR; i++ ) {
psCNG->CNG_smth_Gain_Q16 += SKP_SMULWB( psDecCtrl->Gains_Q16[ i ] - psCNG->CNG_smth_Gain_Q16, CNG_GAIN_SMTH_Q16 );
}
}
/* Add CNG when packet is lost and / or when low speech activity */
if( psDec->lossCnt ) {//|| psDec->vadFlag == NO_VOICE_ACTIVITY ) {
/* Generate CNG excitation */
SKP_Silk_CNG_exc( CNG_sig, psCNG->CNG_exc_buf_Q10,
psCNG->CNG_smth_Gain_Q16, length, &psCNG->rand_seed );
/* Convert CNG NLSF to filter representation */
SKP_Silk_NLSF2A_stable( LPC_buf, psCNG->CNG_smth_NLSF_Q15, psDec->LPC_order );
Gain_Q26 = ( SKP_int32 )1 << 26; /* 1.0 */
/* Generate CNG signal, by synthesis filtering */
if( psDec->LPC_order == 16 ) {
SKP_Silk_LPC_synthesis_order16( CNG_sig, LPC_buf,
Gain_Q26, psCNG->CNG_synth_state, CNG_sig, length );
} else {
SKP_Silk_LPC_synthesis_filter( CNG_sig, LPC_buf,
Gain_Q26, psCNG->CNG_synth_state, CNG_sig, length, psDec->LPC_order );
}
/* Mix with signal */
for( i = 0; i < length; i++ ) {
tmp_32 = signal[ i ] + CNG_sig[ i ];
signal[ i ] = SKP_SAT16( tmp_32 );
}
} else {
SKP_memset( psCNG->CNG_synth_state, 0, psDec->LPC_order * sizeof( SKP_int32 ) );
}
}
/* Finds LPC vector from correlations, and converts to NLSF */
void SKP_Silk_find_LPC_FIX(
SKP_int NLSF_Q15[], /* O NLSFs */
SKP_int *interpIndex, /* O NLSF interpolation index, only used for NLSF interpolation */
const SKP_int prev_NLSFq_Q15[], /* I previous NLSFs, only used for NLSF interpolation */
const SKP_int useInterpolatedNLSFs, /* I Flag */
const SKP_int LPC_order, /* I LPC order */
const SKP_int16 x[], /* I Input signal */
const SKP_int subfr_length /* I Input signal subframe length including preceeding samples */
)
{
SKP_int k;
SKP_int32 a_Q16[ MAX_LPC_ORDER ];
SKP_int isInterpLower, shift;
SKP_int16 S[ MAX_LPC_ORDER ];
SKP_int32 res_nrg0, res_nrg1;
SKP_int rshift0, rshift1;
/* Used only for LSF interpolation */
SKP_int32 a_tmp_Q16[ MAX_LPC_ORDER ], res_nrg_interp, res_nrg, res_tmp_nrg;
SKP_int res_nrg_interp_Q, res_nrg_Q, res_tmp_nrg_Q;
SKP_int16 a_tmp_Q12[ MAX_LPC_ORDER ];
SKP_int NLSF0_Q15[ MAX_LPC_ORDER ];
SKP_int16 LPC_res[ ( MAX_FRAME_LENGTH + NB_SUBFR * MAX_LPC_ORDER ) / 2 ];
/* Default: no interpolation */
*interpIndex = 4;
/* Burg AR analysis for the full frame */
SKP_Silk_burg_modified( &res_nrg, &res_nrg_Q, a_Q16, x, subfr_length, NB_SUBFR, SKP_FIX_CONST( FIND_LPC_COND_FAC, 32 ), LPC_order );
SKP_Silk_bwexpander_32( a_Q16, LPC_order, SKP_FIX_CONST( FIND_LPC_CHIRP, 16 ) );
if( useInterpolatedNLSFs == 1 ) {
/* Optimal solution for last 10 ms */
SKP_Silk_burg_modified( &res_tmp_nrg, &res_tmp_nrg_Q, a_tmp_Q16, x + ( NB_SUBFR >> 1 ) * subfr_length,
subfr_length, ( NB_SUBFR >> 1 ), SKP_FIX_CONST( FIND_LPC_COND_FAC, 32 ), LPC_order );
SKP_Silk_bwexpander_32( a_tmp_Q16, LPC_order, SKP_FIX_CONST( FIND_LPC_CHIRP, 16 ) );
/* subtract residual energy here, as that's easier than adding it to the */
/* residual energy of the first 10 ms in each iteration of the search below */
shift = res_tmp_nrg_Q - res_nrg_Q;
if( shift >= 0 ) {
if( shift < 32 ) {
res_nrg = res_nrg - SKP_RSHIFT( res_tmp_nrg, shift );
}
} else {
SKP_assert( shift > -32 );
res_nrg = SKP_RSHIFT( res_nrg, -shift ) - res_tmp_nrg;
res_nrg_Q = res_tmp_nrg_Q;
}
/* Convert to NLSFs */
SKP_Silk_A2NLSF( NLSF_Q15, a_tmp_Q16, LPC_order );
/* Search over interpolation indices to find the one with lowest residual energy */
for( k = 3; k >= 0; k-- ) {
/* Interpolate NLSFs for first half */
SKP_Silk_interpolate( NLSF0_Q15, prev_NLSFq_Q15, NLSF_Q15, k, LPC_order );
/* Convert to LPC for residual energy evaluation */
SKP_Silk_NLSF2A_stable( a_tmp_Q12, NLSF0_Q15, LPC_order );
/* Calculate residual energy with NLSF interpolation */
SKP_memset( S, 0, LPC_order * sizeof( SKP_int16 ) );
SKP_Silk_LPC_analysis_filter( x, a_tmp_Q12, S, LPC_res, 2 * subfr_length, LPC_order );
SKP_Silk_sum_sqr_shift( &res_nrg0, &rshift0, LPC_res + LPC_order, subfr_length - LPC_order );
SKP_Silk_sum_sqr_shift( &res_nrg1, &rshift1, LPC_res + LPC_order + subfr_length, subfr_length - LPC_order );
/* Add subframe energies from first half frame */
shift = rshift0 - rshift1;
if( shift >= 0 ) {
res_nrg1 = SKP_RSHIFT( res_nrg1, shift );
res_nrg_interp_Q = -rshift0;
} else {
res_nrg0 = SKP_RSHIFT( res_nrg0, -shift );
res_nrg_interp_Q = -rshift1;
}
res_nrg_interp = SKP_ADD32( res_nrg0, res_nrg1 );
/* Compare with first half energy without NLSF interpolation, or best interpolated value so far */
shift = res_nrg_interp_Q - res_nrg_Q;
if( shift >= 0 ) {
if( SKP_RSHIFT( res_nrg_interp, shift ) < res_nrg ) {
isInterpLower = SKP_TRUE;
} else {
isInterpLower = SKP_FALSE;
}
} else {
if( -shift < 32 ) {
if( res_nrg_interp < SKP_RSHIFT( res_nrg, -shift ) ) {
isInterpLower = SKP_TRUE;
} else {
isInterpLower = SKP_FALSE;
}
} else {
isInterpLower = SKP_FALSE;
}
}
/* Determine whether current interpolated NLSFs are best so far */
if( isInterpLower == SKP_TRUE ) {
/* Interpolation has lower residual energy */
res_nrg = res_nrg_interp;
res_nrg_Q = res_nrg_interp_Q;
*interpIndex = k;
}
}
}
void SKP_Silk_decode_pulses(
SKP_Silk_range_coder_state *psRC, /* I/O Range coder state */
SKP_Silk_decoder_control *psDecCtrl, /* I/O Decoder control */
SKP_int q[], /* O Excitation signal */
const SKP_int frame_length /* I Frame length (preliminary) */
)
{
SKP_int i, j, k, iter, abs_q, nLS, bit;
SKP_int sum_pulses[ MAX_NB_SHELL_BLOCKS ], nLshifts[ MAX_NB_SHELL_BLOCKS ];
SKP_int *pulses_ptr;
const SKP_uint16 *cdf_ptr;
/*********************/
/* Decode rate level */
/*********************/
SKP_Silk_range_decoder( &psDecCtrl->RateLevelIndex, psRC,
SKP_Silk_rate_levels_CDF[ psDecCtrl->sigtype ], SKP_Silk_rate_levels_CDF_offset );
/* Calculate number of shell blocks */
iter = frame_length / SHELL_CODEC_FRAME_LENGTH;
/***************************************************/
/* Sum-Weighted-Pulses Decoding */
/***************************************************/
cdf_ptr = SKP_Silk_pulses_per_block_CDF[ psDecCtrl->RateLevelIndex ];
for( i = 0; i < iter; i++ ) {
nLshifts[ i ] = 0;
SKP_Silk_range_decoder( &sum_pulses[ i ], psRC, cdf_ptr, SKP_Silk_pulses_per_block_CDF_offset );
/* LSB indication */
while( sum_pulses[ i ] == ( MAX_PULSES + 1 ) ) {
nLshifts[ i ]++;
SKP_Silk_range_decoder( &sum_pulses[ i ], psRC,
SKP_Silk_pulses_per_block_CDF[ N_RATE_LEVELS - 1 ], SKP_Silk_pulses_per_block_CDF_offset );
}
}
/***************************************************/
/* Shell decoding */
/***************************************************/
for( i = 0; i < iter; i++ ) {
if( sum_pulses[ i ] > 0 ) {
SKP_Silk_shell_decoder( &q[ SKP_SMULBB( i, SHELL_CODEC_FRAME_LENGTH ) ], psRC, sum_pulses[ i ] );
} else {
SKP_memset( &q[ SKP_SMULBB( i, SHELL_CODEC_FRAME_LENGTH ) ], 0, SHELL_CODEC_FRAME_LENGTH * sizeof( SKP_int ) );
}
}
/***************************************************/
/* LSB Decoding */
/***************************************************/
for( i = 0; i < iter; i++ ) {
if( nLshifts[ i ] > 0 ) {
nLS = nLshifts[ i ];
pulses_ptr = &q[ SKP_SMULBB( i, SHELL_CODEC_FRAME_LENGTH ) ];
for( k = 0; k < SHELL_CODEC_FRAME_LENGTH; k++ ) {
abs_q = pulses_ptr[ k ];
for( j = 0; j < nLS; j++ ) {
abs_q = SKP_LSHIFT( abs_q, 1 );
SKP_Silk_range_decoder( &bit, psRC, SKP_Silk_lsb_CDF, 1 );
abs_q += bit;
}
pulses_ptr[ k ] = abs_q;
}
}
}
/****************************************/
/* Decode and add signs to pulse signal */
/****************************************/
SKP_Silk_decode_signs( psRC, q, frame_length, psDecCtrl->sigtype,
psDecCtrl->QuantOffsetType, psDecCtrl->RateLevelIndex);
}
/* Find pitch lags */
void silk_find_pitch_lags_FIX(
silk_encoder_state_FIX *psEnc, /* I/O encoder state */
silk_encoder_control_FIX *psEncCtrl, /* I/O encoder control */
opus_int16 res[], /* O residual */
const opus_int16 x[] /* I Speech signal */
)
{
opus_int buf_len, i, scale;
opus_int32 thrhld_Q15, res_nrg;
const opus_int16 *x_buf, *x_buf_ptr;
opus_int16 Wsig[ FIND_PITCH_LPC_WIN_MAX ], *Wsig_ptr;
opus_int32 auto_corr[ MAX_FIND_PITCH_LPC_ORDER + 1 ];
opus_int16 rc_Q15[ MAX_FIND_PITCH_LPC_ORDER ];
opus_int32 A_Q24[ MAX_FIND_PITCH_LPC_ORDER ];
opus_int16 A_Q12[ MAX_FIND_PITCH_LPC_ORDER ];
/******************************************/
/* Setup buffer lengths etc based on Fs */
/******************************************/
buf_len = psEnc->sCmn.la_pitch + psEnc->sCmn.frame_length + psEnc->sCmn.ltp_mem_length;
/* Safty check */
SKP_assert( buf_len >= psEnc->sCmn.pitch_LPC_win_length );
x_buf = x - psEnc->sCmn.ltp_mem_length;
/*************************************/
/* Estimate LPC AR coefficients */
/*************************************/
/* Calculate windowed signal */
/* First LA_LTP samples */
x_buf_ptr = x_buf + buf_len - psEnc->sCmn.pitch_LPC_win_length;
Wsig_ptr = Wsig;
silk_apply_sine_window( Wsig_ptr, x_buf_ptr, 1, psEnc->sCmn.la_pitch );
/* Middle un - windowed samples */
Wsig_ptr += psEnc->sCmn.la_pitch;
x_buf_ptr += psEnc->sCmn.la_pitch;
SKP_memcpy( Wsig_ptr, x_buf_ptr, ( psEnc->sCmn.pitch_LPC_win_length - SKP_LSHIFT( psEnc->sCmn.la_pitch, 1 ) ) * sizeof( opus_int16 ) );
/* Last LA_LTP samples */
Wsig_ptr += psEnc->sCmn.pitch_LPC_win_length - SKP_LSHIFT( psEnc->sCmn.la_pitch, 1 );
x_buf_ptr += psEnc->sCmn.pitch_LPC_win_length - SKP_LSHIFT( psEnc->sCmn.la_pitch, 1 );
silk_apply_sine_window( Wsig_ptr, x_buf_ptr, 2, psEnc->sCmn.la_pitch );
/* Calculate autocorrelation sequence */
silk_autocorr( auto_corr, &scale, Wsig, psEnc->sCmn.pitch_LPC_win_length, psEnc->sCmn.pitchEstimationLPCOrder + 1 );
/* Add white noise, as fraction of energy */
auto_corr[ 0 ] = SKP_SMLAWB( auto_corr[ 0 ], auto_corr[ 0 ], SILK_FIX_CONST( FIND_PITCH_WHITE_NOISE_FRACTION, 16 ) ) + 1;
/* Calculate the reflection coefficients using schur */
res_nrg = silk_schur( rc_Q15, auto_corr, psEnc->sCmn.pitchEstimationLPCOrder );
/* Prediction gain */
psEncCtrl->predGain_Q16 = silk_DIV32_varQ( auto_corr[ 0 ], SKP_max_int( res_nrg, 1 ), 16 );
/* Convert reflection coefficients to prediction coefficients */
silk_k2a( A_Q24, rc_Q15, psEnc->sCmn.pitchEstimationLPCOrder );
/* Convert From 32 bit Q24 to 16 bit Q12 coefs */
for( i = 0; i < psEnc->sCmn.pitchEstimationLPCOrder; i++ ) {
A_Q12[ i ] = ( opus_int16 )SKP_SAT16( SKP_RSHIFT( A_Q24[ i ], 12 ) );
}
/* Do BWE */
silk_bwexpander( A_Q12, psEnc->sCmn.pitchEstimationLPCOrder, SILK_FIX_CONST( FIND_PITCH_BANDWITH_EXPANSION, 16 ) );
/*****************************************/
/* LPC analysis filtering */
/*****************************************/
silk_LPC_analysis_filter( res, x_buf, A_Q12, buf_len, psEnc->sCmn.pitchEstimationLPCOrder );
if( psEnc->sCmn.indices.signalType != TYPE_NO_VOICE_ACTIVITY && psEnc->sCmn.first_frame_after_reset == 0 ) {
/* Threshold for pitch estimator */
thrhld_Q15 = SILK_FIX_CONST( 0.6, 15 );
thrhld_Q15 = SKP_SMLABB( thrhld_Q15, SILK_FIX_CONST( -0.004, 15 ), psEnc->sCmn.pitchEstimationLPCOrder );
thrhld_Q15 = SKP_SMLABB( thrhld_Q15, SILK_FIX_CONST( -0.1, 7 ), psEnc->sCmn.speech_activity_Q8 );
thrhld_Q15 = SKP_SMLABB( thrhld_Q15, SILK_FIX_CONST( -0.15, 15 ), SKP_RSHIFT( psEnc->sCmn.prevSignalType, 1 ) );
thrhld_Q15 = SKP_SMLAWB( thrhld_Q15, SILK_FIX_CONST( -0.1, 16 ), psEnc->sCmn.input_tilt_Q15 );
thrhld_Q15 = SKP_SAT16( thrhld_Q15 );
/*****************************************/
/* Call pitch estimator */
/*****************************************/
if( silk_pitch_analysis_core( res, psEncCtrl->pitchL, &psEnc->sCmn.indices.lagIndex, &psEnc->sCmn.indices.contourIndex,
&psEnc->LTPCorr_Q15, psEnc->sCmn.prevLag, psEnc->sCmn.pitchEstimationThreshold_Q16,
( opus_int16 )thrhld_Q15, psEnc->sCmn.fs_kHz, psEnc->sCmn.pitchEstimationComplexity, psEnc->sCmn.nb_subfr ) == 0 )
{
psEnc->sCmn.indices.signalType = TYPE_VOICED;
} else {
psEnc->sCmn.indices.signalType = TYPE_UNVOICED;
}
} else {
SKP_memset( psEncCtrl->pitchL, 0, sizeof( psEncCtrl->pitchL ) );
psEnc->sCmn.indices.lagIndex = 0;
psEnc->sCmn.indices.contourIndex = 0;
psEnc->LTPCorr_Q15 = 0;
}
}
SKP_int SKP_Silk_decode_frame(
SKP_Silk_decoder_state *psDec, /* I/O Pointer to Silk decoder state */
ec_dec *psRangeDec, /* I/O Compressor data structure */
SKP_int16 pOut[], /* O Pointer to output speech frame */
SKP_int32 *pN, /* O Pointer to size of output frame */
const SKP_int nBytes, /* I Payload length */
SKP_int lostFlag /* I 0: no loss, 1 loss, 2 decode fec */
)
{
SKP_Silk_decoder_control sDecCtrl;
SKP_int i, L, mv_len, ret = 0;
SKP_int8 flags;
SKP_int32 LBRR_symbol;
SKP_int pulses[ MAX_FRAME_LENGTH ];
TIC(DECODE_FRAME)
L = psDec->frame_length;
sDecCtrl.LTP_scale_Q14 = 0;
/* Safety checks */
SKP_assert( L > 0 && L <= MAX_FRAME_LENGTH );
/********************************************/
/* Decode Frame if packet is not lost */
/********************************************/
if( lostFlag != PACKET_LOST && psDec->nFramesDecoded == 0 ) {
/* First decoder call for this payload */
/* Decode VAD flags and LBRR flag */
flags = SKP_RSHIFT( psRangeDec->buf[ 0 ], 7 - psDec->nFramesPerPacket ) &
( SKP_LSHIFT( 1, psDec->nFramesPerPacket + 1 ) - 1 );
psDec->LBRR_flag = flags & 1;
for( i = psDec->nFramesPerPacket - 1; i >= 0 ; i-- ) {
flags = SKP_RSHIFT( flags, 1 );
psDec->VAD_flags[ i ] = flags & 1;
}
for( i = 0; i < psDec->nFramesPerPacket + 1; i++ ) {
ec_dec_icdf( psRangeDec, SKP_Silk_uniform2_iCDF, 8 );
}
/* Decode LBRR flags */
SKP_memset( psDec->LBRR_flags, 0, sizeof( psDec->LBRR_flags ) );
if( psDec->LBRR_flag ) {
if( psDec->nFramesPerPacket == 1 ) {
psDec->LBRR_flags[ 0 ] = 1;
} else {
LBRR_symbol = ec_dec_icdf( psRangeDec, SKP_Silk_LBRR_flags_iCDF_ptr[ psDec->nFramesPerPacket - 2 ], 8 ) + 1;
for( i = 0; i < psDec->nFramesPerPacket; i++ ) {
psDec->LBRR_flags[ i ] = SKP_RSHIFT( LBRR_symbol, i ) & 1;
}
}
}
if( lostFlag == DECODE_NORMAL ) {
/* Regular decoding: skip all LBRR data */
for( i = 0; i < psDec->nFramesPerPacket; i++ ) {
if( psDec->LBRR_flags[ i ] ) {
SKP_Silk_decode_indices( psDec, psRangeDec, i, 1 );
SKP_Silk_decode_pulses( psRangeDec, pulses, psDec->indices.signalType,
psDec->indices.quantOffsetType, psDec->frame_length );
}
}
}
}
if( lostFlag == DECODE_LBRR && psDec->LBRR_flags[ psDec->nFramesDecoded ] == 0 ) {
/* Treat absent LBRR data as lost frame */
lostFlag = PACKET_LOST;
psDec->nFramesDecoded++;
}
if( lostFlag != PACKET_LOST ) {
/*********************************************/
/* Decode quantization indices of side info */
/*********************************************/
TIC(decode_indices)
SKP_Silk_decode_indices( psDec, psRangeDec, psDec->nFramesDecoded, lostFlag );
TOC(decode_indices)
/*********************************************/
/* Decode quantization indices of excitation */
/*********************************************/
TIC(decode_pulses)
SKP_Silk_decode_pulses( psRangeDec, pulses, psDec->indices.signalType,
psDec->indices.quantOffsetType, psDec->frame_length );
TOC(decode_pulses)
/********************************************/
/* Decode parameters and pulse signal */
/********************************************/
TIC(decode_params)
SKP_Silk_decode_parameters( psDec, &sDecCtrl );
TOC(decode_params)
/* Update length. Sampling frequency may have changed */
L = psDec->frame_length;
/********************************************************/
/* Run inverse NSQ */
/********************************************************/
TIC(decode_core)
SKP_Silk_decode_core( psDec, &sDecCtrl, pOut, pulses );
TOC(decode_core)
/********************************************************/
/* Update PLC state */
/********************************************************/
SKP_Silk_PLC( psDec, &sDecCtrl, pOut, L, 0 );
psDec->lossCnt = 0;
psDec->prevSignalType = psDec->indices.signalType;
SKP_assert( psDec->prevSignalType >= 0 && psDec->prevSignalType <= 2 );
/* A frame has been decoded without errors */
psDec->first_frame_after_reset = 0;
psDec->nFramesDecoded++;
} else {
/* Handle packet loss by extrapolation */
SKP_Silk_PLC( psDec, &sDecCtrl, pOut, L, 1 );
}
/*************************/
/* Update output buffer. */
/*************************/
SKP_assert( psDec->ltp_mem_length >= psDec->frame_length );
mv_len = psDec->ltp_mem_length - psDec->frame_length;
SKP_memmove( psDec->outBuf, &psDec->outBuf[ psDec->frame_length ], mv_len * sizeof(SKP_int16) );
SKP_memcpy( &psDec->outBuf[ mv_len ], pOut, psDec->frame_length * sizeof( SKP_int16 ) );
/****************************************************************/
/* Ensure smooth connection of extrapolated and good frames */
/****************************************************************/
SKP_Silk_PLC_glue_frames( psDec, &sDecCtrl, pOut, L );
/************************************************/
/* Comfort noise generation / estimation */
/************************************************/
SKP_Silk_CNG( psDec, &sDecCtrl, pOut, L );
/********************************************/
/* HP filter output */
/********************************************/
TIC(HP_out)
SKP_Silk_biquad_alt( pOut, psDec->HP_B, psDec->HP_A, psDec->HPState, pOut, L );
TOC(HP_out)
/* Update some decoder state variables */
psDec->lagPrev = sDecCtrl.pitchL[ psDec->nb_subfr - 1 ];
/********************************************/
/* set output frame length */
/********************************************/
*pN = ( SKP_int16 )L;
TOC(DECODE_FRAME)
return ret;
}
void SKP_Silk_PLC_update(
SKP_Silk_decoder_state *psDec, /* (I/O) Decoder state */
SKP_Silk_decoder_control *psDecCtrl, /* (I/O) Decoder control */
SKP_int16 signal[],
SKP_int length
)
{
SKP_int32 LTP_Gain_Q14, temp_LTP_Gain_Q14;
SKP_int i, j;
SKP_Silk_PLC_struct *psPLC;
psPLC = &psDec->sPLC;
/* Update parameters used in case of packet loss */
psDec->prev_sigtype = psDecCtrl->sigtype;
LTP_Gain_Q14 = 0;
if( psDecCtrl->sigtype == SIG_TYPE_VOICED ) {
/* Find the parameters for the last subframe which contains a pitch pulse */
for( j = 0; j * psDec->subfr_length < psDecCtrl->pitchL[ NB_SUBFR - 1 ]; j++ ) {
temp_LTP_Gain_Q14 = 0;
for( i = 0; i < LTP_ORDER; i++ ) {
temp_LTP_Gain_Q14 += psDecCtrl->LTPCoef_Q14[ ( NB_SUBFR - 1 - j ) * LTP_ORDER + i ];
}
if( temp_LTP_Gain_Q14 > LTP_Gain_Q14 ) {
LTP_Gain_Q14 = temp_LTP_Gain_Q14;
SKP_memcpy( psPLC->LTPCoef_Q14,
&psDecCtrl->LTPCoef_Q14[ SKP_SMULBB( NB_SUBFR - 1 - j, LTP_ORDER ) ],
LTP_ORDER * sizeof( SKP_int16 ) );
psPLC->pitchL_Q8 = SKP_LSHIFT( psDecCtrl->pitchL[ NB_SUBFR - 1 - j ], 8 );
}
}
#if USE_SINGLE_TAP
SKP_memset( psPLC->LTPCoef_Q14, 0, LTP_ORDER * sizeof( SKP_int16 ) );
psPLC->LTPCoef_Q14[ LTP_ORDER / 2 ] = LTP_Gain_Q14;
#endif
/* Limit LT coefs */
if( LTP_Gain_Q14 < V_PITCH_GAIN_START_MIN_Q14 ) {
SKP_int scale_Q10;
SKP_int32 tmp;
tmp = SKP_LSHIFT( V_PITCH_GAIN_START_MIN_Q14, 10 );
scale_Q10 = SKP_DIV32( tmp, SKP_max( LTP_Gain_Q14, 1 ) );
for( i = 0; i < LTP_ORDER; i++ ) {
psPLC->LTPCoef_Q14[ i ] = SKP_RSHIFT( SKP_SMULBB( psPLC->LTPCoef_Q14[ i ], scale_Q10 ), 10 );
}
} else if( LTP_Gain_Q14 > V_PITCH_GAIN_START_MAX_Q14 ) {
SKP_int scale_Q14;
SKP_int32 tmp;
tmp = SKP_LSHIFT( V_PITCH_GAIN_START_MAX_Q14, 14 );
scale_Q14 = SKP_DIV32( tmp, SKP_max( LTP_Gain_Q14, 1 ) );
for( i = 0; i < LTP_ORDER; i++ ) {
psPLC->LTPCoef_Q14[ i ] = SKP_RSHIFT( SKP_SMULBB( psPLC->LTPCoef_Q14[ i ], scale_Q14 ), 14 );
}
}
} else {
psPLC->pitchL_Q8 = SKP_LSHIFT( SKP_SMULBB( psDec->fs_kHz, 18 ), 8 );
SKP_memset( psPLC->LTPCoef_Q14, 0, LTP_ORDER * sizeof( SKP_int16 ));
}
/* Save LPC coeficients */
SKP_memcpy( psPLC->prevLPC_Q12, psDecCtrl->PredCoef_Q12[ 1 ], psDec->LPC_order * sizeof( SKP_int16 ) );
psPLC->prevLTP_scale_Q14 = psDecCtrl->LTP_scale_Q14;
/* Save Gains */
SKP_memcpy( psPLC->prevGain_Q16, psDecCtrl->Gains_Q16, NB_SUBFR * sizeof( SKP_int32 ) );
}
/* Encode quantization indices of excitation */
void SKP_Silk_encode_pulses(
ec_enc *psRangeEnc, /* I/O compressor data structure */
const SKP_int signalType, /* I Sigtype */
const SKP_int quantOffsetType, /* I quantOffsetType */
SKP_int8 pulses[], /* I quantization indices */
const SKP_int frame_length /* I Frame length */
)
{
SKP_int i, k, j, iter, bit, nLS, scale_down, RateLevelIndex = 0;
SKP_int32 abs_q, minSumBits_Q5, sumBits_Q5;
SKP_int abs_pulses[ MAX_FRAME_LENGTH ];
SKP_int sum_pulses[ MAX_NB_SHELL_BLOCKS ];
SKP_int nRshifts[ MAX_NB_SHELL_BLOCKS ];
SKP_int pulses_comb[ 8 ];
SKP_int *abs_pulses_ptr;
const SKP_int8 *pulses_ptr;
const SKP_uint8 *cdf_ptr;
const SKP_uint8 *nBits_ptr;
SKP_memset( pulses_comb, 0, 8 * sizeof( SKP_int ) ); // Fixing Valgrind reported problem
/****************************/
/* Prepare for shell coding */
/****************************/
/* Calculate number of shell blocks */
SKP_assert( 1 << LOG2_SHELL_CODEC_FRAME_LENGTH == SHELL_CODEC_FRAME_LENGTH );
iter = SKP_RSHIFT( frame_length, LOG2_SHELL_CODEC_FRAME_LENGTH );
if( iter * SHELL_CODEC_FRAME_LENGTH < frame_length ){
SKP_assert( frame_length == 12 * 10 ); /* Make sure only happens for 10 ms @ 12 kHz */
iter++;
SKP_memset( &pulses[ frame_length ], 0, SHELL_CODEC_FRAME_LENGTH * sizeof(SKP_int8));
}
/* Take the absolute value of the pulses */
for( i = 0; i < iter * SHELL_CODEC_FRAME_LENGTH; i+=4 ) {
abs_pulses[i+0] = ( SKP_int )SKP_abs( pulses[ i + 0 ] );
abs_pulses[i+1] = ( SKP_int )SKP_abs( pulses[ i + 1 ] );
abs_pulses[i+2] = ( SKP_int )SKP_abs( pulses[ i + 2 ] );
abs_pulses[i+3] = ( SKP_int )SKP_abs( pulses[ i + 3 ] );
}
/* Calc sum pulses per shell code frame */
abs_pulses_ptr = abs_pulses;
for( i = 0; i < iter; i++ ) {
nRshifts[ i ] = 0;
while( 1 ) {
/* 1+1 -> 2 */
scale_down = combine_and_check( pulses_comb, abs_pulses_ptr, SKP_Silk_max_pulses_table[ 0 ], 8 );
/* 2+2 -> 4 */
scale_down += combine_and_check( pulses_comb, pulses_comb, SKP_Silk_max_pulses_table[ 1 ], 4 );
/* 4+4 -> 8 */
scale_down += combine_and_check( pulses_comb, pulses_comb, SKP_Silk_max_pulses_table[ 2 ], 2 );
/* 8+8 -> 16 */
scale_down += combine_and_check( &sum_pulses[ i ], pulses_comb, SKP_Silk_max_pulses_table[ 3 ], 1 );
if( scale_down ) {
/* We need to downscale the quantization signal */
nRshifts[ i ]++;
for( k = 0; k < SHELL_CODEC_FRAME_LENGTH; k++ ) {
abs_pulses_ptr[ k ] = SKP_RSHIFT( abs_pulses_ptr[ k ], 1 );
}
} else {
/* Jump out of while(1) loop and go to next shell coding frame */
break;
}
}
abs_pulses_ptr += SHELL_CODEC_FRAME_LENGTH;
}
/**************/
/* Rate level */
/**************/
/* find rate level that leads to fewest bits for coding of pulses per block info */
minSumBits_Q5 = SKP_int32_MAX;
for( k = 0; k < N_RATE_LEVELS - 1; k++ ) {
nBits_ptr = SKP_Silk_pulses_per_block_BITS_Q5[ k ];
sumBits_Q5 = SKP_Silk_rate_levels_BITS_Q5[ signalType >> 1 ][ k ];
for( i = 0; i < iter; i++ ) {
if( nRshifts[ i ] > 0 ) {
sumBits_Q5 += nBits_ptr[ MAX_PULSES + 1 ];
} else {
sumBits_Q5 += nBits_ptr[ sum_pulses[ i ] ];
}
}
if( sumBits_Q5 < minSumBits_Q5 ) {
minSumBits_Q5 = sumBits_Q5;
RateLevelIndex = k;
}
}
ec_enc_icdf( psRangeEnc, RateLevelIndex, SKP_Silk_rate_levels_iCDF[ signalType >> 1 ], 8 );
/***************************************************/
/* Sum-Weighted-Pulses Encoding */
/***************************************************/
cdf_ptr = SKP_Silk_pulses_per_block_iCDF[ RateLevelIndex ];
for( i = 0; i < iter; i++ ) {
if( nRshifts[ i ] == 0 ) {
ec_enc_icdf( psRangeEnc, sum_pulses[ i ], cdf_ptr, 8 );
} else {
ec_enc_icdf( psRangeEnc, MAX_PULSES + 1, cdf_ptr, 8 );
for( k = 0; k < nRshifts[ i ] - 1; k++ ) {
ec_enc_icdf( psRangeEnc, MAX_PULSES + 1, SKP_Silk_pulses_per_block_iCDF[ N_RATE_LEVELS - 1 ], 8 );
}
ec_enc_icdf( psRangeEnc, sum_pulses[ i ], SKP_Silk_pulses_per_block_iCDF[ N_RATE_LEVELS - 1 ], 8 );
}
}
/******************/
/* Shell Encoding */
/******************/
for( i = 0; i < iter; i++ ) {
if( sum_pulses[ i ] > 0 ) {
SKP_Silk_shell_encoder( psRangeEnc, &abs_pulses[ i * SHELL_CODEC_FRAME_LENGTH ] );
}
}
/****************/
/* LSB Encoding */
/****************/
for( i = 0; i < iter; i++ ) {
if( nRshifts[ i ] > 0 ) {
pulses_ptr = &pulses[ i * SHELL_CODEC_FRAME_LENGTH ];
nLS = nRshifts[ i ] - 1;
for( k = 0; k < SHELL_CODEC_FRAME_LENGTH; k++ ) {
abs_q = (SKP_int8)SKP_abs( pulses_ptr[ k ] );
for( j = nLS; j > 0; j-- ) {
bit = SKP_RSHIFT( abs_q, j ) & 1;
ec_enc_icdf( psRangeEnc, bit, SKP_Silk_lsb_iCDF, 8 );
}
bit = abs_q & 1;
ec_enc_icdf( psRangeEnc, bit, SKP_Silk_lsb_iCDF, 8 );
}
}
}
#if! USE_CELT_PVQ
/****************/
/* Encode signs */
/****************/
SKP_Silk_encode_signs( psRangeEnc, pulses, frame_length, signalType, quantOffsetType, sum_pulses );
#endif
}
void SKP_Silk_find_pred_coefs_FIX(
SKP_Silk_encoder_state_FIX *psEnc, /* I/O encoder state */
SKP_Silk_encoder_control_FIX *psEncCtrl, /* I/O encoder control */
const SKP_int16 res_pitch[], /* I Residual from pitch analysis */
const SKP_int16 x[] /* I Speech signal */
)
{
SKP_int i;
SKP_int32 WLTP[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ];
SKP_int32 invGains_Q16[ MAX_NB_SUBFR ], local_gains[ MAX_NB_SUBFR ], Wght_Q15[ MAX_NB_SUBFR ];
SKP_int16 NLSF_Q15[ MAX_LPC_ORDER ];
const SKP_int16 *x_ptr;
SKP_int16 *x_pre_ptr, LPC_in_pre[ MAX_NB_SUBFR * MAX_LPC_ORDER + MAX_FRAME_LENGTH ];
SKP_int32 tmp, min_gain_Q16;
SKP_int LTP_corrs_rshift[ MAX_NB_SUBFR ];
/* weighting for weighted least squares */
min_gain_Q16 = SKP_int32_MAX >> 6;
for( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
min_gain_Q16 = SKP_min( min_gain_Q16, psEncCtrl->Gains_Q16[ i ] );
}
for( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
/* Divide to Q16 */
SKP_assert( psEncCtrl->Gains_Q16[ i ] > 0 );
/* Invert and normalize gains, and ensure that maximum invGains_Q16 is within range of a 16 bit int */
invGains_Q16[ i ] = SKP_DIV32_varQ( min_gain_Q16, psEncCtrl->Gains_Q16[ i ], 16 - 2 );
/* Ensure Wght_Q15 a minimum value 1 */
invGains_Q16[ i ] = SKP_max( invGains_Q16[ i ], 363 );
/* Square the inverted gains */
SKP_assert( invGains_Q16[ i ] == SKP_SAT16( invGains_Q16[ i ] ) );
tmp = SKP_SMULWB( invGains_Q16[ i ], invGains_Q16[ i ] );
Wght_Q15[ i ] = SKP_RSHIFT( tmp, 1 );
/* Invert the inverted and normalized gains */
local_gains[ i ] = SKP_DIV32( ( 1 << 16 ), invGains_Q16[ i ] );
}
if( psEnc->sCmn.indices.signalType == TYPE_VOICED ) {
/**********/
/* VOICED */
/**********/
SKP_assert( psEnc->sCmn.ltp_mem_length - psEnc->sCmn.predictLPCOrder >= psEncCtrl->pitchL[ 0 ] + LTP_ORDER / 2 );
/* LTP analysis */
SKP_Silk_find_LTP_FIX( psEncCtrl->LTPCoef_Q14, WLTP, &psEncCtrl->LTPredCodGain_Q7,
res_pitch, psEncCtrl->pitchL, Wght_Q15, psEnc->sCmn.subfr_length,
psEnc->sCmn.nb_subfr, psEnc->sCmn.ltp_mem_length, LTP_corrs_rshift );
/* Quantize LTP gain parameters */
SKP_Silk_quant_LTP_gains( psEncCtrl->LTPCoef_Q14, psEnc->sCmn.indices.LTPIndex, &psEnc->sCmn.indices.PERIndex,
WLTP, psEnc->sCmn.mu_LTP_Q9, psEnc->sCmn.LTPQuantLowComplexity, psEnc->sCmn.nb_subfr);
/* Control LTP scaling */
SKP_Silk_LTP_scale_ctrl_FIX( psEnc, psEncCtrl );
/* Create LTP residual */
SKP_Silk_LTP_analysis_filter_FIX( LPC_in_pre, psEnc->x_buf + psEnc->sCmn.ltp_mem_length - psEnc->sCmn.predictLPCOrder,
psEncCtrl->LTPCoef_Q14, psEncCtrl->pitchL, invGains_Q16, psEnc->sCmn.subfr_length, psEnc->sCmn.nb_subfr, psEnc->sCmn.predictLPCOrder );
} else {
/************/
/* UNVOICED */
/************/
/* Create signal with prepended subframes, scaled by inverse gains */
x_ptr = x - psEnc->sCmn.predictLPCOrder;
x_pre_ptr = LPC_in_pre;
for( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
SKP_Silk_scale_copy_vector16( x_pre_ptr, x_ptr, invGains_Q16[ i ],
psEnc->sCmn.subfr_length + psEnc->sCmn.predictLPCOrder );
x_pre_ptr += psEnc->sCmn.subfr_length + psEnc->sCmn.predictLPCOrder;
x_ptr += psEnc->sCmn.subfr_length;
}
SKP_memset( psEncCtrl->LTPCoef_Q14, 0, psEnc->sCmn.nb_subfr * LTP_ORDER * sizeof( SKP_int16 ) );
psEncCtrl->LTPredCodGain_Q7 = 0;
}
/* LPC_in_pre contains the LTP-filtered input for voiced, and the unfiltered input for unvoiced */
TIC(FIND_LPC)
SKP_Silk_find_LPC_FIX( NLSF_Q15, &psEnc->sCmn.indices.NLSFInterpCoef_Q2, psEnc->sCmn.prev_NLSFq_Q15,
psEnc->sCmn.useInterpolatedNLSFs, psEnc->sCmn.first_frame_after_reset, psEnc->sCmn.predictLPCOrder,
LPC_in_pre, psEnc->sCmn.subfr_length + psEnc->sCmn.predictLPCOrder, psEnc->sCmn.nb_subfr );
TOC(FIND_LPC)
/* Quantize LSFs */
TIC(PROCESS_LSFS)
SKP_Silk_process_NLSFs( &psEnc->sCmn, psEncCtrl->PredCoef_Q12, NLSF_Q15, psEnc->sCmn.prev_NLSFq_Q15 );
TOC(PROCESS_LSFS)
/* Calculate residual energy using quantized LPC coefficients */
SKP_Silk_residual_energy_FIX( psEncCtrl->ResNrg, psEncCtrl->ResNrgQ, LPC_in_pre, psEncCtrl->PredCoef_Q12, local_gains,
psEnc->sCmn.subfr_length, psEnc->sCmn.nb_subfr, psEnc->sCmn.predictLPCOrder );
/* Copy to prediction struct for use in next frame for fluctuation reduction */
SKP_memcpy( psEnc->sCmn.prev_NLSFq_Q15, NLSF_Q15, sizeof( psEnc->sCmn.prev_NLSFq_Q15 ) );
}
/* Encode quantization indices of excitation */
void SKP_Silk_encode_pulses(
SKP_Silk_range_coder_state *psRC, /* I/O Range coder state */
const SKP_int sigtype, /* I Sigtype */
const SKP_int QuantOffsetType,/* I QuantOffsetType */
const SKP_int8 q[], /* I quantization indices */
const SKP_int frame_length /* I Frame length */
)
{
SKP_int i, k, j, iter, bit, nLS, scale_down, RateLevelIndex = 0;
SKP_int32 abs_q, minSumBits_Q6, sumBits_Q6;
SKP_int abs_pulses[ MAX_FRAME_LENGTH ];
SKP_int sum_pulses[ MAX_NB_SHELL_BLOCKS ];
SKP_int nRshifts[ MAX_NB_SHELL_BLOCKS ];
SKP_int pulses_comb[ 8 ];
SKP_int *abs_pulses_ptr;
const SKP_int8 *pulses_ptr;
const SKP_uint16 *cdf_ptr;
const SKP_int16 *nBits_ptr;
SKP_memset( pulses_comb, 0, 8 * sizeof( SKP_int ) ); // Fixing Valgrind reported problem
/****************************/
/* Prepare for shell coding */
/****************************/
/* Calculate number of shell blocks */
iter = frame_length / SHELL_CODEC_FRAME_LENGTH;
/* Take the absolute value of the pulses */
for( i = 0; i < frame_length; i+=4 ) {
abs_pulses[i+0] = ( SKP_int )SKP_abs( q[ i + 0 ] );
abs_pulses[i+1] = ( SKP_int )SKP_abs( q[ i + 1 ] );
abs_pulses[i+2] = ( SKP_int )SKP_abs( q[ i + 2 ] );
abs_pulses[i+3] = ( SKP_int )SKP_abs( q[ i + 3 ] );
}
/* Calc sum pulses per shell code frame */
abs_pulses_ptr = abs_pulses;
for( i = 0; i < iter; i++ ) {
nRshifts[ i ] = 0;
while( 1 ) {
/* 1+1 -> 2 */
scale_down = combine_and_check( pulses_comb, abs_pulses_ptr, SKP_Silk_max_pulses_table[ 0 ], 8 );
/* 2+2 -> 4 */
scale_down += combine_and_check( pulses_comb, pulses_comb, SKP_Silk_max_pulses_table[ 1 ], 4 );
/* 4+4 -> 8 */
scale_down += combine_and_check( pulses_comb, pulses_comb, SKP_Silk_max_pulses_table[ 2 ], 2 );
/* 8+8 -> 16 */
sum_pulses[ i ] = pulses_comb[ 0 ] + pulses_comb[ 1 ];
if( sum_pulses[ i ] > SKP_Silk_max_pulses_table[ 3 ] ) {
scale_down++;
}
if( scale_down ) {
/* We need to down scale the quantization signal */
nRshifts[ i ]++;
for( k = 0; k < SHELL_CODEC_FRAME_LENGTH; k++ ) {
abs_pulses_ptr[ k ] = SKP_RSHIFT( abs_pulses_ptr[ k ], 1 );
}
} else {
/* Jump out of while(1) loop and go to next shell coding frame */
break;
}
}
abs_pulses_ptr += SHELL_CODEC_FRAME_LENGTH;
}
/**************/
/* Rate level */
/**************/
/* find rate level that leads to fewest bits for coding of pulses per block info */
minSumBits_Q6 = SKP_int32_MAX;
for( k = 0; k < N_RATE_LEVELS - 1; k++ ) {
nBits_ptr = SKP_Silk_pulses_per_block_BITS_Q6[ k ];
sumBits_Q6 = SKP_Silk_rate_levels_BITS_Q6[sigtype][ k ];
for( i = 0; i < iter; i++ ) {
if( nRshifts[ i ] > 0 ) {
sumBits_Q6 += nBits_ptr[ MAX_PULSES + 1 ];
} else {
sumBits_Q6 += nBits_ptr[ sum_pulses[ i ] ];
}
}
if( sumBits_Q6 < minSumBits_Q6 ) {
minSumBits_Q6 = sumBits_Q6;
RateLevelIndex = k;
}
}
SKP_Silk_range_encoder( psRC, RateLevelIndex, SKP_Silk_rate_levels_CDF[ sigtype ] );
/***************************************************/
/* Sum-Weighted-Pulses Encoding */
/***************************************************/
cdf_ptr = SKP_Silk_pulses_per_block_CDF[ RateLevelIndex ];
for( i = 0; i < iter; i++ ) {
if( nRshifts[ i ] == 0 ) {
SKP_Silk_range_encoder( psRC, sum_pulses[ i ], cdf_ptr );
} else {
SKP_Silk_range_encoder( psRC, MAX_PULSES + 1, cdf_ptr );
for( k = 0; k < nRshifts[ i ] - 1; k++ ) {
SKP_Silk_range_encoder( psRC, MAX_PULSES + 1, SKP_Silk_pulses_per_block_CDF[ N_RATE_LEVELS - 1 ] );
}
SKP_Silk_range_encoder( psRC, sum_pulses[ i ], SKP_Silk_pulses_per_block_CDF[ N_RATE_LEVELS - 1 ] );
}
}
/******************/
/* Shell Encoding */
/******************/
for( i = 0; i < iter; i++ ) {
if( sum_pulses[ i ] > 0 ) {
SKP_Silk_shell_encoder( psRC, &abs_pulses[ i * SHELL_CODEC_FRAME_LENGTH ] );
}
}
/****************/
/* LSB Encoding */
/****************/
for( i = 0; i < iter; i++ ) {
if( nRshifts[ i ] > 0 ) {
pulses_ptr = &q[ i * SHELL_CODEC_FRAME_LENGTH ];
nLS = nRshifts[ i ] - 1;
for( k = 0; k < SHELL_CODEC_FRAME_LENGTH; k++ ) {
abs_q = (SKP_int8)SKP_abs( pulses_ptr[ k ] );
for( j = nLS; j > 0; j-- ) {
bit = SKP_RSHIFT( abs_q, j ) & 1;
SKP_Silk_range_encoder( psRC, bit, SKP_Silk_lsb_CDF );
}
bit = abs_q & 1;
SKP_Silk_range_encoder( psRC, bit, SKP_Silk_lsb_CDF );
}
}
}
/****************/
/* Encode signs */
/****************/
SKP_Silk_encode_signs( psRC, q, frame_length, sigtype, QuantOffsetType, RateLevelIndex );
}
/* Compute reflection coefficients from input signal */
void SKP_Silk_burg_modified(
SKP_int32 *res_nrg, /* O residual energy */
SKP_int *res_nrg_Q, /* O residual energy Q value */
SKP_int32 A_Q16[], /* O prediction coefficients (length order) */
const SKP_int16 x[], /* I input signal, length: nb_subfr * ( D + subfr_length ) */
const SKP_int subfr_length, /* I input signal subframe length (including D preceeding samples) */
const SKP_int nb_subfr, /* I number of subframes stacked in x */
const SKP_int32 WhiteNoiseFrac_Q32, /* I fraction added to zero-lag autocorrelation */
const SKP_int D /* I order */
)
{
SKP_int k, n, s, lz, rshifts, rshifts_extra;
SKP_int32 C0, num, nrg, rc_Q31, Atmp_QA, Atmp1, tmp1, tmp2, x1, x2;
const SKP_int16 *x_ptr;
SKP_int32 C_first_row[ SKP_Silk_MAX_ORDER_LPC ];
SKP_int32 C_last_row[ SKP_Silk_MAX_ORDER_LPC ];
SKP_int32 Af_QA[ SKP_Silk_MAX_ORDER_LPC ];
SKP_int32 CAf[ SKP_Silk_MAX_ORDER_LPC + 1 ];
SKP_int32 CAb[ SKP_Silk_MAX_ORDER_LPC + 1 ];
SKP_assert( subfr_length * nb_subfr <= MAX_FRAME_SIZE );
SKP_assert( nb_subfr <= MAX_NB_SUBFR );
/* Compute autocorrelations, added over subframes */
SKP_Silk_sum_sqr_shift( &C0, &rshifts, x, nb_subfr * subfr_length );
if( rshifts > MAX_RSHIFTS ) {
C0 = SKP_LSHIFT32( C0, rshifts - MAX_RSHIFTS );
SKP_assert( C0 > 0 );
rshifts = MAX_RSHIFTS;
} else {
lz = SKP_Silk_CLZ32( C0 ) - 1;
rshifts_extra = N_BITS_HEAD_ROOM - lz;
if( rshifts_extra > 0 ) {
rshifts_extra = SKP_min( rshifts_extra, MAX_RSHIFTS - rshifts );
C0 = SKP_RSHIFT32( C0, rshifts_extra );
} else {
rshifts_extra = SKP_max( rshifts_extra, MIN_RSHIFTS - rshifts );
C0 = SKP_LSHIFT32( C0, -rshifts_extra );
}
rshifts += rshifts_extra;
}
SKP_memset( C_first_row, 0, SKP_Silk_MAX_ORDER_LPC * sizeof( SKP_int32 ) );
if( rshifts > 0 ) {
for( s = 0; s < nb_subfr; s++ ) {
x_ptr = x + s * subfr_length;
for( n = 1; n < D + 1; n++ ) {
C_first_row[ n - 1 ] += (SKP_int32)SKP_RSHIFT64(
SKP_Silk_inner_prod16_aligned_64( x_ptr, x_ptr + n, subfr_length - n ), rshifts );
}
}
} else {
for( s = 0; s < nb_subfr; s++ ) {
x_ptr = x + s * subfr_length;
for( n = 1; n < D + 1; n++ ) {
C_first_row[ n - 1 ] += SKP_LSHIFT32(
SKP_Silk_inner_prod_aligned( x_ptr, x_ptr + n, subfr_length - n ), -rshifts );
}
}
}
SKP_memcpy( C_last_row, C_first_row, SKP_Silk_MAX_ORDER_LPC * sizeof( SKP_int32 ) );
/* Initialize */
CAb[ 0 ] = CAf[ 0 ] = C0 + SKP_SMMUL( WhiteNoiseFrac_Q32, C0 ) + 1; // Q(-rshifts)
for( n = 0; n < D; n++ ) {
/* Update first row of correlation matrix (without first element) */
/* Update last row of correlation matrix (without last element, stored in reversed order) */
/* Update C * Af */
/* Update C * flipud(Af) (stored in reversed order) */
if( rshifts > -2 ) {
for( s = 0; s < nb_subfr; s++ ) {
x_ptr = x + s * subfr_length;
x1 = -SKP_LSHIFT32( (SKP_int32)x_ptr[ n ], 16 - rshifts ); // Q(16-rshifts)
x2 = -SKP_LSHIFT32( (SKP_int32)x_ptr[ subfr_length - n - 1 ], 16 - rshifts ); // Q(16-rshifts)
tmp1 = SKP_LSHIFT32( (SKP_int32)x_ptr[ n ], QA - 16 ); // Q(QA-16)
tmp2 = SKP_LSHIFT32( (SKP_int32)x_ptr[ subfr_length - n - 1 ], QA - 16 ); // Q(QA-16)
for( k = 0; k < n; k++ ) {
C_first_row[ k ] = SKP_SMLAWB( C_first_row[ k ], x1, x_ptr[ n - k - 1 ] ); // Q( -rshifts )
C_last_row[ k ] = SKP_SMLAWB( C_last_row[ k ], x2, x_ptr[ subfr_length - n + k ] ); // Q( -rshifts )
Atmp_QA = Af_QA[ k ];
tmp1 = SKP_SMLAWB( tmp1, Atmp_QA, x_ptr[ n - k - 1 ] ); // Q(QA-16)
tmp2 = SKP_SMLAWB( tmp2, Atmp_QA, x_ptr[ subfr_length - n + k ] ); // Q(QA-16)
}
tmp1 = SKP_LSHIFT32( -tmp1, 32 - QA - rshifts ); // Q(16-rshifts)
tmp2 = SKP_LSHIFT32( -tmp2, 32 - QA - rshifts ); // Q(16-rshifts)
for( k = 0; k <= n; k++ ) {
CAf[ k ] = SKP_SMLAWB( CAf[ k ], tmp1, x_ptr[ n - k ] ); // Q( -rshift )
CAb[ k ] = SKP_SMLAWB( CAb[ k ], tmp2, x_ptr[ subfr_length - n + k - 1 ] ); // Q( -rshift )
}
}
} else {
for( s = 0; s < nb_subfr; s++ ) {
x_ptr = x + s * subfr_length;
x1 = -SKP_LSHIFT32( (SKP_int32)x_ptr[ n ], -rshifts ); // Q( -rshifts )
x2 = -SKP_LSHIFT32( (SKP_int32)x_ptr[ subfr_length - n - 1 ], -rshifts ); // Q( -rshifts )
tmp1 = SKP_LSHIFT32( (SKP_int32)x_ptr[ n ], 17 ); // Q17
tmp2 = SKP_LSHIFT32( (SKP_int32)x_ptr[ subfr_length - n - 1 ], 17 ); // Q17
for( k = 0; k < n; k++ ) {
C_first_row[ k ] = SKP_MLA( C_first_row[ k ], x1, x_ptr[ n - k - 1 ] ); // Q( -rshifts )
C_last_row[ k ] = SKP_MLA( C_last_row[ k ], x2, x_ptr[ subfr_length - n + k ] ); // Q( -rshifts )
Atmp1 = SKP_RSHIFT_ROUND( Af_QA[ k ], QA - 17 ); // Q17
tmp1 = SKP_MLA( tmp1, x_ptr[ n - k - 1 ], Atmp1 ); // Q17
tmp2 = SKP_MLA( tmp2, x_ptr[ subfr_length - n + k ], Atmp1 ); // Q17
}
tmp1 = -tmp1; // Q17
tmp2 = -tmp2; // Q17
for( k = 0; k <= n; k++ ) {
CAf[ k ] = SKP_SMLAWW( CAf[ k ], tmp1,
SKP_LSHIFT32( (SKP_int32)x_ptr[ n - k ], -rshifts - 1 ) ); // Q( -rshift )
CAb[ k ] = SKP_SMLAWW( CAb[ k ], tmp2,
SKP_LSHIFT32( (SKP_int32)x_ptr[ subfr_length - n + k - 1 ], -rshifts - 1 ) );// Q( -rshift )
}
}
}
/* Calculate nominator and denominator for the next order reflection (parcor) coefficient */
tmp1 = C_first_row[ n ]; // Q( -rshifts )
tmp2 = C_last_row[ n ]; // Q( -rshifts )
num = 0; // Q( -rshifts )
nrg = SKP_ADD32( CAb[ 0 ], CAf[ 0 ] ); // Q( 1-rshifts )
for( k = 0; k < n; k++ ) {
Atmp_QA = Af_QA[ k ];
lz = SKP_Silk_CLZ32( SKP_abs( Atmp_QA ) ) - 1;
lz = SKP_min( 32 - QA, lz );
Atmp1 = SKP_LSHIFT32( Atmp_QA, lz ); // Q( QA + lz )
tmp1 = SKP_ADD_LSHIFT32( tmp1, SKP_SMMUL( C_last_row[ n - k - 1 ], Atmp1 ), 32 - QA - lz ); // Q( -rshifts )
tmp2 = SKP_ADD_LSHIFT32( tmp2, SKP_SMMUL( C_first_row[ n - k - 1 ], Atmp1 ), 32 - QA - lz ); // Q( -rshifts )
num = SKP_ADD_LSHIFT32( num, SKP_SMMUL( CAb[ n - k ], Atmp1 ), 32 - QA - lz ); // Q( -rshifts )
nrg = SKP_ADD_LSHIFT32( nrg, SKP_SMMUL( SKP_ADD32( CAb[ k + 1 ], CAf[ k + 1 ] ),
Atmp1 ), 32 - QA - lz ); // Q( 1-rshifts )
}
CAf[ n + 1 ] = tmp1; // Q( -rshifts )
CAb[ n + 1 ] = tmp2; // Q( -rshifts )
num = SKP_ADD32( num, tmp2 ); // Q( -rshifts )
num = SKP_LSHIFT32( -num, 1 ); // Q( 1-rshifts )
/* Calculate the next order reflection (parcor) coefficient */
if( SKP_abs( num ) < nrg ) {
rc_Q31 = SKP_DIV32_varQ( num, nrg, 31 );
} else {
/* Negative energy or ratio too high; set remaining coefficients to zero and exit loop */
SKP_memset( &Af_QA[ n ], 0, ( D - n ) * sizeof( SKP_int32 ) );
SKP_assert( 0 );
break;
}
/* Update the AR coefficients */
for( k = 0; k < (n + 1) >> 1; k++ ) {
tmp1 = Af_QA[ k ]; // QA
tmp2 = Af_QA[ n - k - 1 ]; // QA
Af_QA[ k ] = SKP_ADD_LSHIFT32( tmp1, SKP_SMMUL( tmp2, rc_Q31 ), 1 ); // QA
Af_QA[ n - k - 1 ] = SKP_ADD_LSHIFT32( tmp2, SKP_SMMUL( tmp1, rc_Q31 ), 1 ); // QA
}
Af_QA[ n ] = SKP_RSHIFT32( rc_Q31, 31 - QA ); // QA
/* Update C * Af and C * Ab */
for( k = 0; k <= n + 1; k++ ) {
tmp1 = CAf[ k ]; // Q( -rshifts )
tmp2 = CAb[ n - k + 1 ]; // Q( -rshifts )
CAf[ k ] = SKP_ADD_LSHIFT32( tmp1, SKP_SMMUL( tmp2, rc_Q31 ), 1 ); // Q( -rshifts )
CAb[ n - k + 1 ] = SKP_ADD_LSHIFT32( tmp2, SKP_SMMUL( tmp1, rc_Q31 ), 1 ); // Q( -rshifts )
}
}
/* Return residual energy */
nrg = CAf[ 0 ]; // Q( -rshifts )
tmp1 = 1 << 16; // Q16
for( k = 0; k < D; k++ ) {
Atmp1 = SKP_RSHIFT_ROUND( Af_QA[ k ], QA - 16 ); // Q16
nrg = SKP_SMLAWW( nrg, CAf[ k + 1 ], Atmp1 ); // Q( -rshifts )
tmp1 = SKP_SMLAWW( tmp1, Atmp1, Atmp1 ); // Q16
A_Q16[ k ] = -Atmp1;
}
*res_nrg = SKP_SMLAWW( nrg, SKP_SMMUL( WhiteNoiseFrac_Q32, C0 ), -tmp1 ); // Q( -rshifts )
*res_nrg_Q = -rshifts;
}
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
}
/* Compute reflection coefficients from input signal */
SKP_float SKP_Silk_burg_modified_FLP( /* O returns residual energy */
SKP_float A[], /* O prediction coefficients (length order) */
const SKP_float x[], /* I input signal, length: nb_subfr*(D+L_sub) */
const SKP_int subfr_length, /* I input signal subframe length (including D preceeding samples) */
const SKP_int nb_subfr, /* I number of subframes stacked in x */
const SKP_float WhiteNoiseFrac, /* I fraction added to zero-lag autocorrelation */
const SKP_int D /* I order */
)
{
SKP_int k, n, s;
double C0, num, nrg_f, nrg_b, rc, Atmp, tmp1, tmp2;
const SKP_float *x_ptr;
double C_first_row[ SKP_Silk_MAX_ORDER_LPC ], C_last_row[ SKP_Silk_MAX_ORDER_LPC ];
double CAf[ SKP_Silk_MAX_ORDER_LPC + 1 ], CAb[ SKP_Silk_MAX_ORDER_LPC + 1 ];
double Af[ SKP_Silk_MAX_ORDER_LPC ];
SKP_assert( subfr_length * nb_subfr <= MAX_FRAME_SIZE );
SKP_assert( nb_subfr <= MAX_NB_SUBFR );
/* Compute autocorrelations, added over subframes */
C0 = SKP_Silk_energy_FLP( x, nb_subfr * subfr_length );
SKP_memset( C_first_row, 0, SKP_Silk_MAX_ORDER_LPC * sizeof( double ) );
for( s = 0; s < nb_subfr; s++ ) {
x_ptr = x + s * subfr_length;
for( n = 1; n < D + 1; n++ ) {
C_first_row[ n - 1 ] += SKP_Silk_inner_product_FLP( x_ptr, x_ptr + n, subfr_length - n );
}
}
SKP_memcpy( C_last_row, C_first_row, SKP_Silk_MAX_ORDER_LPC * sizeof( double ) );
/* Initialize */
CAb[ 0 ] = CAf[ 0 ] = C0 + WhiteNoiseFrac * C0 + 1e-9f;
for( n = 0; n < D; n++ ) {
/* Update first row of correlation matrix (without first element) */
/* Update last row of correlation matrix (without last element, stored in reversed order) */
/* Update C * Af */
/* Update C * flipud(Af) (stored in reversed order) */
for( s = 0; s < nb_subfr; s++ ) {
x_ptr = x + s * subfr_length;
tmp1 = x_ptr[ n ];
tmp2 = x_ptr[ subfr_length - n - 1 ];
for( k = 0; k < n; k++ ) {
C_first_row[ k ] -= x_ptr[ n ] * x_ptr[ n - k - 1 ];
C_last_row[ k ] -= x_ptr[ subfr_length - n - 1 ] * x_ptr[ subfr_length - n + k ];
Atmp = Af[ k ];
SKP_assert( subfr_length - n + k + s * subfr_length >= 0 );
SKP_assert( subfr_length - n + k + s * subfr_length < nb_subfr * subfr_length );
tmp1 += x_ptr[ n - k - 1 ] * Atmp;
tmp2 += x_ptr[ subfr_length - n + k ] * Atmp;
}
for( k = 0; k <= n; k++ ) {
CAf[ k ] -= tmp1 * x_ptr[ n - k ];
CAb[ k ] -= tmp2 * x_ptr[ subfr_length - n + k - 1 ];
}
}
tmp1 = C_first_row[ n ];
tmp2 = C_last_row[ n ];
for( k = 0; k < n; k++ ) {
Atmp = Af[ k ];
tmp1 += C_last_row[ n - k - 1 ] * Atmp;
tmp2 += C_first_row[ n - k - 1 ] * Atmp;
}
CAf[ n + 1 ] = tmp1;
CAb[ n + 1 ] = tmp2;
/* Calculate nominator and denominator for the next order reflection (parcor) coefficient */
num = CAb[ n + 1 ];
nrg_b = CAb[ 0 ];
nrg_f = CAf[ 0 ];
for( k = 0; k < n; k++ ) {
Atmp = Af[ k ];
num += CAb[ n - k ] * Atmp;
nrg_b += CAb[ k + 1 ] * Atmp;
nrg_f += CAf[ k + 1 ] * Atmp;
}
SKP_assert( nrg_f > 0.0 );
SKP_assert( nrg_b > 0.0 );
/* Calculate the next order reflection (parcor) coefficient */
rc = -2.0 * num / ( nrg_f + nrg_b );
SKP_assert( rc > -1.0 && rc < 1.0 );
/* Update the AR coefficients */
for( k = 0; k < (n + 1) >> 1; k++ ) {
tmp1 = Af[ k ];
tmp2 = Af[ n - k - 1 ];
Af[ k ] = tmp1 + rc * tmp2;
Af[ n - k - 1 ] = tmp2 + rc * tmp1;
}
Af[ n ] = rc;
/* Update C * Af and C * Ab */
for( k = 0; k <= n + 1; k++ ) {
tmp1 = CAf[ k ];
CAf[ k ] += rc * CAb[ n - k + 1 ];
CAb[ n - k + 1 ] += rc * tmp1;
}
}
/* Return residual energy */
nrg_f = CAf[ 0 ];
tmp1 = 1.0;
for( k = 0; k < D; k++ ) {
Atmp = Af[ k ];
nrg_f += CAf[ k + 1 ] * Atmp;
tmp1 += Atmp * Atmp;
A[ k ] = (SKP_float)(-Atmp);
}
nrg_f -= WhiteNoiseFrac * C0 * tmp1;
return (SKP_float)nrg_f;
}
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 );
}
