938216cce435d96a6ebe91ee70fc4e20dbdadc4d
[opus.git] / silk / fixed / encode_frame_FIX.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, (subject to the limitations in the disclaimer below)
5 are permitted provided that the following conditions 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 Skype Limited, nor the names of specific
12 contributors, may be used to endorse or promote products derived from
13 this software without specific prior written permission.
14 NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED
15 BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
16 CONTRIBUTORS ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
17 BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
18 FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19 COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
22 USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
23 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 ***********************************************************************/
27
28 #ifdef HAVE_CONFIG_H
29 #include "config.h"
30 #endif
31
32 #include "main_FIX.h"
33 #include "tuning_parameters.h"
34
35 /* Low Bitrate Redundancy (LBRR) encoding. Reuse all parameters but encode with lower bitrate           */
36 static inline void silk_LBRR_encode_FIX(
37     silk_encoder_state_FIX          *psEnc,             /* I/O  Pointer to Silk FIX encoder state           */
38     silk_encoder_control_FIX        *psEncCtrl,         /* I/O  Pointer to Silk FIX encoder control struct  */
39     const opus_int16                 xfw[],              /* I    Input signal                                */
40     opus_int                         condCoding         /* I    The type of conditional coding used so far for this frame */
41 );
42
43 void silk_encode_do_VAD_FIX(
44     silk_encoder_state_FIX          *psEnc              /* I/O  Encoder state FIX                       */
45 )
46 {
47     /****************************/
48     /* Voice Activity Detection */
49     /****************************/
50 TIC(VAD)
51     silk_VAD_GetSA_Q8( &psEnc->sCmn, psEnc->sCmn.inputBuf + 1 );
52 TOC(VAD)
53
54     /**************************************************/
55     /* Convert speech activity into VAD and DTX flags */
56     /**************************************************/
57     if( psEnc->sCmn.speech_activity_Q8 < SILK_FIX_CONST( SPEECH_ACTIVITY_DTX_THRES, 8 ) ) {
58         psEnc->sCmn.indices.signalType = TYPE_NO_VOICE_ACTIVITY;
59         psEnc->sCmn.noSpeechCounter++;
60         if( psEnc->sCmn.noSpeechCounter < NB_SPEECH_FRAMES_BEFORE_DTX ) {
61             psEnc->sCmn.inDTX = 0;
62         } else if( psEnc->sCmn.noSpeechCounter > MAX_CONSECUTIVE_DTX + NB_SPEECH_FRAMES_BEFORE_DTX ) {
63             psEnc->sCmn.noSpeechCounter = NB_SPEECH_FRAMES_BEFORE_DTX;
64             psEnc->sCmn.inDTX           = 0;
65         }
66         psEnc->sCmn.VAD_flags[ psEnc->sCmn.nFramesEncoded ] = 0;
67     } else {
68         psEnc->sCmn.noSpeechCounter    = 0;
69         psEnc->sCmn.inDTX              = 0;
70         psEnc->sCmn.indices.signalType = TYPE_UNVOICED;
71         psEnc->sCmn.VAD_flags[ psEnc->sCmn.nFramesEncoded ] = 1;
72     }
73 }
74
75 /****************/
76 /* Encode frame */
77 /****************/
78 opus_int silk_encode_frame_FIX(
79     silk_encoder_state_FIX          *psEnc,             /* I/O  Encoder state FIX                       */
80     opus_int32                       *pnBytesOut,        /*   O  Number of payload bytes                 */
81     ec_enc                          *psRangeEnc,        /* I/O  compressor data structure               */
82     opus_int                         condCoding,        /* I    The type of conditional coding to use   */
83     opus_int                         maxBits,           /* I    If > 0: maximum number of output bits   */
84     opus_int                         useCBR             /* I    Flag to force constant-bitrate operation */
85 )
86 {
87     silk_encoder_control_FIX sEncCtrl;
88     opus_int     i, iter, maxIter, found_upper, found_lower, ret = 0;
89     opus_int16   *x_frame, *res_pitch_frame;
90     opus_int16   xfw[ MAX_FRAME_LENGTH ];
91     opus_int16   res_pitch[ 2 * MAX_FRAME_LENGTH + LA_PITCH_MAX ];
92     ec_enc       sRangeEnc_copy, sRangeEnc_copy2;
93     silk_nsq_state sNSQ_copy, sNSQ_copy2;
94     opus_int32   seed_copy, nBits, nBits_lower, nBits_upper, gainMult_lower, gainMult_upper;
95     opus_int16   gainMult_Q8;
96     opus_int16   ec_prevLagIndex_copy;
97     opus_int     ec_prevSignalType_copy;
98     opus_int8    LastGainIndex_copy2;
99     opus_uint8   ec_buf_copy[ 512 ];
100
101 TIC(ENCODE_FRAME)
102
103     psEnc->sCmn.indices.Seed = psEnc->sCmn.frameCounter++ & 3;
104
105     /**************************************************************/
106     /* Setup Input Pointers, and insert frame in input buffer    */
107     /*************************************************************/
108     /* pointers aligned with start of frame to encode */
109     x_frame         = psEnc->x_buf + psEnc->sCmn.ltp_mem_length;    /* start of frame to encode */
110     res_pitch_frame = res_pitch    + psEnc->sCmn.ltp_mem_length;    /* start of pitch LPC residual frame */
111
112     /***************************************/
113     /* Ensure smooth bandwidth transitions */
114     /***************************************/
115     silk_LP_variable_cutoff( &psEnc->sCmn.sLP, psEnc->sCmn.inputBuf + 1, psEnc->sCmn.frame_length );
116
117     /*******************************************/
118     /* Copy new frame to front of input buffer */
119     /*******************************************/
120     silk_memcpy( x_frame + LA_SHAPE_MS * psEnc->sCmn.fs_kHz, psEnc->sCmn.inputBuf + 1, psEnc->sCmn.frame_length * sizeof( opus_int16 ) );
121
122     /*****************************************/
123     /* Find pitch lags, initial LPC analysis */
124     /*****************************************/
125 TIC(FIND_PITCH)
126     silk_find_pitch_lags_FIX( psEnc, &sEncCtrl, res_pitch, x_frame );
127 TOC(FIND_PITCH)
128
129     /************************/
130     /* Noise shape analysis */
131     /************************/
132 TIC(NOISE_SHAPE_ANALYSIS)
133     silk_noise_shape_analysis_FIX( psEnc, &sEncCtrl, res_pitch_frame, x_frame );
134 TOC(NOISE_SHAPE_ANALYSIS)
135
136     /***************************************************/
137     /* Find linear prediction coefficients (LPC + LTP) */
138     /***************************************************/
139 TIC(FIND_PRED_COEF)
140     silk_find_pred_coefs_FIX( psEnc, &sEncCtrl, res_pitch, x_frame, condCoding );
141 TOC(FIND_PRED_COEF)
142
143     /****************************************/
144     /* Process gains                        */
145     /****************************************/
146 TIC(PROCESS_GAINS)
147     silk_process_gains_FIX( psEnc, &sEncCtrl, condCoding );
148 TOC(PROCESS_GAINS)
149
150     /*****************************************/
151     /* Prefiltering for noise shaper         */
152     /*****************************************/
153 TIC(PREFILTER)
154     silk_prefilter_FIX( psEnc, &sEncCtrl, xfw, x_frame );
155 TOC(PREFILTER)
156
157     /****************************************/
158     /* Low Bitrate Redundant Encoding       */
159     /****************************************/
160 TIC(LBRR)
161     silk_LBRR_encode_FIX( psEnc, &sEncCtrl, xfw, condCoding );
162 TOC(LBRR)
163
164     /* Loop over quantizer and entroy coding to control bitrate */
165     maxIter = 5;
166     gainMult_Q8 = SILK_FIX_CONST( 1, 8 );
167     found_lower = 0;
168     found_upper = 0;
169     for( iter = 0; ; iter++ ) {
170         if( maxBits > 0 && !psEnc->sCmn.prefillFlag ) {
171             /* Copy part of the input state */
172             silk_memcpy( &sRangeEnc_copy, psRangeEnc, sizeof( ec_enc ) );
173             silk_memcpy( &sNSQ_copy, &psEnc->sCmn.sNSQ, sizeof( silk_nsq_state ) );
174             seed_copy = psEnc->sCmn.indices.Seed;
175             ec_prevLagIndex_copy = psEnc->sCmn.ec_prevLagIndex;
176             ec_prevSignalType_copy = psEnc->sCmn.ec_prevSignalType;
177         }
178
179         /*****************************************/
180         /* Noise shaping quantization            */
181         /*****************************************/
182 TIC(NSQ)
183         if( psEnc->sCmn.nStatesDelayedDecision > 1 || psEnc->sCmn.warping_Q16 > 0 ) {
184             silk_NSQ_del_dec( &psEnc->sCmn, &psEnc->sCmn.sNSQ, &psEnc->sCmn.indices, xfw, psEnc->sCmn.pulses,
185                 sEncCtrl.PredCoef_Q12[ 0 ], sEncCtrl.LTPCoef_Q14, sEncCtrl.AR2_Q13, sEncCtrl.HarmShapeGain_Q14,
186                 sEncCtrl.Tilt_Q14, sEncCtrl.LF_shp_Q14, sEncCtrl.Gains_Q16, sEncCtrl.pitchL, sEncCtrl.Lambda_Q10, sEncCtrl.LTP_scale_Q14 );
187         } else {
188             silk_NSQ( &psEnc->sCmn, &psEnc->sCmn.sNSQ, &psEnc->sCmn.indices, xfw, psEnc->sCmn.pulses,
189                 sEncCtrl.PredCoef_Q12[ 0 ], sEncCtrl.LTPCoef_Q14, sEncCtrl.AR2_Q13, sEncCtrl.HarmShapeGain_Q14,
190                 sEncCtrl.Tilt_Q14, sEncCtrl.LF_shp_Q14, sEncCtrl.Gains_Q16, sEncCtrl.pitchL, sEncCtrl.Lambda_Q10, sEncCtrl.LTP_scale_Q14 );
191         }
192 TOC(NSQ)
193
194         if( psEnc->sCmn.prefillFlag ) {
195             break;
196         } else {
197             /****************************************/
198             /* Encode Parameters                    */
199             /****************************************/
200 TIC(ENCODE_PARAMS)
201             silk_encode_indices( &psEnc->sCmn, psRangeEnc, psEnc->sCmn.nFramesEncoded, 0, condCoding );
202 TOC(ENCODE_PARAMS)
203
204             /****************************************/
205             /* Encode Excitation Signal             */
206             /****************************************/
207 TIC(ENCODE_PULSES)
208             silk_encode_pulses( psRangeEnc, psEnc->sCmn.indices.signalType, psEnc->sCmn.indices.quantOffsetType,
209                 psEnc->sCmn.pulses, psEnc->sCmn.frame_length );
210 TOC(ENCODE_PULSES)
211
212         }
213
214         nBits = ec_tell( psRangeEnc );
215
216         if( maxBits == 0 || ( useCBR == 0 && iter == 0 && nBits <= maxBits ) ) {
217             break;
218         }
219
220         if( iter == maxIter ) {
221             if( nBits > maxBits && found_lower ) {
222                 /* Restore output state from earlier iteration that did meet the bitrate budget */
223                 silk_memcpy( psRangeEnc, &sRangeEnc_copy2, sizeof( ec_enc ) );
224                 silk_memcpy( psRangeEnc->buf, ec_buf_copy, sRangeEnc_copy2.offs );
225                 silk_memcpy( &psEnc->sCmn.sNSQ, &sNSQ_copy2, sizeof( silk_nsq_state ) );
226                 psEnc->sShape.LastGainIndex = LastGainIndex_copy2;
227             }
228             break;
229         }
230
231         if( nBits > maxBits ) {
232             found_upper = 1;
233             nBits_upper = nBits;
234             gainMult_upper = gainMult_Q8;
235             if( found_lower == 0 && iter >= 2 ) {
236                 /* Adjust the quantizer's rate/distortion tradeoff */
237                 sEncCtrl.Lambda_Q10 = silk_ADD_RSHIFT32( sEncCtrl.Lambda_Q10, sEncCtrl.Lambda_Q10, 1 );
238             }
239         } else if( nBits < maxBits - 5 ) {
240             found_lower = 1;
241             nBits_lower = nBits;
242             gainMult_lower = gainMult_Q8;
243             /* Copy part of the output state */
244             silk_memcpy( &sRangeEnc_copy2, psRangeEnc, sizeof( ec_enc ) );
245             silk_memcpy( ec_buf_copy, psRangeEnc->buf, psRangeEnc->offs );
246             silk_memcpy( &sNSQ_copy2, &psEnc->sCmn.sNSQ, sizeof( silk_nsq_state ) );
247             LastGainIndex_copy2 = psEnc->sShape.LastGainIndex;
248         } else {
249             /* Within 5 bits of budget: close enough */
250             break;
251         }
252
253         if( ( found_lower & found_upper ) == 0 ) {
254             /* Adjust gain according to high-rate rate/distortion curve */
255             opus_int32 gain_factor_Q16;\r
256             gain_factor_Q16 = silk_log2lin( silk_LSHIFT( nBits - maxBits, 7 ) / psEnc->sCmn.frame_length + SILK_FIX_CONST( 16, 7 ) );\r
257             if( nBits > maxBits ) {
258                 gain_factor_Q16 = silk_max_32( gain_factor_Q16, SILK_FIX_CONST( 1.3, 16 ) );
259             }
260             gainMult_Q8 = silk_SMULWB( gain_factor_Q16, gainMult_Q8 );\r
261         } else {
262             /* Adjust gain by interpolating */
263             gainMult_Q8 = gainMult_lower + silk_DIV32_16( silk_MUL( gainMult_upper - gainMult_lower, maxBits - nBits_lower ), nBits_upper - nBits_lower );
264             /* New gain multplier must be between 25% and 75% of old range (note that gainMult_upper < gainMult_lower) */
265             if( gainMult_Q8 > gainMult_lower + silk_RSHIFT32( gainMult_upper - gainMult_lower, 2 ) ) {
266                 gainMult_Q8 = gainMult_lower + silk_RSHIFT32( gainMult_upper - gainMult_lower, 2 );
267             } else 
268             if( gainMult_Q8 < gainMult_upper - silk_RSHIFT32( gainMult_upper - gainMult_lower, 2 ) ) {
269                 gainMult_Q8 = gainMult_upper - silk_RSHIFT32( gainMult_upper - gainMult_lower, 2 );
270             } 
271         }
272
273         for( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
274             sEncCtrl.Gains_Q16[ i ] = silk_LSHIFT_SAT32( silk_SMULWB( sEncCtrl.GainsUnq_Q16[ i ], gainMult_Q8 ), 8 );
275         }
276         psEnc->sShape.LastGainIndex = sEncCtrl.lastGainIndexPrev;
277
278         /* Noise shaping quantization */
279         silk_gains_quant( psEnc->sCmn.indices.GainsIndices, sEncCtrl.Gains_Q16,
280                 &psEnc->sShape.LastGainIndex, condCoding == CODE_CONDITIONALLY, psEnc->sCmn.nb_subfr );
281
282         /* Restore part of the input state */
283         silk_memcpy( psRangeEnc, &sRangeEnc_copy, sizeof( ec_enc ) );
284         silk_memcpy( &psEnc->sCmn.sNSQ, &sNSQ_copy, sizeof( silk_nsq_state ) );
285         psEnc->sCmn.indices.Seed = seed_copy;
286         psEnc->sCmn.ec_prevLagIndex = ec_prevLagIndex_copy;
287         psEnc->sCmn.ec_prevSignalType = ec_prevSignalType_copy;
288     }
289
290     /* Update input buffer */
291     silk_memmove( psEnc->x_buf, &psEnc->x_buf[ psEnc->sCmn.frame_length ],
292         ( psEnc->sCmn.ltp_mem_length + LA_SHAPE_MS * psEnc->sCmn.fs_kHz ) * sizeof( opus_int16 ) );
293
294     /* Parameters needed for next frame */
295     psEnc->sCmn.prevLag        = sEncCtrl.pitchL[ psEnc->sCmn.nb_subfr - 1 ];
296     psEnc->sCmn.prevSignalType = psEnc->sCmn.indices.signalType;
297
298     /* Exit without entropy coding */
299     if( psEnc->sCmn.prefillFlag ) {
300         /* No payload */
301         *pnBytesOut = 0;
302         return ret;
303     }
304
305     /****************************************/
306     /* Finalize payload                     */
307     /****************************************/
308     psEnc->sCmn.first_frame_after_reset = 0;
309     /* Payload size */
310     *pnBytesOut = silk_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );
311
312     TOC(ENCODE_FRAME)
313
314 #ifdef SAVE_ALL_INTERNAL_DATA
315     {
316         silk_float tmp[ MAX_NB_SUBFR * LTP_ORDER ];
317         int i;
318         DEBUG_STORE_DATA( xf.dat,                   x_frame + LA_SHAPE_MS * psEnc->sCmn.fs_kHz, psEnc->sCmn.frame_length * sizeof( opus_int16 ) );
319         DEBUG_STORE_DATA( xfw.dat,                  xfw,                            psEnc->sCmn.frame_length    * sizeof( opus_int16 ) );
320         DEBUG_STORE_DATA( pitchL.dat,               sEncCtrl.pitchL,                psEnc->sCmn.nb_subfr        * sizeof( opus_int ) );
321         for( i = 0; i < psEnc->sCmn.nb_subfr * LTP_ORDER; i++ ) {
322             tmp[ i ] = (silk_float)sEncCtrl.LTPCoef_Q14[ i ] / 16384.0f;
323         }
324         DEBUG_STORE_DATA( pitchG_quantized.dat,     tmp,                            psEnc->sCmn.nb_subfr * LTP_ORDER * sizeof( silk_float ) );
325         for( i = 0; i <psEnc->sCmn.predictLPCOrder; i++ ) {
326             tmp[ i ] = (silk_float)sEncCtrl.PredCoef_Q12[ 1 ][ i ] / 4096.0f;
327         }
328         DEBUG_STORE_DATA( PredCoef.dat,             tmp,                            psEnc->sCmn.predictLPCOrder * sizeof( silk_float ) );
329
330         tmp[ 0 ] = (silk_float)sEncCtrl.LTPredCodGain_Q7 / 128.0f;
331         DEBUG_STORE_DATA( LTPredCodGain.dat,        tmp,                            sizeof( silk_float ) );
332         tmp[ 0 ] = (silk_float)psEnc->LTPCorr_Q15 / 32768.0f;
333         DEBUG_STORE_DATA( LTPcorr.dat,              tmp,                            sizeof( silk_float ) );
334         tmp[ 0 ] = (silk_float)psEnc->sCmn.input_tilt_Q15 / 32768.0f;
335         DEBUG_STORE_DATA( tilt.dat,                 tmp,                            sizeof( silk_float ) );
336         for( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
337             tmp[ i ] = (silk_float)sEncCtrl.Gains_Q16[ i ] / 65536.0f;
338         }
339         DEBUG_STORE_DATA( gains.dat,                tmp,                            psEnc->sCmn.nb_subfr * sizeof( silk_float ) );
340         DEBUG_STORE_DATA( gains_indices.dat,        &psEnc->sCmn.indices.GainsIndices, psEnc->sCmn.nb_subfr * sizeof( opus_int ) );
341         tmp[ 0 ] = (silk_float)sEncCtrl.current_SNR_dB_Q7 / 128.0f;
342         DEBUG_STORE_DATA( current_SNR_db.dat,       tmp,                            sizeof( silk_float ) );
343         DEBUG_STORE_DATA( quantOffsetType.dat,      &psEnc->sCmn.indices.quantOffsetType, sizeof( opus_int ) );
344         tmp[ 0 ] = (silk_float)psEnc->sCmn.speech_activity_Q8 / 256.0f;
345         DEBUG_STORE_DATA( speech_activity.dat,      tmp,                            sizeof( silk_float ) );
346         for( i = 0; i < VAD_N_BANDS; i++ ) {
347             tmp[ i ] = (silk_float)psEnc->sCmn.input_quality_bands_Q15[ i ] / 32768.0f;
348         }
349         DEBUG_STORE_DATA( input_quality_bands.dat,  tmp,                       VAD_N_BANDS * sizeof( silk_float ) );
350         DEBUG_STORE_DATA( signalType.dat,           &psEnc->sCmn.indices.signalType,         sizeof( opus_int8) );
351         DEBUG_STORE_DATA( lag_index.dat,            &psEnc->sCmn.indices.lagIndex,           sizeof( opus_int16 ) );
352         DEBUG_STORE_DATA( contour_index.dat,        &psEnc->sCmn.indices.contourIndex,       sizeof( opus_int8 ) );
353         DEBUG_STORE_DATA( per_index.dat,            &psEnc->sCmn.indices.PERIndex,           sizeof( opus_int8) );
354     }
355 #endif
356     return ret;
357 }
358
359 /* Low-Bitrate Redundancy (LBRR) encoding. Reuse all parameters but encode excitation at lower bitrate  */
360 void silk_LBRR_encode_FIX(
361     silk_encoder_state_FIX          *psEnc,         /* I/O  Pointer to Silk FIX encoder state           */
362     silk_encoder_control_FIX        *psEncCtrl,     /* I/O  Pointer to Silk FIX encoder control struct  */
363     const opus_int16                 xfw[],          /* I    Input signal                                */
364     opus_int                         condCoding     /* I    The type of conditional coding used so far for this frame */
365 )
366 {
367     opus_int32   TempGains_Q16[ MAX_NB_SUBFR ];
368     SideInfoIndices *psIndices_LBRR = &psEnc->sCmn.indices_LBRR[ psEnc->sCmn.nFramesEncoded ];
369     silk_nsq_state sNSQ_LBRR;
370
371     /*******************************************/
372     /* Control use of inband LBRR              */
373     /*******************************************/
374     if( psEnc->sCmn.LBRR_enabled && psEnc->sCmn.speech_activity_Q8 > SILK_FIX_CONST( LBRR_SPEECH_ACTIVITY_THRES, 8 ) ) {
375         psEnc->sCmn.LBRR_flags[ psEnc->sCmn.nFramesEncoded ] = 1;
376
377         /* Copy noise shaping quantizer state and quantization indices from regular encoding */
378         silk_memcpy( &sNSQ_LBRR, &psEnc->sCmn.sNSQ, sizeof( silk_nsq_state ) );
379         silk_memcpy( psIndices_LBRR, &psEnc->sCmn.indices, sizeof( SideInfoIndices ) );
380
381         /* Save original gains */
382         silk_memcpy( TempGains_Q16, psEncCtrl->Gains_Q16, psEnc->sCmn.nb_subfr * sizeof( opus_int32 ) );
383
384         if( psEnc->sCmn.nFramesEncoded == 0 || psEnc->sCmn.LBRR_flags[ psEnc->sCmn.nFramesEncoded - 1 ] == 0 ) {
385             /* First frame in packet or previous frame not LBRR coded */
386             psEnc->sCmn.LBRRprevLastGainIndex = psEnc->sShape.LastGainIndex;
387
388             /* Increase Gains to get target LBRR rate */
389             psIndices_LBRR->GainsIndices[ 0 ] = psIndices_LBRR->GainsIndices[ 0 ] + psEnc->sCmn.LBRR_GainIncreases;
390             psIndices_LBRR->GainsIndices[ 0 ] = silk_min_int( psIndices_LBRR->GainsIndices[ 0 ], N_LEVELS_QGAIN - 1 );
391         }
392
393         /* Decode to get gains in sync with decoder         */
394         /* Overwrite unquantized gains with quantized gains */
395         silk_gains_dequant( psEncCtrl->Gains_Q16, psIndices_LBRR->GainsIndices,
396             &psEnc->sCmn.LBRRprevLastGainIndex, condCoding == CODE_CONDITIONALLY, psEnc->sCmn.nb_subfr );
397
398         /*****************************************/
399         /* Noise shaping quantization            */
400         /*****************************************/
401         if( psEnc->sCmn.nStatesDelayedDecision > 1 || psEnc->sCmn.warping_Q16 > 0 ) {
402             silk_NSQ_del_dec( &psEnc->sCmn, &sNSQ_LBRR, psIndices_LBRR, xfw,
403                 psEnc->sCmn.pulses_LBRR[ psEnc->sCmn.nFramesEncoded ], psEncCtrl->PredCoef_Q12[ 0 ], psEncCtrl->LTPCoef_Q14,
404                 psEncCtrl->AR2_Q13, psEncCtrl->HarmShapeGain_Q14, psEncCtrl->Tilt_Q14, psEncCtrl->LF_shp_Q14,
405                 psEncCtrl->Gains_Q16, psEncCtrl->pitchL, psEncCtrl->Lambda_Q10, psEncCtrl->LTP_scale_Q14 );
406         } else {
407             silk_NSQ( &psEnc->sCmn, &sNSQ_LBRR, psIndices_LBRR, xfw,
408                 psEnc->sCmn.pulses_LBRR[ psEnc->sCmn.nFramesEncoded ], psEncCtrl->PredCoef_Q12[ 0 ], psEncCtrl->LTPCoef_Q14,
409                 psEncCtrl->AR2_Q13, psEncCtrl->HarmShapeGain_Q14, psEncCtrl->Tilt_Q14, psEncCtrl->LF_shp_Q14,
410                 psEncCtrl->Gains_Q16, psEncCtrl->pitchL, psEncCtrl->Lambda_Q10, psEncCtrl->LTP_scale_Q14 );
411         }
412
413         /* Restore original gains */
414         silk_memcpy( psEncCtrl->Gains_Q16, TempGains_Q16, psEnc->sCmn.nb_subfr * sizeof( opus_int32 ) );
415     }
416 }