Fix some GCC warings in the silk/ directory.
[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     /* Check values in encoder control structure */
143     if( ( ret = check_control_input( encControl ) != 0 ) ) {
144         silk_assert( 0 );
145         return ret;
146     }
147
148     if( encControl->nChannelsInternal > psEnc->nChannelsInternal ) {
149         /* Mono -> Stereo transition: init state of second channel and stereo state */
150         ret += silk_init_encoder( &psEnc->state_Fxx[ 1 ] );
151         silk_memset( psEnc->sStereo.pred_prev_Q13, 0, sizeof( psEnc->sStereo.pred_prev_Q13 ) );
152         silk_memset( psEnc->sStereo.sSide, 0, sizeof( psEnc->sStereo.sSide ) );
153         silk_memset( psEnc->sStereo.mid_side_amp_Q0, 0, sizeof( psEnc->sStereo.mid_side_amp_Q0 ) );
154         psEnc->sStereo.width_prev_Q14 = 0;
155         psEnc->sStereo.smth_width_Q14 = SILK_FIX_CONST( 1, 14 );
156         if( psEnc->nChannelsAPI == 2 ) {
157             silk_memcpy( &psEnc->state_Fxx[ 1 ].sCmn.resampler_state, &psEnc->state_Fxx[ 0 ].sCmn.resampler_state, sizeof( silk_resampler_state_struct ) );
158             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 ) );
159         }
160     }
161     psEnc->nChannelsAPI = encControl->nChannelsAPI;
162     psEnc->nChannelsInternal = encControl->nChannelsInternal;
163
164     nBlocksOf10ms = silk_DIV32( 100 * nSamplesIn, encControl->API_sampleRate );
165     if( prefillFlag ) {
166         /* Only accept input length of 10 ms */
167         if( nBlocksOf10ms != 1 ) {
168             ret = SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES;
169             silk_assert( 0 );
170             return ret;
171         }
172         /* Reset Encoder */
173         for( n = 0; n < encControl->nChannelsInternal; n++ ) {
174             if( (ret = silk_init_encoder( &psEnc->state_Fxx[ n ] ) ) != 0 ) {
175                 silk_assert( 0 );
176             }
177         }
178         tmp_payloadSize_ms = encControl->payloadSize_ms;
179         encControl->payloadSize_ms = 10;
180         tmp_complexity = encControl->complexity;
181         encControl->complexity = 0;
182         for( n = 0; n < encControl->nChannelsInternal; n++ ) {
183             psEnc->state_Fxx[ n ].sCmn.controlled_since_last_payload = 0;
184             psEnc->state_Fxx[ n ].sCmn.prefillFlag = 1;
185         }
186     } else {
187         /* Only accept input lengths that are a multiple of 10 ms */
188         if( nBlocksOf10ms * encControl->API_sampleRate != 100 * nSamplesIn || nSamplesIn < 0 ) {
189             ret = SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES;
190             silk_assert( 0 );
191             return ret;
192         }
193         /* Make sure no more than one packet can be produced */
194         if( 1000 * (opus_int32)nSamplesIn > encControl->payloadSize_ms * encControl->API_sampleRate ) {
195             ret = SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES;
196             silk_assert( 0 );
197             return ret;
198         }
199     }
200
201     TargetRate_bps = silk_RSHIFT32( encControl->bitRate, encControl->nChannelsInternal - 1 );
202     for( n = 0; n < encControl->nChannelsInternal; n++ ) {
203         /* JMV: Force the side channel to the same rate as the mid. Is this the right way? */
204         int force_fs_kHz = (n==1) ? psEnc->state_Fxx[0].sCmn.fs_kHz : 0;
205         if( ( ret = silk_control_encoder( &psEnc->state_Fxx[ n ], encControl, TargetRate_bps, psEnc->allowBandwidthSwitch, n, force_fs_kHz ) ) != 0 ) {
206             silk_assert( 0 );
207             return ret;
208         }
209     }
210     silk_assert( encControl->nChannelsInternal == 1 || psEnc->state_Fxx[ 0 ].sCmn.fs_kHz == psEnc->state_Fxx[ 1 ].sCmn.fs_kHz );
211
212     /* Input buffering/resampling and encoding */
213     while( 1 ) {
214         nSamplesToBuffer  = psEnc->state_Fxx[ 0 ].sCmn.frame_length - psEnc->state_Fxx[ 0 ].sCmn.inputBufIx;
215         nSamplesToBuffer  = silk_min( nSamplesToBuffer, 10 * nBlocksOf10ms * psEnc->state_Fxx[ 0 ].sCmn.fs_kHz );
216         nSamplesFromInput = silk_DIV32_16( nSamplesToBuffer * psEnc->state_Fxx[ 0 ].sCmn.API_fs_Hz, psEnc->state_Fxx[ 0 ].sCmn.fs_kHz * 1000 );
217         /* Resample and write to buffer */
218         if( encControl->nChannelsAPI == 2 && encControl->nChannelsInternal == 2 ) {
219             for( n = 0; n < nSamplesFromInput; n++ ) {
220                 buf[ n ] = samplesIn[ 2 * n ];
221             }
222             /* Making sure to start both resamplers from the same state when switching from mono to stereo */
223             if(psEnc->nPrevChannelsInternal == 1)
224                silk_memcpy(&psEnc->state_Fxx[ 1 ].sCmn.resampler_state, &psEnc->state_Fxx[ 0 ].sCmn.resampler_state, sizeof(psEnc->state_Fxx[ 1 ].sCmn.resampler_state));
225
226             ret += silk_resampler( &psEnc->state_Fxx[ 0 ].sCmn.resampler_state,
227                 &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.inputBufIx + 2 ], buf, nSamplesFromInput );
228             psEnc->state_Fxx[ 0 ].sCmn.inputBufIx += nSamplesToBuffer;
229
230             nSamplesToBuffer  = psEnc->state_Fxx[ 1 ].sCmn.frame_length - psEnc->state_Fxx[ 1 ].sCmn.inputBufIx;
231             nSamplesToBuffer  = silk_min( nSamplesToBuffer, 10 * nBlocksOf10ms * psEnc->state_Fxx[ 1 ].sCmn.fs_kHz );
232             for( n = 0; n < nSamplesFromInput; n++ ) {
233                 buf[ n ] = samplesIn[ 2 * n + 1 ];
234             }
235             ret += silk_resampler( &psEnc->state_Fxx[ 1 ].sCmn.resampler_state,
236                 &psEnc->state_Fxx[ 1 ].sCmn.inputBuf[ psEnc->state_Fxx[ 1 ].sCmn.inputBufIx + 2 ], buf, nSamplesFromInput );
237             psEnc->state_Fxx[ 1 ].sCmn.inputBufIx += nSamplesToBuffer;
238         } else if( encControl->nChannelsAPI == 2 && encControl->nChannelsInternal == 1 ) {
239             /* Combine left and right channels before resampling */
240             for( n = 0; n < nSamplesFromInput; n++ ) {
241                 buf[ n ] = (opus_int16)silk_RSHIFT_ROUND( samplesIn[ 2 * n ] + samplesIn[ 2 * n + 1 ],  1 );
242             }
243             ret += silk_resampler( &psEnc->state_Fxx[ 0 ].sCmn.resampler_state,
244                 &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.inputBufIx + 2 ], buf, nSamplesFromInput );
245             psEnc->state_Fxx[ 0 ].sCmn.inputBufIx += nSamplesToBuffer;
246         } else {
247             silk_assert( encControl->nChannelsAPI == 1 && encControl->nChannelsInternal == 1 );
248             ret += silk_resampler( &psEnc->state_Fxx[ 0 ].sCmn.resampler_state,
249                 &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.inputBufIx + 2 ], samplesIn, nSamplesFromInput );
250             psEnc->state_Fxx[ 0 ].sCmn.inputBufIx += nSamplesToBuffer;
251         }
252         psEnc->nPrevChannelsInternal = encControl->nChannelsInternal;
253
254         samplesIn  += nSamplesFromInput * encControl->nChannelsAPI;
255         nSamplesIn -= nSamplesFromInput;
256
257         /* Default */
258         psEnc->allowBandwidthSwitch = 0;
259
260         /* Silk encoder */
261         if( psEnc->state_Fxx[ 0 ].sCmn.inputBufIx >= psEnc->state_Fxx[ 0 ].sCmn.frame_length ) {
262             /* Enough data in input buffer, so encode */
263             silk_assert( psEnc->state_Fxx[ 0 ].sCmn.inputBufIx == psEnc->state_Fxx[ 0 ].sCmn.frame_length );
264             silk_assert( encControl->nChannelsInternal == 1 || psEnc->state_Fxx[ 1 ].sCmn.inputBufIx == psEnc->state_Fxx[ 1 ].sCmn.frame_length );
265
266             /* Deal with LBRR data */
267             if( psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded == 0 && !prefillFlag ) {
268                 /* Create space at start of payload for VAD and FEC flags */
269                 opus_uint8 iCDF[ 2 ] = { 0, 0 };
270                 iCDF[ 0 ] = 256 - silk_RSHIFT( 256, ( psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket + 1 ) * encControl->nChannelsInternal );
271                 ec_enc_icdf( psRangeEnc, 0, iCDF, 8 );
272
273                 /* Encode any LBRR data from previous packet */
274                 /* Encode LBRR flags */
275                 for( n = 0; n < encControl->nChannelsInternal; n++ ) {
276                     LBRR_symbol = 0;
277                     for( i = 0; i < psEnc->state_Fxx[ n ].sCmn.nFramesPerPacket; i++ ) {
278                         LBRR_symbol |= silk_LSHIFT( psEnc->state_Fxx[ n ].sCmn.LBRR_flags[ i ], i );
279                     }
280                     psEnc->state_Fxx[ n ].sCmn.LBRR_flag = LBRR_symbol > 0 ? 1 : 0;
281                     if( LBRR_symbol && psEnc->state_Fxx[ n ].sCmn.nFramesPerPacket > 1 ) {
282                         ec_enc_icdf( psRangeEnc, LBRR_symbol - 1, silk_LBRR_flags_iCDF_ptr[ psEnc->state_Fxx[ n ].sCmn.nFramesPerPacket - 2 ], 8 );
283                     }
284                 }
285
286                 /* Code LBRR indices and excitation signals */
287                 for( i = 0; i < psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket; i++ ) {
288                     for( n = 0; n < encControl->nChannelsInternal; n++ ) {
289                         if( psEnc->state_Fxx[ n ].sCmn.LBRR_flags[ i ] ) {
290                             if( encControl->nChannelsInternal == 2 && n == 0 ) {
291                                 silk_stereo_encode_pred( psRangeEnc, psEnc->sStereo.predIx[ i ] );
292                                 /* For LBRR data there's no need to code the mid-only flag if the side-channel LBRR flag is set */
293                                 if( psEnc->state_Fxx[ 1 ].sCmn.LBRR_flags[ i ] == 0 ) {
294                                     silk_stereo_encode_mid_only( psRangeEnc, psEnc->sStereo.mid_only_flags[ i ] );
295                                 }
296                             }
297                             silk_encode_indices( &psEnc->state_Fxx[ n ].sCmn, psRangeEnc, i, 1 );
298                             silk_encode_pulses( psRangeEnc, psEnc->state_Fxx[ n ].sCmn.indices_LBRR[i].signalType, psEnc->state_Fxx[ n ].sCmn.indices_LBRR[i].quantOffsetType,
299                                 psEnc->state_Fxx[ n ].sCmn.pulses_LBRR[ i ], psEnc->state_Fxx[ n ].sCmn.frame_length );
300                         }
301                     }
302                 }
303
304                 /* Reset LBRR flags */
305                 for( n = 0; n < encControl->nChannelsInternal; n++ ) {
306                     silk_memset( psEnc->state_Fxx[ n ].sCmn.LBRR_flags, 0, sizeof( psEnc->state_Fxx[ n ].sCmn.LBRR_flags ) );
307                 }
308             }
309
310             silk_HP_variable_cutoff( psEnc->state_Fxx );
311
312             /* Total target bits for packet */
313             nBits = silk_DIV32_16( silk_MUL( encControl->bitRate, encControl->payloadSize_ms ), 1000 );
314             /* Subtract half of the bits already used */
315             if (!prefillFlag)
316                 nBits -= ec_tell( psRangeEnc ) >> 1;
317             /* Divide by number of uncoded frames left in packet */
318             nBits = silk_DIV32_16( nBits, psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket - psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded );
319             /* Convert to bits/second */
320             if( encControl->payloadSize_ms == 10 ) {
321                 TargetRate_bps = silk_SMULBB( nBits, 100 );
322             } else {
323                 TargetRate_bps = silk_SMULBB( nBits, 50 );
324             }
325             /* Subtract fraction of bits in excess of target in previous packets */
326             TargetRate_bps -= silk_DIV32_16( silk_MUL( psEnc->nBitsExceeded, 1000 ), BITRESERVOIR_DECAY_TIME_MS );
327             /* Never exceed input bitrate */
328             TargetRate_bps = silk_LIMIT( TargetRate_bps, encControl->bitRate, 5000 );
329
330             /* Convert Left/Right to Mid/Side */
331             if( encControl->nChannelsInternal == 2 ) {
332                 silk_stereo_LR_to_MS( &psEnc->sStereo, &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ 2 ], &psEnc->state_Fxx[ 1 ].sCmn.inputBuf[ 2 ],
333                     psEnc->sStereo.predIx[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ], &psEnc->sStereo.mid_only_flags[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ],
334                     MStargetRates_bps, TargetRate_bps, psEnc->state_Fxx[ 0 ].sCmn.speech_activity_Q8,
335                     psEnc->state_Fxx[ 0 ].sCmn.fs_kHz, psEnc->state_Fxx[ 0 ].sCmn.frame_length );
336                 if (!prefillFlag) {
337                     silk_stereo_encode_pred( psRangeEnc, psEnc->sStereo.predIx[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ] );
338                     silk_stereo_encode_mid_only( psRangeEnc, psEnc->sStereo.mid_only_flags[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ] );
339                 }
340             } else {
341                 /* Buffering */
342                 silk_memcpy( psEnc->state_Fxx[ 0 ].sCmn.inputBuf, psEnc->sStereo.sMid, 2 * sizeof( opus_int16 ) );
343                 silk_memcpy( psEnc->sStereo.sMid, &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.frame_length ], 2 * sizeof( opus_int16 ) );
344             }
345
346             /* Encode */
347             for( n = 0; n < encControl->nChannelsInternal; n++ ) {
348                 if( encControl->nChannelsInternal == 1 ) {
349                     channelRate_bps = TargetRate_bps;
350                 } else {
351                     channelRate_bps = MStargetRates_bps[ n ];
352                 }
353
354                 if( channelRate_bps > 0 ) {
355                     silk_control_SNR( &psEnc->state_Fxx[ n ].sCmn, channelRate_bps );
356
357                     if( ( ret = silk_encode_frame_Fxx( &psEnc->state_Fxx[ n ], nBytesOut, psRangeEnc ) ) != 0 ) {
358                         silk_assert( 0 );
359                     }
360                 }
361
362                 psEnc->state_Fxx[ n ].sCmn.controlled_since_last_payload = 0;
363                 psEnc->state_Fxx[ n ].sCmn.inputBufIx = 0;
364             }
365
366             /* Insert VAD and FEC flags at beginning of bitstream */
367             if( *nBytesOut > 0 ) {
368                 flags = 0;
369                 for( n = 0; n < encControl->nChannelsInternal; n++ ) {
370                     for( i = 0; i < psEnc->state_Fxx[ n ].sCmn.nFramesPerPacket; i++ ) {
371                         flags  = silk_LSHIFT( flags, 1 );
372                         flags |= psEnc->state_Fxx[ n ].sCmn.VAD_flags[ i ];
373                     }
374                     flags  = silk_LSHIFT( flags, 1 );
375                     flags |= psEnc->state_Fxx[ n ].sCmn.LBRR_flag;
376                 }
377                 if (!prefillFlag)
378                     ec_enc_patch_initial_bits( psRangeEnc, flags, ( psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket + 1 ) * encControl->nChannelsInternal );
379
380                 /* Return zero bytes if all channels DTXed */
381                 if( psEnc->state_Fxx[ 0 ].sCmn.inDTX && ( encControl->nChannelsInternal == 1 || psEnc->state_Fxx[ 1 ].sCmn.inDTX ) ) {
382                     *nBytesOut = 0;
383                 }
384
385                 psEnc->nBitsExceeded += *nBytesOut * 8;
386                 psEnc->nBitsExceeded -= silk_DIV32_16( silk_MUL( encControl->bitRate, encControl->payloadSize_ms ), 1000 );
387                 psEnc->nBitsExceeded  = silk_LIMIT( psEnc->nBitsExceeded, 0, 10000 );
388
389                 /* Update flag indicating if bandwidth switching is allowed */
390                 speech_act_thr_for_switch_Q8 = silk_SMLAWB( SILK_FIX_CONST( SPEECH_ACTIVITY_DTX_THRES, 8 ),
391                     SILK_FIX_CONST( ( 1 - SPEECH_ACTIVITY_DTX_THRES ) / MAX_BANDWIDTH_SWITCH_DELAY_MS, 16 + 8 ), psEnc->timeSinceSwitchAllowed_ms );
392                 if( psEnc->state_Fxx[ 0 ].sCmn.speech_activity_Q8 < speech_act_thr_for_switch_Q8 ) {
393                     psEnc->allowBandwidthSwitch = 1;
394                     psEnc->timeSinceSwitchAllowed_ms = 0;
395                 } else {
396                     psEnc->allowBandwidthSwitch = 0;
397                     psEnc->timeSinceSwitchAllowed_ms += encControl->payloadSize_ms;
398                 }
399             }
400
401             if( nSamplesIn == 0 ) {
402                 break;
403             }
404         } else {
405             break;
406         }
407     }
408
409     encControl->allowBandwidthSwitch = psEnc->allowBandwidthSwitch;
410     encControl->inWBmodeWithoutVariableLP = psEnc->state_Fxx[ 0 ].sCmn.fs_kHz == 16 && psEnc->state_Fxx[ 0 ].sCmn.sLP.mode == 0;
411     encControl->internalSampleRate = silk_SMULBB( psEnc->state_Fxx[ 0 ].sCmn.fs_kHz, 1000 );
412     encControl->stereoWidth_Q14 = psEnc->sStereo.width_prev_Q14;
413     if( prefillFlag ) {
414         encControl->payloadSize_ms = tmp_payloadSize_ms;
415         encControl->complexity = tmp_complexity;
416         for( n = 0; n < encControl->nChannelsInternal; n++ ) {
417             psEnc->state_Fxx[ n ].sCmn.controlled_since_last_payload = 0;
418             psEnc->state_Fxx[ n ].sCmn.prefillFlag = 0;
419         }
420     }
421
422     return ret;
423 }
424