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