Make compiler settings consistent. Actually produce the libary, remove the opus_demo...
[opus.git] / silk / NSQ.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
34 static inline void silk_nsq_scale_states(
35     const silk_encoder_state *psEncC,           /* I    Encoder State                   */
36     silk_nsq_state      *NSQ,                   /* I/O  NSQ state                       */
37     const opus_int32    x_Q3[],                 /* I    input in Q3                     */
38     opus_int32          x_sc_Q10[],             /* O    input scaled with 1/Gain        */
39     const opus_int16    sLTP[],                 /* I    re-whitened LTP state in Q0     */
40     opus_int32          sLTP_Q15[],             /* O    LTP state matching scaled input */
41     opus_int            subfr,                  /* I    subframe number                 */
42     const opus_int      LTP_scale_Q14,          /* I                                    */
43     const opus_int32    Gains_Q16[ MAX_NB_SUBFR ], /* I                                 */
44     const opus_int      pitchL[ MAX_NB_SUBFR ], /* I    Pitch lag                       */
45     const opus_int      signal_type             /* I    Signal type                     */
46 );
47
48 static inline void silk_noise_shape_quantizer(
49     silk_nsq_state      *NSQ,                   /* I/O  NSQ state                       */
50     opus_int            signalType,             /* I    Signal type                     */
51     const opus_int32    x_sc_Q10[],             /* I                                    */
52     opus_int8           pulses[],               /* O                                    */
53     opus_int16          xq[],                   /* O                                    */
54     opus_int32          sLTP_Q15[],             /* I/O  LTP state                       */
55     const opus_int16    a_Q12[],                /* I    Short term prediction coefs     */
56     const opus_int16    b_Q14[],                /* I    Long term prediction coefs      */
57     const opus_int16    AR_shp_Q13[],           /* I    Noise shaping AR coefs          */
58     opus_int            lag,                    /* I    Pitch lag                       */
59     opus_int32          HarmShapeFIRPacked_Q14, /* I                                    */
60     opus_int            Tilt_Q14,               /* I    Spectral tilt                   */
61     opus_int32          LF_shp_Q14,             /* I                                    */
62     opus_int32          Gain_Q16,               /* I                                    */
63     opus_int            Lambda_Q10,             /* I                                    */
64     opus_int            offset_Q10,             /* I                                    */
65     opus_int            length,                 /* I    Input length                    */
66     opus_int            shapingLPCOrder,        /* I    Noise shaping AR filter order   */
67     opus_int            predictLPCOrder         /* I    Prediction filter order         */
68 );
69
70 void silk_NSQ(
71     const silk_encoder_state    *psEncC,                                    /* I/O  Encoder State                   */
72     silk_nsq_state              *NSQ,                                       /* I/O  NSQ state                       */
73     SideInfoIndices             *psIndices,                                 /* I/O  Quantization Indices            */
74     const opus_int32            x_Q3[],                                     /* I    Prefiltered input signal        */
75     opus_int8                   pulses[],                                   /* O    Quantized pulse signal          */
76     const opus_int16            PredCoef_Q12[ 2 * MAX_LPC_ORDER ],          /* I    Short term prediction coefs     */
77     const opus_int16            LTPCoef_Q14[ LTP_ORDER * MAX_NB_SUBFR ],    /* I    Long term prediction coefs      */
78     const opus_int16            AR2_Q13[ MAX_NB_SUBFR * MAX_SHAPE_LPC_ORDER ], /* I Noise shaping coefs             */
79     const opus_int              HarmShapeGain_Q14[ MAX_NB_SUBFR ],          /* I    Long term shaping coefs         */
80     const opus_int              Tilt_Q14[ MAX_NB_SUBFR ],                   /* I    Spectral tilt                   */
81     const opus_int32            LF_shp_Q14[ MAX_NB_SUBFR ],                 /* I    Low frequency shaping coefs     */
82     const opus_int32            Gains_Q16[ MAX_NB_SUBFR ],                  /* I    Quantization step sizes         */
83     const opus_int              pitchL[ MAX_NB_SUBFR ],                     /* I    Pitch lags                      */
84     const opus_int              Lambda_Q10,                                 /* I    Rate/distortion tradeoff        */
85     const opus_int              LTP_scale_Q14                               /* I    LTP state scaling               */
86 )
87 {
88     opus_int            k, lag, start_idx, LSF_interpolation_flag;
89     const opus_int16    *A_Q12, *B_Q14, *AR_shp_Q13;
90     opus_int16          *pxq;
91     opus_int32          sLTP_Q15[ 2 * MAX_FRAME_LENGTH ];
92     opus_int16          sLTP[     2 * MAX_FRAME_LENGTH ];
93     opus_int32          HarmShapeFIRPacked_Q14;
94     opus_int            offset_Q10;
95     opus_int32          x_sc_Q10[ MAX_SUB_FRAME_LENGTH ];
96
97     NSQ->rand_seed = psIndices->Seed;
98
99     /* Set unvoiced lag to the previous one, overwrite later for voiced */
100     lag = NSQ->lagPrev;
101
102     silk_assert( NSQ->prev_gain_Q16 != 0 );
103
104     offset_Q10 = silk_Quantization_Offsets_Q10[ psIndices->signalType >> 1 ][ psIndices->quantOffsetType ];
105
106     if( psIndices->NLSFInterpCoef_Q2 == 4 ) {
107         LSF_interpolation_flag = 0;
108     } else {
109         LSF_interpolation_flag = 1;
110     }
111
112     /* Set up pointers to start of sub frame */
113     NSQ->sLTP_shp_buf_idx = psEncC->ltp_mem_length;
114     NSQ->sLTP_buf_idx     = psEncC->ltp_mem_length;
115     pxq                   = &NSQ->xq[ psEncC->ltp_mem_length ];
116     for( k = 0; k < psEncC->nb_subfr; k++ ) {
117         A_Q12      = &PredCoef_Q12[ (( k >> 1 ) | ( 1 - LSF_interpolation_flag )) * MAX_LPC_ORDER ];
118         B_Q14      = &LTPCoef_Q14[ k * LTP_ORDER ];
119         AR_shp_Q13 = &AR2_Q13[     k * MAX_SHAPE_LPC_ORDER ];
120
121         /* Noise shape parameters */
122         silk_assert( HarmShapeGain_Q14[ k ] >= 0 );
123         HarmShapeFIRPacked_Q14  =                          silk_RSHIFT( HarmShapeGain_Q14[ k ], 2 );
124         HarmShapeFIRPacked_Q14 |= silk_LSHIFT( (opus_int32)silk_RSHIFT( HarmShapeGain_Q14[ k ], 1 ), 16 );
125
126         NSQ->rewhite_flag = 0;
127         if( psIndices->signalType == TYPE_VOICED ) {
128             /* Voiced */
129             lag = pitchL[ k ];
130
131             /* Re-whitening */
132             if( ( k & ( 3 - silk_LSHIFT( LSF_interpolation_flag, 1 ) ) ) == 0 ) {
133                 /* Rewhiten with new A coefs */
134                 start_idx = psEncC->ltp_mem_length - lag - psEncC->predictLPCOrder - LTP_ORDER / 2;
135                 silk_assert( start_idx > 0 );
136
137                 silk_LPC_analysis_filter( &sLTP[ start_idx ], &NSQ->xq[ start_idx + k * psEncC->subfr_length ],
138                     A_Q12, psEncC->ltp_mem_length - start_idx, psEncC->predictLPCOrder );
139
140                 NSQ->rewhite_flag = 1;
141                 NSQ->sLTP_buf_idx = psEncC->ltp_mem_length;
142             }
143         }
144
145         silk_nsq_scale_states( psEncC, NSQ, x_Q3, x_sc_Q10, sLTP, sLTP_Q15, k, LTP_scale_Q14, Gains_Q16, pitchL, psIndices->signalType );
146
147         silk_noise_shape_quantizer( NSQ, psIndices->signalType, x_sc_Q10, pulses, pxq, sLTP_Q15, A_Q12, B_Q14,
148             AR_shp_Q13, lag, HarmShapeFIRPacked_Q14, Tilt_Q14[ k ], LF_shp_Q14[ k ], Gains_Q16[ k ], Lambda_Q10,
149             offset_Q10, psEncC->subfr_length, psEncC->shapingLPCOrder, psEncC->predictLPCOrder );
150
151         x_Q3   += psEncC->subfr_length;
152         pulses += psEncC->subfr_length;
153         pxq    += psEncC->subfr_length;
154     }
155
156     /* Update lagPrev for next frame */
157     NSQ->lagPrev = pitchL[ psEncC->nb_subfr - 1 ];
158
159     /* Save quantized speech and noise shaping signals */
160     /* DEBUG_STORE_DATA( enc.pcm, &NSQ->xq[ psEncC->ltp_mem_length ], psEncC->frame_length * sizeof( opus_int16 ) ) */
161     silk_memmove( NSQ->xq,           &NSQ->xq[           psEncC->frame_length ], psEncC->ltp_mem_length * sizeof( opus_int16 ) );
162     silk_memmove( NSQ->sLTP_shp_Q14, &NSQ->sLTP_shp_Q14[ psEncC->frame_length ], psEncC->ltp_mem_length * sizeof( opus_int32 ) );
163 }
164
165 /***********************************/
166 /* silk_noise_shape_quantizer  */
167 /***********************************/
168 static inline void silk_noise_shape_quantizer(
169     silk_nsq_state      *NSQ,                   /* I/O  NSQ state                       */
170     opus_int            signalType,             /* I    Signal type                     */
171     const opus_int32    x_sc_Q10[],             /* I                                    */
172     opus_int8           pulses[],               /* O                                    */
173     opus_int16          xq[],                   /* O                                    */
174     opus_int32          sLTP_Q15[],             /* I/O  LTP state                       */
175     const opus_int16    a_Q12[],                /* I    Short term prediction coefs     */
176     const opus_int16    b_Q14[],                /* I    Long term prediction coefs      */
177     const opus_int16    AR_shp_Q13[],           /* I    Noise shaping AR coefs          */
178     opus_int            lag,                    /* I    Pitch lag                       */
179     opus_int32          HarmShapeFIRPacked_Q14, /* I                                    */
180     opus_int            Tilt_Q14,               /* I    Spectral tilt                   */
181     opus_int32          LF_shp_Q14,             /* I                                    */
182     opus_int32          Gain_Q16,               /* I                                    */
183     opus_int            Lambda_Q10,             /* I                                    */
184     opus_int            offset_Q10,             /* I                                    */
185     opus_int            length,                 /* I    Input length                    */
186     opus_int            shapingLPCOrder,        /* I    Noise shaping AR filter order   */
187     opus_int            predictLPCOrder         /* I    Prediction filter order         */
188 )
189 {
190     opus_int     i, j;
191     opus_int32   LTP_pred_Q13, LPC_pred_Q10, n_AR_Q12, n_LTP_Q13;
192     opus_int32   n_LF_Q12, r_Q10, rr_Q10, q1_Q0, q1_Q10, q2_Q10, rd1_Q20, rd2_Q20;
193     opus_int32   exc_Q14, LPC_exc_Q14, xq_Q14, Gain_Q10;
194     opus_int32   tmp1, tmp2, sLF_AR_shp_Q14;
195     opus_int32   *psLPC_Q14, *shp_lag_ptr, *pred_lag_ptr;
196
197     shp_lag_ptr  = &NSQ->sLTP_shp_Q14[ NSQ->sLTP_shp_buf_idx - lag + HARM_SHAPE_FIR_TAPS / 2 ];
198     pred_lag_ptr = &sLTP_Q15[ NSQ->sLTP_buf_idx - lag + LTP_ORDER / 2 ];
199     Gain_Q10     = silk_RSHIFT( Gain_Q16, 6 );
200
201     /* Set up short term AR state */
202     psLPC_Q14 = &NSQ->sLPC_Q14[ NSQ_LPC_BUF_LENGTH - 1 ];
203
204     for( i = 0; i < length; i++ ) {
205         /* Generate dither */
206         NSQ->rand_seed = silk_RAND( NSQ->rand_seed );
207
208         /* Short-term prediction */
209         silk_assert( predictLPCOrder == 10 || predictLPCOrder == 16 );
210         /* Avoids introducing a bias because silk_SMLAWB() always rounds to -inf */
211         LPC_pred_Q10 = silk_RSHIFT( predictLPCOrder, 1 );
212         LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[  0 ], a_Q12[ 0 ] );
213         LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -1 ], a_Q12[ 1 ] );
214         LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -2 ], a_Q12[ 2 ] );
215         LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -3 ], a_Q12[ 3 ] );
216         LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -4 ], a_Q12[ 4 ] );
217         LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -5 ], a_Q12[ 5 ] );
218         LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -6 ], a_Q12[ 6 ] );
219         LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -7 ], a_Q12[ 7 ] );
220         LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -8 ], a_Q12[ 8 ] );
221         LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -9 ], a_Q12[ 9 ] );
222         if( predictLPCOrder == 16 ) {
223             LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -10 ], a_Q12[ 10 ] );
224             LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -11 ], a_Q12[ 11 ] );
225             LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -12 ], a_Q12[ 12 ] );
226             LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -13 ], a_Q12[ 13 ] );
227             LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -14 ], a_Q12[ 14 ] );
228             LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -15 ], a_Q12[ 15 ] );
229         }
230
231         /* Long-term prediction */
232         if( signalType == TYPE_VOICED ) {
233             /* Unrolled loop */
234             /* Avoids introducing a bias because silk_SMLAWB() always rounds to -inf */
235             LTP_pred_Q13 = 2;
236             LTP_pred_Q13 = silk_SMLAWB( LTP_pred_Q13, pred_lag_ptr[  0 ], b_Q14[ 0 ] );
237             LTP_pred_Q13 = silk_SMLAWB( LTP_pred_Q13, pred_lag_ptr[ -1 ], b_Q14[ 1 ] );
238             LTP_pred_Q13 = silk_SMLAWB( LTP_pred_Q13, pred_lag_ptr[ -2 ], b_Q14[ 2 ] );
239             LTP_pred_Q13 = silk_SMLAWB( LTP_pred_Q13, pred_lag_ptr[ -3 ], b_Q14[ 3 ] );
240             LTP_pred_Q13 = silk_SMLAWB( LTP_pred_Q13, pred_lag_ptr[ -4 ], b_Q14[ 4 ] );
241             pred_lag_ptr++;
242         } else {
243             LTP_pred_Q13 = 0;
244         }
245
246         /* Noise shape feedback */
247         silk_assert( ( shapingLPCOrder & 1 ) == 0 );   /* check that order is even */
248         tmp2 = psLPC_Q14[ 0 ];
249         tmp1 = NSQ->sAR2_Q14[ 0 ];
250         NSQ->sAR2_Q14[ 0 ] = tmp2;
251         n_AR_Q12 = silk_RSHIFT( shapingLPCOrder, 1 );
252         n_AR_Q12 = silk_SMLAWB( n_AR_Q12, tmp2, AR_shp_Q13[ 0 ] );
253         for( j = 2; j < shapingLPCOrder; j += 2 ) {
254             tmp2 = NSQ->sAR2_Q14[ j - 1 ];
255             NSQ->sAR2_Q14[ j - 1 ] = tmp1;
256             n_AR_Q12 = silk_SMLAWB( n_AR_Q12, tmp1, AR_shp_Q13[ j - 1 ] );
257             tmp1 = NSQ->sAR2_Q14[ j + 0 ];
258             NSQ->sAR2_Q14[ j + 0 ] = tmp2;
259             n_AR_Q12 = silk_SMLAWB( n_AR_Q12, tmp2, AR_shp_Q13[ j ] );
260         }
261         NSQ->sAR2_Q14[ shapingLPCOrder - 1 ] = tmp1;
262         n_AR_Q12 = silk_SMLAWB( n_AR_Q12, tmp1, AR_shp_Q13[ shapingLPCOrder - 1 ] );
263
264         n_AR_Q12 = silk_LSHIFT32( n_AR_Q12, 1 );                                /* Q11 -> Q12 */
265         n_AR_Q12 = silk_SMLAWB( n_AR_Q12, NSQ->sLF_AR_shp_Q14, Tilt_Q14 );
266
267         n_LF_Q12 = silk_SMULWB( NSQ->sLTP_shp_Q14[ NSQ->sLTP_shp_buf_idx - 1 ], LF_shp_Q14 );
268         n_LF_Q12 = silk_SMLAWT( n_LF_Q12, NSQ->sLF_AR_shp_Q14, LF_shp_Q14 );
269
270         silk_assert( lag > 0 || signalType != TYPE_VOICED );
271
272         /* Combine prediction and noise shaping signals */
273         tmp1 = silk_SUB32( silk_LSHIFT32( LPC_pred_Q10, 2 ), n_AR_Q12 );        /* Q12 */
274         tmp1 = silk_SUB32( tmp1, n_LF_Q12 );                                    /* Q12 */
275         if( lag > 0 ) {
276             /* Symmetric, packed FIR coefficients */
277             n_LTP_Q13 = silk_SMULWB( silk_ADD32( shp_lag_ptr[ 0 ], shp_lag_ptr[ -2 ] ), HarmShapeFIRPacked_Q14 );
278             n_LTP_Q13 = silk_SMLAWT( n_LTP_Q13, shp_lag_ptr[ -1 ],                      HarmShapeFIRPacked_Q14 );
279             n_LTP_Q13 = silk_LSHIFT( n_LTP_Q13, 1 );
280             shp_lag_ptr++;
281
282             tmp2 = silk_SUB32( LTP_pred_Q13, n_LTP_Q13 );                       /* Q13 */
283             tmp1 = silk_ADD_LSHIFT32( tmp2, tmp1, 1 );                          /* Q13 */
284             tmp1 = silk_RSHIFT_ROUND( tmp1, 3 );                                /* Q10 */
285         } else {
286             tmp1 = silk_RSHIFT_ROUND( tmp1, 2 );                                /* Q10 */
287         }
288
289         r_Q10 = silk_SUB32( x_sc_Q10[ i ], tmp1 );                              /* residual error Q10 */
290
291         /* Flip sign depending on dither */
292         if ( NSQ->rand_seed < 0 ) {
293            r_Q10 = -r_Q10;
294         }
295         r_Q10 = silk_LIMIT_32( r_Q10, -(31 << 10), 30 << 10 );
296
297         /* Find two quantization level candidates and measure their rate-distortion */
298         q1_Q10 = silk_SUB32( r_Q10, offset_Q10 );
299         q1_Q0 = silk_RSHIFT( q1_Q10, 10 );
300         if( q1_Q0 > 0 ) {
301             q1_Q10  = silk_SUB32( silk_LSHIFT( q1_Q0, 10 ), QUANT_LEVEL_ADJUST_Q10 );
302             q1_Q10  = silk_ADD32( q1_Q10, offset_Q10 );
303             q2_Q10  = silk_ADD32( q1_Q10, 1024 );
304             rd1_Q20 = silk_SMULBB( q1_Q10, Lambda_Q10 );
305             rd2_Q20 = silk_SMULBB( q2_Q10, Lambda_Q10 );
306         } else if( q1_Q0 == 0 ) {
307             q1_Q10  = offset_Q10;
308             q2_Q10  = silk_ADD32( q1_Q10, 1024 - QUANT_LEVEL_ADJUST_Q10 );
309             rd1_Q20 = silk_SMULBB( q1_Q10, Lambda_Q10 );
310             rd2_Q20 = silk_SMULBB( q2_Q10, Lambda_Q10 );
311         } else if( q1_Q0 == -1 ) {
312             q2_Q10  = offset_Q10;
313             q1_Q10  = silk_SUB32( q2_Q10, 1024 - QUANT_LEVEL_ADJUST_Q10 );
314             rd1_Q20 = silk_SMULBB( -q1_Q10, Lambda_Q10 );
315             rd2_Q20 = silk_SMULBB(  q2_Q10, Lambda_Q10 );
316         } else {            /* Q1_Q0 < -1 */
317             q1_Q10  = silk_ADD32( silk_LSHIFT( q1_Q0, 10 ), QUANT_LEVEL_ADJUST_Q10 );
318             q1_Q10  = silk_ADD32( q1_Q10, offset_Q10 );
319             q2_Q10  = silk_ADD32( q1_Q10, 1024 );
320             rd1_Q20 = silk_SMULBB( -q1_Q10, Lambda_Q10 );
321             rd2_Q20 = silk_SMULBB( -q2_Q10, Lambda_Q10 );
322         }
323         rr_Q10  = silk_SUB32( r_Q10, q1_Q10 );
324         rd1_Q20 = silk_SMLABB( rd1_Q20, rr_Q10, rr_Q10 );
325         rr_Q10  = silk_SUB32( r_Q10, q2_Q10 );
326         rd2_Q20 = silk_SMLABB( rd2_Q20, rr_Q10, rr_Q10 );
327
328         if( rd2_Q20 < rd1_Q20 ) {
329             q1_Q10 = q2_Q10;
330         }
331
332         pulses[ i ] = (opus_int8)silk_RSHIFT_ROUND( q1_Q10, 10 );
333
334         /* Excitation */
335         exc_Q14 = silk_LSHIFT( q1_Q10, 4 );
336         if ( NSQ->rand_seed < 0 ) {
337            exc_Q14 = -exc_Q14;
338         }
339
340         /* Add predictions */
341         LPC_exc_Q14 = silk_ADD_LSHIFT32( exc_Q14, LTP_pred_Q13, 1 );
342         xq_Q14      = silk_ADD_LSHIFT32( LPC_exc_Q14, LPC_pred_Q10, 4 );
343
344         /* Scale XQ back to normal level before saving */
345         xq[ i ] = (opus_int16)silk_SAT16( silk_RSHIFT_ROUND( silk_SMULWW( xq_Q14, Gain_Q10 ), 8 ) );
346
347         /* Update states */
348         psLPC_Q14++;
349         *psLPC_Q14 = xq_Q14;
350         sLF_AR_shp_Q14 = silk_SUB_LSHIFT32( xq_Q14, n_AR_Q12, 2 );
351         NSQ->sLF_AR_shp_Q14 = sLF_AR_shp_Q14;
352
353         NSQ->sLTP_shp_Q14[ NSQ->sLTP_shp_buf_idx ] = silk_SUB_LSHIFT32( sLF_AR_shp_Q14, n_LF_Q12, 2 );
354         sLTP_Q15[ NSQ->sLTP_buf_idx ] = silk_LSHIFT( LPC_exc_Q14, 1 );
355         NSQ->sLTP_shp_buf_idx++;
356         NSQ->sLTP_buf_idx++;
357
358         /* Make dither dependent on quantized signal */
359         NSQ->rand_seed = silk_ADD32_ovflw( NSQ->rand_seed, pulses[ i ] );
360     }
361
362     /* Update LPC synth buffer */
363     silk_memcpy( NSQ->sLPC_Q14, &NSQ->sLPC_Q14[ length ], NSQ_LPC_BUF_LENGTH * sizeof( opus_int32 ) );
364 }
365
366 static inline void silk_nsq_scale_states(
367     const silk_encoder_state *psEncC,           /* I    Encoder State                   */
368     silk_nsq_state      *NSQ,                   /* I/O  NSQ state                       */
369     const opus_int32    x_Q3[],                 /* I    input in Q3                     */
370     opus_int32          x_sc_Q10[],             /* O    input scaled with 1/Gain        */
371     const opus_int16    sLTP[],                 /* I    re-whitened LTP state in Q0     */
372     opus_int32          sLTP_Q15[],             /* O    LTP state matching scaled input */
373     opus_int            subfr,                  /* I    subframe number                 */
374     const opus_int      LTP_scale_Q14,          /* I                                    */
375     const opus_int32    Gains_Q16[ MAX_NB_SUBFR ], /* I                                 */
376     const opus_int      pitchL[ MAX_NB_SUBFR ], /* I    Pitch lag                       */
377     const opus_int      signal_type             /* I    Signal type                     */
378 )
379 {
380     opus_int   i, lag;
381     opus_int32 gain_adj_Q16, inv_gain_Q31, inv_gain_Q23;
382
383     lag          = pitchL[ subfr ];
384     inv_gain_Q31 = silk_INVERSE32_varQ( silk_max( Gains_Q16[ subfr ], 1 ), 47 );
385     silk_assert( inv_gain_Q31 != 0 );
386
387     /* Calculate gain adjustment factor */
388     if( Gains_Q16[ subfr ] != NSQ->prev_gain_Q16 ) {
389         gain_adj_Q16 =  silk_DIV32_varQ( NSQ->prev_gain_Q16, Gains_Q16[ subfr ], 16 );
390     } else {
391         gain_adj_Q16 = (opus_int32)1 << 16;
392     }
393
394     /* Scale input */
395     inv_gain_Q23 = silk_RSHIFT_ROUND( inv_gain_Q31, 8 );
396     for( i = 0; i < psEncC->subfr_length; i++ ) {
397         x_sc_Q10[ i ] = silk_SMULWW( x_Q3[ i ], inv_gain_Q23 );
398     }
399
400     /* Save inverse gain */
401     NSQ->prev_gain_Q16 = Gains_Q16[ subfr ];
402
403     /* After rewhitening the LTP state is un-scaled, so scale with inv_gain_Q16 */
404     if( NSQ->rewhite_flag ) {
405         if( subfr == 0 ) {
406             /* Do LTP downscaling */
407             inv_gain_Q31 = silk_LSHIFT( silk_SMULWB( inv_gain_Q31, LTP_scale_Q14 ), 2 );
408         }
409         for( i = NSQ->sLTP_buf_idx - lag - LTP_ORDER / 2; i < NSQ->sLTP_buf_idx; i++ ) {
410             silk_assert( i < MAX_FRAME_LENGTH );
411             sLTP_Q15[ i ] = silk_SMULWB( inv_gain_Q31, sLTP[ i ] );
412         }
413     }
414
415     /* Adjust for changing gain */
416     if( gain_adj_Q16 != (opus_int32)1 << 16 ) {
417         /* Scale long-term shaping state */
418         for( i = NSQ->sLTP_shp_buf_idx - psEncC->ltp_mem_length; i < NSQ->sLTP_shp_buf_idx; i++ ) {
419             NSQ->sLTP_shp_Q14[ i ] = silk_SMULWW( gain_adj_Q16, NSQ->sLTP_shp_Q14[ i ] );
420         }
421
422         /* Scale long-term prediction state */
423         if( signal_type == TYPE_VOICED && NSQ->rewhite_flag == 0 ) {
424             for( i = NSQ->sLTP_buf_idx - lag - LTP_ORDER / 2; i < NSQ->sLTP_buf_idx; i++ ) {
425                 sLTP_Q15[ i ] = silk_SMULWW( gain_adj_Q16, sLTP_Q15[ i ] );
426             }
427         }
428
429         NSQ->sLF_AR_shp_Q14 = silk_SMULWW( gain_adj_Q16, NSQ->sLF_AR_shp_Q14 );
430
431         /* Scale short-term prediction and shaping states */
432         for( i = 0; i < NSQ_LPC_BUF_LENGTH; i++ ) {
433             NSQ->sLPC_Q14[ i ] = silk_SMULWW( gain_adj_Q16, NSQ->sLPC_Q14[ i ] );
434         }
435         for( i = 0; i < MAX_SHAPE_LPC_ORDER; i++ ) {
436             NSQ->sAR2_Q14[ i ] = silk_SMULWW( gain_adj_Q16, NSQ->sAR2_Q14[ i ] );
437         }
438     }
439 }