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