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