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