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