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