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