increase NSQ decision delay from 32 to 40
[opus.git] / silk / mips / NSQ_del_dec_mipsr1.h
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 #ifndef __NSQ_DEL_DEC_MIPSR1_H__
29 #define __NSQ_DEL_DEC_MIPSR1_H__
30
31 #ifdef HAVE_CONFIG_H
32 #include "config.h"
33 #endif
34
35 #include "main.h"
36 #include "stack_alloc.h"
37
38 #define OVERRIDE_silk_noise_shape_quantizer_del_dec
39 static inline void silk_noise_shape_quantizer_del_dec(
40     silk_nsq_state      *NSQ,                   /* I/O  NSQ state                           */
41     NSQ_del_dec_struct  psDelDec[],             /* I/O  Delayed decision states             */
42     opus_int            signalType,             /* I    Signal type                         */
43     const opus_int32    x_Q10[],                /* I                                        */
44     opus_int8           pulses[],               /* O                                        */
45     opus_int16          xq[],                   /* O                                        */
46     opus_int32          sLTP_Q15[],             /* I/O  LTP filter state                    */
47     opus_int32          delayedGain_Q10[],      /* I/O  Gain delay buffer                   */
48     const opus_int16    a_Q12[],                /* I    Short term prediction coefs         */
49     const opus_int16    b_Q14[],                /* I    Long term prediction coefs          */
50     const opus_int16    AR_shp_Q13[],           /* I    Noise shaping coefs                 */
51     opus_int            lag,                    /* I    Pitch lag                           */
52     opus_int32          HarmShapeFIRPacked_Q14, /* I                                        */
53     opus_int            Tilt_Q14,               /* I    Spectral tilt                       */
54     opus_int32          LF_shp_Q14,             /* I                                        */
55     opus_int32          Gain_Q16,               /* I                                        */
56     opus_int            Lambda_Q10,             /* I                                        */
57     opus_int            offset_Q10,             /* I                                        */
58     opus_int            length,                 /* I    Input length                        */
59     opus_int            subfr,                  /* I    Subframe number                     */
60     opus_int            shapingLPCOrder,        /* I    Shaping LPC filter order            */
61     opus_int            predictLPCOrder,        /* I    Prediction filter order             */
62     opus_int            warping_Q16,            /* I                                        */
63     opus_int            nStatesDelayedDecision, /* I    Number of states in decision tree   */
64     opus_int            *smpl_buf_idx,          /* I    Index to newest samples in buffers  */
65     opus_int            decisionDelay,          /* I                                        */
66     int                 arch                    /* I                                        */
67 )
68 {
69     opus_int     i, j, k, Winner_ind, RDmin_ind, RDmax_ind, last_smple_idx;
70     opus_int32   Winner_rand_state;
71     opus_int32   LTP_pred_Q14, LPC_pred_Q14, n_AR_Q14, n_LTP_Q14;
72     opus_int32   n_LF_Q14, r_Q10, rr_Q10, rd1_Q10, rd2_Q10, RDmin_Q10, RDmax_Q10;
73     opus_int32   q1_Q0, q1_Q10, q2_Q10, exc_Q14, LPC_exc_Q14, xq_Q14, Gain_Q10;
74     opus_int32   tmp1, tmp2, sLF_AR_shp_Q14;
75     opus_int32   *pred_lag_ptr, *shp_lag_ptr, *psLPC_Q14;
76     NSQ_sample_struct  psSampleState[ MAX_DEL_DEC_STATES ][ 2 ];
77     NSQ_del_dec_struct *psDD;
78     NSQ_sample_struct  *psSS;
79     opus_int16 b_Q14_0, b_Q14_1, b_Q14_2, b_Q14_3, b_Q14_4;
80     opus_int16 a_Q12_0, a_Q12_1, a_Q12_2, a_Q12_3, a_Q12_4, a_Q12_5, a_Q12_6;
81     opus_int16 a_Q12_7, a_Q12_8, a_Q12_9, a_Q12_10, a_Q12_11, a_Q12_12, a_Q12_13;
82     opus_int16 a_Q12_14, a_Q12_15;
83
84     opus_int32 cur, prev, next;
85
86     /*Unused.*/
87     (void)arch;
88
89     //Intialize b_Q14 variables
90     b_Q14_0 = b_Q14[ 0 ];
91     b_Q14_1 = b_Q14[ 1 ];
92     b_Q14_2 = b_Q14[ 2 ];
93     b_Q14_3 = b_Q14[ 3 ];
94     b_Q14_4 = b_Q14[ 4 ];
95
96     //Intialize a_Q12 variables
97     a_Q12_0 = a_Q12[0];
98     a_Q12_1 = a_Q12[1];
99     a_Q12_2 = a_Q12[2];
100     a_Q12_3 = a_Q12[3];
101     a_Q12_4 = a_Q12[4];
102     a_Q12_5 = a_Q12[5];
103     a_Q12_6 = a_Q12[6];
104     a_Q12_7 = a_Q12[7];
105     a_Q12_8 = a_Q12[8];
106     a_Q12_9 = a_Q12[9];
107     a_Q12_10 = a_Q12[10];
108     a_Q12_11 = a_Q12[11];
109     a_Q12_12 = a_Q12[12];
110     a_Q12_13 = a_Q12[13];
111     a_Q12_14 = a_Q12[14];
112     a_Q12_15 = a_Q12[15];
113
114     long long temp64;
115
116     silk_assert( nStatesDelayedDecision > 0 );
117
118     shp_lag_ptr  = &NSQ->sLTP_shp_Q14[ NSQ->sLTP_shp_buf_idx - lag + HARM_SHAPE_FIR_TAPS / 2 ];
119     pred_lag_ptr = &sLTP_Q15[ NSQ->sLTP_buf_idx - lag + LTP_ORDER / 2 ];
120     Gain_Q10     = silk_RSHIFT( Gain_Q16, 6 );
121
122     for( i = 0; i < length; i++ ) {
123         /* Perform common calculations used in all states */
124
125         /* Long-term prediction */
126         if( signalType == TYPE_VOICED ) {
127             /* Unrolled loop */
128             /* Avoids introducing a bias because silk_SMLAWB() always rounds to -inf */
129             temp64 = __builtin_mips_mult(pred_lag_ptr[ 0 ], b_Q14_0 );
130             temp64 = __builtin_mips_madd( temp64, pred_lag_ptr[ -1 ], b_Q14_1 );
131             temp64 = __builtin_mips_madd( temp64, pred_lag_ptr[ -2 ], b_Q14_2 );
132             temp64 = __builtin_mips_madd( temp64, pred_lag_ptr[ -3 ], b_Q14_3 );
133             temp64 = __builtin_mips_madd( temp64, pred_lag_ptr[ -4 ], b_Q14_4 );
134             temp64 += 32768;
135             LTP_pred_Q14 = __builtin_mips_extr_w(temp64, 16);
136             LTP_pred_Q14 = silk_LSHIFT( LTP_pred_Q14, 1 );                          /* Q13 -> Q14 */
137             pred_lag_ptr++;
138         } else {
139             LTP_pred_Q14 = 0;
140         }
141
142         /* Long-term shaping */
143         if( lag > 0 ) {
144             /* Symmetric, packed FIR coefficients */
145             n_LTP_Q14 = silk_SMULWB( silk_ADD32( shp_lag_ptr[ 0 ], shp_lag_ptr[ -2 ] ), HarmShapeFIRPacked_Q14 );
146             n_LTP_Q14 = silk_SMLAWT( n_LTP_Q14, shp_lag_ptr[ -1 ],                      HarmShapeFIRPacked_Q14 );
147             n_LTP_Q14 = silk_SUB_LSHIFT32( LTP_pred_Q14, n_LTP_Q14, 2 );            /* Q12 -> Q14 */
148             shp_lag_ptr++;
149         } else {
150             n_LTP_Q14 = 0;
151         }
152
153         for( k = 0; k < nStatesDelayedDecision; k++ ) {
154             /* Delayed decision state */
155             psDD = &psDelDec[ k ];
156
157             /* Sample state */
158             psSS = psSampleState[ k ];
159
160             /* Generate dither */
161             psDD->Seed = silk_RAND( psDD->Seed );
162
163             /* Pointer used in short term prediction and shaping */
164             psLPC_Q14 = &psDD->sLPC_Q14[ NSQ_LPC_BUF_LENGTH - 1 + i ];
165             /* Short-term prediction */
166             silk_assert( predictLPCOrder == 10 || predictLPCOrder == 16 );
167             temp64 = __builtin_mips_mult(psLPC_Q14[  0 ], a_Q12_0 );
168             temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -1 ], a_Q12_1 );
169             temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -2 ], a_Q12_2 );
170             temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -3 ], a_Q12_3 );
171             temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -4 ], a_Q12_4 );
172             temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -5 ], a_Q12_5 );
173             temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -6 ], a_Q12_6 );
174             temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -7 ], a_Q12_7 );
175             temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -8 ], a_Q12_8 );
176             temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -9 ], a_Q12_9 );
177             if( predictLPCOrder == 16 ) {
178                 temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -10 ], a_Q12_10 );
179                 temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -11 ], a_Q12_11 );
180                 temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -12 ], a_Q12_12 );
181                 temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -13 ], a_Q12_13 );
182                 temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -14 ], a_Q12_14 );
183                 temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -15 ], a_Q12_15 );
184             }
185             temp64 += 32768;
186             LPC_pred_Q14 = __builtin_mips_extr_w(temp64, 16);
187
188             LPC_pred_Q14 = silk_LSHIFT( LPC_pred_Q14, 4 );                              /* Q10 -> Q14 */
189
190             /* Noise shape feedback */
191             silk_assert( ( shapingLPCOrder & 1 ) == 0 );   /* check that order is even */
192             /* Output of lowpass section */
193             tmp2 = silk_SMLAWB( psLPC_Q14[ 0 ], psDD->sAR2_Q14[ 0 ], warping_Q16 );
194             /* Output of allpass section */
195             tmp1 = silk_SMLAWB( psDD->sAR2_Q14[ 0 ], psDD->sAR2_Q14[ 1 ] - tmp2, warping_Q16 );
196             psDD->sAR2_Q14[ 0 ] = tmp2;
197
198             temp64 = __builtin_mips_mult(tmp2, AR_shp_Q13[ 0 ] );
199
200             prev = psDD->sAR2_Q14[ 1 ];
201
202             /* Loop over allpass sections */
203             for( j = 2; j < shapingLPCOrder; j += 2 ) {
204                 cur = psDD->sAR2_Q14[ j ];
205                 next = psDD->sAR2_Q14[ j+1 ];
206                 /* Output of allpass section */
207                 tmp2 = silk_SMLAWB( prev, cur - tmp1, warping_Q16 );
208                 psDD->sAR2_Q14[ j - 1 ] = tmp1;
209                 temp64 = __builtin_mips_madd( temp64, tmp1, AR_shp_Q13[ j - 1 ] );
210                 temp64 = __builtin_mips_madd( temp64, tmp2, AR_shp_Q13[ j ] );
211                 /* Output of allpass section */
212                 tmp1 = silk_SMLAWB( cur, next - tmp2, warping_Q16 );
213                 psDD->sAR2_Q14[ j + 0 ] = tmp2;
214                 prev = next;
215             }
216             psDD->sAR2_Q14[ shapingLPCOrder - 1 ] = tmp1;
217             temp64 = __builtin_mips_madd( temp64, tmp1, AR_shp_Q13[ shapingLPCOrder - 1 ] );
218             temp64 += 32768;
219             n_AR_Q14 = __builtin_mips_extr_w(temp64, 16);
220             n_AR_Q14 = silk_LSHIFT( n_AR_Q14, 1 );                                      /* Q11 -> Q12 */
221             n_AR_Q14 = silk_SMLAWB( n_AR_Q14, psDD->LF_AR_Q14, Tilt_Q14 );              /* Q12 */
222             n_AR_Q14 = silk_LSHIFT( n_AR_Q14, 2 );                                      /* Q12 -> Q14 */
223
224             n_LF_Q14 = silk_SMULWB( psDD->Shape_Q14[ *smpl_buf_idx ], LF_shp_Q14 );     /* Q12 */
225             n_LF_Q14 = silk_SMLAWT( n_LF_Q14, psDD->LF_AR_Q14, LF_shp_Q14 );            /* Q12 */
226             n_LF_Q14 = silk_LSHIFT( n_LF_Q14, 2 );                                      /* Q12 -> Q14 */
227
228             /* Input minus prediction plus noise feedback                       */
229             /* r = x[ i ] - LTP_pred - LPC_pred + n_AR + n_Tilt + n_LF + n_LTP  */
230             tmp1 = silk_ADD32( n_AR_Q14, n_LF_Q14 );                                    /* Q14 */
231             tmp2 = silk_ADD32( n_LTP_Q14, LPC_pred_Q14 );                               /* Q13 */
232             tmp1 = silk_SUB32( tmp2, tmp1 );                                            /* Q13 */
233             tmp1 = silk_RSHIFT_ROUND( tmp1, 4 );                                        /* Q10 */
234
235             r_Q10 = silk_SUB32( x_Q10[ i ], tmp1 );                                     /* residual error Q10 */
236
237             /* Flip sign depending on dither */
238             if ( psDD->Seed < 0 ) {
239                 r_Q10 = -r_Q10;
240             }
241             r_Q10 = silk_LIMIT_32( r_Q10, -(31 << 10), 30 << 10 );
242
243             /* Find two quantization level candidates and measure their rate-distortion */
244             q1_Q10 = silk_SUB32( r_Q10, offset_Q10 );
245             q1_Q0 = silk_RSHIFT( q1_Q10, 10 );
246             if( q1_Q0 > 0 ) {
247                 q1_Q10  = silk_SUB32( silk_LSHIFT( q1_Q0, 10 ), QUANT_LEVEL_ADJUST_Q10 );
248                 q1_Q10  = silk_ADD32( q1_Q10, offset_Q10 );
249                 q2_Q10  = silk_ADD32( q1_Q10, 1024 );
250                 rd1_Q10 = silk_SMULBB( q1_Q10, Lambda_Q10 );
251                 rd2_Q10 = silk_SMULBB( q2_Q10, Lambda_Q10 );
252             } else if( q1_Q0 == 0 ) {
253                 q1_Q10  = offset_Q10;
254                 q2_Q10  = silk_ADD32( q1_Q10, 1024 - QUANT_LEVEL_ADJUST_Q10 );
255                 rd1_Q10 = silk_SMULBB( q1_Q10, Lambda_Q10 );
256                 rd2_Q10 = silk_SMULBB( q2_Q10, Lambda_Q10 );
257             } else if( q1_Q0 == -1 ) {
258                 q2_Q10  = offset_Q10;
259                 q1_Q10  = silk_SUB32( q2_Q10, 1024 - QUANT_LEVEL_ADJUST_Q10 );
260                 rd1_Q10 = silk_SMULBB( -q1_Q10, Lambda_Q10 );
261                 rd2_Q10 = silk_SMULBB(  q2_Q10, Lambda_Q10 );
262             } else {            /* q1_Q0 < -1 */
263                 q1_Q10  = silk_ADD32( silk_LSHIFT( q1_Q0, 10 ), QUANT_LEVEL_ADJUST_Q10 );
264                 q1_Q10  = silk_ADD32( q1_Q10, offset_Q10 );
265                 q2_Q10  = silk_ADD32( q1_Q10, 1024 );
266                 rd1_Q10 = silk_SMULBB( -q1_Q10, Lambda_Q10 );
267                 rd2_Q10 = silk_SMULBB( -q2_Q10, Lambda_Q10 );
268             }
269             rr_Q10  = silk_SUB32( r_Q10, q1_Q10 );
270             rd1_Q10 = silk_RSHIFT( silk_SMLABB( rd1_Q10, rr_Q10, rr_Q10 ), 10 );
271             rr_Q10  = silk_SUB32( r_Q10, q2_Q10 );
272             rd2_Q10 = silk_RSHIFT( silk_SMLABB( rd2_Q10, rr_Q10, rr_Q10 ), 10 );
273
274             if( rd1_Q10 < rd2_Q10 ) {
275                 psSS[ 0 ].RD_Q10 = silk_ADD32( psDD->RD_Q10, rd1_Q10 );
276                 psSS[ 1 ].RD_Q10 = silk_ADD32( psDD->RD_Q10, rd2_Q10 );
277                 psSS[ 0 ].Q_Q10  = q1_Q10;
278                 psSS[ 1 ].Q_Q10  = q2_Q10;
279             } else {
280                 psSS[ 0 ].RD_Q10 = silk_ADD32( psDD->RD_Q10, rd2_Q10 );
281                 psSS[ 1 ].RD_Q10 = silk_ADD32( psDD->RD_Q10, rd1_Q10 );
282                 psSS[ 0 ].Q_Q10  = q2_Q10;
283                 psSS[ 1 ].Q_Q10  = q1_Q10;
284             }
285
286             /* Update states for best quantization */
287
288             /* Quantized excitation */
289             exc_Q14 = silk_LSHIFT32( psSS[ 0 ].Q_Q10, 4 );
290             if ( psDD->Seed < 0 ) {
291                 exc_Q14 = -exc_Q14;
292             }
293
294             /* Add predictions */
295             LPC_exc_Q14 = silk_ADD32( exc_Q14, LTP_pred_Q14 );
296             xq_Q14      = silk_ADD32( LPC_exc_Q14, LPC_pred_Q14 );
297
298             /* Update states */
299             sLF_AR_shp_Q14         = silk_SUB32( xq_Q14, n_AR_Q14 );
300             psSS[ 0 ].sLTP_shp_Q14 = silk_SUB32( sLF_AR_shp_Q14, n_LF_Q14 );
301             psSS[ 0 ].LF_AR_Q14    = sLF_AR_shp_Q14;
302             psSS[ 0 ].LPC_exc_Q14  = LPC_exc_Q14;
303             psSS[ 0 ].xq_Q14       = xq_Q14;
304
305             /* Update states for second best quantization */
306
307             /* Quantized excitation */
308             exc_Q14 = silk_LSHIFT32( psSS[ 1 ].Q_Q10, 4 );
309             if ( psDD->Seed < 0 ) {
310                 exc_Q14 = -exc_Q14;
311             }
312
313
314             /* Add predictions */
315             LPC_exc_Q14 = silk_ADD32( exc_Q14, LTP_pred_Q14 );
316             xq_Q14      = silk_ADD32( LPC_exc_Q14, LPC_pred_Q14 );
317
318             /* Update states */
319             sLF_AR_shp_Q14         = silk_SUB32( xq_Q14, n_AR_Q14 );
320             psSS[ 1 ].sLTP_shp_Q14 = silk_SUB32( sLF_AR_shp_Q14, n_LF_Q14 );
321             psSS[ 1 ].LF_AR_Q14    = sLF_AR_shp_Q14;
322             psSS[ 1 ].LPC_exc_Q14  = LPC_exc_Q14;
323             psSS[ 1 ].xq_Q14       = xq_Q14;
324         }
325
326         *smpl_buf_idx  = ( *smpl_buf_idx - 1 ) % DECISION_DELAY;
327         if( *smpl_buf_idx < 0 ) *smpl_buf_idx += DECISION_DELAY;
328         last_smple_idx = ( *smpl_buf_idx + decisionDelay ) % DECISION_DELAY;
329
330         /* Find winner */
331         RDmin_Q10 = psSampleState[ 0 ][ 0 ].RD_Q10;
332         Winner_ind = 0;
333         for( k = 1; k < nStatesDelayedDecision; k++ ) {
334             if( psSampleState[ k ][ 0 ].RD_Q10 < RDmin_Q10 ) {
335                 RDmin_Q10  = psSampleState[ k ][ 0 ].RD_Q10;
336                 Winner_ind = k;
337             }
338         }
339
340         /* Increase RD values of expired states */
341         Winner_rand_state = psDelDec[ Winner_ind ].RandState[ last_smple_idx ];
342         for( k = 0; k < nStatesDelayedDecision; k++ ) {
343             if( psDelDec[ k ].RandState[ last_smple_idx ] != Winner_rand_state ) {
344                 psSampleState[ k ][ 0 ].RD_Q10 = silk_ADD32( psSampleState[ k ][ 0 ].RD_Q10, silk_int32_MAX >> 4 );
345                 psSampleState[ k ][ 1 ].RD_Q10 = silk_ADD32( psSampleState[ k ][ 1 ].RD_Q10, silk_int32_MAX >> 4 );
346                 silk_assert( psSampleState[ k ][ 0 ].RD_Q10 >= 0 );
347             }
348         }
349
350         /* Find worst in first set and best in second set */
351         RDmax_Q10  = psSampleState[ 0 ][ 0 ].RD_Q10;
352         RDmin_Q10  = psSampleState[ 0 ][ 1 ].RD_Q10;
353         RDmax_ind = 0;
354         RDmin_ind = 0;
355         for( k = 1; k < nStatesDelayedDecision; k++ ) {
356             /* find worst in first set */
357             if( psSampleState[ k ][ 0 ].RD_Q10 > RDmax_Q10 ) {
358                 RDmax_Q10  = psSampleState[ k ][ 0 ].RD_Q10;
359                 RDmax_ind = k;
360             }
361             /* find best in second set */
362             if( psSampleState[ k ][ 1 ].RD_Q10 < RDmin_Q10 ) {
363                 RDmin_Q10  = psSampleState[ k ][ 1 ].RD_Q10;
364                 RDmin_ind = k;
365             }
366         }
367
368         /* Replace a state if best from second set outperforms worst in first set */
369         if( RDmin_Q10 < RDmax_Q10 ) {
370             silk_memcpy( ( (opus_int32 *)&psDelDec[ RDmax_ind ] ) + i,
371                          ( (opus_int32 *)&psDelDec[ RDmin_ind ] ) + i, sizeof( NSQ_del_dec_struct ) - i * sizeof( opus_int32) );
372             silk_memcpy( &psSampleState[ RDmax_ind ][ 0 ], &psSampleState[ RDmin_ind ][ 1 ], sizeof( NSQ_sample_struct ) );
373         }
374
375         /* Write samples from winner to output and long-term filter states */
376         psDD = &psDelDec[ Winner_ind ];
377         if( subfr > 0 || i >= decisionDelay ) {
378             pulses[  i - decisionDelay ] = (opus_int8)silk_RSHIFT_ROUND( psDD->Q_Q10[ last_smple_idx ], 10 );
379             xq[ i - decisionDelay ] = (opus_int16)silk_SAT16( silk_RSHIFT_ROUND(
380                 silk_SMULWW( psDD->Xq_Q14[ last_smple_idx ], delayedGain_Q10[ last_smple_idx ] ), 8 ) );
381             NSQ->sLTP_shp_Q14[ NSQ->sLTP_shp_buf_idx - decisionDelay ] = psDD->Shape_Q14[ last_smple_idx ];
382             sLTP_Q15[          NSQ->sLTP_buf_idx     - decisionDelay ] = psDD->Pred_Q15[  last_smple_idx ];
383         }
384         NSQ->sLTP_shp_buf_idx++;
385         NSQ->sLTP_buf_idx++;
386
387         /* Update states */
388         for( k = 0; k < nStatesDelayedDecision; k++ ) {
389             psDD                                     = &psDelDec[ k ];
390             psSS                                     = &psSampleState[ k ][ 0 ];
391             psDD->LF_AR_Q14                          = psSS->LF_AR_Q14;
392             psDD->sLPC_Q14[ NSQ_LPC_BUF_LENGTH + i ] = psSS->xq_Q14;
393             psDD->Xq_Q14[    *smpl_buf_idx ]         = psSS->xq_Q14;
394             psDD->Q_Q10[     *smpl_buf_idx ]         = psSS->Q_Q10;
395             psDD->Pred_Q15[  *smpl_buf_idx ]         = silk_LSHIFT32( psSS->LPC_exc_Q14, 1 );
396             psDD->Shape_Q14[ *smpl_buf_idx ]         = psSS->sLTP_shp_Q14;
397             psDD->Seed                               = silk_ADD32_ovflw( psDD->Seed, silk_RSHIFT_ROUND( psSS->Q_Q10, 10 ) );
398             psDD->RandState[ *smpl_buf_idx ]         = psDD->Seed;
399             psDD->RD_Q10                             = psSS->RD_Q10;
400         }
401         delayedGain_Q10[     *smpl_buf_idx ]         = Gain_Q10;
402     }
403     /* Update LPC states */
404     for( k = 0; k < nStatesDelayedDecision; k++ ) {
405         psDD = &psDelDec[ k ];
406         silk_memcpy( psDD->sLPC_Q14, &psDD->sLPC_Q14[ length ], NSQ_LPC_BUF_LENGTH * sizeof( opus_int32 ) );
407     }
408 }
409
410 #endif /* __NSQ_DEL_DEC_MIPSR1_H__ */