Fixes a bug that was falsely triggering DTX for 60 ms stereo
[opus.git] / silk / enc_API.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 #include "define.h"
32 #include "API.h"
33 #include "control.h"
34 #include "typedef.h"
35 #include "structs.h"
36 #include "tuning_parameters.h"
37 #ifdef FIXED_POINT
38 #include "main_FIX.h"
39 #else
40 #include "main_FLP.h"
41 #endif
42
43 /****************************************/
44 /* Encoder functions                    */
45 /****************************************/
46
47 opus_int silk_Get_Encoder_Size( int *encSizeBytes )
48 {
49     opus_int ret = SILK_NO_ERROR;
50
51     *encSizeBytes = sizeof( silk_encoder );
52
53     return ret;
54 }
55
56 /*************************/
57 /* Init or Reset encoder */
58 /*************************/
59 opus_int silk_InitEncoder(
60     void                            *encState,          /* I/O: State                                           */
61     silk_EncControlStruct           *encStatus          /* O:   Control structure                               */
62 )
63 {
64     silk_encoder *psEnc;
65     opus_int n, ret = SILK_NO_ERROR;
66
67     psEnc = (silk_encoder *)encState;
68
69     /* Reset encoder */
70     silk_memset( psEnc, 0, sizeof( silk_encoder ) );
71     for( n = 0; n < ENCODER_NUM_CHANNELS; n++ ) {
72         if( ret += silk_init_encoder( &psEnc->state_Fxx[ n ] ) ) {
73             silk_assert( 0 );
74         }
75     }
76
77     psEnc->nChannelsAPI = 1;
78     psEnc->nChannelsInternal = 1;
79
80     /* Read control structure */
81     if( ret += silk_QueryEncoder( encState, encStatus ) ) {
82         silk_assert( 0 );
83     }
84
85     return ret;
86 }
87
88 /***************************************/
89 /* Read control structure from encoder */
90 /***************************************/
91 opus_int silk_QueryEncoder(
92     const void *encState,                       /* I:   State Vector                                    */
93     silk_EncControlStruct *encStatus            /* O:   Control Structure                               */
94 )
95 {
96     opus_int ret = SILK_NO_ERROR;
97     silk_encoder_state_Fxx *state_Fxx;
98     silk_encoder *psEnc = (silk_encoder *)encState;
99
100     state_Fxx = psEnc->state_Fxx;
101
102     encStatus->nChannelsAPI              = psEnc->nChannelsAPI;
103     encStatus->nChannelsInternal         = psEnc->nChannelsInternal;
104     encStatus->API_sampleRate            = state_Fxx[ 0 ].sCmn.API_fs_Hz;
105     encStatus->maxInternalSampleRate     = state_Fxx[ 0 ].sCmn.maxInternal_fs_Hz;
106     encStatus->minInternalSampleRate     = state_Fxx[ 0 ].sCmn.minInternal_fs_Hz;
107     encStatus->desiredInternalSampleRate = state_Fxx[ 0 ].sCmn.desiredInternal_fs_Hz;
108     encStatus->payloadSize_ms            = state_Fxx[ 0 ].sCmn.PacketSize_ms;
109     encStatus->bitRate                   = state_Fxx[ 0 ].sCmn.TargetRate_bps;
110     encStatus->packetLossPercentage      = state_Fxx[ 0 ].sCmn.PacketLoss_perc;
111     encStatus->complexity                = state_Fxx[ 0 ].sCmn.Complexity;
112     encStatus->useInBandFEC              = state_Fxx[ 0 ].sCmn.useInBandFEC;
113     encStatus->useDTX                    = state_Fxx[ 0 ].sCmn.useDTX;
114     encStatus->useCBR                    = state_Fxx[ 0 ].sCmn.useCBR;
115     encStatus->internalSampleRate        = silk_SMULBB( state_Fxx[ 0 ].sCmn.fs_kHz, 1000 );
116     encStatus->allowBandwidthSwitch      = state_Fxx[ 0 ].sCmn.allow_bandwidth_switch;
117     encStatus->inWBmodeWithoutVariableLP = state_Fxx[ 0 ].sCmn.fs_kHz == 16 && state_Fxx[ 0 ].sCmn.sLP.mode == 0;
118
119     return ret;
120 }
121
122 /**************************/
123 /* Encode frame with Silk */
124 /**************************/
125 opus_int silk_Encode(
126     void                                *encState,      /* I/O: State                                           */
127     silk_EncControlStruct               *encControl,    /* I:   Control structure                               */
128     const opus_int16                     *samplesIn,     /* I:   Speech sample input vector                      */
129     opus_int                             nSamplesIn,     /* I:   Number of samples in input vector               */
130     ec_enc                              *psRangeEnc,    /* I/O  Compressor data structure                       */
131     opus_int                             *nBytesOut,     /* I/O: Number of bytes in payload (input: Max bytes)   */
132     const opus_int                       prefillFlag     /* I:   Flag to indicate prefilling buffers; no coding  */
133 )
134 {
135     opus_int   n, i, nBits, flags, tmp_payloadSize_ms = 0, tmp_complexity = 0, ret = 0;
136     opus_int   nSamplesToBuffer, nBlocksOf10ms, nSamplesFromInput = 0;
137     opus_int   speech_act_thr_for_switch_Q8;
138     opus_int32 TargetRate_bps, MStargetRates_bps[ 2 ], channelRate_bps, LBRR_symbol;
139     silk_encoder *psEnc = ( silk_encoder * )encState;
140     opus_int16 buf[ MAX_FRAME_LENGTH_MS * MAX_API_FS_KHZ ];
141
142     psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded = psEnc->state_Fxx[ 1 ].sCmn.nFramesEncoded = 0;
143
144     /* Check values in encoder control structure */
145     if( ( ret = check_control_input( encControl ) != 0 ) ) {
146         silk_assert( 0 );
147         return ret;
148     }
149
150     if( encControl->nChannelsInternal > psEnc->nChannelsInternal ) {
151         /* Mono -> Stereo transition: init state of second channel and stereo state */
152         ret += silk_init_encoder( &psEnc->state_Fxx[ 1 ] );
153         silk_memset( psEnc->sStereo.pred_prev_Q13, 0, sizeof( psEnc->sStereo.pred_prev_Q13 ) );
154         silk_memset( psEnc->sStereo.sSide, 0, sizeof( psEnc->sStereo.sSide ) );
155         silk_memset( psEnc->sStereo.mid_side_amp_Q0, 0, sizeof( psEnc->sStereo.mid_side_amp_Q0 ) );
156         psEnc->sStereo.width_prev_Q14 = 0;
157         psEnc->sStereo.smth_width_Q14 = SILK_FIX_CONST( 1, 14 );
158         if( psEnc->nChannelsAPI == 2 ) {
159             silk_memcpy( &psEnc->state_Fxx[ 1 ].sCmn.resampler_state, &psEnc->state_Fxx[ 0 ].sCmn.resampler_state, sizeof( silk_resampler_state_struct ) );
160             silk_memcpy( &psEnc->state_Fxx[ 1 ].sCmn.In_HP_State,     &psEnc->state_Fxx[ 0 ].sCmn.In_HP_State,     sizeof( psEnc->state_Fxx[ 1 ].sCmn.In_HP_State ) );
161         }
162     }
163     psEnc->nChannelsAPI = encControl->nChannelsAPI;
164     psEnc->nChannelsInternal = encControl->nChannelsInternal;
165
166     nBlocksOf10ms = silk_DIV32( 100 * nSamplesIn, encControl->API_sampleRate );
167     if( prefillFlag ) {
168         /* Only accept input length of 10 ms */
169         if( nBlocksOf10ms != 1 ) {
170             ret = SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES;
171             silk_assert( 0 );
172             return ret;
173         }
174         /* Reset Encoder */
175         for( n = 0; n < encControl->nChannelsInternal; n++ ) {
176             if( (ret = silk_init_encoder( &psEnc->state_Fxx[ n ] ) ) != 0 ) {
177                 silk_assert( 0 );
178             }
179         }
180         tmp_payloadSize_ms = encControl->payloadSize_ms;
181         encControl->payloadSize_ms = 10;
182         tmp_complexity = encControl->complexity;
183         encControl->complexity = 0;
184         for( n = 0; n < encControl->nChannelsInternal; n++ ) {
185             psEnc->state_Fxx[ n ].sCmn.controlled_since_last_payload = 0;
186             psEnc->state_Fxx[ n ].sCmn.prefillFlag = 1;
187         }
188     } else {
189         /* Only accept input lengths that are a multiple of 10 ms */
190         if( nBlocksOf10ms * encControl->API_sampleRate != 100 * nSamplesIn || nSamplesIn < 0 ) {
191             ret = SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES;
192             silk_assert( 0 );
193             return ret;
194         }
195         /* Make sure no more than one packet can be produced */
196         if( 1000 * (opus_int32)nSamplesIn > encControl->payloadSize_ms * encControl->API_sampleRate ) {
197             ret = SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES;
198             silk_assert( 0 );
199             return ret;
200         }
201     }
202
203     TargetRate_bps = silk_RSHIFT32( encControl->bitRate, encControl->nChannelsInternal - 1 );
204     for( n = 0; n < encControl->nChannelsInternal; n++ ) {
205         /* JMV: Force the side channel to the same rate as the mid. Is this the right way? */
206         int force_fs_kHz = (n==1) ? psEnc->state_Fxx[0].sCmn.fs_kHz : 0;
207         if( ( ret = silk_control_encoder( &psEnc->state_Fxx[ n ], encControl, TargetRate_bps, psEnc->allowBandwidthSwitch, n, force_fs_kHz ) ) != 0 ) {
208             silk_assert( 0 );
209             return ret;
210         }
211     }
212     silk_assert( encControl->nChannelsInternal == 1 || psEnc->state_Fxx[ 0 ].sCmn.fs_kHz == psEnc->state_Fxx[ 1 ].sCmn.fs_kHz );
213
214     /* Input buffering/resampling and encoding */
215     while( 1 ) {
216         nSamplesToBuffer  = psEnc->state_Fxx[ 0 ].sCmn.frame_length - psEnc->state_Fxx[ 0 ].sCmn.inputBufIx;
217         nSamplesToBuffer  = silk_min( nSamplesToBuffer, 10 * nBlocksOf10ms * psEnc->state_Fxx[ 0 ].sCmn.fs_kHz );
218         nSamplesFromInput = silk_DIV32_16( nSamplesToBuffer * psEnc->state_Fxx[ 0 ].sCmn.API_fs_Hz, psEnc->state_Fxx[ 0 ].sCmn.fs_kHz * 1000 );
219         /* Resample and write to buffer */
220         if( encControl->nChannelsAPI == 2 && encControl->nChannelsInternal == 2 ) {
221             for( n = 0; n < nSamplesFromInput; n++ ) {
222                 buf[ n ] = samplesIn[ 2 * n ];
223             }
224             /* Making sure to start both resamplers from the same state when switching from mono to stereo */
225             if(psEnc->nPrevChannelsInternal == 1)
226                silk_memcpy(&psEnc->state_Fxx[ 1 ].sCmn.resampler_state, &psEnc->state_Fxx[ 0 ].sCmn.resampler_state, sizeof(psEnc->state_Fxx[ 1 ].sCmn.resampler_state));
227
228             ret += silk_resampler( &psEnc->state_Fxx[ 0 ].sCmn.resampler_state,
229                 &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.inputBufIx + 2 ], buf, nSamplesFromInput );
230             psEnc->state_Fxx[ 0 ].sCmn.inputBufIx += nSamplesToBuffer;
231
232             nSamplesToBuffer  = psEnc->state_Fxx[ 1 ].sCmn.frame_length - psEnc->state_Fxx[ 1 ].sCmn.inputBufIx;
233             nSamplesToBuffer  = silk_min( nSamplesToBuffer, 10 * nBlocksOf10ms * psEnc->state_Fxx[ 1 ].sCmn.fs_kHz );
234             for( n = 0; n < nSamplesFromInput; n++ ) {
235                 buf[ n ] = samplesIn[ 2 * n + 1 ];
236             }
237             ret += silk_resampler( &psEnc->state_Fxx[ 1 ].sCmn.resampler_state,
238                 &psEnc->state_Fxx[ 1 ].sCmn.inputBuf[ psEnc->state_Fxx[ 1 ].sCmn.inputBufIx + 2 ], buf, nSamplesFromInput );
239             psEnc->state_Fxx[ 1 ].sCmn.inputBufIx += nSamplesToBuffer;
240         } else if( encControl->nChannelsAPI == 2 && encControl->nChannelsInternal == 1 ) {
241             /* Combine left and right channels before resampling */
242             for( n = 0; n < nSamplesFromInput; n++ ) {
243                 buf[ n ] = (opus_int16)silk_RSHIFT_ROUND( samplesIn[ 2 * n ] + samplesIn[ 2 * n + 1 ],  1 );
244             }
245             ret += silk_resampler( &psEnc->state_Fxx[ 0 ].sCmn.resampler_state,
246                 &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.inputBufIx + 2 ], buf, nSamplesFromInput );
247             psEnc->state_Fxx[ 0 ].sCmn.inputBufIx += nSamplesToBuffer;
248         } else {
249             silk_assert( encControl->nChannelsAPI == 1 && encControl->nChannelsInternal == 1 );
250             ret += silk_resampler( &psEnc->state_Fxx[ 0 ].sCmn.resampler_state,
251                 &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.inputBufIx + 2 ], samplesIn, nSamplesFromInput );
252             psEnc->state_Fxx[ 0 ].sCmn.inputBufIx += nSamplesToBuffer;
253         }
254         psEnc->nPrevChannelsInternal = encControl->nChannelsInternal;
255
256         samplesIn  += nSamplesFromInput * encControl->nChannelsAPI;
257         nSamplesIn -= nSamplesFromInput;
258
259         /* Default */
260         psEnc->allowBandwidthSwitch = 0;
261
262         /* Silk encoder */
263         if( psEnc->state_Fxx[ 0 ].sCmn.inputBufIx >= psEnc->state_Fxx[ 0 ].sCmn.frame_length ) {
264             /* Enough data in input buffer, so encode */
265             silk_assert( psEnc->state_Fxx[ 0 ].sCmn.inputBufIx == psEnc->state_Fxx[ 0 ].sCmn.frame_length );
266             silk_assert( encControl->nChannelsInternal == 1 || psEnc->state_Fxx[ 1 ].sCmn.inputBufIx == psEnc->state_Fxx[ 1 ].sCmn.frame_length );
267
268             /* Deal with LBRR data */
269             if( psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded == 0 && !prefillFlag ) {
270                 /* Create space at start of payload for VAD and FEC flags */
271                 opus_uint8 iCDF[ 2 ] = { 0, 0 };
272                 iCDF[ 0 ] = 256 - silk_RSHIFT( 256, ( psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket + 1 ) * encControl->nChannelsInternal );
273                 ec_enc_icdf( psRangeEnc, 0, iCDF, 8 );
274
275                 /* Encode any LBRR data from previous packet */
276                 /* Encode LBRR flags */
277                 for( n = 0; n < encControl->nChannelsInternal; n++ ) {
278                     LBRR_symbol = 0;
279                     for( i = 0; i < psEnc->state_Fxx[ n ].sCmn.nFramesPerPacket; i++ ) {
280                         LBRR_symbol |= silk_LSHIFT( psEnc->state_Fxx[ n ].sCmn.LBRR_flags[ i ], i );
281                     }
282                     psEnc->state_Fxx[ n ].sCmn.LBRR_flag = LBRR_symbol > 0 ? 1 : 0;
283                     if( LBRR_symbol && psEnc->state_Fxx[ n ].sCmn.nFramesPerPacket > 1 ) {
284                         ec_enc_icdf( psRangeEnc, LBRR_symbol - 1, silk_LBRR_flags_iCDF_ptr[ psEnc->state_Fxx[ n ].sCmn.nFramesPerPacket - 2 ], 8 );
285                     }
286                 }
287
288                 /* Code LBRR indices and excitation signals */
289                 for( i = 0; i < psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket; i++ ) {
290                     for( n = 0; n < encControl->nChannelsInternal; n++ ) {
291                         if( psEnc->state_Fxx[ n ].sCmn.LBRR_flags[ i ] ) {
292                             if( encControl->nChannelsInternal == 2 && n == 0 ) {
293                                 silk_stereo_encode_pred( psRangeEnc, psEnc->sStereo.predIx[ i ] );
294                                 /* For LBRR data there's no need to code the mid-only flag if the side-channel LBRR flag is set */
295                                 if( psEnc->state_Fxx[ 1 ].sCmn.LBRR_flags[ i ] == 0 ) {
296                                     silk_stereo_encode_mid_only( psRangeEnc, psEnc->sStereo.mid_only_flags[ i ] );
297                                 }
298                             }
299                             silk_encode_indices( &psEnc->state_Fxx[ n ].sCmn, psRangeEnc, i, 1 );
300                             silk_encode_pulses( psRangeEnc, psEnc->state_Fxx[ n ].sCmn.indices_LBRR[i].signalType, psEnc->state_Fxx[ n ].sCmn.indices_LBRR[i].quantOffsetType,
301                                 psEnc->state_Fxx[ n ].sCmn.pulses_LBRR[ i ], psEnc->state_Fxx[ n ].sCmn.frame_length );
302                         }
303                     }
304                 }
305
306                 /* Reset LBRR flags */
307                 for( n = 0; n < encControl->nChannelsInternal; n++ ) {
308                     silk_memset( psEnc->state_Fxx[ n ].sCmn.LBRR_flags, 0, sizeof( psEnc->state_Fxx[ n ].sCmn.LBRR_flags ) );
309                 }
310             }
311
312             silk_HP_variable_cutoff( psEnc->state_Fxx );
313
314             /* Total target bits for packet */
315             nBits = silk_DIV32_16( silk_MUL( encControl->bitRate, encControl->payloadSize_ms ), 1000 );
316             /* Subtract half of the bits already used */
317             if (!prefillFlag)
318                 nBits -= ec_tell( psRangeEnc ) >> 1;
319             /* Divide by number of uncoded frames left in packet */
320             nBits = silk_DIV32_16( nBits, psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket - psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded );
321             /* Convert to bits/second */
322             if( encControl->payloadSize_ms == 10 ) {
323                 TargetRate_bps = silk_SMULBB( nBits, 100 );
324             } else {
325                 TargetRate_bps = silk_SMULBB( nBits, 50 );
326             }
327             /* Subtract fraction of bits in excess of target in previous packets */
328             TargetRate_bps -= silk_DIV32_16( silk_MUL( psEnc->nBitsExceeded, 1000 ), BITRESERVOIR_DECAY_TIME_MS );
329             /* Never exceed input bitrate */
330             TargetRate_bps = silk_LIMIT( TargetRate_bps, encControl->bitRate, 5000 );
331
332             /* Convert Left/Right to Mid/Side */
333             if( encControl->nChannelsInternal == 2 ) {
334                 silk_stereo_LR_to_MS( &psEnc->sStereo, &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ 2 ], &psEnc->state_Fxx[ 1 ].sCmn.inputBuf[ 2 ],
335                     psEnc->sStereo.predIx[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ], &psEnc->sStereo.mid_only_flags[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ],
336                     MStargetRates_bps, TargetRate_bps, psEnc->state_Fxx[ 0 ].sCmn.speech_activity_Q8,
337                     psEnc->state_Fxx[ 0 ].sCmn.fs_kHz, psEnc->state_Fxx[ 0 ].sCmn.frame_length );
338                 if (!prefillFlag) {
339                     silk_stereo_encode_pred( psRangeEnc, psEnc->sStereo.predIx[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ] );
340                     silk_stereo_encode_mid_only( psRangeEnc, psEnc->sStereo.mid_only_flags[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ] );
341                 }
342             } else {
343                 /* Buffering */
344                 silk_memcpy( psEnc->state_Fxx[ 0 ].sCmn.inputBuf, psEnc->sStereo.sMid, 2 * sizeof( opus_int16 ) );
345                 silk_memcpy( psEnc->sStereo.sMid, &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.frame_length ], 2 * sizeof( opus_int16 ) );
346             }
347
348             /* Encode */
349             for( n = 0; n < encControl->nChannelsInternal; n++ ) {
350                 if( encControl->nChannelsInternal == 1 ) {
351                     channelRate_bps = TargetRate_bps;
352                 } else {
353                     channelRate_bps = MStargetRates_bps[ n ];
354                 }
355
356                 if( channelRate_bps > 0 ) {
357                     silk_control_SNR( &psEnc->state_Fxx[ n ].sCmn, channelRate_bps );
358
359                     if( ( ret = silk_encode_frame_Fxx( &psEnc->state_Fxx[ n ], nBytesOut, psRangeEnc ) ) != 0 ) {
360                         silk_assert( 0 );
361                     }
362                 }
363                 psEnc->state_Fxx[ n ].sCmn.nFramesEncoded++;
364                 psEnc->state_Fxx[ n ].sCmn.controlled_since_last_payload = 0;
365                 psEnc->state_Fxx[ n ].sCmn.inputBufIx = 0;
366             }
367
368             /* Insert VAD and FEC flags at beginning of bitstream */
369             if( *nBytesOut > 0 && psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded == psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket) {
370                 flags = 0;
371                 for( n = 0; n < encControl->nChannelsInternal; n++ ) {
372                     for( i = 0; i < psEnc->state_Fxx[ n ].sCmn.nFramesPerPacket; i++ ) {
373                         flags  = silk_LSHIFT( flags, 1 );
374                         flags |= psEnc->state_Fxx[ n ].sCmn.VAD_flags[ i ];
375                     }
376                     flags  = silk_LSHIFT( flags, 1 );
377                     flags |= psEnc->state_Fxx[ n ].sCmn.LBRR_flag;
378                 }
379                 if (!prefillFlag)
380                     ec_enc_patch_initial_bits( psRangeEnc, flags, ( psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket + 1 ) * encControl->nChannelsInternal );
381
382                 /* Return zero bytes if all channels DTXed */
383                 if( psEnc->state_Fxx[ 0 ].sCmn.inDTX && ( encControl->nChannelsInternal == 1 || psEnc->state_Fxx[ 1 ].sCmn.inDTX ) ) {
384                     *nBytesOut = 0;
385                 }
386
387                 psEnc->nBitsExceeded += *nBytesOut * 8;
388                 psEnc->nBitsExceeded -= silk_DIV32_16( silk_MUL( encControl->bitRate, encControl->payloadSize_ms ), 1000 );
389                 psEnc->nBitsExceeded  = silk_LIMIT( psEnc->nBitsExceeded, 0, 10000 );
390
391                 /* Update flag indicating if bandwidth switching is allowed */
392                 speech_act_thr_for_switch_Q8 = silk_SMLAWB( SILK_FIX_CONST( SPEECH_ACTIVITY_DTX_THRES, 8 ),
393                     SILK_FIX_CONST( ( 1 - SPEECH_ACTIVITY_DTX_THRES ) / MAX_BANDWIDTH_SWITCH_DELAY_MS, 16 + 8 ), psEnc->timeSinceSwitchAllowed_ms );
394                 if( psEnc->state_Fxx[ 0 ].sCmn.speech_activity_Q8 < speech_act_thr_for_switch_Q8 ) {
395                     psEnc->allowBandwidthSwitch = 1;
396                     psEnc->timeSinceSwitchAllowed_ms = 0;
397                 } else {
398                     psEnc->allowBandwidthSwitch = 0;
399                     psEnc->timeSinceSwitchAllowed_ms += encControl->payloadSize_ms;
400                 }
401             }
402
403             if( nSamplesIn == 0 ) {
404                 break;
405             }
406         } else {
407             break;
408         }
409     }
410
411     encControl->allowBandwidthSwitch = psEnc->allowBandwidthSwitch;
412     encControl->inWBmodeWithoutVariableLP = psEnc->state_Fxx[ 0 ].sCmn.fs_kHz == 16 && psEnc->state_Fxx[ 0 ].sCmn.sLP.mode == 0;
413     encControl->internalSampleRate = silk_SMULBB( psEnc->state_Fxx[ 0 ].sCmn.fs_kHz, 1000 );
414     encControl->stereoWidth_Q14 = psEnc->sStereo.width_prev_Q14;
415     if( prefillFlag ) {
416         encControl->payloadSize_ms = tmp_payloadSize_ms;
417         encControl->complexity = tmp_complexity;
418         for( n = 0; n < encControl->nChannelsInternal; n++ ) {
419             psEnc->state_Fxx[ n ].sCmn.controlled_since_last_payload = 0;
420             psEnc->state_Fxx[ n ].sCmn.prefillFlag = 0;
421         }
422     }
423
424     return ret;
425 }
426