/* 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; }