NSQ_del_dec.c (39492B)
1 /*********************************************************************** 2 Copyright (c) 2006-2011, Skype Limited. All rights reserved. 3 Redistribution and use in source and binary forms, with or without 4 modification, are permitted provided that the following conditions 5 are met: 6 - Redistributions of source code must retain the above copyright notice, 7 this list of conditions and the following disclaimer. 8 - Redistributions in binary form must reproduce the above copyright 9 notice, this list of conditions and the following disclaimer in the 10 documentation and/or other materials provided with the distribution. 11 - Neither the name of Internet Society, IETF or IETF Trust, nor the 12 names of specific contributors, may be used to endorse or promote 13 products derived from this software without specific prior written 14 permission. 15 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 16 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 19 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 20 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 21 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 22 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 23 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 24 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 25 POSSIBILITY OF SUCH DAMAGE. 26 ***********************************************************************/ 27 28 #ifdef HAVE_CONFIG_H 29 #include "config.h" 30 #endif 31 32 #include "main.h" 33 #include "stack_alloc.h" 34 #include "NSQ.h" 35 36 37 typedef struct { 38 opus_int32 sLPC_Q14[ MAX_SUB_FRAME_LENGTH + NSQ_LPC_BUF_LENGTH ]; 39 opus_int32 RandState[ DECISION_DELAY ]; 40 opus_int32 Q_Q10[ DECISION_DELAY ]; 41 opus_int32 Xq_Q14[ DECISION_DELAY ]; 42 opus_int32 Pred_Q15[ DECISION_DELAY ]; 43 opus_int32 Shape_Q14[ DECISION_DELAY ]; 44 opus_int32 sAR2_Q14[ MAX_SHAPE_LPC_ORDER ]; 45 opus_int32 LF_AR_Q14; 46 opus_int32 Diff_Q14; 47 opus_int32 Seed; 48 opus_int32 SeedInit; 49 opus_int32 RD_Q10; 50 } NSQ_del_dec_struct; 51 52 typedef struct { 53 opus_int32 Q_Q10; 54 opus_int32 RD_Q10; 55 opus_int32 xq_Q14; 56 opus_int32 LF_AR_Q14; 57 opus_int32 Diff_Q14; 58 opus_int32 sLTP_shp_Q14; 59 opus_int32 LPC_exc_Q14; 60 } NSQ_sample_struct; 61 62 typedef NSQ_sample_struct NSQ_sample_pair[ 2 ]; 63 64 static OPUS_INLINE void silk_nsq_del_dec_scale_states( 65 const silk_encoder_state *psEncC, /* I Encoder State */ 66 silk_nsq_state *NSQ, /* I/O NSQ state */ 67 NSQ_del_dec_struct psDelDec[], /* I/O Delayed decision states */ 68 const opus_int16 x16[], /* I Input */ 69 opus_int32 x_sc_Q10[], /* O Input scaled with 1/Gain in Q10 */ 70 const opus_int16 sLTP[], /* I Re-whitened LTP state in Q0 */ 71 opus_int32 sLTP_Q15[], /* O LTP state matching scaled input */ 72 opus_int subfr, /* I Subframe number */ 73 opus_int nStatesDelayedDecision, /* I Number of del dec states */ 74 const opus_int LTP_scale_Q14, /* I LTP state scaling */ 75 const opus_int32 Gains_Q16[ MAX_NB_SUBFR ], /* I */ 76 const opus_int pitchL[ MAX_NB_SUBFR ], /* I Pitch lag */ 77 const opus_int signal_type, /* I Signal type */ 78 const opus_int decisionDelay /* I Decision delay */ 79 ); 80 81 /******************************************/ 82 /* Noise shape quantizer for one subframe */ 83 /******************************************/ 84 static OPUS_INLINE void silk_noise_shape_quantizer_del_dec( 85 silk_nsq_state *NSQ, /* I/O NSQ state */ 86 NSQ_del_dec_struct psDelDec[], /* I/O Delayed decision states */ 87 opus_int signalType, /* I Signal type */ 88 const opus_int32 x_Q10[], /* I */ 89 opus_int8 pulses[], /* O */ 90 opus_int16 xq[], /* O */ 91 opus_int32 sLTP_Q15[], /* I/O LTP filter state */ 92 opus_int32 delayedGain_Q10[], /* I/O Gain delay buffer */ 93 const opus_int16 a_Q12[], /* I Short term prediction coefs */ 94 const opus_int16 b_Q14[], /* I Long term prediction coefs */ 95 const opus_int16 AR_shp_Q13[], /* I Noise shaping coefs */ 96 opus_int lag, /* I Pitch lag */ 97 opus_int32 HarmShapeFIRPacked_Q14, /* I */ 98 opus_int Tilt_Q14, /* I Spectral tilt */ 99 opus_int32 LF_shp_Q14, /* I */ 100 opus_int32 Gain_Q16, /* I */ 101 opus_int Lambda_Q10, /* I */ 102 opus_int offset_Q10, /* I */ 103 opus_int length, /* I Input length */ 104 opus_int subfr, /* I Subframe number */ 105 opus_int shapingLPCOrder, /* I Shaping LPC filter order */ 106 opus_int predictLPCOrder, /* I Prediction filter order */ 107 opus_int warping_Q16, /* I */ 108 opus_int nStatesDelayedDecision, /* I Number of states in decision tree */ 109 opus_int *smpl_buf_idx, /* I/O Index to newest samples in buffers */ 110 opus_int decisionDelay, /* I */ 111 int arch /* I */ 112 ); 113 114 void silk_NSQ_del_dec_c( 115 const silk_encoder_state *psEncC, /* I Encoder State */ 116 silk_nsq_state *NSQ, /* I/O NSQ state */ 117 SideInfoIndices *psIndices, /* I/O Quantization Indices */ 118 const opus_int16 x16[], /* I Input */ 119 opus_int8 pulses[], /* O Quantized pulse signal */ 120 const opus_int16 *PredCoef_Q12, /* I Short term prediction coefs */ 121 const opus_int16 LTPCoef_Q14[ LTP_ORDER * MAX_NB_SUBFR ], /* I Long term prediction coefs */ 122 const opus_int16 AR_Q13[ MAX_NB_SUBFR * MAX_SHAPE_LPC_ORDER ], /* I Noise shaping coefs */ 123 const opus_int HarmShapeGain_Q14[ MAX_NB_SUBFR ], /* I Long term shaping coefs */ 124 const opus_int Tilt_Q14[ MAX_NB_SUBFR ], /* I Spectral tilt */ 125 const opus_int32 LF_shp_Q14[ MAX_NB_SUBFR ], /* I Low frequency shaping coefs */ 126 const opus_int32 Gains_Q16[ MAX_NB_SUBFR ], /* I Quantization step sizes */ 127 const opus_int pitchL[ MAX_NB_SUBFR ], /* I Pitch lags */ 128 const opus_int Lambda_Q10, /* I Rate/distortion tradeoff */ 129 const opus_int LTP_scale_Q14 /* I LTP state scaling */ 130 ) 131 { 132 opus_int i, k, lag, start_idx, LSF_interpolation_flag, Winner_ind, subfr; 133 opus_int last_smple_idx, smpl_buf_idx, decisionDelay; 134 const opus_int16 *A_Q12, *B_Q14, *AR_shp_Q13; 135 opus_int16 *pxq; 136 VARDECL( opus_int32, sLTP_Q15 ); 137 VARDECL( opus_int16, sLTP ); 138 opus_int32 HarmShapeFIRPacked_Q14; 139 opus_int offset_Q10; 140 opus_int32 RDmin_Q10, Gain_Q10; 141 VARDECL( opus_int32, x_sc_Q10 ); 142 VARDECL( opus_int32, delayedGain_Q10 ); 143 VARDECL( NSQ_del_dec_struct, psDelDec ); 144 NSQ_del_dec_struct *psDD; 145 SAVE_STACK; 146 147 /* Set unvoiced lag to the previous one, overwrite later for voiced */ 148 lag = NSQ->lagPrev; 149 150 silk_assert( NSQ->prev_gain_Q16 != 0 ); 151 152 /* Initialize delayed decision states */ 153 ALLOC( psDelDec, psEncC->nStatesDelayedDecision, NSQ_del_dec_struct ); 154 silk_memset( psDelDec, 0, psEncC->nStatesDelayedDecision * sizeof( NSQ_del_dec_struct ) ); 155 for( k = 0; k < psEncC->nStatesDelayedDecision; k++ ) { 156 psDD = &psDelDec[ k ]; 157 psDD->Seed = ( k + psIndices->Seed ) & 3; 158 psDD->SeedInit = psDD->Seed; 159 psDD->RD_Q10 = 0; 160 psDD->LF_AR_Q14 = NSQ->sLF_AR_shp_Q14; 161 psDD->Diff_Q14 = NSQ->sDiff_shp_Q14; 162 psDD->Shape_Q14[ 0 ] = NSQ->sLTP_shp_Q14[ psEncC->ltp_mem_length - 1 ]; 163 silk_memcpy( psDD->sLPC_Q14, NSQ->sLPC_Q14, NSQ_LPC_BUF_LENGTH * sizeof( opus_int32 ) ); 164 silk_memcpy( psDD->sAR2_Q14, NSQ->sAR2_Q14, sizeof( NSQ->sAR2_Q14 ) ); 165 } 166 167 offset_Q10 = silk_Quantization_Offsets_Q10[ psIndices->signalType >> 1 ][ psIndices->quantOffsetType ]; 168 smpl_buf_idx = 0; /* index of oldest samples */ 169 170 decisionDelay = silk_min_int( DECISION_DELAY, psEncC->subfr_length ); 171 172 /* For voiced frames limit the decision delay to lower than the pitch lag */ 173 if( psIndices->signalType == TYPE_VOICED ) { 174 for( k = 0; k < psEncC->nb_subfr; k++ ) { 175 decisionDelay = silk_min_int( decisionDelay, pitchL[ k ] - LTP_ORDER / 2 - 1 ); 176 } 177 } else { 178 if( lag > 0 ) { 179 decisionDelay = silk_min_int( decisionDelay, lag - LTP_ORDER / 2 - 1 ); 180 } 181 } 182 183 if( psIndices->NLSFInterpCoef_Q2 == 4 ) { 184 LSF_interpolation_flag = 0; 185 } else { 186 LSF_interpolation_flag = 1; 187 } 188 189 ALLOC( sLTP_Q15, psEncC->ltp_mem_length + psEncC->frame_length, opus_int32 ); 190 ALLOC( sLTP, psEncC->ltp_mem_length + psEncC->frame_length, opus_int16 ); 191 ALLOC( x_sc_Q10, psEncC->subfr_length, opus_int32 ); 192 ALLOC( delayedGain_Q10, DECISION_DELAY, opus_int32 ); 193 /* Set up pointers to start of sub frame */ 194 pxq = &NSQ->xq[ psEncC->ltp_mem_length ]; 195 NSQ->sLTP_shp_buf_idx = psEncC->ltp_mem_length; 196 NSQ->sLTP_buf_idx = psEncC->ltp_mem_length; 197 subfr = 0; 198 for( k = 0; k < psEncC->nb_subfr; k++ ) { 199 A_Q12 = &PredCoef_Q12[ ( ( k >> 1 ) | ( 1 - LSF_interpolation_flag ) ) * MAX_LPC_ORDER ]; 200 B_Q14 = <PCoef_Q14[ k * LTP_ORDER ]; 201 AR_shp_Q13 = &AR_Q13[ k * MAX_SHAPE_LPC_ORDER ]; 202 203 /* Noise shape parameters */ 204 silk_assert( HarmShapeGain_Q14[ k ] >= 0 ); 205 HarmShapeFIRPacked_Q14 = silk_RSHIFT( HarmShapeGain_Q14[ k ], 2 ); 206 HarmShapeFIRPacked_Q14 |= silk_LSHIFT( (opus_int32)silk_RSHIFT( HarmShapeGain_Q14[ k ], 1 ), 16 ); 207 208 NSQ->rewhite_flag = 0; 209 if( psIndices->signalType == TYPE_VOICED ) { 210 /* Voiced */ 211 lag = pitchL[ k ]; 212 213 /* Re-whitening */ 214 if( ( k & ( 3 - silk_LSHIFT( LSF_interpolation_flag, 1 ) ) ) == 0 ) { 215 if( k == 2 ) { 216 /* RESET DELAYED DECISIONS */ 217 /* Find winner */ 218 RDmin_Q10 = psDelDec[ 0 ].RD_Q10; 219 Winner_ind = 0; 220 for( i = 1; i < psEncC->nStatesDelayedDecision; i++ ) { 221 if( psDelDec[ i ].RD_Q10 < RDmin_Q10 ) { 222 RDmin_Q10 = psDelDec[ i ].RD_Q10; 223 Winner_ind = i; 224 } 225 } 226 for( i = 0; i < psEncC->nStatesDelayedDecision; i++ ) { 227 if( i != Winner_ind ) { 228 psDelDec[ i ].RD_Q10 += ( silk_int32_MAX >> 4 ); 229 silk_assert( psDelDec[ i ].RD_Q10 >= 0 ); 230 } 231 } 232 233 /* Copy final part of signals from winner state to output and long-term filter states */ 234 psDD = &psDelDec[ Winner_ind ]; 235 last_smple_idx = smpl_buf_idx + decisionDelay; 236 for( i = 0; i < decisionDelay; i++ ) { 237 last_smple_idx = ( last_smple_idx - 1 ) % DECISION_DELAY; 238 if( last_smple_idx < 0 ) last_smple_idx += DECISION_DELAY; 239 pulses[ i - decisionDelay ] = (opus_int8)silk_RSHIFT_ROUND( psDD->Q_Q10[ last_smple_idx ], 10 ); 240 pxq[ i - decisionDelay ] = (opus_int16)silk_SAT16( silk_RSHIFT_ROUND( 241 silk_SMULWW( psDD->Xq_Q14[ last_smple_idx ], Gains_Q16[ 1 ] ), 14 ) ); 242 NSQ->sLTP_shp_Q14[ NSQ->sLTP_shp_buf_idx - decisionDelay + i ] = psDD->Shape_Q14[ last_smple_idx ]; 243 } 244 245 subfr = 0; 246 } 247 248 /* Rewhiten with new A coefs */ 249 start_idx = psEncC->ltp_mem_length - lag - psEncC->predictLPCOrder - LTP_ORDER / 2; 250 celt_assert( start_idx > 0 ); 251 252 silk_LPC_analysis_filter( &sLTP[ start_idx ], &NSQ->xq[ start_idx + k * psEncC->subfr_length ], 253 A_Q12, psEncC->ltp_mem_length - start_idx, psEncC->predictLPCOrder, psEncC->arch ); 254 255 NSQ->sLTP_buf_idx = psEncC->ltp_mem_length; 256 NSQ->rewhite_flag = 1; 257 } 258 } 259 260 silk_nsq_del_dec_scale_states( psEncC, NSQ, psDelDec, x16, x_sc_Q10, sLTP, sLTP_Q15, k, 261 psEncC->nStatesDelayedDecision, LTP_scale_Q14, Gains_Q16, pitchL, psIndices->signalType, decisionDelay ); 262 263 silk_noise_shape_quantizer_del_dec( NSQ, psDelDec, psIndices->signalType, x_sc_Q10, pulses, pxq, sLTP_Q15, 264 delayedGain_Q10, A_Q12, B_Q14, AR_shp_Q13, lag, HarmShapeFIRPacked_Q14, Tilt_Q14[ k ], LF_shp_Q14[ k ], 265 Gains_Q16[ k ], Lambda_Q10, offset_Q10, psEncC->subfr_length, subfr++, psEncC->shapingLPCOrder, 266 psEncC->predictLPCOrder, psEncC->warping_Q16, psEncC->nStatesDelayedDecision, &smpl_buf_idx, decisionDelay, psEncC->arch ); 267 268 x16 += psEncC->subfr_length; 269 pulses += psEncC->subfr_length; 270 pxq += psEncC->subfr_length; 271 } 272 273 /* Find winner */ 274 RDmin_Q10 = psDelDec[ 0 ].RD_Q10; 275 Winner_ind = 0; 276 for( k = 1; k < psEncC->nStatesDelayedDecision; k++ ) { 277 if( psDelDec[ k ].RD_Q10 < RDmin_Q10 ) { 278 RDmin_Q10 = psDelDec[ k ].RD_Q10; 279 Winner_ind = k; 280 } 281 } 282 283 /* Copy final part of signals from winner state to output and long-term filter states */ 284 psDD = &psDelDec[ Winner_ind ]; 285 psIndices->Seed = psDD->SeedInit; 286 last_smple_idx = smpl_buf_idx + decisionDelay; 287 Gain_Q10 = silk_RSHIFT32( Gains_Q16[ psEncC->nb_subfr - 1 ], 6 ); 288 for( i = 0; i < decisionDelay; i++ ) { 289 last_smple_idx = ( last_smple_idx - 1 ) % DECISION_DELAY; 290 if( last_smple_idx < 0 ) last_smple_idx += DECISION_DELAY; 291 292 pulses[ i - decisionDelay ] = (opus_int8)silk_RSHIFT_ROUND( psDD->Q_Q10[ last_smple_idx ], 10 ); 293 pxq[ i - decisionDelay ] = (opus_int16)silk_SAT16( silk_RSHIFT_ROUND( 294 silk_SMULWW( psDD->Xq_Q14[ last_smple_idx ], Gain_Q10 ), 8 ) ); 295 NSQ->sLTP_shp_Q14[ NSQ->sLTP_shp_buf_idx - decisionDelay + i ] = psDD->Shape_Q14[ last_smple_idx ]; 296 } 297 silk_memcpy( NSQ->sLPC_Q14, &psDD->sLPC_Q14[ psEncC->subfr_length ], NSQ_LPC_BUF_LENGTH * sizeof( opus_int32 ) ); 298 silk_memcpy( NSQ->sAR2_Q14, psDD->sAR2_Q14, sizeof( psDD->sAR2_Q14 ) ); 299 300 /* Update states */ 301 NSQ->sLF_AR_shp_Q14 = psDD->LF_AR_Q14; 302 NSQ->sDiff_shp_Q14 = psDD->Diff_Q14; 303 NSQ->lagPrev = pitchL[ psEncC->nb_subfr - 1 ]; 304 305 /* Save quantized speech signal */ 306 silk_memmove( NSQ->xq, &NSQ->xq[ psEncC->frame_length ], psEncC->ltp_mem_length * sizeof( opus_int16 ) ); 307 silk_memmove( NSQ->sLTP_shp_Q14, &NSQ->sLTP_shp_Q14[ psEncC->frame_length ], psEncC->ltp_mem_length * sizeof( opus_int32 ) ); 308 RESTORE_STACK; 309 } 310 311 /******************************************/ 312 /* Noise shape quantizer for one subframe */ 313 /******************************************/ 314 #ifndef OVERRIDE_silk_noise_shape_quantizer_del_dec 315 static OPUS_INLINE void silk_noise_shape_quantizer_del_dec( 316 silk_nsq_state *NSQ, /* I/O NSQ state */ 317 NSQ_del_dec_struct psDelDec[], /* I/O Delayed decision states */ 318 opus_int signalType, /* I Signal type */ 319 const opus_int32 x_Q10[], /* I */ 320 opus_int8 pulses[], /* O */ 321 opus_int16 xq[], /* O */ 322 opus_int32 sLTP_Q15[], /* I/O LTP filter state */ 323 opus_int32 delayedGain_Q10[], /* I/O Gain delay buffer */ 324 const opus_int16 a_Q12[], /* I Short term prediction coefs */ 325 const opus_int16 b_Q14[], /* I Long term prediction coefs */ 326 const opus_int16 AR_shp_Q13[], /* I Noise shaping coefs */ 327 opus_int lag, /* I Pitch lag */ 328 opus_int32 HarmShapeFIRPacked_Q14, /* I */ 329 opus_int Tilt_Q14, /* I Spectral tilt */ 330 opus_int32 LF_shp_Q14, /* I */ 331 opus_int32 Gain_Q16, /* I */ 332 opus_int Lambda_Q10, /* I */ 333 opus_int offset_Q10, /* I */ 334 opus_int length, /* I Input length */ 335 opus_int subfr, /* I Subframe number */ 336 opus_int shapingLPCOrder, /* I Shaping LPC filter order */ 337 opus_int predictLPCOrder, /* I Prediction filter order */ 338 opus_int warping_Q16, /* I */ 339 opus_int nStatesDelayedDecision, /* I Number of states in decision tree */ 340 opus_int *smpl_buf_idx, /* I/O Index to newest samples in buffers */ 341 opus_int decisionDelay, /* I */ 342 int arch /* I */ 343 ) 344 { 345 opus_int i, j, k, Winner_ind, RDmin_ind, RDmax_ind, last_smple_idx; 346 opus_int32 Winner_rand_state; 347 opus_int32 LTP_pred_Q14, LPC_pred_Q14, n_AR_Q14, n_LTP_Q14; 348 opus_int32 n_LF_Q14, r_Q10, rr_Q10, rd1_Q10, rd2_Q10, RDmin_Q10, RDmax_Q10; 349 opus_int32 q1_Q0, q1_Q10, q2_Q10, exc_Q14, LPC_exc_Q14, xq_Q14, Gain_Q10; 350 opus_int32 tmp1, tmp2, sLF_AR_shp_Q14; 351 opus_int32 *pred_lag_ptr, *shp_lag_ptr, *psLPC_Q14; 352 #ifdef silk_short_prediction_create_arch_coef 353 opus_int32 a_Q12_arch[MAX_LPC_ORDER]; 354 #endif 355 356 VARDECL( NSQ_sample_pair, psSampleState ); 357 NSQ_del_dec_struct *psDD; 358 NSQ_sample_struct *psSS; 359 SAVE_STACK; 360 361 celt_assert( nStatesDelayedDecision > 0 ); 362 ALLOC( psSampleState, nStatesDelayedDecision, NSQ_sample_pair ); 363 364 shp_lag_ptr = &NSQ->sLTP_shp_Q14[ NSQ->sLTP_shp_buf_idx - lag + HARM_SHAPE_FIR_TAPS / 2 ]; 365 pred_lag_ptr = &sLTP_Q15[ NSQ->sLTP_buf_idx - lag + LTP_ORDER / 2 ]; 366 Gain_Q10 = silk_RSHIFT( Gain_Q16, 6 ); 367 368 #ifdef silk_short_prediction_create_arch_coef 369 silk_short_prediction_create_arch_coef(a_Q12_arch, a_Q12, predictLPCOrder); 370 #endif 371 372 for( i = 0; i < length; i++ ) { 373 /* Perform common calculations used in all states */ 374 375 /* Long-term prediction */ 376 if( signalType == TYPE_VOICED ) { 377 /* Unrolled loop */ 378 /* Avoids introducing a bias because silk_SMLAWB() always rounds to -inf */ 379 LTP_pred_Q14 = 2; 380 LTP_pred_Q14 = silk_SMLAWB( LTP_pred_Q14, pred_lag_ptr[ 0 ], b_Q14[ 0 ] ); 381 LTP_pred_Q14 = silk_SMLAWB( LTP_pred_Q14, pred_lag_ptr[ -1 ], b_Q14[ 1 ] ); 382 LTP_pred_Q14 = silk_SMLAWB( LTP_pred_Q14, pred_lag_ptr[ -2 ], b_Q14[ 2 ] ); 383 LTP_pred_Q14 = silk_SMLAWB( LTP_pred_Q14, pred_lag_ptr[ -3 ], b_Q14[ 3 ] ); 384 LTP_pred_Q14 = silk_SMLAWB( LTP_pred_Q14, pred_lag_ptr[ -4 ], b_Q14[ 4 ] ); 385 LTP_pred_Q14 = silk_LSHIFT( LTP_pred_Q14, 1 ); /* Q13 -> Q14 */ 386 pred_lag_ptr++; 387 } else { 388 LTP_pred_Q14 = 0; 389 } 390 391 /* Long-term shaping */ 392 if( lag > 0 ) { 393 /* Symmetric, packed FIR coefficients */ 394 n_LTP_Q14 = silk_SMULWB( silk_ADD_SAT32( shp_lag_ptr[ 0 ], shp_lag_ptr[ -2 ] ), HarmShapeFIRPacked_Q14 ); 395 n_LTP_Q14 = silk_SMLAWT( n_LTP_Q14, shp_lag_ptr[ -1 ], HarmShapeFIRPacked_Q14 ); 396 n_LTP_Q14 = silk_SUB_LSHIFT32( LTP_pred_Q14, n_LTP_Q14, 2 ); /* Q12 -> Q14 */ 397 shp_lag_ptr++; 398 } else { 399 n_LTP_Q14 = 0; 400 } 401 402 for( k = 0; k < nStatesDelayedDecision; k++ ) { 403 /* Delayed decision state */ 404 psDD = &psDelDec[ k ]; 405 406 /* Sample state */ 407 psSS = psSampleState[ k ]; 408 409 /* Generate dither */ 410 psDD->Seed = silk_RAND( psDD->Seed ); 411 412 /* Pointer used in short term prediction and shaping */ 413 psLPC_Q14 = &psDD->sLPC_Q14[ NSQ_LPC_BUF_LENGTH - 1 + i ]; 414 /* Short-term prediction */ 415 LPC_pred_Q14 = silk_noise_shape_quantizer_short_prediction(psLPC_Q14, a_Q12, a_Q12_arch, predictLPCOrder, arch); 416 LPC_pred_Q14 = silk_LSHIFT( LPC_pred_Q14, 4 ); /* Q10 -> Q14 */ 417 418 /* Noise shape feedback */ 419 celt_assert( ( shapingLPCOrder & 1 ) == 0 ); /* check that order is even */ 420 /* Output of lowpass section */ 421 tmp2 = silk_SMLAWB( psDD->Diff_Q14, psDD->sAR2_Q14[ 0 ], warping_Q16 ); 422 /* Output of allpass section */ 423 tmp1 = silk_SMLAWB( psDD->sAR2_Q14[ 0 ], silk_SUB32_ovflw(psDD->sAR2_Q14[ 1 ], tmp2), warping_Q16 ); 424 psDD->sAR2_Q14[ 0 ] = tmp2; 425 n_AR_Q14 = silk_RSHIFT( shapingLPCOrder, 1 ); 426 n_AR_Q14 = silk_SMLAWB( n_AR_Q14, tmp2, AR_shp_Q13[ 0 ] ); 427 /* Loop over allpass sections */ 428 for( j = 2; j < shapingLPCOrder; j += 2 ) { 429 /* Output of allpass section */ 430 tmp2 = silk_SMLAWB( psDD->sAR2_Q14[ j - 1 ], silk_SUB32_ovflw(psDD->sAR2_Q14[ j + 0 ], tmp1), warping_Q16 ); 431 psDD->sAR2_Q14[ j - 1 ] = tmp1; 432 n_AR_Q14 = silk_SMLAWB( n_AR_Q14, tmp1, AR_shp_Q13[ j - 1 ] ); 433 /* Output of allpass section */ 434 tmp1 = silk_SMLAWB( psDD->sAR2_Q14[ j + 0 ], silk_SUB32_ovflw(psDD->sAR2_Q14[ j + 1 ], tmp2), warping_Q16 ); 435 psDD->sAR2_Q14[ j + 0 ] = tmp2; 436 n_AR_Q14 = silk_SMLAWB( n_AR_Q14, tmp2, AR_shp_Q13[ j ] ); 437 } 438 psDD->sAR2_Q14[ shapingLPCOrder - 1 ] = tmp1; 439 n_AR_Q14 = silk_SMLAWB( n_AR_Q14, tmp1, AR_shp_Q13[ shapingLPCOrder - 1 ] ); 440 441 n_AR_Q14 = silk_LSHIFT( n_AR_Q14, 1 ); /* Q11 -> Q12 */ 442 n_AR_Q14 = silk_SMLAWB( n_AR_Q14, psDD->LF_AR_Q14, Tilt_Q14 ); /* Q12 */ 443 n_AR_Q14 = silk_LSHIFT( n_AR_Q14, 2 ); /* Q12 -> Q14 */ 444 445 n_LF_Q14 = silk_SMULWB( psDD->Shape_Q14[ *smpl_buf_idx ], LF_shp_Q14 ); /* Q12 */ 446 n_LF_Q14 = silk_SMLAWT( n_LF_Q14, psDD->LF_AR_Q14, LF_shp_Q14 ); /* Q12 */ 447 n_LF_Q14 = silk_LSHIFT( n_LF_Q14, 2 ); /* Q12 -> Q14 */ 448 449 /* Input minus prediction plus noise feedback */ 450 /* r = x[ i ] - LTP_pred - LPC_pred + n_AR + n_Tilt + n_LF + n_LTP */ 451 tmp1 = silk_ADD_SAT32( n_AR_Q14, n_LF_Q14 ); /* Q14 */ 452 tmp2 = silk_ADD32_ovflw( n_LTP_Q14, LPC_pred_Q14 ); /* Q13 */ 453 tmp1 = silk_SUB_SAT32( tmp2, tmp1 ); /* Q13 */ 454 tmp1 = silk_RSHIFT_ROUND( tmp1, 4 ); /* Q10 */ 455 456 r_Q10 = silk_SUB32( x_Q10[ i ], tmp1 ); /* residual error Q10 */ 457 458 /* Flip sign depending on dither */ 459 if ( psDD->Seed < 0 ) { 460 r_Q10 = -r_Q10; 461 } 462 r_Q10 = silk_LIMIT_32( r_Q10, -(31 << 10), 30 << 10 ); 463 464 /* Find two quantization level candidates and measure their rate-distortion */ 465 q1_Q10 = silk_SUB32( r_Q10, offset_Q10 ); 466 q1_Q0 = silk_RSHIFT( q1_Q10, 10 ); 467 if (Lambda_Q10 > 2048) { 468 /* For aggressive RDO, the bias becomes more than one pulse. */ 469 int rdo_offset = Lambda_Q10/2 - 512; 470 if (q1_Q10 > rdo_offset) { 471 q1_Q0 = silk_RSHIFT( q1_Q10 - rdo_offset, 10 ); 472 } else if (q1_Q10 < -rdo_offset) { 473 q1_Q0 = silk_RSHIFT( q1_Q10 + rdo_offset, 10 ); 474 } else if (q1_Q10 < 0) { 475 q1_Q0 = -1; 476 } else { 477 q1_Q0 = 0; 478 } 479 } 480 if( q1_Q0 > 0 ) { 481 q1_Q10 = silk_SUB32( silk_LSHIFT( q1_Q0, 10 ), QUANT_LEVEL_ADJUST_Q10 ); 482 q1_Q10 = silk_ADD32( q1_Q10, offset_Q10 ); 483 q2_Q10 = silk_ADD32( q1_Q10, 1024 ); 484 rd1_Q10 = silk_SMULBB( q1_Q10, Lambda_Q10 ); 485 rd2_Q10 = silk_SMULBB( q2_Q10, Lambda_Q10 ); 486 } else if( q1_Q0 == 0 ) { 487 q1_Q10 = offset_Q10; 488 q2_Q10 = silk_ADD32( q1_Q10, 1024 - QUANT_LEVEL_ADJUST_Q10 ); 489 rd1_Q10 = silk_SMULBB( q1_Q10, Lambda_Q10 ); 490 rd2_Q10 = silk_SMULBB( q2_Q10, Lambda_Q10 ); 491 } else if( q1_Q0 == -1 ) { 492 q2_Q10 = offset_Q10; 493 q1_Q10 = silk_SUB32( q2_Q10, 1024 - QUANT_LEVEL_ADJUST_Q10 ); 494 rd1_Q10 = silk_SMULBB( -q1_Q10, Lambda_Q10 ); 495 rd2_Q10 = silk_SMULBB( q2_Q10, Lambda_Q10 ); 496 } else { /* q1_Q0 < -1 */ 497 q1_Q10 = silk_ADD32( silk_LSHIFT( q1_Q0, 10 ), QUANT_LEVEL_ADJUST_Q10 ); 498 q1_Q10 = silk_ADD32( q1_Q10, offset_Q10 ); 499 q2_Q10 = silk_ADD32( q1_Q10, 1024 ); 500 rd1_Q10 = silk_SMULBB( -q1_Q10, Lambda_Q10 ); 501 rd2_Q10 = silk_SMULBB( -q2_Q10, Lambda_Q10 ); 502 } 503 rr_Q10 = silk_SUB32( r_Q10, q1_Q10 ); 504 rd1_Q10 = silk_RSHIFT( silk_SMLABB( rd1_Q10, rr_Q10, rr_Q10 ), 10 ); 505 rr_Q10 = silk_SUB32( r_Q10, q2_Q10 ); 506 rd2_Q10 = silk_RSHIFT( silk_SMLABB( rd2_Q10, rr_Q10, rr_Q10 ), 10 ); 507 508 if( rd1_Q10 < rd2_Q10 ) { 509 psSS[ 0 ].RD_Q10 = silk_ADD32( psDD->RD_Q10, rd1_Q10 ); 510 psSS[ 1 ].RD_Q10 = silk_ADD32( psDD->RD_Q10, rd2_Q10 ); 511 psSS[ 0 ].Q_Q10 = q1_Q10; 512 psSS[ 1 ].Q_Q10 = q2_Q10; 513 } else { 514 psSS[ 0 ].RD_Q10 = silk_ADD32( psDD->RD_Q10, rd2_Q10 ); 515 psSS[ 1 ].RD_Q10 = silk_ADD32( psDD->RD_Q10, rd1_Q10 ); 516 psSS[ 0 ].Q_Q10 = q2_Q10; 517 psSS[ 1 ].Q_Q10 = q1_Q10; 518 } 519 520 /* Update states for best quantization */ 521 522 /* Quantized excitation */ 523 exc_Q14 = silk_LSHIFT32( psSS[ 0 ].Q_Q10, 4 ); 524 if ( psDD->Seed < 0 ) { 525 exc_Q14 = -exc_Q14; 526 } 527 528 /* Add predictions */ 529 LPC_exc_Q14 = silk_ADD32( exc_Q14, LTP_pred_Q14 ); 530 xq_Q14 = silk_ADD32_ovflw( LPC_exc_Q14, LPC_pred_Q14 ); 531 532 /* Update states */ 533 psSS[ 0 ].Diff_Q14 = silk_SUB32_ovflw( xq_Q14, silk_LSHIFT32( x_Q10[ i ], 4 ) ); 534 sLF_AR_shp_Q14 = silk_SUB32_ovflw( psSS[ 0 ].Diff_Q14, n_AR_Q14 ); 535 psSS[ 0 ].sLTP_shp_Q14 = silk_SUB_SAT32( sLF_AR_shp_Q14, n_LF_Q14 ); 536 psSS[ 0 ].LF_AR_Q14 = sLF_AR_shp_Q14; 537 psSS[ 0 ].LPC_exc_Q14 = LPC_exc_Q14; 538 psSS[ 0 ].xq_Q14 = xq_Q14; 539 540 /* Update states for second best quantization */ 541 542 /* Quantized excitation */ 543 exc_Q14 = silk_LSHIFT32( psSS[ 1 ].Q_Q10, 4 ); 544 if ( psDD->Seed < 0 ) { 545 exc_Q14 = -exc_Q14; 546 } 547 548 /* Add predictions */ 549 LPC_exc_Q14 = silk_ADD32( exc_Q14, LTP_pred_Q14 ); 550 xq_Q14 = silk_ADD32_ovflw( LPC_exc_Q14, LPC_pred_Q14 ); 551 552 /* Update states */ 553 psSS[ 1 ].Diff_Q14 = silk_SUB32_ovflw( xq_Q14, silk_LSHIFT32( x_Q10[ i ], 4 ) ); 554 sLF_AR_shp_Q14 = silk_SUB32_ovflw( psSS[ 1 ].Diff_Q14, n_AR_Q14 ); 555 psSS[ 1 ].sLTP_shp_Q14 = silk_SUB_SAT32( sLF_AR_shp_Q14, n_LF_Q14 ); 556 psSS[ 1 ].LF_AR_Q14 = sLF_AR_shp_Q14; 557 psSS[ 1 ].LPC_exc_Q14 = LPC_exc_Q14; 558 psSS[ 1 ].xq_Q14 = xq_Q14; 559 } 560 561 *smpl_buf_idx = ( *smpl_buf_idx - 1 ) % DECISION_DELAY; 562 if( *smpl_buf_idx < 0 ) *smpl_buf_idx += DECISION_DELAY; 563 last_smple_idx = ( *smpl_buf_idx + decisionDelay ) % DECISION_DELAY; 564 565 /* Find winner */ 566 RDmin_Q10 = psSampleState[ 0 ][ 0 ].RD_Q10; 567 Winner_ind = 0; 568 for( k = 1; k < nStatesDelayedDecision; k++ ) { 569 if( psSampleState[ k ][ 0 ].RD_Q10 < RDmin_Q10 ) { 570 RDmin_Q10 = psSampleState[ k ][ 0 ].RD_Q10; 571 Winner_ind = k; 572 } 573 } 574 575 /* Increase RD values of expired states */ 576 Winner_rand_state = psDelDec[ Winner_ind ].RandState[ last_smple_idx ]; 577 for( k = 0; k < nStatesDelayedDecision; k++ ) { 578 if( psDelDec[ k ].RandState[ last_smple_idx ] != Winner_rand_state ) { 579 psSampleState[ k ][ 0 ].RD_Q10 = silk_ADD32( psSampleState[ k ][ 0 ].RD_Q10, silk_int32_MAX >> 4 ); 580 psSampleState[ k ][ 1 ].RD_Q10 = silk_ADD32( psSampleState[ k ][ 1 ].RD_Q10, silk_int32_MAX >> 4 ); 581 silk_assert( psSampleState[ k ][ 0 ].RD_Q10 >= 0 ); 582 } 583 } 584 585 /* Find worst in first set and best in second set */ 586 RDmax_Q10 = psSampleState[ 0 ][ 0 ].RD_Q10; 587 RDmin_Q10 = psSampleState[ 0 ][ 1 ].RD_Q10; 588 RDmax_ind = 0; 589 RDmin_ind = 0; 590 for( k = 1; k < nStatesDelayedDecision; k++ ) { 591 /* find worst in first set */ 592 if( psSampleState[ k ][ 0 ].RD_Q10 > RDmax_Q10 ) { 593 RDmax_Q10 = psSampleState[ k ][ 0 ].RD_Q10; 594 RDmax_ind = k; 595 } 596 /* find best in second set */ 597 if( psSampleState[ k ][ 1 ].RD_Q10 < RDmin_Q10 ) { 598 RDmin_Q10 = psSampleState[ k ][ 1 ].RD_Q10; 599 RDmin_ind = k; 600 } 601 } 602 603 /* Replace a state if best from second set outperforms worst in first set */ 604 if( RDmin_Q10 < RDmax_Q10 ) { 605 silk_memcpy( ( (opus_int32 *)&psDelDec[ RDmax_ind ] ) + i, 606 ( (opus_int32 *)&psDelDec[ RDmin_ind ] ) + i, sizeof( NSQ_del_dec_struct ) - i * sizeof( opus_int32) ); 607 silk_memcpy( &psSampleState[ RDmax_ind ][ 0 ], &psSampleState[ RDmin_ind ][ 1 ], sizeof( NSQ_sample_struct ) ); 608 } 609 610 /* Write samples from winner to output and long-term filter states */ 611 psDD = &psDelDec[ Winner_ind ]; 612 if( subfr > 0 || i >= decisionDelay ) { 613 pulses[ i - decisionDelay ] = (opus_int8)silk_RSHIFT_ROUND( psDD->Q_Q10[ last_smple_idx ], 10 ); 614 xq[ i - decisionDelay ] = (opus_int16)silk_SAT16( silk_RSHIFT_ROUND( 615 silk_SMULWW( psDD->Xq_Q14[ last_smple_idx ], delayedGain_Q10[ last_smple_idx ] ), 8 ) ); 616 NSQ->sLTP_shp_Q14[ NSQ->sLTP_shp_buf_idx - decisionDelay ] = psDD->Shape_Q14[ last_smple_idx ]; 617 sLTP_Q15[ NSQ->sLTP_buf_idx - decisionDelay ] = psDD->Pred_Q15[ last_smple_idx ]; 618 } 619 NSQ->sLTP_shp_buf_idx++; 620 NSQ->sLTP_buf_idx++; 621 622 /* Update states */ 623 for( k = 0; k < nStatesDelayedDecision; k++ ) { 624 psDD = &psDelDec[ k ]; 625 psSS = &psSampleState[ k ][ 0 ]; 626 psDD->LF_AR_Q14 = psSS->LF_AR_Q14; 627 psDD->Diff_Q14 = psSS->Diff_Q14; 628 psDD->sLPC_Q14[ NSQ_LPC_BUF_LENGTH + i ] = psSS->xq_Q14; 629 psDD->Xq_Q14[ *smpl_buf_idx ] = psSS->xq_Q14; 630 psDD->Q_Q10[ *smpl_buf_idx ] = psSS->Q_Q10; 631 psDD->Pred_Q15[ *smpl_buf_idx ] = silk_LSHIFT32( psSS->LPC_exc_Q14, 1 ); 632 psDD->Shape_Q14[ *smpl_buf_idx ] = psSS->sLTP_shp_Q14; 633 psDD->Seed = silk_ADD32_ovflw( psDD->Seed, silk_RSHIFT_ROUND( psSS->Q_Q10, 10 ) ); 634 psDD->RandState[ *smpl_buf_idx ] = psDD->Seed; 635 psDD->RD_Q10 = psSS->RD_Q10; 636 } 637 delayedGain_Q10[ *smpl_buf_idx ] = Gain_Q10; 638 } 639 /* Update LPC states */ 640 for( k = 0; k < nStatesDelayedDecision; k++ ) { 641 psDD = &psDelDec[ k ]; 642 silk_memcpy( psDD->sLPC_Q14, &psDD->sLPC_Q14[ length ], NSQ_LPC_BUF_LENGTH * sizeof( opus_int32 ) ); 643 } 644 RESTORE_STACK; 645 } 646 #endif /* OVERRIDE_silk_noise_shape_quantizer_del_dec */ 647 648 static OPUS_INLINE void silk_nsq_del_dec_scale_states( 649 const silk_encoder_state *psEncC, /* I Encoder State */ 650 silk_nsq_state *NSQ, /* I/O NSQ state */ 651 NSQ_del_dec_struct psDelDec[], /* I/O Delayed decision states */ 652 const opus_int16 x16[], /* I Input */ 653 opus_int32 x_sc_Q10[], /* O Input scaled with 1/Gain in Q10 */ 654 const opus_int16 sLTP[], /* I Re-whitened LTP state in Q0 */ 655 opus_int32 sLTP_Q15[], /* O LTP state matching scaled input */ 656 opus_int subfr, /* I Subframe number */ 657 opus_int nStatesDelayedDecision, /* I Number of del dec states */ 658 const opus_int LTP_scale_Q14, /* I LTP state scaling */ 659 const opus_int32 Gains_Q16[ MAX_NB_SUBFR ], /* I */ 660 const opus_int pitchL[ MAX_NB_SUBFR ], /* I Pitch lag */ 661 const opus_int signal_type, /* I Signal type */ 662 const opus_int decisionDelay /* I Decision delay */ 663 ) 664 { 665 opus_int i, k, lag; 666 opus_int32 gain_adj_Q16, inv_gain_Q31, inv_gain_Q26; 667 NSQ_del_dec_struct *psDD; 668 669 lag = pitchL[ subfr ]; 670 inv_gain_Q31 = silk_INVERSE32_varQ( silk_max( Gains_Q16[ subfr ], 1 ), 47 ); 671 silk_assert( inv_gain_Q31 != 0 ); 672 673 /* Scale input */ 674 inv_gain_Q26 = silk_RSHIFT_ROUND( inv_gain_Q31, 5 ); 675 for( i = 0; i < psEncC->subfr_length; i++ ) { 676 x_sc_Q10[ i ] = silk_SMULWW( x16[ i ], inv_gain_Q26 ); 677 } 678 679 /* After rewhitening the LTP state is un-scaled, so scale with inv_gain_Q16 */ 680 if( NSQ->rewhite_flag ) { 681 if( subfr == 0 ) { 682 /* Do LTP downscaling */ 683 inv_gain_Q31 = silk_LSHIFT( silk_SMULWB( inv_gain_Q31, LTP_scale_Q14 ), 2 ); 684 } 685 for( i = NSQ->sLTP_buf_idx - lag - LTP_ORDER / 2; i < NSQ->sLTP_buf_idx; i++ ) { 686 silk_assert( i < MAX_FRAME_LENGTH ); 687 sLTP_Q15[ i ] = silk_SMULWB( inv_gain_Q31, sLTP[ i ] ); 688 } 689 } 690 691 /* Adjust for changing gain */ 692 if( Gains_Q16[ subfr ] != NSQ->prev_gain_Q16 ) { 693 gain_adj_Q16 = silk_DIV32_varQ( NSQ->prev_gain_Q16, Gains_Q16[ subfr ], 16 ); 694 695 /* Scale long-term shaping state */ 696 for( i = NSQ->sLTP_shp_buf_idx - psEncC->ltp_mem_length; i < NSQ->sLTP_shp_buf_idx; i++ ) { 697 NSQ->sLTP_shp_Q14[ i ] = silk_SMULWW( gain_adj_Q16, NSQ->sLTP_shp_Q14[ i ] ); 698 } 699 700 /* Scale long-term prediction state */ 701 if( signal_type == TYPE_VOICED && NSQ->rewhite_flag == 0 ) { 702 for( i = NSQ->sLTP_buf_idx - lag - LTP_ORDER / 2; i < NSQ->sLTP_buf_idx - decisionDelay; i++ ) { 703 sLTP_Q15[ i ] = silk_SMULWW( gain_adj_Q16, sLTP_Q15[ i ] ); 704 } 705 } 706 707 for( k = 0; k < nStatesDelayedDecision; k++ ) { 708 psDD = &psDelDec[ k ]; 709 710 /* Scale scalar states */ 711 psDD->LF_AR_Q14 = silk_SMULWW( gain_adj_Q16, psDD->LF_AR_Q14 ); 712 psDD->Diff_Q14 = silk_SMULWW( gain_adj_Q16, psDD->Diff_Q14 ); 713 714 /* Scale short-term prediction and shaping states */ 715 for( i = 0; i < NSQ_LPC_BUF_LENGTH; i++ ) { 716 psDD->sLPC_Q14[ i ] = silk_SMULWW( gain_adj_Q16, psDD->sLPC_Q14[ i ] ); 717 } 718 for( i = 0; i < MAX_SHAPE_LPC_ORDER; i++ ) { 719 psDD->sAR2_Q14[ i ] = silk_SMULWW( gain_adj_Q16, psDD->sAR2_Q14[ i ] ); 720 } 721 for( i = 0; i < DECISION_DELAY; i++ ) { 722 psDD->Pred_Q15[ i ] = silk_SMULWW( gain_adj_Q16, psDD->Pred_Q15[ i ] ); 723 psDD->Shape_Q14[ i ] = silk_SMULWW( gain_adj_Q16, psDD->Shape_Q14[ i ] ); 724 } 725 } 726 727 /* Save inverse gain */ 728 NSQ->prev_gain_Q16 = Gains_Q16[ subfr ]; 729 } 730 }