/* Resample with a 2x downsampler (optional), a 2nd order AR filter followed by FIR interpolation */
void silk_resampler_private_down_FIR(
void *SS, /* I/O: Resampler state */
opus_int16 out[], /* O: Output signal */
const opus_int16 in[], /* I: Input signal */
opus_int32 inLen /* I: Number of input samples */
)
{
silk_resampler_state_struct *S = (silk_resampler_state_struct *)SS;
opus_int32 nSamplesIn;
opus_int32 max_index_Q16, index_increment_Q16;
opus_int16 buf1[ RESAMPLER_MAX_BATCH_SIZE_IN / 2 ];
opus_int32 buf2[ RESAMPLER_MAX_BATCH_SIZE_IN + RESAMPLER_DOWN_ORDER_FIR ];
const opus_int16 *FIR_Coefs;
/* Copy buffered samples to start of buffer */
SKP_memcpy( buf2, S->sFIR, RESAMPLER_DOWN_ORDER_FIR * sizeof( opus_int32 ) );
FIR_Coefs = &S->Coefs[ 2 ];
/* Iterate over blocks of frameSizeIn input samples */
index_increment_Q16 = S->invRatio_Q16;
while( 1 ) {
nSamplesIn = SKP_min( inLen, S->batchSize );
if( S->input2x == 1 ) {
/* Downsample 2x */
silk_resampler_down2( S->sDown2, buf1, in, nSamplesIn );
nSamplesIn = SKP_RSHIFT32( nSamplesIn, 1 );
/* Second-order AR filter (output in Q8) */
silk_resampler_private_AR2( S->sIIR, &buf2[ RESAMPLER_DOWN_ORDER_FIR ], buf1, S->Coefs, nSamplesIn );
} else {
/* Second-order AR filter (output in Q8) */
silk_resampler_private_AR2( S->sIIR, &buf2[ RESAMPLER_DOWN_ORDER_FIR ], in, S->Coefs, nSamplesIn );
}
max_index_Q16 = SKP_LSHIFT32( nSamplesIn, 16 );
/* Interpolate filtered signal */
if( S->FIR_Fracs == 1 ) {
out = silk_resampler_private_down_FIR_INTERPOL0(out, buf2, FIR_Coefs, max_index_Q16, index_increment_Q16);
} else {
out = silk_resampler_private_down_FIR_INTERPOL1(out, buf2, FIR_Coefs, max_index_Q16, index_increment_Q16, S->FIR_Fracs);
}
in += nSamplesIn << S->input2x;
inLen -= nSamplesIn << S->input2x;
if( inLen > S->input2x ) {
/* More iterations to do; copy last part of filtered signal to beginning of buffer */
SKP_memcpy( buf2, &buf2[ nSamplesIn ], RESAMPLER_DOWN_ORDER_FIR * sizeof( opus_int32 ) );
} else {
break;
}
}
/* Copy last part of filtered signal to the state for the next call */
SKP_memcpy( S->sFIR, &buf2[ nSamplesIn ], RESAMPLER_DOWN_ORDER_FIR * sizeof( opus_int32 ) );
}
/* Upsample using a combination of allpass-based 2x upsampling and FIR interpolation */
void SKP_Silk_resampler_private_IIR_FIR(
void *SS, /* I/O: Resampler state */
SKP_int16 out[], /* O: Output signal */
const SKP_int16 in[], /* I: Input signal */
SKP_int32 inLen /* I: Number of input samples */
)
{
SKP_Silk_resampler_state_struct *S = (SKP_Silk_resampler_state_struct *)SS;
SKP_int32 nSamplesIn, table_index;
SKP_int32 max_index_Q16, index_Q16, index_increment_Q16, res_Q15;
SKP_int16 buf[ 2 * RESAMPLER_MAX_BATCH_SIZE_IN + RESAMPLER_ORDER_FIR_144 ];
SKP_int16 *buf_ptr;
/* Copy buffered samples to start of buffer */
SKP_memcpy( buf, S->sFIR, RESAMPLER_ORDER_FIR_144 * sizeof( SKP_int32 ) );
/* Iterate over blocks of frameSizeIn input samples */
index_increment_Q16 = S->invRatio_Q16;
while( 1 ) {
nSamplesIn = SKP_min( inLen, S->batchSize );
if( S->input2x == 1 ) {
/* Upsample 2x */
S->up2_function( S->sIIR, &buf[ RESAMPLER_ORDER_FIR_144 ], in, nSamplesIn );
} else {
/* Fourth-order ARMA filter */
SKP_Silk_resampler_private_ARMA4( S->sIIR, &buf[ RESAMPLER_ORDER_FIR_144 ], in, S->Coefs, nSamplesIn );
}
max_index_Q16 = SKP_LSHIFT32( nSamplesIn, 16 + S->input2x ); /* +1 if 2x upsampling */
/* Interpolate upsampled signal and store in output array */
for( index_Q16 = 0; index_Q16 < max_index_Q16; index_Q16 += index_increment_Q16 ) {
table_index = SKP_SMULWB( index_Q16 & 0xFFFF, 144 );
buf_ptr = &buf[ index_Q16 >> 16 ];
res_Q15 = SKP_SMULBB( buf_ptr[ 0 ], SKP_Silk_resampler_frac_FIR_144[ table_index ][ 0 ] );
res_Q15 = SKP_SMLABB( res_Q15, buf_ptr[ 1 ], SKP_Silk_resampler_frac_FIR_144[ table_index ][ 1 ] );
res_Q15 = SKP_SMLABB( res_Q15, buf_ptr[ 2 ], SKP_Silk_resampler_frac_FIR_144[ table_index ][ 2 ] );
res_Q15 = SKP_SMLABB( res_Q15, buf_ptr[ 3 ], SKP_Silk_resampler_frac_FIR_144[ 143 - table_index ][ 2 ] );
res_Q15 = SKP_SMLABB( res_Q15, buf_ptr[ 4 ], SKP_Silk_resampler_frac_FIR_144[ 143 - table_index ][ 1 ] );
res_Q15 = SKP_SMLABB( res_Q15, buf_ptr[ 5 ], SKP_Silk_resampler_frac_FIR_144[ 143 - table_index ][ 0 ] );
*out++ = (SKP_int16)SKP_SAT16( SKP_RSHIFT_ROUND( res_Q15, 15 ) );
}
in += nSamplesIn;
inLen -= nSamplesIn;
if( inLen > 0 ) {
/* More iterations to do; copy last part of filtered signal to beginning of buffer */
SKP_memcpy( buf, &buf[ nSamplesIn << S->input2x ], RESAMPLER_ORDER_FIR_144 * sizeof( SKP_int32 ) );
} else {
break;
}
}
/* Copy last part of filtered signal to the state for the next call */
SKP_memcpy( S->sFIR, &buf[nSamplesIn << S->input2x ], RESAMPLER_ORDER_FIR_144 * sizeof( SKP_int32 ) );
}
/* Helper function, interpolates the filter taps */
SKP_INLINE void silk_LP_interpolate_filter_taps(
SKP_int32 B_Q28[ TRANSITION_NB ],
SKP_int32 A_Q28[ TRANSITION_NA ],
const SKP_int ind,
const SKP_int32 fac_Q16
)
{
SKP_int nb, na;
if( ind < TRANSITION_INT_NUM - 1 ) {
if( fac_Q16 > 0 ) {
if( fac_Q16 < 32768 ) { /* fac_Q16 is in range of a 16-bit int */
/* Piece-wise linear interpolation of B and A */
for( nb = 0; nb < TRANSITION_NB; nb++ ) {
B_Q28[ nb ] = SKP_SMLAWB(
silk_Transition_LP_B_Q28[ ind ][ nb ],
silk_Transition_LP_B_Q28[ ind + 1 ][ nb ] -
silk_Transition_LP_B_Q28[ ind ][ nb ],
fac_Q16 );
}
for( na = 0; na < TRANSITION_NA; na++ ) {
A_Q28[ na ] = SKP_SMLAWB(
silk_Transition_LP_A_Q28[ ind ][ na ],
silk_Transition_LP_A_Q28[ ind + 1 ][ na ] -
silk_Transition_LP_A_Q28[ ind ][ na ],
fac_Q16 );
}
} else { /* ( fac_Q16 - ( 1 << 16 ) ) is in range of a 16-bit int */
SKP_assert( fac_Q16 - ( 1 << 16 ) == SKP_SAT16( fac_Q16 - ( 1 << 16 ) ) );
/* Piece-wise linear interpolation of B and A */
for( nb = 0; nb < TRANSITION_NB; nb++ ) {
B_Q28[ nb ] = SKP_SMLAWB(
silk_Transition_LP_B_Q28[ ind + 1 ][ nb ],
silk_Transition_LP_B_Q28[ ind + 1 ][ nb ] -
silk_Transition_LP_B_Q28[ ind ][ nb ],
fac_Q16 - ( 1 << 16 ) );
}
for( na = 0; na < TRANSITION_NA; na++ ) {
A_Q28[ na ] = SKP_SMLAWB(
silk_Transition_LP_A_Q28[ ind + 1 ][ na ],
silk_Transition_LP_A_Q28[ ind + 1 ][ na ] -
silk_Transition_LP_A_Q28[ ind ][ na ],
fac_Q16 - ( 1 << 16 ) );
}
}
} else {
SKP_memcpy( B_Q28, silk_Transition_LP_B_Q28[ ind ], TRANSITION_NB * sizeof( SKP_int32 ) );
SKP_memcpy( A_Q28, silk_Transition_LP_A_Q28[ ind ], TRANSITION_NA * sizeof( SKP_int32 ) );
}
} else {
SKP_memcpy( B_Q28, silk_Transition_LP_B_Q28[ TRANSITION_INT_NUM - 1 ], TRANSITION_NB * sizeof( SKP_int32 ) );
SKP_memcpy( A_Q28, silk_Transition_LP_A_Q28[ TRANSITION_INT_NUM - 1 ], TRANSITION_NA * sizeof( SKP_int32 ) );
}
}
/* Downsample by a factor 3, low quality */
void SKP_Silk_resampler_down3(
SKP_int32 *S, /* I/O: State vector [ 8 ] */
SKP_int16 *out, /* O: Output signal [ floor(inLen/3) ] */
const SKP_int16 *in, /* I: Input signal [ inLen ] */
SKP_int32 inLen /* I: Number of input samples */
)
{
SKP_int32 nSamplesIn, counter, res_Q6;
SKP_int32 buf[ RESAMPLER_MAX_BATCH_SIZE_IN + ORDER_FIR ];
SKP_int32 *buf_ptr;
/* Copy buffered samples to start of buffer */
SKP_memcpy( buf, S, ORDER_FIR * sizeof( SKP_int32 ) );
/* Iterate over blocks of frameSizeIn input samples */
while( 1 ) {
nSamplesIn = SKP_min( inLen, RESAMPLER_MAX_BATCH_SIZE_IN );
/* Second-order AR filter (output in Q8) */
SKP_Silk_resampler_private_AR2( &S[ ORDER_FIR ], &buf[ ORDER_FIR ], in,
SKP_Silk_Resampler_1_3_COEFS_LQ, nSamplesIn );
/* Interpolate filtered signal */
buf_ptr = buf;
counter = nSamplesIn;
while( counter > 2 ) {
/* Inner product */
res_Q6 = SKP_SMULWB( SKP_ADD32( buf_ptr[ 0 ], buf_ptr[ 5 ] ), SKP_Silk_Resampler_1_3_COEFS_LQ[ 2 ] );
res_Q6 = SKP_SMLAWB( res_Q6, SKP_ADD32( buf_ptr[ 1 ], buf_ptr[ 4 ] ), SKP_Silk_Resampler_1_3_COEFS_LQ[ 3 ] );
res_Q6 = SKP_SMLAWB( res_Q6, SKP_ADD32( buf_ptr[ 2 ], buf_ptr[ 3 ] ), SKP_Silk_Resampler_1_3_COEFS_LQ[ 4 ] );
/* Scale down, saturate and store in output array */
*out++ = (SKP_int16)SKP_SAT16( SKP_RSHIFT_ROUND( res_Q6, 6 ) );
buf_ptr += 3;
counter -= 3;
}
in += nSamplesIn;
inLen -= nSamplesIn;
if( inLen > 0 ) {
/* More iterations to do; copy last part of filtered signal to beginning of buffer */
SKP_memcpy( buf, &buf[ nSamplesIn ], ORDER_FIR * sizeof( SKP_int32 ) );
} else {
break;
}
}
/* Copy last part of filtered signal to the state for the next call */
SKP_memcpy( S, &buf[ nSamplesIn ], ORDER_FIR * sizeof( SKP_int32 ) );
}
/* Convert adaptive Mid/Side representation to Left/Right stereo signal */
void silk_stereo_MS_to_LR(
stereo_dec_state *state, /* I/O State */
opus_int16 x1[], /* I/O Left input signal, becomes mid signal */
opus_int16 x2[], /* I/O Right input signal, becomes side signal */
const opus_int32 pred_Q13[], /* I Predictors */
opus_int fs_kHz, /* I Samples rate (kHz) */
opus_int frame_length /* I Number of samples */
)
{
opus_int n, denom_Q16, delta0_Q13, delta1_Q13;
opus_int32 sum, diff, pred0_Q13, pred1_Q13;
/* Buffering */
SKP_memcpy( x1, state->sMid, 2 * sizeof( opus_int16 ) );
SKP_memcpy( x2, state->sSide, 2 * sizeof( opus_int16 ) );
SKP_memcpy( state->sMid, &x1[ frame_length ], 2 * sizeof( opus_int16 ) );
SKP_memcpy( state->sSide, &x2[ frame_length ], 2 * sizeof( opus_int16 ) );
/* Interpolate predictors and add prediction to side channel */
pred0_Q13 = state->pred_prev_Q13[ 0 ];
pred1_Q13 = state->pred_prev_Q13[ 1 ];
denom_Q16 = SKP_DIV32_16( 1 << 16, STEREO_INTERP_LEN_MS * fs_kHz );
delta0_Q13 = SKP_RSHIFT_ROUND( SKP_SMULBB( pred_Q13[ 0 ] - state->pred_prev_Q13[ 0 ], denom_Q16 ), 16 );
delta1_Q13 = SKP_RSHIFT_ROUND( SKP_SMULBB( pred_Q13[ 1 ] - state->pred_prev_Q13[ 1 ], denom_Q16 ), 16 );
for( n = 0; n < STEREO_INTERP_LEN_MS * fs_kHz; n++ ) {
pred0_Q13 += delta0_Q13;
pred1_Q13 += delta1_Q13;
sum = SKP_LSHIFT( SKP_ADD_LSHIFT( x1[ n ] + x1[ n + 2 ], x1[ n + 1 ], 1 ), 9 ); /* Q11 */
sum = SKP_SMLAWB( SKP_LSHIFT( ( opus_int32 )x2[ n + 1 ], 8 ), sum, pred0_Q13 ); /* Q8 */
sum = SKP_SMLAWB( sum, SKP_LSHIFT( ( opus_int32 )x1[ n + 1 ], 11 ), pred1_Q13 ); /* Q8 */
x2[ n + 1 ] = (opus_int16)SKP_SAT16( SKP_RSHIFT_ROUND( sum, 8 ) );
}
pred0_Q13 = pred_Q13[ 0 ];
pred1_Q13 = pred_Q13[ 1 ];
for( n = STEREO_INTERP_LEN_MS * fs_kHz; n < frame_length; n++ ) {
sum = SKP_LSHIFT( SKP_ADD_LSHIFT( x1[ n ] + x1[ n + 2 ], x1[ n + 1 ], 1 ), 9 ); /* Q11 */
sum = SKP_SMLAWB( SKP_LSHIFT( ( opus_int32 )x2[ n + 1 ], 8 ), sum, pred0_Q13 ); /* Q8 */
sum = SKP_SMLAWB( sum, SKP_LSHIFT( ( opus_int32 )x1[ n + 1 ], 11 ), pred1_Q13 ); /* Q8 */
x2[ n + 1 ] = (opus_int16)SKP_SAT16( SKP_RSHIFT_ROUND( sum, 8 ) );
}
state->pred_prev_Q13[ 0 ] = pred_Q13[ 0 ];
state->pred_prev_Q13[ 1 ] = pred_Q13[ 1 ];
/* Convert to left/right signals */
for( n = 0; n < frame_length; n++ ) {
sum = x1[ n + 1 ] + (opus_int32)x2[ n + 1 ];
diff = x1[ n + 1 ] - (opus_int32)x2[ n + 1 ];
x1[ n + 1 ] = (opus_int16)SKP_SAT16( sum );
x2[ n + 1 ] = (opus_int16)SKP_SAT16( diff );
}
}
/* Upsample using a combination of allpass-based 2x upsampling and FIR interpolation */
void SKP_Silk_resampler_private_IIR_FIR(
void *SS, /* I/O: Resampler state */
SKP_int16 out[], /* O: Output signal */
const SKP_int16 in[], /* I: Input signal */
SKP_int32 inLen /* I: Number of input samples */
)
{
SKP_Silk_resampler_state_struct *S = (SKP_Silk_resampler_state_struct *)SS;
SKP_int32 nSamplesIn;
SKP_int32 max_index_Q16, index_increment_Q16;
SKP_int16 buf[ 2 * RESAMPLER_MAX_BATCH_SIZE_IN + RESAMPLER_ORDER_FIR_144 ];
/* Copy buffered samples to start of buffer */
SKP_memcpy( buf, S->sFIR, RESAMPLER_ORDER_FIR_144 * sizeof( SKP_int32 ) );
/* Iterate over blocks of frameSizeIn input samples */
index_increment_Q16 = S->invRatio_Q16;
while( 1 ) {
nSamplesIn = SKP_min( inLen, S->batchSize );
if( S->input2x == 1 ) {
/* Upsample 2x */
S->up2_function( S->sIIR, &buf[ RESAMPLER_ORDER_FIR_144 ], in, nSamplesIn );
} else {
/* Fourth-order ARMA filter */
SKP_Silk_resampler_private_ARMA4( S->sIIR, &buf[ RESAMPLER_ORDER_FIR_144 ], in, S->Coefs, nSamplesIn );
}
max_index_Q16 = SKP_LSHIFT32( nSamplesIn, 16 + S->input2x ); /* +1 if 2x upsampling */
out = SKP_Silk_resampler_private_IIR_FIR_INTERPOL(out, buf, max_index_Q16, index_increment_Q16);
in += nSamplesIn;
inLen -= nSamplesIn;
if( inLen > 0 ) {
/* More iterations to do; copy last part of filtered signal to beginning of buffer */
SKP_memcpy( buf, &buf[ nSamplesIn << S->input2x ], RESAMPLER_ORDER_FIR_144 * sizeof( SKP_int32 ) );
} else {
break;
}
}
/* Copy last part of filtered signal to the state for the next call */
SKP_memcpy( S->sFIR, &buf[nSamplesIn << S->input2x ], RESAMPLER_ORDER_FIR_144 * sizeof( SKP_int32 ) );
}
/* 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;
}
}
}
/* this code is based on silk_a2k_FLP() */
opus_int silk_LPC_inverse_pred_gain_FLP( /* O: returns 1 if unstable, otherwise 0 */
SKP_float *invGain, /* O: inverse prediction gain, energy domain */
const SKP_float *A, /* I: prediction coefficients [order] */
opus_int32 order /* I: prediction order */
)
{
opus_int k, n;
double rc, rc_mult1, rc_mult2;
SKP_float Atmp[ 2 ][ SILK_MAX_ORDER_LPC ];
SKP_float *Aold, *Anew;
Anew = Atmp[ order & 1 ];
SKP_memcpy( Anew, A, order * sizeof(SKP_float) );
*invGain = 1.0f;
for( k = order - 1; k > 0; k-- ) {
rc = -Anew[ k ];
if (rc > RC_THRESHOLD || rc < -RC_THRESHOLD) {
return 1;
}
rc_mult1 = 1.0f - rc * rc;
rc_mult2 = 1.0f / rc_mult1;
*invGain *= (SKP_float)rc_mult1;
/* swap pointers */
Aold = Anew;
Anew = Atmp[ k & 1 ];
for( n = 0; n < k; n++ ) {
Anew[ n ] = (SKP_float)( ( Aold[ n ] - Aold[ k - n - 1 ] * rc ) * rc_mult2 );
}
}
rc = -Anew[ 0 ];
if ( rc > RC_THRESHOLD || rc < -RC_THRESHOLD ) {
return 1;
}
rc_mult1 = 1.0f - rc * rc;
*invGain *= (SKP_float)rc_mult1;
return 0;
}
/* Initialize range decoder */
void SKP_Silk_range_dec_init(
SKP_Silk_range_coder_state *psRC, /* O compressor data structure */
const SKP_uint8 buffer[], /* I buffer for compressed data [bufferLength] */
const SKP_int32 bufferLength /* I buffer length (in bytes) */
)
{
/* check input */
if( bufferLength > MAX_ARITHM_BYTES ) {
psRC->error = RANGE_CODER_DEC_PAYLOAD_TOO_LONG;
return;
}
/* Initialize structure */
/* Copy to internal buffer */
SKP_memcpy( psRC->buffer, buffer, bufferLength * sizeof( SKP_uint8 ) );
psRC->bufferLength = bufferLength;
psRC->bufferIx = 0;
psRC->base_Q32 =
SKP_LSHIFT_uint( (SKP_uint32)buffer[ 0 ], 24 ) |
SKP_LSHIFT_uint( (SKP_uint32)buffer[ 1 ], 16 ) |
SKP_LSHIFT_uint( (SKP_uint32)buffer[ 2 ], 8 ) |
(SKP_uint32)buffer[ 3 ];
psRC->range_Q16 = 0x0000FFFF;
psRC->error = 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 );
}
int SKP_Silk_encode_frame_FIX(SKP_Silk_encoder_state_FIX * psEnc, /* I/O Pointer to Silk FIX encoder state */
uint8_t * pCode, /* O Pointer to payload */
int16_t * pnBytesOut, /* I/O Pointer to number of payload bytes */
/* input: max length; output: used */
const int16_t * pIn /* I Pointer to input speech frame */
) {
SKP_Silk_encoder_control_FIX sEncCtrl;
int i, nBytes, ret = 0;
int16_t *x_frame, *res_pitch_frame;
int16_t xfw[MAX_FRAME_LENGTH];
int16_t pIn_HP[MAX_FRAME_LENGTH];
int16_t res_pitch[2 * MAX_FRAME_LENGTH + LA_PITCH_MAX];
int LBRR_idx, frame_terminator, SNR_dB_Q7;
const uint16_t *FrameTermination_CDF;
/* Low bitrate redundancy parameters */
uint8_t LBRRpayload[MAX_ARITHM_BYTES];
int16_t nBytesLBRR;
//int32_t Seed[ MAX_LAYERS ];
sEncCtrl.sCmn.Seed = psEnc->sCmn.frameCounter++ & 3;
/**************************************************************/
/* Setup Input Pointers, and insert frame in input buffer */
/*************************************************************/
x_frame = psEnc->x_buf + psEnc->sCmn.frame_length; /* start of frame to encode */
res_pitch_frame = res_pitch + psEnc->sCmn.frame_length; /* start of pitch LPC residual frame */
/****************************/
/* Voice Activity Detection */
/****************************/
ret =
SKP_Silk_VAD_GetSA_Q8(&psEnc->sCmn.sVAD, &psEnc->speech_activity_Q8,
&SNR_dB_Q7, sEncCtrl.input_quality_bands_Q15,
&sEncCtrl.input_tilt_Q15, pIn,
psEnc->sCmn.frame_length);
/*******************************************/
/* High-pass filtering of the input signal */
/*******************************************/
#if HIGH_PASS_INPUT
/* Variable high-pass filter */
SKP_Silk_HP_variable_cutoff_FIX(psEnc, &sEncCtrl, pIn_HP, pIn);
#else
SKP_memcpy(pIn_HP, pIn, psEnc->sCmn.frame_length * sizeof(int16_t));
#endif
#if SWITCH_TRANSITION_FILTERING
/* Ensure smooth bandwidth transitions */
SKP_Silk_LP_variable_cutoff(&psEnc->sCmn.sLP,
x_frame + psEnc->sCmn.la_shape, pIn_HP,
psEnc->sCmn.frame_length);
#else
SKP_memcpy(x_frame + psEnc->sCmn.la_shape, pIn_HP,
psEnc->sCmn.frame_length * sizeof(int16_t));
#endif
/*****************************************/
/* Find pitch lags, initial LPC analysis */
/*****************************************/
SKP_Silk_find_pitch_lags_FIX(psEnc, &sEncCtrl, res_pitch, x_frame);
/************************/
/* Noise shape analysis */
/************************/
SKP_Silk_noise_shape_analysis_FIX(psEnc, &sEncCtrl, res_pitch_frame,
x_frame);
/*****************************************/
/* Prefiltering for noise shaper */
/*****************************************/
SKP_Silk_prefilter_FIX(psEnc, &sEncCtrl, xfw, x_frame);
/***************************************************/
/* Find linear prediction coefficients (LPC + LTP) */
/***************************************************/
SKP_Silk_find_pred_coefs_FIX(psEnc, &sEncCtrl, res_pitch);
/****************************************/
/* Process gains */
/****************************************/
SKP_Silk_process_gains_FIX(psEnc, &sEncCtrl);
psEnc->sCmn.sigtype[psEnc->sCmn.nFramesInPayloadBuf] =
sEncCtrl.sCmn.sigtype;
psEnc->sCmn.QuantOffsetType[psEnc->sCmn.nFramesInPayloadBuf] =
sEncCtrl.sCmn.QuantOffsetType;
/****************************************/
/* Low Bitrate Redundant Encoding */
/****************************************/
nBytesLBRR = MAX_ARITHM_BYTES;
SKP_Silk_LBRR_encode_FIX(psEnc, &sEncCtrl, LBRRpayload, &nBytesLBRR,
xfw);
/*****************************************/
/* Noise shaping quantization */
/*****************************************/
psEnc->NoiseShapingQuantizer(&psEnc->sCmn, &sEncCtrl.sCmn, &psEnc->sNSQ,
xfw,
&psEnc->sCmn.q[psEnc->sCmn.
nFramesInPayloadBuf *
psEnc->sCmn.frame_length],
sEncCtrl.sCmn.NLSFInterpCoef_Q2,
sEncCtrl.PredCoef_Q12[0],
sEncCtrl.LTPCoef_Q14, sEncCtrl.AR2_Q13,
sEncCtrl.HarmShapeGain_Q14,
sEncCtrl.Tilt_Q14, sEncCtrl.LF_shp_Q14,
sEncCtrl.Gains_Q16, sEncCtrl.Lambda_Q10,
sEncCtrl.LTP_scale_Q14);
/**************************************************/
/* Convert speech activity into VAD and DTX flags */
/**************************************************/
if (psEnc->speech_activity_Q8 < SPEECH_ACTIVITY_DTX_THRES_Q8) {
psEnc->sCmn.vadFlag = NO_VOICE_ACTIVITY;
psEnc->sCmn.noSpeechCounter++;
if (psEnc->sCmn.noSpeechCounter > NO_SPEECH_FRAMES_BEFORE_DTX) {
psEnc->sCmn.inDTX = 1;
}
if (psEnc->sCmn.noSpeechCounter > MAX_CONSECUTIVE_DTX) {
psEnc->sCmn.noSpeechCounter = 0;
psEnc->sCmn.inDTX = 0;
}
} else {
psEnc->sCmn.noSpeechCounter = 0;
psEnc->sCmn.inDTX = 0;
psEnc->sCmn.vadFlag = VOICE_ACTIVITY;
}
/****************************************/
/* Initialize arithmetic coder */
/****************************************/
if (psEnc->sCmn.nFramesInPayloadBuf == 0) {
SKP_Silk_range_enc_init(&psEnc->sCmn.sRC);
psEnc->sCmn.nBytesInPayloadBuf = 0;
}
/****************************************/
/* Encode Parameters */
/****************************************/
if (psEnc->sCmn.bitstream_v == BIT_STREAM_V4) {
SKP_Silk_encode_parameters_v4(&psEnc->sCmn, &sEncCtrl.sCmn,
&psEnc->sCmn.sRC);
FrameTermination_CDF = SKP_Silk_FrameTermination_v4_CDF;
} else {
SKP_Silk_encode_parameters(&psEnc->sCmn, &sEncCtrl.sCmn,
&psEnc->sCmn.sRC,
&psEnc->sCmn.q[psEnc->sCmn.
nFramesInPayloadBuf *
psEnc->sCmn.
frame_length]);
FrameTermination_CDF = SKP_Silk_FrameTermination_CDF;
}
/****************************************/
/* Update Buffers and State */
/****************************************/
/* Update Input buffer */
SKP_memmove(psEnc->x_buf, &psEnc->x_buf[psEnc->sCmn.frame_length],
(psEnc->sCmn.frame_length +
psEnc->sCmn.la_shape) * sizeof(int16_t));
/* parameters needed for next frame */
psEnc->sCmn.prev_sigtype = sEncCtrl.sCmn.sigtype;
psEnc->sCmn.prevLag = sEncCtrl.sCmn.pitchL[NB_SUBFR - 1];
psEnc->sCmn.first_frame_after_reset = 0;
if (psEnc->sCmn.sRC.error) {
/* encoder returned error: clear payload buffer */
psEnc->sCmn.nFramesInPayloadBuf = 0;
} else {
psEnc->sCmn.nFramesInPayloadBuf++;
}
/****************************************/
/* finalize payload and copy to output */
/****************************************/
if (psEnc->sCmn.nFramesInPayloadBuf * FRAME_LENGTH_MS >=
psEnc->sCmn.PacketSize_ms) {
LBRR_idx = (psEnc->sCmn.oldest_LBRR_idx + 1) & LBRR_IDX_MASK;
/* Check if FEC information should be added */
frame_terminator = SKP_SILK_LAST_FRAME;
if (psEnc->sCmn.LBRR_buffer[LBRR_idx].usage ==
SKP_SILK_ADD_LBRR_TO_PLUS1) {
frame_terminator = SKP_SILK_LBRR_VER1;
}
if (psEnc->sCmn.LBRR_buffer[psEnc->sCmn.oldest_LBRR_idx].
usage == SKP_SILK_ADD_LBRR_TO_PLUS2) {
frame_terminator = SKP_SILK_LBRR_VER2;
LBRR_idx = psEnc->sCmn.oldest_LBRR_idx;
}
/* Add the frame termination info to stream */
SKP_Silk_range_encoder(&psEnc->sCmn.sRC, frame_terminator,
FrameTermination_CDF);
if (psEnc->sCmn.bitstream_v == BIT_STREAM_V4) {
/* Code excitation signal */
for (i = 0; i < psEnc->sCmn.nFramesInPayloadBuf; i++) {
SKP_Silk_encode_pulses(&psEnc->sCmn.sRC,
psEnc->sCmn.sigtype[i],
psEnc->sCmn.
QuantOffsetType[i],
&psEnc->sCmn.q[i *
psEnc->
sCmn.
frame_length],
psEnc->sCmn.
frame_length);
}
}
/* payload length so far */
SKP_Silk_range_coder_get_length(&psEnc->sCmn.sRC, &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);
SKP_memcpy(pCode, psEnc->sCmn.sRC.buffer,
nBytes * sizeof(uint8_t));
if (frame_terminator > SKP_SILK_MORE_FRAMES &&
*pnBytesOut >=
nBytes + psEnc->sCmn.LBRR_buffer[LBRR_idx].nBytes) {
/* Get old packet and add to payload. */
SKP_memcpy(&pCode[nBytes],
psEnc->sCmn.LBRR_buffer[LBRR_idx].
payload,
psEnc->sCmn.LBRR_buffer[LBRR_idx].
nBytes * sizeof(uint8_t));
nBytes +=
psEnc->sCmn.LBRR_buffer[LBRR_idx].nBytes;
}
*pnBytesOut = nBytes;
/* Update FEC buffer */
SKP_memcpy(psEnc->sCmn.
LBRR_buffer[psEnc->sCmn.oldest_LBRR_idx].
payload, LBRRpayload,
nBytesLBRR * sizeof(uint8_t));
psEnc->sCmn.LBRR_buffer[psEnc->sCmn.oldest_LBRR_idx].
nBytes = nBytesLBRR;
/* This line tells describes how FEC should be used */
psEnc->sCmn.LBRR_buffer[psEnc->sCmn.oldest_LBRR_idx].
usage = sEncCtrl.sCmn.LBRR_usage;
psEnc->sCmn.oldest_LBRR_idx =
(psEnc->sCmn.oldest_LBRR_idx + 1) & LBRR_IDX_MASK;
/* Reset number of frames in payload buffer */
psEnc->sCmn.nFramesInPayloadBuf = 0;
} else {
/* Not enough space: Payload will be discarded */
*pnBytesOut = 0;
nBytes = 0;
psEnc->sCmn.nFramesInPayloadBuf = 0;
ret = SKP_SILK_ENC_PAYLOAD_BUF_TOO_SHORT;
}
} 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, frame_terminator,
FrameTermination_CDF);
/* payload length so far */
SKP_Silk_range_coder_get_length(&psEnc->sCmn.sRC, &nBytes);
if (psEnc->sCmn.bitstream_v == BIT_STREAM_V4) {
/* Take into account the q signal that isnt in the bitstream yet */
nBytes += SKP_Silk_pulses_to_bytes(&psEnc->sCmn,
&psEnc->sCmn.
q[(psEnc->sCmn.
nFramesInPayloadBuf
-
1) *
psEnc->sCmn.
frame_length]);
}
}
/* Check for arithmetic coder errors */
if (psEnc->sCmn.sRC.error) {
ret = SKP_SILK_ENC_INTERNAL_ERROR;
}
/* simulate number of ms buffered in channel because of exceeding TargetRate */
assert((8 * 1000 *
((int64_t) nBytes -
(int64_t) psEnc->sCmn.nBytesInPayloadBuf)) ==
SKP_SAT32(8 * 1000 *
((int64_t) nBytes -
(int64_t) psEnc->sCmn.nBytesInPayloadBuf)));
assert(psEnc->sCmn.TargetRate_bps > 0);
psEnc->BufferedInChannel_ms +=
SKP_DIV32(8 * 1000 * (nBytes - psEnc->sCmn.nBytesInPayloadBuf),
psEnc->sCmn.TargetRate_bps);
psEnc->BufferedInChannel_ms -= FRAME_LENGTH_MS;
psEnc->BufferedInChannel_ms =
SKP_LIMIT(psEnc->BufferedInChannel_ms, 0, 100);
psEnc->sCmn.nBytesInPayloadBuf = nBytes;
if (psEnc->speech_activity_Q8 > WB_DETECT_ACTIVE_SPEECH_LEVEL_THRES_Q8) {
psEnc->sCmn.sSWBdetect.ActiveSpeech_ms =
SKP_ADD_POS_SAT32(psEnc->sCmn.sSWBdetect.ActiveSpeech_ms,
FRAME_LENGTH_MS);
}
return (ret);
}
void SKP_Silk_PLC_conceal(
SKP_Silk_decoder_state *psDec, /* I/O Decoder state */
SKP_Silk_decoder_control *psDecCtrl, /* I/O Decoder control */
SKP_int16 signal[], /* O concealed signal */
SKP_int length /* I length of residual */
)
{
SKP_int i, j, k;
SKP_int16 *B_Q14, exc_buf[ MAX_FRAME_LENGTH ], *exc_buf_ptr;
SKP_int16 rand_scale_Q14, A_Q12_tmp[ MAX_LPC_ORDER ];
SKP_int32 rand_seed, harm_Gain_Q15, rand_Gain_Q15;
SKP_int lag, idx, shift1, shift2;
SKP_int32 energy1, energy2, *rand_ptr, *pred_lag_ptr, Atmp;
SKP_int32 sig_Q10[ MAX_FRAME_LENGTH ], *sig_Q10_ptr, LPC_exc_Q10, LPC_pred_Q10, LTP_pred_Q14;
SKP_Silk_PLC_struct *psPLC;
psPLC = &psDec->sPLC;
/* Update LTP buffer */
SKP_memcpy( psDec->sLTP_Q16, &psDec->sLTP_Q16[ psDec->frame_length ], psDec->frame_length * sizeof( SKP_int32 ) );
/* LPC concealment. Apply BWE to previous LPC */
SKP_Silk_bwexpander( psPLC->prevLPC_Q12, psDec->LPC_order, BWE_COEF_Q16 );
/* Find random noise component */
/* Scale previous excitation signal */
exc_buf_ptr = exc_buf;
for( k = ( NB_SUBFR >> 1 ); k < NB_SUBFR; k++ ) {
for( i = 0; i < psDec->subfr_length; i++ ) {
exc_buf_ptr[ i ] = ( SKP_int16 )SKP_RSHIFT(
SKP_SMULWW( psDec->exc_Q10[ i + k * psDec->subfr_length ], psPLC->prevGain_Q16[ k ] ), 10 );
}
exc_buf_ptr += psDec->subfr_length;
}
/* Find the subframe with lowest energy of the last two and use that as random noise generator */
SKP_Silk_sum_sqr_shift( &energy1, &shift1, exc_buf, psDec->subfr_length );
SKP_Silk_sum_sqr_shift( &energy2, &shift2, &exc_buf[ psDec->subfr_length ], psDec->subfr_length );
if( SKP_RSHIFT( energy1, shift2 ) < SKP_RSHIFT( energy1, shift2 ) ) {
/* First sub-frame has lowest energy */
rand_ptr = &psDec->exc_Q10[ SKP_max_int( 0, 3 * psDec->subfr_length - RAND_BUF_SIZE ) ];
} else {
/* Second sub-frame has lowest energy */
rand_ptr = &psDec->exc_Q10[ SKP_max_int( 0, psDec->frame_length - RAND_BUF_SIZE ) ];
}
/* Setup Gain to random noise component */
B_Q14 = psPLC->LTPCoef_Q14;
rand_scale_Q14 = psPLC->randScale_Q14;
/* Setup attenuation gains */
harm_Gain_Q15 = HARM_ATT_Q15[ SKP_min_int( NB_ATT - 1, psDec->lossCnt ) ];
if( psDec->prev_sigtype == SIG_TYPE_VOICED ) {
rand_Gain_Q15 = PLC_RAND_ATTENUATE_V_Q15[ SKP_min_int( NB_ATT - 1, psDec->lossCnt ) ];
} else {
rand_Gain_Q15 = PLC_RAND_ATTENUATE_UV_Q15[ SKP_min_int( NB_ATT - 1, psDec->lossCnt ) ];
}
/* First Lost frame */
if( psDec->lossCnt == 0 ) {
rand_scale_Q14 = (1 << 14 );
/* Reduce random noise Gain for voiced frames */
if( psDec->prev_sigtype == SIG_TYPE_VOICED ) {
for( i = 0; i < LTP_ORDER; i++ ) {
rand_scale_Q14 -= B_Q14[ i ];
}
rand_scale_Q14 = SKP_max_16( 3277, rand_scale_Q14 ); /* 0.2 */
rand_scale_Q14 = ( SKP_int16 )SKP_RSHIFT( SKP_SMULBB( rand_scale_Q14, psPLC->prevLTP_scale_Q14 ), 14 );
}
/* Reduce random noise for unvoiced frames with high LPC gain */
if( psDec->prev_sigtype == SIG_TYPE_UNVOICED ) {
SKP_int32 invGain_Q30, down_scale_Q30;
SKP_Silk_LPC_inverse_pred_gain( &invGain_Q30, psPLC->prevLPC_Q12, psDec->LPC_order );
down_scale_Q30 = SKP_min_32( SKP_RSHIFT( ( 1 << 30 ), LOG2_INV_LPC_GAIN_HIGH_THRES ), invGain_Q30 );
down_scale_Q30 = SKP_max_32( SKP_RSHIFT( ( 1 << 30 ), LOG2_INV_LPC_GAIN_LOW_THRES ), down_scale_Q30 );
down_scale_Q30 = SKP_LSHIFT( down_scale_Q30, LOG2_INV_LPC_GAIN_HIGH_THRES );
rand_Gain_Q15 = SKP_RSHIFT( SKP_SMULWB( down_scale_Q30, rand_Gain_Q15 ), 14 );
}
}
rand_seed = psPLC->rand_seed;
lag = SKP_RSHIFT_ROUND( psPLC->pitchL_Q8, 8 );
psDec->sLTP_buf_idx = psDec->frame_length;
/***************************/
/* LTP synthesis filtering */
/***************************/
sig_Q10_ptr = sig_Q10;
for( k = 0; k < NB_SUBFR; k++ ) {
/* Setup pointer */
pred_lag_ptr = &psDec->sLTP_Q16[ psDec->sLTP_buf_idx - lag + LTP_ORDER / 2 ];
for( i = 0; i < psDec->subfr_length; i++ ) {
rand_seed = SKP_RAND( rand_seed );
idx = SKP_RSHIFT( rand_seed, 25 ) & RAND_BUF_MASK;
/* Unrolled loop */
LTP_pred_Q14 = SKP_SMULWB( pred_lag_ptr[ 0 ], B_Q14[ 0 ] );
LTP_pred_Q14 = SKP_SMLAWB( LTP_pred_Q14, pred_lag_ptr[ -1 ], B_Q14[ 1 ] );
LTP_pred_Q14 = SKP_SMLAWB( LTP_pred_Q14, pred_lag_ptr[ -2 ], B_Q14[ 2 ] );
LTP_pred_Q14 = SKP_SMLAWB( LTP_pred_Q14, pred_lag_ptr[ -3 ], B_Q14[ 3 ] );
LTP_pred_Q14 = SKP_SMLAWB( LTP_pred_Q14, pred_lag_ptr[ -4 ], B_Q14[ 4 ] );
pred_lag_ptr++;
/* Generate LPC residual */
LPC_exc_Q10 = SKP_LSHIFT( SKP_SMULWB( rand_ptr[ idx ], rand_scale_Q14 ), 2 ); /* Random noise part */
LPC_exc_Q10 = SKP_ADD32( LPC_exc_Q10, SKP_RSHIFT_ROUND( LTP_pred_Q14, 4 ) ); /* Harmonic part */
/* Update states */
psDec->sLTP_Q16[ psDec->sLTP_buf_idx ] = SKP_LSHIFT( LPC_exc_Q10, 6 );
psDec->sLTP_buf_idx++;
/* Save LPC residual */
sig_Q10_ptr[ i ] = LPC_exc_Q10;
}
sig_Q10_ptr += psDec->subfr_length;
/* Gradually reduce LTP gain */
for( j = 0; j < LTP_ORDER; j++ ) {
B_Q14[ j ] = SKP_RSHIFT( SKP_SMULBB( harm_Gain_Q15, B_Q14[ j ] ), 15 );
}
/* Gradually reduce excitation gain */
rand_scale_Q14 = SKP_RSHIFT( SKP_SMULBB( rand_scale_Q14, rand_Gain_Q15 ), 15 );
/* Slowly increase pitch lag */
psPLC->pitchL_Q8 += SKP_SMULWB( psPLC->pitchL_Q8, PITCH_DRIFT_FAC_Q16 );
psPLC->pitchL_Q8 = SKP_min_32( psPLC->pitchL_Q8, SKP_LSHIFT( SKP_SMULBB( MAX_PITCH_LAG_MS, psDec->fs_kHz ), 8 ) );
lag = SKP_RSHIFT_ROUND( psPLC->pitchL_Q8, 8 );
}
/***************************/
/* LPC synthesis filtering */
/***************************/
sig_Q10_ptr = sig_Q10;
/* Preload LPC coeficients to array on stack. Gives small performance gain */
SKP_memcpy( A_Q12_tmp, psPLC->prevLPC_Q12, psDec->LPC_order * sizeof( SKP_int16 ) );
SKP_assert( psDec->LPC_order >= 10 ); /* check that unrolling works */
for( k = 0; k < NB_SUBFR; k++ ) {
for( i = 0; i < psDec->subfr_length; i++ ){
/* unrolled */
Atmp = *( ( SKP_int32* )&A_Q12_tmp[ 0 ] ); /* read two coefficients at once */
LPC_pred_Q10 = SKP_SMULWB( psDec->sLPC_Q14[ MAX_LPC_ORDER + i - 1 ], Atmp );
LPC_pred_Q10 = SKP_SMLAWT( LPC_pred_Q10, psDec->sLPC_Q14[ MAX_LPC_ORDER + i - 2 ], Atmp );
Atmp = *( ( SKP_int32* )&A_Q12_tmp[ 2 ] );
LPC_pred_Q10 = SKP_SMLAWB( LPC_pred_Q10, psDec->sLPC_Q14[ MAX_LPC_ORDER + i - 3 ], Atmp );
LPC_pred_Q10 = SKP_SMLAWT( LPC_pred_Q10, psDec->sLPC_Q14[ MAX_LPC_ORDER + i - 4 ], Atmp );
Atmp = *( ( SKP_int32* )&A_Q12_tmp[ 4 ] );
LPC_pred_Q10 = SKP_SMLAWB( LPC_pred_Q10, psDec->sLPC_Q14[ MAX_LPC_ORDER + i - 5 ], Atmp );
LPC_pred_Q10 = SKP_SMLAWT( LPC_pred_Q10, psDec->sLPC_Q14[ MAX_LPC_ORDER + i - 6 ], Atmp );
Atmp = *( ( SKP_int32* )&A_Q12_tmp[ 6 ] );
LPC_pred_Q10 = SKP_SMLAWB( LPC_pred_Q10, psDec->sLPC_Q14[ MAX_LPC_ORDER + i - 7 ], Atmp );
LPC_pred_Q10 = SKP_SMLAWT( LPC_pred_Q10, psDec->sLPC_Q14[ MAX_LPC_ORDER + i - 8 ], Atmp );
Atmp = *( ( SKP_int32* )&A_Q12_tmp[ 8 ] );
LPC_pred_Q10 = SKP_SMLAWB( LPC_pred_Q10, psDec->sLPC_Q14[ MAX_LPC_ORDER + i - 9 ], Atmp );
LPC_pred_Q10 = SKP_SMLAWT( LPC_pred_Q10, psDec->sLPC_Q14[ MAX_LPC_ORDER + i - 10 ], Atmp );
for( j = 10 ; j < psDec->LPC_order ; j+=2 ) {
Atmp = *( ( SKP_int32* )&A_Q12_tmp[ j ] );
LPC_pred_Q10 = SKP_SMLAWB( LPC_pred_Q10, psDec->sLPC_Q14[ MAX_LPC_ORDER + i - 1 - j ], Atmp );
LPC_pred_Q10 = SKP_SMLAWT( LPC_pred_Q10, psDec->sLPC_Q14[ MAX_LPC_ORDER + i - 2 - j ], Atmp );
}
/* Add prediction to LPC residual */
sig_Q10_ptr[ i ] = SKP_ADD32( sig_Q10_ptr[ i ], LPC_pred_Q10 );
/* Update states */
psDec->sLPC_Q14[ MAX_LPC_ORDER + i ] = SKP_LSHIFT( sig_Q10_ptr[ i ], 4 );
}
sig_Q10_ptr += psDec->subfr_length;
/* Update LPC filter state */
SKP_memcpy( psDec->sLPC_Q14, &psDec->sLPC_Q14[ psDec->subfr_length ], MAX_LPC_ORDER * sizeof( SKP_int32 ) );
}
/* Scale with Gain */
for( i = 0; i < psDec->frame_length; i++ ) {
signal[ i ] = ( SKP_int16 )SKP_SAT16( SKP_RSHIFT_ROUND( SKP_SMULWW( sig_Q10[ i ], psPLC->prevGain_Q16[ NB_SUBFR - 1 ] ), 10 ) );
}
/**************************************/
/* Update states */
/**************************************/
psPLC->rand_seed = rand_seed;
psPLC->randScale_Q14 = rand_scale_Q14;
for( i = 0; i < NB_SUBFR; i++ ) {
psDecCtrl->pitchL[ i ] = lag;
}
}
void SKP_Silk_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 ) );
}
/* 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 ) {
void SKP_Silk_noise_shape_analysis_FIX(
SKP_Silk_encoder_state_FIX *psEnc, /* I/O Encoder state FIX */
SKP_Silk_encoder_control_FIX *psEncCtrl, /* I/O Encoder control FIX */
const SKP_int16 *pitch_res, /* I LPC residual from pitch analysis */
const SKP_int16 *x /* I Input signal [ frame_length + la_shape ] */
)
{
SKP_Silk_shape_state_FIX *psShapeSt = &psEnc->sShape;
SKP_int k, i, nSamples, Qnrg, b_Q14, warping_Q16, scale = 0;
SKP_int32 SNR_adj_dB_Q7, HarmBoost_Q16, HarmShapeGain_Q16, Tilt_Q16, tmp32;
SKP_int32 nrg, pre_nrg_Q30, log_energy_Q7, log_energy_prev_Q7, energy_variation_Q7;
SKP_int32 delta_Q16, BWExp1_Q16, BWExp2_Q16, gain_mult_Q16, gain_add_Q16, strength_Q16, b_Q8;
SKP_int32 auto_corr[ MAX_SHAPE_LPC_ORDER + 1 ];
SKP_int32 refl_coef_Q16[ MAX_SHAPE_LPC_ORDER ];
SKP_int32 AR1_Q24[ MAX_SHAPE_LPC_ORDER ];
SKP_int32 AR2_Q24[ MAX_SHAPE_LPC_ORDER ];
SKP_int16 x_windowed[ SHAPE_LPC_WIN_MAX ];
const SKP_int16 *x_ptr, *pitch_res_ptr;
SKP_int32 sqrt_nrg[ NB_SUBFR ], Qnrg_vec[ NB_SUBFR ];
/* Point to start of first LPC analysis block */
x_ptr = x - psEnc->sCmn.la_shape;
/****************/
/* CONTROL SNR */
/****************/
/* Reduce SNR_dB values if recent bitstream has exceeded TargetRate */
psEncCtrl->current_SNR_dB_Q7 = psEnc->SNR_dB_Q7 - SKP_SMULWB( SKP_LSHIFT( ( SKP_int32 )psEnc->BufferedInChannel_ms, 7 ),
SKP_FIX_CONST( 0.05, 16 ) );
/* Reduce SNR_dB if inband FEC used */
if( psEnc->speech_activity_Q8 > SKP_FIX_CONST( LBRR_SPEECH_ACTIVITY_THRES, 8 ) ) {
psEncCtrl->current_SNR_dB_Q7 -= SKP_RSHIFT( psEnc->inBandFEC_SNR_comp_Q8, 1 );
}
/****************/
/* GAIN CONTROL */
/****************/
/* Input quality is the average of the quality in the lowest two VAD bands */
psEncCtrl->input_quality_Q14 = ( SKP_int )SKP_RSHIFT( ( SKP_int32 )psEncCtrl->input_quality_bands_Q15[ 0 ]
+ psEncCtrl->input_quality_bands_Q15[ 1 ], 2 );
/* Coding quality level, between 0.0_Q0 and 1.0_Q0, but in Q14 */
psEncCtrl->coding_quality_Q14 = SKP_RSHIFT( SKP_Silk_sigm_Q15( SKP_RSHIFT_ROUND( psEncCtrl->current_SNR_dB_Q7 -
SKP_FIX_CONST( 18.0, 7 ), 4 ) ), 1 );
/* Reduce coding SNR during low speech activity */
b_Q8 = SKP_FIX_CONST( 1.0, 8 ) - psEnc->speech_activity_Q8;
b_Q8 = SKP_SMULWB( SKP_LSHIFT( b_Q8, 8 ), b_Q8 );
SNR_adj_dB_Q7 = SKP_SMLAWB( psEncCtrl->current_SNR_dB_Q7,
SKP_SMULBB( SKP_FIX_CONST( -BG_SNR_DECR_dB, 7 ) >> ( 4 + 1 ), b_Q8 ), // Q11
SKP_SMULWB( SKP_FIX_CONST( 1.0, 14 ) + psEncCtrl->input_quality_Q14, psEncCtrl->coding_quality_Q14 ) ); // Q12
if( psEncCtrl->sCmn.sigtype == SIG_TYPE_VOICED ) {
/* Reduce gains for periodic signals */
SNR_adj_dB_Q7 = SKP_SMLAWB( SNR_adj_dB_Q7, SKP_FIX_CONST( HARM_SNR_INCR_dB, 8 ), psEnc->LTPCorr_Q15 );
} else {
/* For unvoiced signals and low-quality input, adjust the quality slower than SNR_dB setting */
SNR_adj_dB_Q7 = SKP_SMLAWB( SNR_adj_dB_Q7,
SKP_SMLAWB( SKP_FIX_CONST( 6.0, 9 ), -SKP_FIX_CONST( 0.4, 18 ), psEncCtrl->current_SNR_dB_Q7 ),
SKP_FIX_CONST( 1.0, 14 ) - psEncCtrl->input_quality_Q14 );
}
/*************************/
/* SPARSENESS PROCESSING */
/*************************/
/* Set quantizer offset */
if( psEncCtrl->sCmn.sigtype == SIG_TYPE_VOICED ) {
/* Initally set to 0; may be overruled in process_gains(..) */
psEncCtrl->sCmn.QuantOffsetType = 0;
psEncCtrl->sparseness_Q8 = 0;
} else {
/* Sparseness measure, based on relative fluctuations of energy per 2 milliseconds */
nSamples = SKP_LSHIFT( psEnc->sCmn.fs_kHz, 1 );
energy_variation_Q7 = 0;
log_energy_prev_Q7 = 0;
pitch_res_ptr = pitch_res;
for( k = 0; k < FRAME_LENGTH_MS / 2; k++ ) {
SKP_Silk_sum_sqr_shift( &nrg, &scale, pitch_res_ptr, nSamples );
nrg += SKP_RSHIFT( nSamples, scale ); // Q(-scale)
log_energy_Q7 = SKP_Silk_lin2log( nrg );
if( k > 0 ) {
energy_variation_Q7 += SKP_abs( log_energy_Q7 - log_energy_prev_Q7 );
}
log_energy_prev_Q7 = log_energy_Q7;
pitch_res_ptr += nSamples;
}
psEncCtrl->sparseness_Q8 = SKP_RSHIFT( SKP_Silk_sigm_Q15( SKP_SMULWB( energy_variation_Q7 -
SKP_FIX_CONST( 5.0, 7 ), SKP_FIX_CONST( 0.1, 16 ) ) ), 7 );
/* Set quantization offset depending on sparseness measure */
if( psEncCtrl->sparseness_Q8 > SKP_FIX_CONST( SPARSENESS_THRESHOLD_QNT_OFFSET, 8 ) ) {
psEncCtrl->sCmn.QuantOffsetType = 0;
} else {
psEncCtrl->sCmn.QuantOffsetType = 1;
}
/* Increase coding SNR for sparse signals */
SNR_adj_dB_Q7 = SKP_SMLAWB( SNR_adj_dB_Q7, SKP_FIX_CONST( SPARSE_SNR_INCR_dB, 15 ), psEncCtrl->sparseness_Q8 - SKP_FIX_CONST( 0.5, 8 ) );
}
/*******************************/
/* Control bandwidth expansion */
/*******************************/
/* More BWE for signals with high prediction gain */
strength_Q16 = SKP_SMULWB( psEncCtrl->predGain_Q16, SKP_FIX_CONST( FIND_PITCH_WHITE_NOISE_FRACTION, 16 ) );
BWExp1_Q16 = BWExp2_Q16 = SKP_DIV32_varQ( SKP_FIX_CONST( BANDWIDTH_EXPANSION, 16 ),
SKP_SMLAWW( SKP_FIX_CONST( 1.0, 16 ), strength_Q16, strength_Q16 ), 16 );
delta_Q16 = SKP_SMULWB( SKP_FIX_CONST( 1.0, 16 ) - SKP_SMULBB( 3, psEncCtrl->coding_quality_Q14 ),
SKP_FIX_CONST( LOW_RATE_BANDWIDTH_EXPANSION_DELTA, 16 ) );
BWExp1_Q16 = SKP_SUB32( BWExp1_Q16, delta_Q16 );
BWExp2_Q16 = SKP_ADD32( BWExp2_Q16, delta_Q16 );
/* BWExp1 will be applied after BWExp2, so make it relative */
BWExp1_Q16 = SKP_DIV32_16( SKP_LSHIFT( BWExp1_Q16, 14 ), SKP_RSHIFT( BWExp2_Q16, 2 ) );
if( psEnc->sCmn.warping_Q16 > 0 ) {
/* Slightly more warping in analysis will move quantization noise up in frequency, where it's better masked */
warping_Q16 = SKP_SMLAWB( psEnc->sCmn.warping_Q16, psEncCtrl->coding_quality_Q14, SKP_FIX_CONST( 0.01, 18 ) );
} else {
warping_Q16 = 0;
}
/********************************************/
/* Compute noise shaping AR coefs and gains */
/********************************************/
for( k = 0; k < NB_SUBFR; k++ ) {
/* Apply window: sine slope followed by flat part followed by cosine slope */
SKP_int shift, slope_part, flat_part;
flat_part = psEnc->sCmn.fs_kHz * 5;
slope_part = SKP_RSHIFT( psEnc->sCmn.shapeWinLength - flat_part, 1 );
SKP_Silk_apply_sine_window_new( x_windowed, x_ptr, 1, slope_part );
shift = slope_part;
SKP_memcpy( x_windowed + shift, x_ptr + shift, flat_part * sizeof(SKP_int16) );
shift += flat_part;
SKP_Silk_apply_sine_window_new( x_windowed + shift, x_ptr + shift, 2, slope_part );
/* Update pointer: next LPC analysis block */
x_ptr += psEnc->sCmn.subfr_length;
if( psEnc->sCmn.warping_Q16 > 0 ) {
/* Calculate warped auto correlation */
SKP_Silk_warped_autocorrelation_FIX( auto_corr, &scale, x_windowed, warping_Q16, psEnc->sCmn.shapeWinLength, psEnc->sCmn.shapingLPCOrder );
} else {
/* Calculate regular auto correlation */
SKP_Silk_autocorr( auto_corr, &scale, x_windowed, psEnc->sCmn.shapeWinLength, psEnc->sCmn.shapingLPCOrder + 1 );
}
/* Add white noise, as a fraction of energy */
auto_corr[0] = SKP_ADD32( auto_corr[0], SKP_max_32( SKP_SMULWB( SKP_RSHIFT( auto_corr[ 0 ], 4 ),
SKP_FIX_CONST( SHAPE_WHITE_NOISE_FRACTION, 20 ) ), 1 ) );
/* Calculate the reflection coefficients using schur */
nrg = SKP_Silk_schur64( refl_coef_Q16, auto_corr, psEnc->sCmn.shapingLPCOrder );
SKP_assert( nrg >= 0 );
/* Convert reflection coefficients to prediction coefficients */
SKP_Silk_k2a_Q16( AR2_Q24, refl_coef_Q16, psEnc->sCmn.shapingLPCOrder );
Qnrg = -scale; // range: -12...30
SKP_assert( Qnrg >= -12 );
SKP_assert( Qnrg <= 30 );
/* Make sure that Qnrg is an even number */
if( Qnrg & 1 ) {
Qnrg -= 1;
nrg >>= 1;
}
tmp32 = SKP_Silk_SQRT_APPROX( nrg );
Qnrg >>= 1; // range: -6...15
sqrt_nrg[ k ] = tmp32;
Qnrg_vec[ k ] = Qnrg;
psEncCtrl->Gains_Q16[ k ] = SKP_LSHIFT_SAT32( tmp32, 16 - Qnrg );
if( psEnc->sCmn.warping_Q16 > 0 ) {
/* Adjust gain for warping */
gain_mult_Q16 = warped_gain( AR2_Q24, warping_Q16, psEnc->sCmn.shapingLPCOrder );
SKP_assert( psEncCtrl->Gains_Q16[ k ] >= 0 );
psEncCtrl->Gains_Q16[ k ] = SKP_SMULWW( psEncCtrl->Gains_Q16[ k ], gain_mult_Q16 );
if( psEncCtrl->Gains_Q16[ k ] < 0 ) {
psEncCtrl->Gains_Q16[ k ] = SKP_int32_MAX;
}
}
/* Bandwidth expansion for synthesis filter shaping */
SKP_Silk_bwexpander_32( AR2_Q24, psEnc->sCmn.shapingLPCOrder, BWExp2_Q16 );
/* Compute noise shaping filter coefficients */
SKP_memcpy( AR1_Q24, AR2_Q24, psEnc->sCmn.shapingLPCOrder * sizeof( SKP_int32 ) );
/* Bandwidth expansion for analysis filter shaping */
SKP_assert( BWExp1_Q16 <= SKP_FIX_CONST( 1.0, 16 ) );
SKP_Silk_bwexpander_32( AR1_Q24, psEnc->sCmn.shapingLPCOrder, BWExp1_Q16 );
/* Ratio of prediction gains, in energy domain */
SKP_Silk_LPC_inverse_pred_gain_Q24( &pre_nrg_Q30, AR2_Q24, psEnc->sCmn.shapingLPCOrder );
SKP_Silk_LPC_inverse_pred_gain_Q24( &nrg, AR1_Q24, psEnc->sCmn.shapingLPCOrder );
//psEncCtrl->GainsPre[ k ] = 1.0f - 0.7f * ( 1.0f - pre_nrg / nrg ) = 0.3f + 0.7f * pre_nrg / nrg;
pre_nrg_Q30 = SKP_LSHIFT32( SKP_SMULWB( pre_nrg_Q30, SKP_FIX_CONST( 0.7, 15 ) ), 1 );
psEncCtrl->GainsPre_Q14[ k ] = ( SKP_int ) SKP_FIX_CONST( 0.3, 14 ) + SKP_DIV32_varQ( pre_nrg_Q30, nrg, 14 );
/* Convert to monic warped prediction coefficients and limit absolute values */
limit_warped_coefs( AR2_Q24, AR1_Q24, warping_Q16, SKP_FIX_CONST( 3.999, 24 ), psEnc->sCmn.shapingLPCOrder );
/* Convert from Q24 to Q13 and store in int16 */
for( i = 0; i < psEnc->sCmn.shapingLPCOrder; i++ ) {
psEncCtrl->AR1_Q13[ k * MAX_SHAPE_LPC_ORDER + i ] = (SKP_int16)SKP_SAT16( SKP_RSHIFT_ROUND( AR1_Q24[ i ], 11 ) );
psEncCtrl->AR2_Q13[ k * MAX_SHAPE_LPC_ORDER + i ] = (SKP_int16)SKP_SAT16( SKP_RSHIFT_ROUND( AR2_Q24[ i ], 11 ) );
}
}
SKP_int SKP_Silk_encode_frame_FLP(
SKP_Silk_encoder_state_FLP *psEnc, /* I/O Encoder state FLP */
SKP_uint8 *pCode, /* O Payload */
SKP_int16 *pnBytesOut, /* I/O Number of payload bytes; */
/* input: max length; output: used */
const SKP_int16 *pIn /* I Input speech frame */
)
{
SKP_Silk_encoder_control_FLP sEncCtrl;
SKP_int k, nBytes, ret = 0;
SKP_float *x_frame, *res_pitch_frame;
SKP_int16 pIn_HP[ MAX_FRAME_LENGTH ];
SKP_int16 pIn_HP_LP[ MAX_FRAME_LENGTH ];
SKP_float xfw[ MAX_FRAME_LENGTH ];
SKP_float res_pitch[ 2 * MAX_FRAME_LENGTH + LA_PITCH_MAX ];
SKP_int LBRR_idx, frame_terminator;
/* Low bitrate redundancy parameters */
SKP_uint8 LBRRpayload[ MAX_ARITHM_BYTES ];
SKP_int16 nBytesLBRR;
const SKP_uint16 *FrameTermination_CDF;
sEncCtrl.sCmn.Seed = psEnc->sCmn.frameCounter++ & 3;
/**************************************************************/
/* Setup Input Pointers, and insert frame in input buffer */
/*************************************************************/
/* pointers aligned with start of frame to encode */
x_frame = psEnc->x_buf + psEnc->sCmn.frame_length; // start of frame to encode
res_pitch_frame = res_pitch + psEnc->sCmn.frame_length; // start of pitch LPC residual frame
/****************************/
/* Voice Activity Detection */
/****************************/
SKP_Silk_VAD_FLP( psEnc, &sEncCtrl, pIn );
/*******************************************/
/* High-pass filtering of the input signal */
/*******************************************/
#if HIGH_PASS_INPUT
/* Variable high-pass filter */
SKP_Silk_HP_variable_cutoff_FLP( psEnc, &sEncCtrl, pIn_HP, pIn );
#else
SKP_memcpy( pIn_HP, pIn, psEnc->sCmn.frame_length * sizeof( SKP_int16 ) );
#endif
#if SWITCH_TRANSITION_FILTERING
/* Ensure smooth bandwidth transitions */
SKP_Silk_LP_variable_cutoff( &psEnc->sCmn.sLP, pIn_HP_LP, pIn_HP, psEnc->sCmn.frame_length );
#else
SKP_memcpy( pIn_HP_LP, pIn_HP, psEnc->sCmn.frame_length * sizeof( SKP_int16 ) );
#endif
/*******************************************/
/* Copy new frame to front of input buffer */
/*******************************************/
SKP_short2float_array( x_frame + LA_SHAPE_MS * psEnc->sCmn.fs_kHz, pIn_HP_LP, psEnc->sCmn.frame_length );
/* Add tiny signal to avoid high CPU load from denormalized floating point numbers */
for( k = 0; k < 8; k++ ) {
x_frame[ LA_SHAPE_MS * psEnc->sCmn.fs_kHz + k * ( psEnc->sCmn.frame_length >> 3 ) ] += ( 1 - ( k & 2 ) ) * 1e-6f;
}
/*****************************************/
/* Find pitch lags, initial LPC analysis */
/*****************************************/
SKP_Silk_find_pitch_lags_FLP( psEnc, &sEncCtrl, res_pitch, x_frame );
/************************/
/* Noise shape analysis */
/************************/
SKP_Silk_noise_shape_analysis_FLP( psEnc, &sEncCtrl, res_pitch_frame, x_frame );
/*****************************************/
/* Prefiltering for noise shaper */
/*****************************************/
SKP_Silk_prefilter_FLP( psEnc, &sEncCtrl, xfw, x_frame );
/***************************************************/
/* Find linear prediction coefficients (LPC + LTP) */
/***************************************************/
SKP_Silk_find_pred_coefs_FLP( psEnc, &sEncCtrl, res_pitch );
/****************************************/
/* Process gains */
/****************************************/
SKP_Silk_process_gains_FLP( psEnc, &sEncCtrl );
/****************************************/
/* Low Bitrate Redundant Encoding */
/****************************************/
nBytesLBRR = MAX_ARITHM_BYTES;
SKP_Silk_LBRR_encode_FLP( psEnc, &sEncCtrl, LBRRpayload, &nBytesLBRR, xfw );
/*****************************************/
/* Noise shaping quantization */
/*****************************************/
SKP_Silk_NSQ_wrapper_FLP( psEnc, &sEncCtrl, xfw, psEnc->sCmn.q, 0 );
/**************************************************/
/* Convert speech activity into VAD and DTX flags */
/**************************************************/
if( psEnc->speech_activity < SPEECH_ACTIVITY_DTX_THRES ) {
psEnc->sCmn.vadFlag = NO_VOICE_ACTIVITY;
psEnc->sCmn.noSpeechCounter++;
if( psEnc->sCmn.noSpeechCounter > NO_SPEECH_FRAMES_BEFORE_DTX ) {
psEnc->sCmn.inDTX = 1;
}
if( psEnc->sCmn.noSpeechCounter > MAX_CONSECUTIVE_DTX + NO_SPEECH_FRAMES_BEFORE_DTX ) {
psEnc->sCmn.noSpeechCounter = NO_SPEECH_FRAMES_BEFORE_DTX;
psEnc->sCmn.inDTX = 0;
}
} else {
psEnc->sCmn.noSpeechCounter = 0;
psEnc->sCmn.inDTX = 0;
psEnc->sCmn.vadFlag = VOICE_ACTIVITY;
}
/****************************************/
/* Initialize range coder */
/****************************************/
if( psEnc->sCmn.nFramesInPayloadBuf == 0 ) {
SKP_Silk_range_enc_init( &psEnc->sCmn.sRC );
psEnc->sCmn.nBytesInPayloadBuf = 0;
}
/****************************************/
/* Encode Parameters */
/****************************************/
SKP_Silk_encode_parameters( &psEnc->sCmn, &sEncCtrl.sCmn, &psEnc->sCmn.sRC, psEnc->sCmn.q );
FrameTermination_CDF = SKP_Silk_FrameTermination_CDF;
/****************************************/
/* Update Buffers and State */
/****************************************/
/* Update input buffer */
SKP_memmove( psEnc->x_buf, &psEnc->x_buf[ psEnc->sCmn.frame_length ],
( psEnc->sCmn.frame_length + LA_SHAPE_MS * psEnc->sCmn.fs_kHz ) * sizeof( SKP_float ) );
/* Parameters needed for next frame */
psEnc->sCmn.prev_sigtype = sEncCtrl.sCmn.sigtype;
psEnc->sCmn.prevLag = sEncCtrl.sCmn.pitchL[ NB_SUBFR - 1];
psEnc->sCmn.first_frame_after_reset = 0;
if( psEnc->sCmn.sRC.error ) {
/* Encoder returned error: Clear payload buffer */
psEnc->sCmn.nFramesInPayloadBuf = 0;
} else {
psEnc->sCmn.nFramesInPayloadBuf++;
}
/****************************************/
/* Finalize payload and copy to output */
/****************************************/
if( psEnc->sCmn.nFramesInPayloadBuf * FRAME_LENGTH_MS >= psEnc->sCmn.PacketSize_ms ) {
LBRR_idx = ( psEnc->sCmn.oldest_LBRR_idx + 1 ) & LBRR_IDX_MASK;
/* Check if FEC information should be added */
frame_terminator = SKP_SILK_LAST_FRAME;
if( psEnc->sCmn.LBRR_buffer[ LBRR_idx ].usage == SKP_SILK_ADD_LBRR_TO_PLUS1 ) {
frame_terminator = SKP_SILK_LBRR_VER1;
}
if( psEnc->sCmn.LBRR_buffer[ psEnc->sCmn.oldest_LBRR_idx ].usage == SKP_SILK_ADD_LBRR_TO_PLUS2 ) {
frame_terminator = SKP_SILK_LBRR_VER2;
LBRR_idx = psEnc->sCmn.oldest_LBRR_idx;
}
/* Add the frame termination info to stream */
SKP_Silk_range_encoder( &psEnc->sCmn.sRC, frame_terminator, FrameTermination_CDF );
/* Payload length so far */
SKP_Silk_range_coder_get_length( &psEnc->sCmn.sRC, &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 );
SKP_memcpy( pCode, psEnc->sCmn.sRC.buffer, nBytes * sizeof( SKP_uint8 ) );
if( frame_terminator > SKP_SILK_MORE_FRAMES &&
*pnBytesOut >= nBytes + psEnc->sCmn.LBRR_buffer[ LBRR_idx ].nBytes ) {
/* Get old packet and add to payload. */
SKP_memcpy( &pCode[ nBytes ],
psEnc->sCmn.LBRR_buffer[ LBRR_idx ].payload,
psEnc->sCmn.LBRR_buffer[ LBRR_idx ].nBytes * sizeof( SKP_uint8 ) );
nBytes += psEnc->sCmn.LBRR_buffer[ LBRR_idx ].nBytes;
}
*pnBytesOut = nBytes;
/* Update FEC buffer */
SKP_memcpy( psEnc->sCmn.LBRR_buffer[ psEnc->sCmn.oldest_LBRR_idx ].payload, LBRRpayload,
nBytesLBRR * sizeof( SKP_uint8 ) );
psEnc->sCmn.LBRR_buffer[ psEnc->sCmn.oldest_LBRR_idx ].nBytes = nBytesLBRR;
/* The line below describes how FEC should be used */
psEnc->sCmn.LBRR_buffer[ psEnc->sCmn.oldest_LBRR_idx ].usage = sEncCtrl.sCmn.LBRR_usage;
psEnc->sCmn.oldest_LBRR_idx = ( ( psEnc->sCmn.oldest_LBRR_idx + 1 ) & LBRR_IDX_MASK );
} else {
/* Not enough space: Payload will be discarded */
*pnBytesOut = 0;
nBytes = 0;
ret = SKP_SILK_ENC_PAYLOAD_BUF_TOO_SHORT;
}
/* Reset the number of frames in payload buffer */
psEnc->sCmn.nFramesInPayloadBuf = 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, frame_terminator, FrameTermination_CDF );
/* Payload length so far */
SKP_Silk_range_coder_get_length( &psEnc->sCmn.sRC, &nBytes );
}
/* Check for arithmetic coder errors */
if( psEnc->sCmn.sRC.error ) {
ret = SKP_SILK_ENC_INTERNAL_ERROR;
}
/* Simulate number of ms buffered in channel because of exceeding TargetRate */
psEnc->BufferedInChannel_ms += ( 8.0f * 1000.0f * ( nBytes - psEnc->sCmn.nBytesInPayloadBuf ) ) / psEnc->sCmn.TargetRate_bps;
psEnc->BufferedInChannel_ms -= FRAME_LENGTH_MS;
psEnc->BufferedInChannel_ms = SKP_LIMIT_float( psEnc->BufferedInChannel_ms, 0.0f, 100.0f );
psEnc->sCmn.nBytesInPayloadBuf = nBytes;
if( psEnc->speech_activity > WB_DETECT_ACTIVE_SPEECH_LEVEL_THRES ) {
psEnc->sCmn.sSWBdetect.ActiveSpeech_ms = SKP_ADD_POS_SAT32( psEnc->sCmn.sSWBdetect.ActiveSpeech_ms, FRAME_LENGTH_MS );
}
return( ret );
}
/* 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 );
}
/* 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 ) );
}
}
/* Decode a frame */
SKP_int SKP_Silk_SDK_Decode(
void* decState, /* I/O: State */
SKP_SILK_SDK_DecControlStruct* decControl, /* I/O: Control structure */
SKP_int lostFlag, /* I: 0: no loss, 1 loss */
const SKP_uint8 *inData, /* I: Encoded input vector */
const SKP_int nBytesIn, /* I: Number of input Bytes */
SKP_int16 *samplesOut, /* O: Decoded output speech vector */
SKP_int16 *nSamplesOut /* I/O: Number of samples (vector/decoded) */
)
{
SKP_int ret = 0, used_bytes, prev_fs_kHz;
SKP_Silk_decoder_state *psDec;
SKP_int16 samplesOutInternal[ MAX_API_FS_KHZ * FRAME_LENGTH_MS ];
SKP_int16 *pSamplesOutInternal;
psDec = (SKP_Silk_decoder_state *)decState;
/* We need this buffer to have room for an internal frame */
pSamplesOutInternal = samplesOut;
if( psDec->fs_kHz * 1000 > decControl->API_sampleRate ) {
pSamplesOutInternal = samplesOutInternal;
}
/**********************************/
/* Test if first frame in payload */
/**********************************/
if( psDec->moreInternalDecoderFrames == 0 ) {
/* First Frame in Payload */
psDec->nFramesDecoded = 0; /* Used to count frames in packet */
}
if( psDec->moreInternalDecoderFrames == 0 && /* First frame in packet */
lostFlag == 0 && /* Not packet loss */
nBytesIn > MAX_ARITHM_BYTES ) { /* Too long payload */
/* Avoid trying to decode a too large packet */
lostFlag = 1;
ret = SKP_SILK_DEC_PAYLOAD_TOO_LARGE;
}
/* Save previous sample frequency */
prev_fs_kHz = psDec->fs_kHz;
/* Call decoder for one frame */
ret += SKP_Silk_decode_frame( psDec, pSamplesOutInternal, nSamplesOut, inData, nBytesIn,
lostFlag, &used_bytes );
if( used_bytes ) { /* Only Call if not a packet loss */
if( psDec->nBytesLeft > 0 && psDec->FrameTermination == SKP_SILK_MORE_FRAMES && psDec->nFramesDecoded < 5 ) {
/* We have more frames in the Payload */
psDec->moreInternalDecoderFrames = 1;
} else {
/* Last frame in Payload */
psDec->moreInternalDecoderFrames = 0;
psDec->nFramesInPacket = psDec->nFramesDecoded;
/* Track inband FEC usage */
if( psDec->vadFlag == VOICE_ACTIVITY ) {
if( psDec->FrameTermination == SKP_SILK_LAST_FRAME ) {
psDec->no_FEC_counter++;
if( psDec->no_FEC_counter > NO_LBRR_THRES ) {
psDec->inband_FEC_offset = 0;
}
} else if( psDec->FrameTermination == SKP_SILK_LBRR_VER1 ) {
psDec->inband_FEC_offset = 1; /* FEC info with 1 packet delay */
psDec->no_FEC_counter = 0;
} else if( psDec->FrameTermination == SKP_SILK_LBRR_VER2 ) {
psDec->inband_FEC_offset = 2; /* FEC info with 2 packets delay */
psDec->no_FEC_counter = 0;
}
}
}
}
if( MAX_API_FS_KHZ * 1000 < decControl->API_sampleRate ||
8000 > decControl->API_sampleRate ) {
ret = SKP_SILK_DEC_INVALID_SAMPLING_FREQUENCY;
return( ret );
}
/* Resample if needed */
if( psDec->fs_kHz * 1000 != decControl->API_sampleRate ) {
SKP_int16 samplesOut_tmp[ MAX_API_FS_KHZ * FRAME_LENGTH_MS ];
SKP_assert( psDec->fs_kHz <= MAX_API_FS_KHZ );
/* Copy to a tmp buffer as the resampling writes to samplesOut */
SKP_memcpy( samplesOut_tmp, pSamplesOutInternal, *nSamplesOut * sizeof( SKP_int16 ) );
/* (Re-)initialize resampler state when switching internal sampling frequency */
if( prev_fs_kHz != psDec->fs_kHz || psDec->prev_API_sampleRate != decControl->API_sampleRate ) {
ret = SKP_Silk_resampler_init( &psDec->resampler_state, SKP_SMULBB( psDec->fs_kHz, 1000 ), decControl->API_sampleRate );
}
/* Resample the output to API_sampleRate */
ret += SKP_Silk_resampler( &psDec->resampler_state, samplesOut, samplesOut_tmp, *nSamplesOut );
/* Update the number of output samples */
*nSamplesOut = SKP_DIV32( ( SKP_int32 )*nSamplesOut * decControl->API_sampleRate, psDec->fs_kHz * 1000 );
} else if( prev_fs_kHz * 1000 > decControl->API_sampleRate ) {
SKP_memcpy( samplesOut, pSamplesOutInternal, *nSamplesOut * sizeof( SKP_int16 ) );
}
psDec->prev_API_sampleRate = decControl->API_sampleRate;
/* Copy all parameters that are needed out of internal structure to the control stucture */
decControl->frameSize = (SKP_uint16)( decControl->API_sampleRate / 50 ) ;
decControl->framesPerPacket = ( SKP_int )psDec->nFramesInPacket;
decControl->inBandFECOffset = ( SKP_int )psDec->inband_FEC_offset;
decControl->moreInternalDecoderFrames = ( SKP_int )psDec->moreInternalDecoderFrames;
return ret;
}
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 ) );
}
SKP_int SKP_Silk_decode_frame(
SKP_Silk_decoder_state *psDec, /* I/O Pointer to Silk decoder state */
SKP_int16 pOut[], /* O Pointer to output speech frame */
SKP_int16 *pN, /* O Pointer to size of output frame */
const SKP_uint8 pCode[], /* I Pointer to payload */
const SKP_int nBytes, /* I Payload length */
SKP_int action, /* I Action from Jitter Buffer */
SKP_int *decBytes /* O Used bytes to decode this frame */
)
{
SKP_Silk_decoder_control sDecCtrl;
SKP_int L, fs_Khz_old, ret = 0;
SKP_int Pulses[ MAX_FRAME_LENGTH ];
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 */
/********************************************/
*decBytes = 0;
if( action == 0 ) {
/********************************************/
/* Initialize arithmetic coder */
/********************************************/
fs_Khz_old = psDec->fs_kHz;
if( psDec->nFramesDecoded == 0 ) {
/* Initialize range decoder state */
SKP_Silk_range_dec_init( &psDec->sRC, pCode, nBytes );
}
/********************************************/
/* Decode parameters and pulse signal */
/********************************************/
SKP_Silk_decode_parameters( psDec, &sDecCtrl, Pulses, 1 );
if( psDec->sRC.error ) {
psDec->nBytesLeft = 0;
action = 1; /* PLC operation */
/* revert fs if changed in decode_parameters */
SKP_Silk_decoder_set_fs( psDec, fs_Khz_old );
/* Avoid crashing */
*decBytes = psDec->sRC.bufferLength;
if( psDec->sRC.error == RANGE_CODER_DEC_PAYLOAD_TOO_LONG ) {
ret = SKP_SILK_DEC_PAYLOAD_TOO_LARGE;
} else {
ret = SKP_SILK_DEC_PAYLOAD_ERROR;
}
} else {
*decBytes = psDec->sRC.bufferLength - psDec->nBytesLeft;
psDec->nFramesDecoded++;
/* Update lengths. Sampling frequency could have changed */
L = psDec->frame_length;
/********************************************************/
/* Run inverse NSQ */
/********************************************************/
SKP_Silk_decode_core( psDec, &sDecCtrl, pOut, Pulses );
/********************************************************/
/* Update PLC state */
/********************************************************/
SKP_Silk_PLC( psDec, &sDecCtrl, pOut, L, action );
psDec->lossCnt = 0;
psDec->prev_sigtype = sDecCtrl.sigtype;
/* A frame has been decoded without errors */
psDec->first_frame_after_reset = 0;
}
}
/*************************************************************/
/* Generate Concealment frame if packet is lost, or corrupt */
/*************************************************************/
if( action == 1 ) {
/* Handle packet loss by extrapolation */
SKP_Silk_PLC( psDec, &sDecCtrl, pOut, L, action );
}
/*************************/
/* Update output buffer. */
/*************************/
SKP_memcpy( psDec->outBuf, pOut, L * 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 */
/********************************************/
SKP_assert( ( ( psDec->fs_kHz == 12 ) && ( L % 3 ) == 0 ) ||
( ( psDec->fs_kHz != 12 ) && ( L % 2 ) == 0 ) );
SKP_Silk_biquad( pOut, psDec->HP_B, psDec->HP_A, psDec->HPState, pOut, L );
/********************************************/
/* set output frame length */
/********************************************/
*pN = ( SKP_int16 )L;
/* Update some decoder state variables */
psDec->lagPrev = sDecCtrl.pitchL[ NB_SUBFR - 1 ];
return ret;
}
/* Resamples input data with a factor 2/3 */
void SKP_Silk_resample_2_3_coarse(int16_t * out, /* O: Output signal */
int16_t * S, /* I/O: Resampler state [ SigProc_Resample_2_3_coarse_NUM_FIR_COEFS - 1 ] */
const int16_t * in, /* I: Input signal */
const int frameLenIn, /* I: Number of input samples */
int16_t * scratch /* I: Scratch memory [ frameLenIn + SigProc_Resample_2_3_coarse_NUM_FIR_COEFS - 1 ] */
)
{
int32_t n, ind, interpol_ind, tmp, index_Q16;
int16_t *in_ptr;
int frameLenOut;
const int16_t *interpol_ptr;
/* Copy buffered samples to start of scratch */
SKP_memcpy(scratch, S,
(SigProc_Resample_2_3_coarse_NUM_FIR_COEFS -
1) * sizeof(int16_t));
/* Then append by the input signal */
SKP_memcpy(&scratch[SigProc_Resample_2_3_coarse_NUM_FIR_COEFS - 1], in,
frameLenIn * sizeof(int16_t));
frameLenOut = SKP_DIV32_16(SKP_MUL(2, frameLenIn), 3);
index_Q16 = 0;
assert(frameLenIn == ((frameLenOut * 3) / 2));
/* Interpolate */
for (n = frameLenOut; n > 0; n--) {
/* Integer part */
ind = SKP_RSHIFT(index_Q16, 16);
/* Pointer to buffered input */
in_ptr = scratch + ind;
/* Fractional part */
interpol_ind =
(SKP_SMULWB
(index_Q16,
SigProc_Resample_2_3_coarse_NUM_INTERPOLATORS) &
(SigProc_Resample_2_3_coarse_NUM_INTERPOLATORS - 1));
/* Pointer to FIR taps */
interpol_ptr =
SigProc_Resample_2_3_coarse_INTERPOL[interpol_ind];
/* Interpolate */
/* Hardcoded for 32 FIR taps */
assert(SigProc_Resample_2_3_coarse_NUM_FIR_COEFS == 32);
tmp =
(int32_t) interpol_ptr[0] * in_ptr[0] +
(int32_t) interpol_ptr[1] * in_ptr[1] +
(int32_t) interpol_ptr[2] * in_ptr[2] +
(int32_t) interpol_ptr[3] * in_ptr[3] +
(int32_t) interpol_ptr[4] * in_ptr[4] +
(int32_t) interpol_ptr[5] * in_ptr[5] +
(int32_t) interpol_ptr[6] * in_ptr[6] +
(int32_t) interpol_ptr[7] * in_ptr[7] +
(int32_t) interpol_ptr[8] * in_ptr[8] +
(int32_t) interpol_ptr[9] * in_ptr[9] +
(int32_t) interpol_ptr[10] * in_ptr[10] +
(int32_t) interpol_ptr[11] * in_ptr[11] +
(int32_t) interpol_ptr[12] * in_ptr[12] +
(int32_t) interpol_ptr[13] * in_ptr[13] +
(int32_t) interpol_ptr[14] * in_ptr[14] +
(int32_t) interpol_ptr[15] * in_ptr[15] +
(int32_t) interpol_ptr[16] * in_ptr[16] +
(int32_t) interpol_ptr[17] * in_ptr[17] +
(int32_t) interpol_ptr[18] * in_ptr[18] +
(int32_t) interpol_ptr[19] * in_ptr[19] +
(int32_t) interpol_ptr[20] * in_ptr[20] +
(int32_t) interpol_ptr[21] * in_ptr[21] +
(int32_t) interpol_ptr[22] * in_ptr[22] +
(int32_t) interpol_ptr[23] * in_ptr[23] +
(int32_t) interpol_ptr[24] * in_ptr[24] +
(int32_t) interpol_ptr[25] * in_ptr[25] +
(int32_t) interpol_ptr[26] * in_ptr[26] +
(int32_t) interpol_ptr[27] * in_ptr[27] +
(int32_t) interpol_ptr[28] * in_ptr[28] +
(int32_t) interpol_ptr[29] * in_ptr[29];
/* Round, saturate and store to output array */
*out++ = (int16_t) SKP_SAT16(SKP_RSHIFT_ROUND(tmp, 15));
/* Update index */
index_Q16 += ((1 << 16) + (1 << 15)); // (3/2)_Q0;
}
/* Move last part of input signal to the sample buffer to prepare for the next call */
SKP_memcpy(S,
&in[frameLenIn -
(SigProc_Resample_2_3_coarse_NUM_FIR_COEFS - 1)],
(SigProc_Resample_2_3_coarse_NUM_FIR_COEFS -
1) * sizeof(int16_t));
}
/* Limit, stabilize, convert and quantize NLSFs */
void silk_process_NLSFs(
silk_encoder_state *psEncC, /* I/O Encoder state */
opus_int16 PredCoef_Q12[ 2 ][ MAX_LPC_ORDER ], /* O Prediction coefficients */
opus_int16 pNLSF_Q15[ MAX_LPC_ORDER ], /* I/O Normalized LSFs (quant out) (0 - (2^15-1)) */
const opus_int16 prev_NLSFq_Q15[ MAX_LPC_ORDER ] /* I Previous Normalized LSFs (0 - (2^15-1)) */
)
{
opus_int i, doInterpolate;
opus_int NLSF_mu_Q20;
opus_int32 i_sqr_Q15;
opus_int16 pNLSF0_temp_Q15[ MAX_LPC_ORDER ];
opus_int16 pNLSFW_QW[ MAX_LPC_ORDER ];
opus_int16 pNLSFW0_temp_QW[ MAX_LPC_ORDER ];
SKP_assert( psEncC->speech_activity_Q8 >= 0 );
SKP_assert( psEncC->speech_activity_Q8 <= SILK_FIX_CONST( 1.0, 8 ) );
/***********************/
/* Calculate mu values */
/***********************/
/* NLSF_mu = 0.003 - 0.0015 * psEnc->speech_activity; */
NLSF_mu_Q20 = SKP_SMLAWB( SILK_FIX_CONST( 0.0025, 20 ), SILK_FIX_CONST( -0.001, 28 ), psEncC->speech_activity_Q8 );
if( psEncC->nb_subfr == 2 ) {
/* Multiply by 1.5 for 10 ms packets */
NLSF_mu_Q20 = SKP_ADD_RSHIFT( NLSF_mu_Q20, NLSF_mu_Q20, 1 );
}
SKP_assert( NLSF_mu_Q20 > 0 );
SKP_assert( NLSF_mu_Q20 <= SILK_FIX_CONST( 0.0045, 20 ) );
/* Calculate NLSF weights */
silk_NLSF_VQ_weights_laroia( pNLSFW_QW, pNLSF_Q15, psEncC->predictLPCOrder );
/* Update NLSF weights for interpolated NLSFs */
doInterpolate = ( psEncC->useInterpolatedNLSFs == 1 ) && ( psEncC->indices.NLSFInterpCoef_Q2 < 4 );
if( doInterpolate ) {
/* Calculate the interpolated NLSF vector for the first half */
silk_interpolate( pNLSF0_temp_Q15, prev_NLSFq_Q15, pNLSF_Q15,
psEncC->indices.NLSFInterpCoef_Q2, psEncC->predictLPCOrder );
/* Calculate first half NLSF weights for the interpolated NLSFs */
silk_NLSF_VQ_weights_laroia( pNLSFW0_temp_QW, pNLSF0_temp_Q15, psEncC->predictLPCOrder );
/* Update NLSF weights with contribution from first half */
i_sqr_Q15 = SKP_LSHIFT( SKP_SMULBB( psEncC->indices.NLSFInterpCoef_Q2, psEncC->indices.NLSFInterpCoef_Q2 ), 11 );
for( i = 0; i < psEncC->predictLPCOrder; i++ ) {
pNLSFW_QW[ i ] = SKP_SMLAWB( SKP_RSHIFT( pNLSFW_QW[ i ], 1 ), pNLSFW0_temp_QW[ i ], i_sqr_Q15 );
SKP_assert( pNLSFW_QW[ i ] <= SKP_int16_MAX );
SKP_assert( pNLSFW_QW[ i ] >= 1 );
}
}
TIC(NLSF_encode)
silk_NLSF_encode( psEncC->indices.NLSFIndices, pNLSF_Q15, psEncC->psNLSF_CB, pNLSFW_QW,
NLSF_mu_Q20, psEncC->NLSF_MSVQ_Survivors, psEncC->indices.signalType );
TOC(NLSF_encode)
/* Convert quantized NLSFs back to LPC coefficients */
silk_NLSF2A( PredCoef_Q12[ 1 ], pNLSF_Q15, psEncC->predictLPCOrder );
if( doInterpolate ) {
/* Calculate the interpolated, quantized LSF vector for the first half */
silk_interpolate( pNLSF0_temp_Q15, prev_NLSFq_Q15, pNLSF_Q15,
psEncC->indices.NLSFInterpCoef_Q2, psEncC->predictLPCOrder );
/* Convert back to LPC coefficients */
silk_NLSF2A( PredCoef_Q12[ 0 ], pNLSF0_temp_Q15, psEncC->predictLPCOrder );
} else {
/* Copy LPC coefficients for first half from second half */
SKP_memcpy( PredCoef_Q12[ 0 ], PredCoef_Q12[ 1 ], psEncC->predictLPCOrder * sizeof( opus_int16 ) );
}
}
/* 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;
}
/* Compute noise shaping coefficients and initial gain values */
void silk_noise_shape_analysis_FLP(
silk_encoder_state_FLP *psEnc, /* I/O Encoder state FLP */
silk_encoder_control_FLP *psEncCtrl, /* I/O Encoder control FLP */
const SKP_float *pitch_res, /* I LPC residual from pitch analysis */
const SKP_float *x /* I Input signal [frame_length + la_shape] */
)
{
silk_shape_state_FLP *psShapeSt = &psEnc->sShape;
SKP_int k, nSamples;
SKP_float SNR_adj_dB, HarmBoost, HarmShapeGain, Tilt;
SKP_float nrg, pre_nrg, log_energy, log_energy_prev, energy_variation;
SKP_float delta, BWExp1, BWExp2, gain_mult, gain_add, strength, b, warping;
SKP_float x_windowed[ SHAPE_LPC_WIN_MAX ];
SKP_float auto_corr[ MAX_SHAPE_LPC_ORDER + 1 ];
const SKP_float *x_ptr, *pitch_res_ptr;
/* Point to start of first LPC analysis block */
x_ptr = x - psEnc->sCmn.la_shape;
/****************/
/* GAIN CONTROL */
/****************/
SNR_adj_dB = psEnc->sCmn.SNR_dB_Q7 * ( 1 / 128.0f );
/* Input quality is the average of the quality in the lowest two VAD bands */
psEncCtrl->input_quality = 0.5f * ( psEnc->sCmn.input_quality_bands_Q15[ 0 ] + psEnc->sCmn.input_quality_bands_Q15[ 1 ] ) * ( 1.0f / 32768.0f );
/* Coding quality level, between 0.0 and 1.0 */
psEncCtrl->coding_quality = SKP_sigmoid( 0.25f * ( SNR_adj_dB - 18.0f ) );
if( psEnc->sCmn.useCBR == 0 ) {
/* Reduce coding SNR during low speech activity */
b = 1.0f - psEnc->sCmn.speech_activity_Q8 * ( 1.0f / 256.0f );
SNR_adj_dB -= BG_SNR_DECR_dB * psEncCtrl->coding_quality * ( 0.5f + 0.5f * psEncCtrl->input_quality ) * b * b;
}
if( psEnc->sCmn.indices.signalType == TYPE_VOICED ) {
/* Reduce gains for periodic signals */
SNR_adj_dB += HARM_SNR_INCR_dB * psEnc->LTPCorr;
} else {
/* For unvoiced signals and low-quality input, adjust the quality slower than SNR_dB setting */
SNR_adj_dB += ( -0.4f * psEnc->sCmn.SNR_dB_Q7 * ( 1 / 128.0f ) + 6.0f ) * ( 1.0f - psEncCtrl->input_quality );
}
/*************************/
/* SPARSENESS PROCESSING */
/*************************/
/* Set quantizer offset */
if( psEnc->sCmn.indices.signalType == TYPE_VOICED ) {
/* Initally set to 0; may be overruled in process_gains(..) */
psEnc->sCmn.indices.quantOffsetType = 0;
psEncCtrl->sparseness = 0.0f;
} else {
/* Sparseness measure, based on relative fluctuations of energy per 2 milliseconds */
nSamples = 2 * psEnc->sCmn.fs_kHz;
energy_variation = 0.0f;
log_energy_prev = 0.0f;
pitch_res_ptr = pitch_res;
for( k = 0; k < SKP_SMULBB( SUB_FRAME_LENGTH_MS, psEnc->sCmn.nb_subfr ) / 2; k++ ) {
nrg = ( SKP_float )nSamples + ( SKP_float )silk_energy_FLP( pitch_res_ptr, nSamples );
log_energy = silk_log2( nrg );
if( k > 0 ) {
energy_variation += SKP_abs_float( log_energy - log_energy_prev );
}
log_energy_prev = log_energy;
pitch_res_ptr += nSamples;
}
psEncCtrl->sparseness = SKP_sigmoid( 0.4f * ( energy_variation - 5.0f ) );
/* Set quantization offset depending on sparseness measure */
if( psEncCtrl->sparseness > SPARSENESS_THRESHOLD_QNT_OFFSET ) {
psEnc->sCmn.indices.quantOffsetType = 0;
} else {
psEnc->sCmn.indices.quantOffsetType = 1;
}
/* Increase coding SNR for sparse signals */
SNR_adj_dB += SPARSE_SNR_INCR_dB * ( psEncCtrl->sparseness - 0.5f );
}
/*******************************/
/* Control bandwidth expansion */
/*******************************/
/* More BWE for signals with high prediction gain */
strength = FIND_PITCH_WHITE_NOISE_FRACTION * psEncCtrl->predGain; /* between 0.0 and 1.0 */
BWExp1 = BWExp2 = BANDWIDTH_EXPANSION / ( 1.0f + strength * strength );
delta = LOW_RATE_BANDWIDTH_EXPANSION_DELTA * ( 1.0f - 0.75f * psEncCtrl->coding_quality );
BWExp1 -= delta;
BWExp2 += delta;
/* BWExp1 will be applied after BWExp2, so make it relative */
BWExp1 /= BWExp2;
if( psEnc->sCmn.warping_Q16 > 0 ) {
/* Slightly more warping in analysis will move quantization noise up in frequency, where it's better masked */
warping = (SKP_float)psEnc->sCmn.warping_Q16 / 65536.0f + 0.01f * psEncCtrl->coding_quality;
} else {
warping = 0.0f;
}
/********************************************/
/* Compute noise shaping AR coefs and gains */
/********************************************/
for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) {
/* Apply window: sine slope followed by flat part followed by cosine slope */
SKP_int shift, slope_part, flat_part;
flat_part = psEnc->sCmn.fs_kHz * 3;
slope_part = ( psEnc->sCmn.shapeWinLength - flat_part ) / 2;
silk_apply_sine_window_FLP( x_windowed, x_ptr, 1, slope_part );
shift = slope_part;
SKP_memcpy( x_windowed + shift, x_ptr + shift, flat_part * sizeof(SKP_float) );
shift += flat_part;
silk_apply_sine_window_FLP( x_windowed + shift, x_ptr + shift, 2, slope_part );
/* Update pointer: next LPC analysis block */
x_ptr += psEnc->sCmn.subfr_length;
if( psEnc->sCmn.warping_Q16 > 0 ) {
/* Calculate warped auto correlation */
silk_warped_autocorrelation_FLP( auto_corr, x_windowed, warping,
psEnc->sCmn.shapeWinLength, psEnc->sCmn.shapingLPCOrder );
} else {
/* Calculate regular auto correlation */
silk_autocorrelation_FLP( auto_corr, x_windowed, psEnc->sCmn.shapeWinLength, psEnc->sCmn.shapingLPCOrder + 1 );
}
/* Add white noise, as a fraction of energy */
auto_corr[ 0 ] += auto_corr[ 0 ] * SHAPE_WHITE_NOISE_FRACTION;
/* Convert correlations to prediction coefficients, and compute residual energy */
nrg = silk_levinsondurbin_FLP( &psEncCtrl->AR2[ k * MAX_SHAPE_LPC_ORDER ], auto_corr, psEnc->sCmn.shapingLPCOrder );
psEncCtrl->Gains[ k ] = ( SKP_float )sqrt( nrg );
if( psEnc->sCmn.warping_Q16 > 0 ) {
/* Adjust gain for warping */
psEncCtrl->Gains[ k ] *= warped_gain( &psEncCtrl->AR2[ k * MAX_SHAPE_LPC_ORDER ], warping, psEnc->sCmn.shapingLPCOrder );
}
/* Bandwidth expansion for synthesis filter shaping */
silk_bwexpander_FLP( &psEncCtrl->AR2[ k * MAX_SHAPE_LPC_ORDER ], psEnc->sCmn.shapingLPCOrder, BWExp2 );
/* Compute noise shaping filter coefficients */
SKP_memcpy(
&psEncCtrl->AR1[ k * MAX_SHAPE_LPC_ORDER ],
&psEncCtrl->AR2[ k * MAX_SHAPE_LPC_ORDER ],
psEnc->sCmn.shapingLPCOrder * sizeof( SKP_float ) );
/* Bandwidth expansion for analysis filter shaping */
silk_bwexpander_FLP( &psEncCtrl->AR1[ k * MAX_SHAPE_LPC_ORDER ], psEnc->sCmn.shapingLPCOrder, BWExp1 );
/* Ratio of prediction gains, in energy domain */
silk_LPC_inverse_pred_gain_FLP( &pre_nrg, &psEncCtrl->AR2[ k * MAX_SHAPE_LPC_ORDER ], psEnc->sCmn.shapingLPCOrder );
silk_LPC_inverse_pred_gain_FLP( &nrg, &psEncCtrl->AR1[ k * MAX_SHAPE_LPC_ORDER ], psEnc->sCmn.shapingLPCOrder );
psEncCtrl->GainsPre[ k ] = 1.0f - 0.7f * ( 1.0f - pre_nrg / nrg );
/* Convert to monic warped prediction coefficients and limit absolute values */
warped_true2monic_coefs( &psEncCtrl->AR2[ k * MAX_SHAPE_LPC_ORDER ], &psEncCtrl->AR1[ k * MAX_SHAPE_LPC_ORDER ],
warping, 3.999f, psEnc->sCmn.shapingLPCOrder );
}
/*****************/
/* Gain tweaking */
/*****************/
/* Increase gains during low speech activity */
gain_mult = (SKP_float)pow( 2.0f, -0.16f * SNR_adj_dB );
gain_add = (SKP_float)pow( 2.0f, 0.16f * MIN_QGAIN_DB );
for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) {
psEncCtrl->Gains[ k ] *= gain_mult;
psEncCtrl->Gains[ k ] += gain_add;
}
gain_mult = 1.0f + INPUT_TILT + psEncCtrl->coding_quality * HIGH_RATE_INPUT_TILT;
for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) {
psEncCtrl->GainsPre[ k ] *= gain_mult;
}
/************************************************/
/* Control low-frequency shaping and noise tilt */
/************************************************/
/* Less low frequency shaping for noisy inputs */
strength = LOW_FREQ_SHAPING * ( 1.0f + LOW_QUALITY_LOW_FREQ_SHAPING_DECR * ( psEnc->sCmn.input_quality_bands_Q15[ 0 ] * ( 1.0f / 32768.0f ) - 1.0f ) );
strength *= psEnc->sCmn.speech_activity_Q8 * ( 1.0f / 256.0f );
if( psEnc->sCmn.indices.signalType == TYPE_VOICED ) {
/* Reduce low frequencies quantization noise for periodic signals, depending on pitch lag */
/*f = 400; freqz([1, -0.98 + 2e-4 * f], [1, -0.97 + 7e-4 * f], 2^12, Fs); axis([0, 1000, -10, 1])*/
for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) {
b = 0.2f / psEnc->sCmn.fs_kHz + 3.0f / psEncCtrl->pitchL[ k ];
psEncCtrl->LF_MA_shp[ k ] = -1.0f + b;
psEncCtrl->LF_AR_shp[ k ] = 1.0f - b - b * strength;
}
Tilt = - HP_NOISE_COEF -
(1 - HP_NOISE_COEF) * HARM_HP_NOISE_COEF * psEnc->sCmn.speech_activity_Q8 * ( 1.0f / 256.0f );
} else {
b = 1.3f / psEnc->sCmn.fs_kHz;
psEncCtrl->LF_MA_shp[ 0 ] = -1.0f + b;
psEncCtrl->LF_AR_shp[ 0 ] = 1.0f - b - b * strength * 0.6f;
for( k = 1; k < psEnc->sCmn.nb_subfr; k++ ) {
psEncCtrl->LF_MA_shp[ k ] = psEncCtrl->LF_MA_shp[ 0 ];
psEncCtrl->LF_AR_shp[ k ] = psEncCtrl->LF_AR_shp[ 0 ];
}
Tilt = -HP_NOISE_COEF;
}
/****************************/
/* HARMONIC SHAPING CONTROL */
/****************************/
/* Control boosting of harmonic frequencies */
HarmBoost = LOW_RATE_HARMONIC_BOOST * ( 1.0f - psEncCtrl->coding_quality ) * psEnc->LTPCorr;
/* More harmonic boost for noisy input signals */
HarmBoost += LOW_INPUT_QUALITY_HARMONIC_BOOST * ( 1.0f - psEncCtrl->input_quality );
if( USE_HARM_SHAPING && psEnc->sCmn.indices.signalType == TYPE_VOICED ) {
/* Harmonic noise shaping */
HarmShapeGain = HARMONIC_SHAPING;
/* More harmonic noise shaping for high bitrates or noisy input */
HarmShapeGain += HIGH_RATE_OR_LOW_QUALITY_HARMONIC_SHAPING *
( 1.0f - ( 1.0f - psEncCtrl->coding_quality ) * psEncCtrl->input_quality );
/* Less harmonic noise shaping for less periodic signals */
HarmShapeGain *= ( SKP_float )sqrt( psEnc->LTPCorr );
} else {
HarmShapeGain = 0.0f;
}
/*************************/
/* Smooth over subframes */
/*************************/
for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) {
psShapeSt->HarmBoost_smth += SUBFR_SMTH_COEF * ( HarmBoost - psShapeSt->HarmBoost_smth );
psEncCtrl->HarmBoost[ k ] = psShapeSt->HarmBoost_smth;
psShapeSt->HarmShapeGain_smth += SUBFR_SMTH_COEF * ( HarmShapeGain - psShapeSt->HarmShapeGain_smth );
psEncCtrl->HarmShapeGain[ k ] = psShapeSt->HarmShapeGain_smth;
psShapeSt->Tilt_smth += SUBFR_SMTH_COEF * ( Tilt - psShapeSt->Tilt_smth );
psEncCtrl->Tilt[ k ] = psShapeSt->Tilt_smth;
}
}
/* 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;
}
}
void SKP_Silk_quant_LTP_gains_FIX(
SKP_int16 B_Q14[], /* I/O (un)quantized LTP gains */
SKP_int cbk_index[], /* O Codebook Index */
SKP_int *periodicity_index, /* O Periodicity Index */
const SKP_int32 W_Q18[], /* I Error Weights in Q18 */
SKP_int mu_Q8, /* I Mu value (R/D tradeoff) */
SKP_int lowComplexity /* I Flag for low complexity */
)
{
SKP_int j, k, temp_idx[ NB_SUBFR ], cbk_size;
const SKP_uint16 *cdf_ptr;
const SKP_int16 *cl_ptr;
const SKP_int16 *cbk_ptr_Q14;
const SKP_int16 *b_Q14_ptr;
const SKP_int32 *W_Q18_ptr;
SKP_int32 rate_dist_subfr, rate_dist, min_rate_dist;
/***************************************************/
/* iterate over different codebooks with different */
/* rates/distortions, and choose best */
/***************************************************/
min_rate_dist = SKP_int32_MAX;
for( k = 0; k < 3; k++ ) {
cdf_ptr = SKP_Silk_LTP_gain_CDF_ptrs[ k ];
cl_ptr = SKP_Silk_LTP_gain_BITS_Q6_ptrs[ k ];
cbk_ptr_Q14 = SKP_Silk_LTP_vq_ptrs_Q14[ k ];
cbk_size = SKP_Silk_LTP_vq_sizes[ k ];
/* Setup pointer to first subframe */
W_Q18_ptr = W_Q18;
b_Q14_ptr = B_Q14;
rate_dist = 0;
for( j = 0; j < NB_SUBFR; j++ ) {
SKP_Silk_VQ_WMat_EC_FIX(
&temp_idx[ j ], /* O index of best codebook vector */
&rate_dist_subfr, /* O best weighted quantization error + mu * rate */
b_Q14_ptr, /* I input vector to be quantized */
W_Q18_ptr, /* I weighting matrix */
cbk_ptr_Q14, /* I codebook */
cl_ptr, /* I code length for each codebook vector */
mu_Q8, /* I tradeoff between weighted error and rate */
cbk_size /* I number of vectors in codebook */
);
rate_dist = SKP_ADD_POS_SAT32( rate_dist, rate_dist_subfr );
b_Q14_ptr += LTP_ORDER;
W_Q18_ptr += LTP_ORDER * LTP_ORDER;
}
/* Avoid never finding a codebook */
rate_dist = SKP_min( SKP_int32_MAX - 1, rate_dist );
if( rate_dist < min_rate_dist ) {
min_rate_dist = rate_dist;
SKP_memcpy( cbk_index, temp_idx, NB_SUBFR * sizeof( SKP_int ) );
*periodicity_index = k;
}
/* Break early in low-complexity mode if rate distortion is below threshold */
if( lowComplexity && ( rate_dist < SKP_Silk_LTP_gain_middle_avg_RD_Q14 ) ) {
break;
}
}
cbk_ptr_Q14 = SKP_Silk_LTP_vq_ptrs_Q14[ *periodicity_index ];
for( j = 0; j < NB_SUBFR; j++ ) {
for( k = 0; k < LTP_ORDER; k++ ) {
B_Q14[ j * LTP_ORDER + k ] = cbk_ptr_Q14[ SKP_MLA( k, cbk_index[ j ], LTP_ORDER ) ];
}
}
}
void silk_find_pitch_lags_FLP(
silk_encoder_state_FLP *psEnc, /* I/O Encoder state FLP */
silk_encoder_control_FLP *psEncCtrl, /* I/O Encoder control FLP */
SKP_float res[], /* O Residual */
const SKP_float x[] /* I Speech signal */
)
{
opus_int buf_len;
SKP_float thrhld, res_nrg;
const SKP_float *x_buf_ptr, *x_buf;
SKP_float auto_corr[ MAX_FIND_PITCH_LPC_ORDER + 1 ];
SKP_float A[ MAX_FIND_PITCH_LPC_ORDER ];
SKP_float refl_coef[ MAX_FIND_PITCH_LPC_ORDER ];
SKP_float Wsig[ FIND_PITCH_LPC_WIN_MAX ];
SKP_float *Wsig_ptr;
/******************************************/
/* 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 coeficients */
/******************************************/
/* 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_FLP( Wsig_ptr, x_buf_ptr, 1, psEnc->sCmn.la_pitch );
/* Middle non-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 - ( psEnc->sCmn.la_pitch << 1 ) ) * sizeof( SKP_float ) );
/* Last LA_LTP samples */
Wsig_ptr += psEnc->sCmn.pitch_LPC_win_length - ( psEnc->sCmn.la_pitch << 1 );
x_buf_ptr += psEnc->sCmn.pitch_LPC_win_length - ( psEnc->sCmn.la_pitch << 1 );
silk_apply_sine_window_FLP( Wsig_ptr, x_buf_ptr, 2, psEnc->sCmn.la_pitch );
/* Calculate autocorrelation sequence */
silk_autocorrelation_FLP( auto_corr, Wsig, psEnc->sCmn.pitch_LPC_win_length, psEnc->sCmn.pitchEstimationLPCOrder + 1 );
/* Add white noise, as a fraction of the energy */
auto_corr[ 0 ] += auto_corr[ 0 ] * FIND_PITCH_WHITE_NOISE_FRACTION + 1;
/* Calculate the reflection coefficients using Schur */
res_nrg = silk_schur_FLP( refl_coef, auto_corr, psEnc->sCmn.pitchEstimationLPCOrder );
/* Prediction gain */
psEncCtrl->predGain = auto_corr[ 0 ] / SKP_max_float( res_nrg, 1.0f );
/* Convert reflection coefficients to prediction coefficients */
silk_k2a_FLP( A, refl_coef, psEnc->sCmn.pitchEstimationLPCOrder );
/* Bandwidth expansion */
silk_bwexpander_FLP( A, psEnc->sCmn.pitchEstimationLPCOrder, FIND_PITCH_BANDWITH_EXPANSION );
/*****************************************/
/* LPC analysis filtering */
/*****************************************/
silk_LPC_analysis_filter_FLP( res, A, x_buf, 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 = 0.6f;
thrhld -= 0.004f * psEnc->sCmn.pitchEstimationLPCOrder;
thrhld -= 0.1f * psEnc->sCmn.speech_activity_Q8 * ( 1.0f / 256.0f );
thrhld -= 0.15f * (psEnc->sCmn.prevSignalType >> 1);
thrhld -= 0.1f * psEnc->sCmn.input_tilt_Q15 * ( 1.0f / 32768.0f );
/*****************************************/
/* Call Pitch estimator */
/*****************************************/
if( silk_pitch_analysis_core_FLP( res, psEncCtrl->pitchL, &psEnc->sCmn.indices.lagIndex,
&psEnc->sCmn.indices.contourIndex, &psEnc->LTPCorr, psEnc->sCmn.prevLag, psEnc->sCmn.pitchEstimationThreshold_Q16 / 65536.0f,
thrhld, 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 {
/* 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;
}
/* 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;
}
}
