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