/* Variable order MA prediction error filter */
void SKP_Silk_MA_Prediction(
const SKP_int16 *in, /* I: Input signal */
const SKP_int16 *B, /* I: MA prediction coefficients, Q12 [order] */
SKP_int32 *S, /* I/O: State vector [order] */
SKP_int16 *out, /* O: Output signal */
const SKP_int32 len, /* I: Signal length */
const SKP_int32 order /* I: Filter order */
)
{
SKP_int k, d, in16;
SKP_int32 out32;
SKP_int32 B32;
if( ( order & 1 ) == 0 && (SKP_int32)( (SKP_int_ptr_size)B & 3 ) == 0 ) {
/* Even order and 4-byte aligned coefficient array */
/* NOTE: the code below loads two int16 values in an int32, and multiplies each using the */
/* SMLABB and SMLABT instructions. On a big-endian CPU the two int16 variables would be */
/* loaded in reverse order and the code will give the wrong result. In that case swapping */
/* the SMLABB and SMLABT instructions should solve the problem. */
for( k = 0; k < len; k++ ) {
in16 = in[ k ];
out32 = SKP_LSHIFT( in16, 12 ) - S[ 0 ];
out32 = SKP_RSHIFT_ROUND( out32, 12 );
for( d = 0; d < order - 2; d += 2 ) {
B32 = *( (SKP_int32*)&B[ d ] ); /* read two coefficients at once */
S[ d ] = SKP_SMLABB_ovflw( S[ d + 1 ], in16, B32 );
S[ d + 1 ] = SKP_SMLABT_ovflw( S[ d + 2 ], in16, B32 );
}
B32 = *( (SKP_int32*)&B[ d ] ); /* read two coefficients at once */
S[ order - 2 ] = SKP_SMLABB_ovflw( S[ order - 1 ], in16, B32 );
S[ order - 1 ] = SKP_SMULBT( in16, B32 );
/* Limit */
out[ k ] = (SKP_int16)SKP_SAT16( out32 );
}
} else {
/* Odd order or not 4-byte aligned coefficient array */
for( k = 0; k < len; k++ ) {
in16 = in[ k ];
out32 = SKP_LSHIFT( in16, 12 ) - S[ 0 ];
out32 = SKP_RSHIFT_ROUND( out32, 12 );
for( d = 0; d < order - 1; d++ ) {
S[ d ] = SKP_SMLABB_ovflw( S[ d + 1 ], in16, B[ d ] );
}
S[ order - 1 ] = SKP_SMULBB( in16, B[ order - 1 ] );
/* Limit */
out[ k ] = (SKP_int16)SKP_SAT16( out32 );
}
}
}
/* Variable order MA prediction error filter */
void SKP_Silk_MA_Prediction(
const SKP_int16 *in, /* I: Input signal */
const SKP_int16 *B, /* I: MA prediction coefficients, Q12 [order] */
SKP_int32 *S, /* I/O: State vector [order] */
SKP_int16 *out, /* O: Output signal */
const SKP_int32 len, /* I: Signal length */
const SKP_int32 order /* I: Filter order */
)
{
SKP_int k, d, in16;
SKP_int32 out32;
for( k = 0; k < len; k++ ) {
in16 = in[ k ];
out32 = SKP_LSHIFT( in16, 12 ) - S[ 0 ];
out32 = SKP_RSHIFT_ROUND( out32, 12 );
for( d = 0; d < order - 1; d++ ) {
S[ d ] = SKP_SMLABB_ovflw( S[ d + 1 ], in16, B[ d ] );
}
S[ order - 1 ] = SKP_SMULBB( in16, B[ order - 1 ] );
/* Limit */
out[ k ] = (SKP_int16)SKP_SAT16( out32 );
}
}
void SKP_Silk_LTP_analysis_filter_FIX(
SKP_int16 *LTP_res, /* O: LTP residual signal of length NB_SUBFR * ( pre_length + subfr_length ) */
const SKP_int16 *x, /* I: Pointer to input signal with at least max( pitchL ) preceeding samples */
const SKP_int16 LTPCoef_Q14[ LTP_ORDER * NB_SUBFR ],/* I: LTP_ORDER LTP coefficients for each NB_SUBFR subframe */
const SKP_int pitchL[ NB_SUBFR ], /* I: Pitch lag, one for each subframe */
const SKP_int32 invGains_Qxx[ NB_SUBFR ], /* I: Inverse quantization gains, one for each subframe */
const SKP_int Qxx, /* I: Inverse quantization gains Q domain */
const SKP_int subfr_length, /* I: Length of each subframe */
const SKP_int pre_length /* I: Length of the preceeding samples starting at &x[0] for each subframe */
)
{
const SKP_int16 *x_ptr, *x_lag_ptr;
SKP_int16 Btmp_Q14[ LTP_ORDER ];
SKP_int16 *LTP_res_ptr;
SKP_int k, i, j;
SKP_int32 LTP_est;
x_ptr = x;
LTP_res_ptr = LTP_res;
for( k = 0; k < NB_SUBFR; k++ ) {
x_lag_ptr = x_ptr - pitchL[ k ];
for( i = 0; i < LTP_ORDER; i++ ) {
Btmp_Q14[ i ] = LTPCoef_Q14[ k * LTP_ORDER + i ];
}
/* LTP analysis FIR filter */
for( i = 0; i < subfr_length + pre_length; i++ ) {
LTP_res_ptr[ i ] = x_ptr[ i ];
/* Long-term prediction */
LTP_est = SKP_SMULBB( x_lag_ptr[ LTP_ORDER / 2 ], Btmp_Q14[ 0 ] );
for( j = 1; j < LTP_ORDER; j++ ) {
LTP_est = SKP_SMLABB_ovflw( LTP_est, x_lag_ptr[ LTP_ORDER / 2 - j ], Btmp_Q14[ j ] );
}
LTP_est = SKP_RSHIFT_ROUND( LTP_est, 14 ); // round and -> Q0
/* Subtract long-term prediction */
LTP_res_ptr[ i ] = ( SKP_int16 )SKP_SAT16( ( SKP_int32 )x_ptr[ i ] - LTP_est );
/* Scale residual */
if( Qxx == 16 ) {
LTP_res_ptr[ i ] = SKP_SMULWB( invGains_Qxx[ k ], LTP_res_ptr[ i ] );
} else {
LTP_res_ptr[ i ] = ( SKP_int16 )SKP_CHECK_FIT16( SKP_RSHIFT64( SKP_SMULL( invGains_Qxx[ k ], LTP_res_ptr[ i ] ), Qxx ) );
}
x_lag_ptr++;
}
/* Update pointers */
LTP_res_ptr += subfr_length + pre_length;
x_ptr += subfr_length;
}
}
/* of int16s to make it fit in an int32 */
void SKP_Silk_sum_sqr_shift(
SKP_int32 *energy, /* O Energy of x, after shifting to the right */
SKP_int *shift, /* O Number of bits right shift applied to energy */
const SKP_int16 *x, /* I Input vector */
SKP_int len /* I Length of input vector */
)
{
SKP_int i, shft;
SKP_int32 in32, nrg_tmp, nrg;
if( (SKP_int32)( (SKP_int_ptr_size)x & 2 ) != 0 ) {
/* Input is not 4-byte aligned */
nrg = SKP_SMULBB( x[ 0 ], x[ 0 ] );
i = 1;
} else {
nrg = 0;
i = 0;
}
shft = 0;
len--;
while( i < len ) {
/* Load two values at once */
in32 = *( (SKP_int32 *)&x[ i ] );
nrg = SKP_SMLABB_ovflw( nrg, in32, in32 );
nrg = SKP_SMLATT_ovflw( nrg, in32, in32 );
i += 2;
if( nrg < 0 ) {
/* Scale down */
nrg = (SKP_int32)SKP_RSHIFT_uint( (SKP_uint32)nrg, 2 );
shft = 2;
break;
}
}
for( ; i < len; i += 2 ) {
/* Load two values at once */
in32 = *( (SKP_int32 *)&x[ i ] );
nrg_tmp = SKP_SMULBB( in32, in32 );
nrg_tmp = SKP_SMLATT_ovflw( nrg_tmp, in32, in32 );
nrg = (SKP_int32)SKP_ADD_RSHIFT_uint( nrg, (SKP_uint32)nrg_tmp, shft );
if( nrg < 0 ) {
/* Scale down */
nrg = (SKP_int32)SKP_RSHIFT_uint( (SKP_uint32)nrg, 2 );
shft += 2;
}
}
if( i == len ) {
/* One sample left to process */
nrg_tmp = SKP_SMULBB( x[ i ], x[ i ] );
nrg = (SKP_int32)SKP_ADD_RSHIFT_uint( nrg, nrg_tmp, shft );
}
/* Make sure to have at least one extra leading zero (two leading zeros in total) */
if( nrg & 0xC0000000 ) {
nrg = SKP_RSHIFT_uint( (SKP_uint32)nrg, 2 );
shft += 2;
}
/* Output arguments */
*shift = shft;
*energy = nrg;
}
