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