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