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