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