Fixing silk fixed point
[opus.git] / silk / silk_enc_API.c
1 /***********************************************************************\r
2 Copyright (c) 2006-2011, Skype Limited. All rights reserved. \r
3 Redistribution and use in source and binary forms, with or without \r
4 modification, (subject to the limitations in the disclaimer below) \r
5 are permitted provided that the following conditions are met:\r
6 - Redistributions of source code must retain the above copyright notice,\r
7 this list of conditions and the following disclaimer.\r
8 - Redistributions in binary form must reproduce the above copyright \r
9 notice, this list of conditions and the following disclaimer in the \r
10 documentation and/or other materials provided with the distribution.\r
11 - Neither the name of Skype Limited, nor the names of specific \r
12 contributors, may be used to endorse or promote products derived from \r
13 this software without specific prior written permission.\r
14 NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED \r
15 BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND \r
16 CONTRIBUTORS ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,\r
17 BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND \r
18 FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE \r
19 COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, \r
20 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\r
21 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF \r
22 USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON \r
23 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \r
24 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE \r
25 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
26 ***********************************************************************/\r
27 \r
28 \r
29 #include "silk_define.h"\r
30 #include "silk_API.h"\r
31 #include "silk_control.h"\r
32 #include "silk_typedef.h"\r
33 #include "silk_structs.h"\r
34 #include "silk_tuning_parameters.h"\r
35 #ifdef FIXED_POINT\r
36 #include "silk_main_FIX.h"\r
37 #else\r
38 #include "silk_main_FLP.h"\r
39 #endif\r
40 \r
41 /****************************************/\r
42 /* Encoder functions                    */\r
43 /****************************************/\r
44 \r
45 SKP_int silk_Get_Encoder_Size( SKP_int32 *encSizeBytes )\r
46 {\r
47     SKP_int ret = SILK_NO_ERROR;\r
48     \r
49     *encSizeBytes = sizeof( silk_encoder );\r
50     \r
51     return ret;\r
52 }\r
53 \r
54 /*************************/\r
55 /* Init or Reset encoder */\r
56 /*************************/\r
57 SKP_int silk_InitEncoder(\r
58     void                            *encState,          /* I/O: State                                           */\r
59     silk_EncControlStruct               *encStatus          /* O:   Control structure                               */\r
60 )\r
61 {\r
62     silk_encoder *psEnc;\r
63     SKP_int n, ret = SILK_NO_ERROR;\r
64 \r
65     psEnc = (silk_encoder *)encState;\r
66     \r
67     /* Reset encoder */\r
68     SKP_memset( psEnc, 0, sizeof( silk_encoder ) );\r
69     for( n = 0; n < ENCODER_NUM_CHANNELS; n++ ) {\r
70         if( ret += silk_init_encoder( &psEnc->state_Fxx[ n ] ) ) {\r
71             SKP_assert( 0 );\r
72         }\r
73     }\r
74 \r
75     psEnc->nChannelsAPI = 1;\r
76     psEnc->nChannelsInternal = 1;\r
77 \r
78     /* Read control structure */\r
79     if( ret += silk_QueryEncoder( encState, encStatus ) ) {\r
80         SKP_assert( 0 );\r
81     }\r
82 \r
83     return ret;\r
84 }\r
85 \r
86 /***************************************/\r
87 /* Read control structure from encoder */\r
88 /***************************************/\r
89 SKP_int silk_QueryEncoder(\r
90     const void *encState,                       /* I:   State Vector                                    */\r
91     silk_EncControlStruct *encStatus            /* O:   Control Structure                               */\r
92 )\r
93 {\r
94     SKP_int ret = SILK_NO_ERROR;\r
95     silk_encoder_state_Fxx *state_Fxx;\r
96     silk_encoder *psEnc = (silk_encoder *)encState;\r
97 \r
98     state_Fxx = psEnc->state_Fxx;\r
99 \r
100     encStatus->nChannelsAPI              = psEnc->nChannelsAPI;\r
101     encStatus->nChannelsInternal         = psEnc->nChannelsInternal;\r
102     encStatus->API_sampleRate            = state_Fxx[ 0 ].sCmn.API_fs_Hz;\r
103     encStatus->maxInternalSampleRate     = state_Fxx[ 0 ].sCmn.maxInternal_fs_Hz;\r
104     encStatus->minInternalSampleRate     = state_Fxx[ 0 ].sCmn.minInternal_fs_Hz;\r
105     encStatus->desiredInternalSampleRate = state_Fxx[ 0 ].sCmn.desiredInternal_fs_Hz;\r
106     encStatus->payloadSize_ms            = state_Fxx[ 0 ].sCmn.PacketSize_ms;\r
107     encStatus->bitRate                   = state_Fxx[ 0 ].sCmn.TargetRate_bps;\r
108     encStatus->packetLossPercentage      = state_Fxx[ 0 ].sCmn.PacketLoss_perc;\r
109     encStatus->complexity                = state_Fxx[ 0 ].sCmn.Complexity;\r
110     encStatus->useInBandFEC              = state_Fxx[ 0 ].sCmn.useInBandFEC;\r
111     encStatus->useDTX                    = state_Fxx[ 0 ].sCmn.useDTX;\r
112     encStatus->useCBR                    = state_Fxx[ 0 ].sCmn.useCBR;\r
113     encStatus->internalSampleRate        = SKP_SMULBB( state_Fxx[ 0 ].sCmn.fs_kHz, 1000 );\r
114     encStatus->allowBandwidthSwitch      = state_Fxx[ 0 ].sCmn.allow_bandwidth_switch;\r
115     encStatus->inWBmodeWithoutVariableLP = state_Fxx[ 0 ].sCmn.fs_kHz == 16 && state_Fxx[ 0 ].sCmn.sLP.mode == 0;\r
116 \r
117     return ret;\r
118 }\r
119 \r
120 /**************************/\r
121 /* Encode frame with Silk */\r
122 /**************************/\r
123 SKP_int silk_Encode( \r
124     void                                *encState,      /* I/O: State                                           */\r
125     silk_EncControlStruct               *encControl,    /* I:   Control structure                               */\r
126     const SKP_int16                     *samplesIn,     /* I:   Speech sample input vector                      */\r
127     SKP_int                             nSamplesIn,     /* I:   Number of samples in input vector               */\r
128     ec_enc                              *psRangeEnc,    /* I/O  Compressor data structure                       */\r
129     SKP_int32                           *nBytesOut,     /* I/O: Number of bytes in payload (input: Max bytes)   */\r
130     const SKP_int                       prefillFlag     /* I:   Flag to indicate prefilling buffers; no coding  */\r
131 )\r
132 {\r
133     SKP_int   n, i, nBits, flags, tmp_payloadSize_ms = 0, tmp_complexity = 0, ret = 0;\r
134     SKP_int   nSamplesToBuffer, nBlocksOf10ms, nSamplesFromInput = 0;\r
135     SKP_int   speech_act_thr_for_switch_Q8;\r
136     SKP_int32 TargetRate_bps, MStargetRates_bps[ 2 ], channelRate_bps, LBRR_symbol;\r
137     silk_encoder *psEnc = ( silk_encoder * )encState;\r
138     SKP_int   MS_predictorIx[ 2 ] = { 0 };\r
139     SKP_int16 buf[ MAX_FRAME_LENGTH_MS * MAX_API_FS_KHZ ];\r
140 \r
141     /* Check values in encoder control structure */\r
142     if( ( ret = check_control_input( encControl ) != 0 ) ) {\r
143         SKP_assert( 0 );\r
144         return ret;\r
145     }\r
146 \r
147     if( encControl->nChannelsInternal > psEnc->nChannelsInternal ) {\r
148         /* Mono -> Stereo transition: init state of second channel and stereo state */\r
149         ret += silk_init_encoder( &psEnc->state_Fxx[ 1 ] );\r
150         SKP_memset( psEnc->sStereo.pred_prev_Q13, 0, sizeof( psEnc->sStereo.pred_prev_Q13 ) );\r
151         SKP_memset( psEnc->sStereo.sSide, 0, sizeof( psEnc->sStereo.sSide ) );\r
152         SKP_memset( psEnc->sStereo.mid_side_amp_Q0, 0, sizeof( psEnc->sStereo.mid_side_amp_Q0 ) );\r
153         psEnc->sStereo.width_prev_Q14 = 0;\r
154         psEnc->sStereo.smth_width_Q14 = SILK_FIX_CONST( 1, 14 );\r
155         if( psEnc->nChannelsAPI == 2 ) {\r
156             SKP_memcpy( &psEnc->state_Fxx[ 1 ].sCmn.resampler_state, &psEnc->state_Fxx[ 0 ].sCmn.resampler_state, sizeof( silk_resampler_state_struct ) );\r
157             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 ) );\r
158         }\r
159     }\r
160     psEnc->nChannelsAPI = encControl->nChannelsAPI;\r
161     psEnc->nChannelsInternal = encControl->nChannelsInternal;\r
162 \r
163     nBlocksOf10ms = SKP_DIV32( 100 * nSamplesIn, encControl->API_sampleRate );\r
164     if( prefillFlag ) {\r
165         /* Only accept input length of 10 ms */\r
166         if( nBlocksOf10ms != 1 ) {\r
167             ret = SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES;\r
168             SKP_assert( 0 );\r
169             return ret;\r
170         }\r
171         /* Reset Encoder */\r
172         for( n = 0; n < encControl->nChannelsInternal; n++ ) {\r
173             if( ret = silk_init_encoder( &psEnc->state_Fxx[ n ] ) ) {\r
174                 SKP_assert( 0 );\r
175             }\r
176         }\r
177         tmp_payloadSize_ms = encControl->payloadSize_ms;\r
178         encControl->payloadSize_ms = 10;\r
179         tmp_complexity = encControl->complexity;\r
180         encControl->complexity = 0;\r
181         for( n = 0; n < encControl->nChannelsInternal; n++ ) {\r
182             psEnc->state_Fxx[ n ].sCmn.controlled_since_last_payload = 0;\r
183             psEnc->state_Fxx[ n ].sCmn.prefillFlag = 1;\r
184         }\r
185     } else {\r
186         /* Only accept input lengths that are a multiple of 10 ms */\r
187         if( nBlocksOf10ms * encControl->API_sampleRate != 100 * nSamplesIn || nSamplesIn < 0 ) {\r
188             ret = SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES;\r
189             SKP_assert( 0 );\r
190             return ret;\r
191         }\r
192         /* Make sure no more than one packet can be produced */\r
193         if( 1000 * (SKP_int32)nSamplesIn > encControl->payloadSize_ms * encControl->API_sampleRate ) {\r
194             ret = SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES;\r
195             SKP_assert( 0 );\r
196             return ret;\r
197         }\r
198     }\r
199 \r
200     TargetRate_bps = SKP_RSHIFT32( encControl->bitRate, encControl->nChannelsInternal - 1 );\r
201     for( n = 0; n < encControl->nChannelsInternal; n++ ) {\r
202         if( ( ret = silk_control_encoder( &psEnc->state_Fxx[ n ], encControl, TargetRate_bps, psEnc->allowBandwidthSwitch, n ) ) != 0 ) {\r
203             SKP_assert( 0 );\r
204             return ret;\r
205         }\r
206     }\r
207     SKP_assert( encControl->nChannelsInternal == 1 || psEnc->state_Fxx[ 0 ].sCmn.fs_kHz == psEnc->state_Fxx[ 1 ].sCmn.fs_kHz );\r
208 \r
209     /* Input buffering/resampling and encoding */\r
210     while( 1 ) {\r
211         nSamplesToBuffer  = psEnc->state_Fxx[ 0 ].sCmn.frame_length - psEnc->state_Fxx[ 0 ].sCmn.inputBufIx;\r
212         nSamplesToBuffer  = SKP_min( nSamplesToBuffer, 10 * nBlocksOf10ms * psEnc->state_Fxx[ 0 ].sCmn.fs_kHz );\r
213         nSamplesFromInput = SKP_DIV32_16( nSamplesToBuffer * psEnc->state_Fxx[ 0 ].sCmn.API_fs_Hz, psEnc->state_Fxx[ 0 ].sCmn.fs_kHz * 1000 );\r
214         /* Resample and write to buffer */\r
215         if( encControl->nChannelsAPI == 2 && encControl->nChannelsInternal == 2 ) {\r
216             for( n = 0; n < nSamplesFromInput; n++ ) {\r
217                 buf[ n ] = samplesIn[ 2 * n ];\r
218             }\r
219             ret += silk_resampler( &psEnc->state_Fxx[ 0 ].sCmn.resampler_state, \r
220                 &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.inputBufIx ], buf, nSamplesFromInput );\r
221             psEnc->state_Fxx[ 0 ].sCmn.inputBufIx += nSamplesToBuffer;\r
222 \r
223             nSamplesToBuffer  = psEnc->state_Fxx[ 1 ].sCmn.frame_length - psEnc->state_Fxx[ 1 ].sCmn.inputBufIx;\r
224             nSamplesToBuffer  = SKP_min( nSamplesToBuffer, 10 * nBlocksOf10ms * psEnc->state_Fxx[ 1 ].sCmn.fs_kHz );\r
225             for( n = 0; n < nSamplesFromInput; n++ ) {\r
226                 buf[ n ] = samplesIn[ 2 * n + 1 ];\r
227             }\r
228             ret += silk_resampler( &psEnc->state_Fxx[ 1 ].sCmn.resampler_state, \r
229                 &psEnc->state_Fxx[ 1 ].sCmn.inputBuf[ psEnc->state_Fxx[ 1 ].sCmn.inputBufIx ], buf, nSamplesFromInput );\r
230             psEnc->state_Fxx[ 1 ].sCmn.inputBufIx += nSamplesToBuffer;\r
231         } else if( encControl->nChannelsAPI == 2 && encControl->nChannelsInternal == 1 ) {\r
232             /* Combine left and right channels before resampling */\r
233             for( n = 0; n < nSamplesFromInput; n++ ) {\r
234                 buf[ n ] = (SKP_int16)SKP_RSHIFT_ROUND( samplesIn[ 2 * n ] + samplesIn[ 2 * n + 1 ],  1 );\r
235             }\r
236             ret += silk_resampler( &psEnc->state_Fxx[ 0 ].sCmn.resampler_state, \r
237                 &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.inputBufIx ], buf, nSamplesFromInput );\r
238             psEnc->state_Fxx[ 0 ].sCmn.inputBufIx += nSamplesToBuffer;\r
239         } else {\r
240             SKP_assert( encControl->nChannelsAPI == 1 && encControl->nChannelsInternal == 1 );\r
241             ret += silk_resampler( &psEnc->state_Fxx[ 0 ].sCmn.resampler_state, \r
242                 &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.inputBufIx ], samplesIn, nSamplesFromInput );\r
243             psEnc->state_Fxx[ 0 ].sCmn.inputBufIx += nSamplesToBuffer;\r
244         }\r
245         samplesIn  += nSamplesFromInput * encControl->nChannelsAPI;\r
246         nSamplesIn -= nSamplesFromInput;\r
247 \r
248         /* Default */\r
249         psEnc->allowBandwidthSwitch = 0;\r
250 \r
251         /* Silk encoder */\r
252         if( psEnc->state_Fxx[ 0 ].sCmn.inputBufIx >= psEnc->state_Fxx[ 0 ].sCmn.frame_length ) {\r
253             /* Enough data in input buffer, so encode */\r
254             SKP_assert( psEnc->state_Fxx[ 0 ].sCmn.inputBufIx == psEnc->state_Fxx[ 0 ].sCmn.frame_length );\r
255             SKP_assert( encControl->nChannelsInternal == 1 || psEnc->state_Fxx[ 1 ].sCmn.inputBufIx == psEnc->state_Fxx[ 1 ].sCmn.frame_length );\r
256 \r
257             /* Deal with LBRR data */\r
258             if( psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded == 0 && !prefillFlag ) {\r
259                 /* Create space at start of payload for VAD and FEC flags */\r
260                 SKP_uint8 iCDF[ 2 ] = { 0, 0 };\r
261                 iCDF[ 0 ] = 256 - SKP_RSHIFT( 256, ( psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket + 1 ) * encControl->nChannelsInternal );\r
262                 ec_enc_icdf( psRangeEnc, 0, iCDF, 8 );\r
263 \r
264                 /* Encode any LBRR data from previous packet */\r
265                 /* Encode LBRR flags */\r
266                 for( n = 0; n < encControl->nChannelsInternal; n++ ) {\r
267                     LBRR_symbol = 0;\r
268                     for( i = 0; i < psEnc->state_Fxx[ n ].sCmn.nFramesPerPacket; i++ ) {\r
269                         LBRR_symbol |= SKP_LSHIFT( psEnc->state_Fxx[ n ].sCmn.LBRR_flags[ i ], i );\r
270                     }\r
271                     psEnc->state_Fxx[ n ].sCmn.LBRR_flag = LBRR_symbol > 0 ? 1 : 0;\r
272                     if( LBRR_symbol && psEnc->state_Fxx[ n ].sCmn.nFramesPerPacket > 1 ) {\r
273                         ec_enc_icdf( psRangeEnc, LBRR_symbol - 1, silk_LBRR_flags_iCDF_ptr[ psEnc->state_Fxx[ n ].sCmn.nFramesPerPacket - 2 ], 8 );\r
274                     }\r
275                 }\r
276 \r
277                 /* Code LBRR indices and excitation signals */\r
278                 for( i = 0; i < psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket; i++ ) {\r
279                     for( n = 0; n < encControl->nChannelsInternal; n++ ) {                \r
280                         if( psEnc->state_Fxx[ n ].sCmn.LBRR_flags[ i ] ) {\r
281                             if( encControl->nChannelsInternal == 2 && n == 0 ) {\r
282                                 silk_stereo_encode_pred( psRangeEnc, psEnc->sStereo.ix[ i ] );\r
283                             }\r
284                             silk_encode_indices( &psEnc->state_Fxx[ n ].sCmn, psRangeEnc, i, 1 );\r
285                             silk_encode_pulses( psRangeEnc, psEnc->state_Fxx[ n ].sCmn.indices_LBRR[i].signalType, psEnc->state_Fxx[ n ].sCmn.indices_LBRR[i].quantOffsetType, \r
286                                 psEnc->state_Fxx[ n ].sCmn.pulses_LBRR[ i ], psEnc->state_Fxx[ n ].sCmn.frame_length );\r
287                         }\r
288                     }\r
289                 }\r
290 \r
291                 /* Reset LBRR flags */\r
292                 for( n = 0; n < encControl->nChannelsInternal; n++ ) {                \r
293                     SKP_memset( psEnc->state_Fxx[ n ].sCmn.LBRR_flags, 0, sizeof( psEnc->state_Fxx[ n ].sCmn.LBRR_flags ) );\r
294                 }\r
295             }\r
296 \r
297             /* High-pass filter */\r
298             silk_HP_variable_cutoff( psEnc->state_Fxx, psEnc->nChannelsInternal );\r
299 \r
300             /* Total target bits for packet */\r
301             nBits = SKP_DIV32_16( SKP_MUL( encControl->bitRate, encControl->payloadSize_ms ), 1000 );\r
302             /* Subtract half of the bits already used */\r
303             nBits -= ec_tell( psRangeEnc ) >> 1;\r
304             /* Divide by number of uncoded frames left in packet */\r
305             nBits = SKP_DIV32_16( nBits, psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket - psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded );\r
306             /* Convert to bits/second */\r
307             if( encControl->payloadSize_ms == 10 ) {\r
308                 TargetRate_bps = SKP_SMULBB( nBits, 100 );\r
309             } else {\r
310                 TargetRate_bps = SKP_SMULBB( nBits, 50 );\r
311             }\r
312             /* Subtract fraction of bits in excess of target in previous packets */\r
313             TargetRate_bps -= SKP_DIV32_16( SKP_MUL( psEnc->nBitsExceeded, 1000 ), BITRESERVOIR_DECAY_TIME_MS );\r
314             /* Never exceed input bitrate */\r
315             TargetRate_bps = SKP_LIMIT( TargetRate_bps, encControl->bitRate, 5000 );\r
316 \r
317             /* Convert Left/Right to Mid/Side */\r
318             if( encControl->nChannelsInternal == 2 ) {\r
319                 silk_stereo_LR_to_MS( &psEnc->sStereo, psEnc->state_Fxx[ 0 ].sCmn.inputBuf, psEnc->state_Fxx[ 1 ].sCmn.inputBuf, \r
320                     psEnc->sStereo.ix[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ], MStargetRates_bps, TargetRate_bps, \r
321                     psEnc->state_Fxx[ 0 ].sCmn.speech_activity_Q8, psEnc->state_Fxx[ 0 ].sCmn.fs_kHz, psEnc->state_Fxx[ 0 ].sCmn.frame_length );\r
322                 silk_stereo_encode_pred( psRangeEnc, psEnc->sStereo.ix[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ] );\r
323             } else {\r
324                 /* Buffering */\r
325                 SKP_memcpy( &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ -2 ], psEnc->sStereo.sMid, 2 * sizeof( SKP_int16 ) );\r
326                 SKP_memcpy( psEnc->sStereo.sMid, &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.frame_length - 2 ], 2 * sizeof( SKP_int16 ) );\r
327             }\r
328 \r
329             /* Encode */\r
330             for( n = 0; n < encControl->nChannelsInternal; n++ ) {\r
331                 if( encControl->nChannelsInternal == 1 ) {\r
332                     channelRate_bps = TargetRate_bps;\r
333                 } else {\r
334                     channelRate_bps = MStargetRates_bps[ n ];\r
335                 }\r
336 \r
337                 if( channelRate_bps > 0 ) {\r
338                     silk_control_SNR( &psEnc->state_Fxx[ n ].sCmn, channelRate_bps );\r
339 \r
340                     if( ( ret = silk_encode_frame_Fxx( &psEnc->state_Fxx[ n ], nBytesOut, psRangeEnc ) ) != 0 ) {\r
341                         SKP_assert( 0 );\r
342                     }\r
343                 }\r
344 \r
345                 psEnc->state_Fxx[ n ].sCmn.controlled_since_last_payload = 0;\r
346                 psEnc->state_Fxx[ n ].sCmn.inputBufIx = 0;\r
347             }\r
348 \r
349             /* Insert VAD and FEC flags at beginning of bitstream */\r
350             if( *nBytesOut > 0 ) {\r
351                 flags = 0;\r
352                 for( n = 0; n < encControl->nChannelsInternal; n++ ) {\r
353                     for( i = 0; i < psEnc->state_Fxx[ n ].sCmn.nFramesPerPacket; i++ ) {\r
354                         flags  = SKP_LSHIFT( flags, 1 );\r
355                         flags |= psEnc->state_Fxx[ n ].sCmn.VAD_flags[ i ];\r
356                     }\r
357                     flags  = SKP_LSHIFT( flags, 1 );\r
358                     flags |= psEnc->state_Fxx[ n ].sCmn.LBRR_flag;\r
359                 }\r
360                 ec_enc_patch_initial_bits( psRangeEnc, flags, ( psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket + 1 ) * encControl->nChannelsInternal );\r
361 \r
362                 /* Return zero bytes if all channels DTXed */\r
363                 if( psEnc->state_Fxx[ 0 ].sCmn.inDTX && ( encControl->nChannelsInternal == 1 || psEnc->state_Fxx[ 1 ].sCmn.inDTX ) ) {\r
364                     *nBytesOut = 0;\r
365                 }\r
366 \r
367                 psEnc->nBitsExceeded += *nBytesOut * 8;\r
368                 psEnc->nBitsExceeded -= SKP_DIV32_16( SKP_MUL( encControl->bitRate, encControl->payloadSize_ms ), 1000 );\r
369                 psEnc->nBitsExceeded  = SKP_LIMIT( psEnc->nBitsExceeded, 0, 10000 );\r
370 \r
371                 /* Update flag indicating if bandwidth switching is allowed */\r
372                 speech_act_thr_for_switch_Q8 = SKP_SMLAWB( SILK_FIX_CONST( SPEECH_ACTIVITY_DTX_THRES, 8 ), \r
373                     SILK_FIX_CONST( ( 1 - SPEECH_ACTIVITY_DTX_THRES ) / MAX_BANDWIDTH_SWITCH_DELAY_MS, 16 + 8 ), psEnc->timeSinceSwitchAllowed_ms );\r
374                 if( psEnc->state_Fxx[ 0 ].sCmn.speech_activity_Q8 < speech_act_thr_for_switch_Q8 ) {\r
375                     psEnc->allowBandwidthSwitch = 1;\r
376                     psEnc->timeSinceSwitchAllowed_ms = 0;\r
377                 } else {\r
378                     psEnc->allowBandwidthSwitch = 0;\r
379                     psEnc->timeSinceSwitchAllowed_ms += encControl->payloadSize_ms;\r
380                 }\r
381             }\r
382 \r
383             if( nSamplesIn == 0 ) {\r
384                 break;\r
385             }\r
386         } else {\r
387             break;\r
388         }\r
389     }\r
390 \r
391     encControl->allowBandwidthSwitch = psEnc->allowBandwidthSwitch;\r
392     encControl->inWBmodeWithoutVariableLP = psEnc->state_Fxx[ 0 ].sCmn.fs_kHz == 16 && psEnc->state_Fxx[ 0 ].sCmn.sLP.mode == 0;\r
393     encControl->internalSampleRate = SKP_SMULBB( psEnc->state_Fxx[ 0 ].sCmn.fs_kHz, 1000 );\r
394     encControl->stereoWidth_Q14 = psEnc->sStereo.width_prev_Q14;\r
395     if( prefillFlag ) {\r
396         encControl->payloadSize_ms = tmp_payloadSize_ms;\r
397         encControl->complexity = tmp_complexity;\r
398         for( n = 0; n < encControl->nChannelsInternal; n++ ) {\r
399             psEnc->state_Fxx[ n ].sCmn.controlled_since_last_payload = 0;\r
400             psEnc->state_Fxx[ n ].sCmn.prefillFlag = 0;\r
401         }\r
402     }\r
403 \r
404     return ret;\r
405 }\r
406 \r