Quality: Increase CELT rate for voiced frames in hybrid mode
[opus.git] / silk / enc_API.c
1 /***********************************************************************
2 Copyright (c) 2006-2011, Skype Limited. All rights reserved.
3 Redistribution and use in source and binary forms, with or without
4 modification, are permitted provided that the following conditions
5 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 Internet Society, IETF or IETF Trust, nor the
12 names of specific contributors, may be used to endorse or promote
13 products derived from this software without specific prior written
14 permission.
15 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
16 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
19 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
20 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
21 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
24 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
25 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 "stack_alloc.h"
36 #include "structs.h"
37 #include "tuning_parameters.h"
38 #ifdef FIXED_POINT
39 #include "main_FIX.h"
40 #else
41 #include "main_FLP.h"
42 #endif
43
44 /***************************************/
45 /* Read control structure from encoder */
46 /***************************************/
47 static opus_int silk_QueryEncoder(                      /* O    Returns error code                              */
48     const void                      *encState,          /* I    State                                           */
49     silk_EncControlStruct           *encStatus          /* O    Encoder Status                                  */
50 );
51
52 /****************************************/
53 /* Encoder functions                    */
54 /****************************************/
55
56 opus_int silk_Get_Encoder_Size(                         /* O    Returns error code                              */
57     opus_int                        *encSizeBytes       /* O    Number of bytes in SILK encoder state           */
58 )
59 {
60     opus_int ret = SILK_NO_ERROR;
61
62     *encSizeBytes = sizeof( silk_encoder );
63
64     return ret;
65 }
66
67 /*************************/
68 /* Init or Reset encoder */
69 /*************************/
70 opus_int silk_InitEncoder(                              /* O    Returns error code                              */
71     void                            *encState,          /* I/O  State                                           */
72     int                              arch,              /* I    Run-time architecture                           */
73     silk_EncControlStruct           *encStatus          /* O    Encoder Status                                  */
74 )
75 {
76     silk_encoder *psEnc;
77     opus_int n, ret = SILK_NO_ERROR;
78
79     psEnc = (silk_encoder *)encState;
80
81     /* Reset encoder */
82     silk_memset( psEnc, 0, sizeof( silk_encoder ) );
83     for( n = 0; n < ENCODER_NUM_CHANNELS; n++ ) {
84         if( ret += silk_init_encoder( &psEnc->state_Fxx[ n ], arch ) ) {
85             silk_assert( 0 );
86         }
87     }
88
89     psEnc->nChannelsAPI = 1;
90     psEnc->nChannelsInternal = 1;
91
92     /* Read control structure */
93     if( ret += silk_QueryEncoder( encState, encStatus ) ) {
94         silk_assert( 0 );
95     }
96
97     return ret;
98 }
99
100 /***************************************/
101 /* Read control structure from encoder */
102 /***************************************/
103 static opus_int silk_QueryEncoder(                      /* O    Returns error code                              */
104     const void                      *encState,          /* I    State                                           */
105     silk_EncControlStruct           *encStatus          /* O    Encoder Status                                  */
106 )
107 {
108     opus_int ret = SILK_NO_ERROR;
109     silk_encoder_state_Fxx *state_Fxx;
110     silk_encoder *psEnc = (silk_encoder *)encState;
111
112     state_Fxx = psEnc->state_Fxx;
113
114     encStatus->nChannelsAPI              = psEnc->nChannelsAPI;
115     encStatus->nChannelsInternal         = psEnc->nChannelsInternal;
116     encStatus->API_sampleRate            = state_Fxx[ 0 ].sCmn.API_fs_Hz;
117     encStatus->maxInternalSampleRate     = state_Fxx[ 0 ].sCmn.maxInternal_fs_Hz;
118     encStatus->minInternalSampleRate     = state_Fxx[ 0 ].sCmn.minInternal_fs_Hz;
119     encStatus->desiredInternalSampleRate = state_Fxx[ 0 ].sCmn.desiredInternal_fs_Hz;
120     encStatus->payloadSize_ms            = state_Fxx[ 0 ].sCmn.PacketSize_ms;
121     encStatus->bitRate                   = state_Fxx[ 0 ].sCmn.TargetRate_bps;
122     encStatus->packetLossPercentage      = state_Fxx[ 0 ].sCmn.PacketLoss_perc;
123     encStatus->complexity                = state_Fxx[ 0 ].sCmn.Complexity;
124     encStatus->useInBandFEC              = state_Fxx[ 0 ].sCmn.useInBandFEC;
125     encStatus->useDTX                    = state_Fxx[ 0 ].sCmn.useDTX;
126     encStatus->useCBR                    = state_Fxx[ 0 ].sCmn.useCBR;
127     encStatus->internalSampleRate        = silk_SMULBB( state_Fxx[ 0 ].sCmn.fs_kHz, 1000 );
128     encStatus->allowBandwidthSwitch      = state_Fxx[ 0 ].sCmn.allow_bandwidth_switch;
129     encStatus->inWBmodeWithoutVariableLP = state_Fxx[ 0 ].sCmn.fs_kHz == 16 && state_Fxx[ 0 ].sCmn.sLP.mode == 0;
130
131     return ret;
132 }
133
134
135 /**************************/
136 /* Encode frame with Silk */
137 /**************************/
138 /* Note: if prefillFlag is set, the input must contain 10 ms of audio, irrespective of what                     */
139 /* encControl->payloadSize_ms is set to                                                                         */
140 opus_int silk_Encode(                                   /* O    Returns error code                              */
141     void                            *encState,          /* I/O  State                                           */
142     silk_EncControlStruct           *encControl,        /* I    Control status                                  */
143     const opus_int16                *samplesIn,         /* I    Speech sample input vector                      */
144     opus_int                        nSamplesIn,         /* I    Number of samples in input vector               */
145     ec_enc                          *psRangeEnc,        /* I/O  Compressor data structure                       */
146     opus_int32                      *nBytesOut,         /* I/O  Number of bytes in payload (input: Max bytes)   */
147     const opus_int                  prefillFlag         /* I    Flag to indicate prefilling buffers no coding   */
148 )
149 {
150     opus_int   n, i, nBits, flags, tmp_payloadSize_ms = 0, tmp_complexity = 0, ret = 0;
151     opus_int   nSamplesToBuffer, nSamplesToBufferMax, nBlocksOf10ms;
152     opus_int   nSamplesFromInput = 0, nSamplesFromInputMax;
153     opus_int   speech_act_thr_for_switch_Q8;
154     opus_int32 TargetRate_bps, MStargetRates_bps[ 2 ], channelRate_bps, LBRR_symbol, sum;
155     silk_encoder *psEnc = ( silk_encoder * )encState;
156     VARDECL( opus_int16, buf );
157     opus_int transition, curr_block, tot_blocks;
158     SAVE_STACK;
159
160     if (encControl->reducedDependency)
161     {
162        psEnc->state_Fxx[0].sCmn.first_frame_after_reset = 1;
163        psEnc->state_Fxx[1].sCmn.first_frame_after_reset = 1;
164     }
165     psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded = psEnc->state_Fxx[ 1 ].sCmn.nFramesEncoded = 0;
166
167     /* Check values in encoder control structure */
168     if( ( ret = check_control_input( encControl ) ) != 0 ) {
169         silk_assert( 0 );
170         RESTORE_STACK;
171         return ret;
172     }
173
174     encControl->switchReady = 0;
175
176     if( encControl->nChannelsInternal > psEnc->nChannelsInternal ) {
177         /* Mono -> Stereo transition: init state of second channel and stereo state */
178         ret += silk_init_encoder( &psEnc->state_Fxx[ 1 ], psEnc->state_Fxx[ 0 ].sCmn.arch );
179         silk_memset( psEnc->sStereo.pred_prev_Q13, 0, sizeof( psEnc->sStereo.pred_prev_Q13 ) );
180         silk_memset( psEnc->sStereo.sSide, 0, sizeof( psEnc->sStereo.sSide ) );
181         psEnc->sStereo.mid_side_amp_Q0[ 0 ] = 0;
182         psEnc->sStereo.mid_side_amp_Q0[ 1 ] = 1;
183         psEnc->sStereo.mid_side_amp_Q0[ 2 ] = 0;
184         psEnc->sStereo.mid_side_amp_Q0[ 3 ] = 1;
185         psEnc->sStereo.width_prev_Q14 = 0;
186         psEnc->sStereo.smth_width_Q14 = SILK_FIX_CONST( 1, 14 );
187         if( psEnc->nChannelsAPI == 2 ) {
188             silk_memcpy( &psEnc->state_Fxx[ 1 ].sCmn.resampler_state, &psEnc->state_Fxx[ 0 ].sCmn.resampler_state, sizeof( silk_resampler_state_struct ) );
189             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 ) );
190         }
191     }
192
193     transition = (encControl->payloadSize_ms != psEnc->state_Fxx[ 0 ].sCmn.PacketSize_ms) || (psEnc->nChannelsInternal != encControl->nChannelsInternal);
194
195     psEnc->nChannelsAPI = encControl->nChannelsAPI;
196     psEnc->nChannelsInternal = encControl->nChannelsInternal;
197
198     nBlocksOf10ms = silk_DIV32( 100 * nSamplesIn, encControl->API_sampleRate );
199     tot_blocks = ( nBlocksOf10ms > 1 ) ? nBlocksOf10ms >> 1 : 1;
200     curr_block = 0;
201     if( prefillFlag ) {
202         /* Only accept input length of 10 ms */
203         if( nBlocksOf10ms != 1 ) {
204             silk_assert( 0 );
205             RESTORE_STACK;
206             return SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES;
207         }
208         /* Reset Encoder */
209         for( n = 0; n < encControl->nChannelsInternal; n++ ) {
210             ret = silk_init_encoder( &psEnc->state_Fxx[ n ], psEnc->state_Fxx[ n ].sCmn.arch );
211             silk_assert( !ret );
212         }
213         tmp_payloadSize_ms = encControl->payloadSize_ms;
214         encControl->payloadSize_ms = 10;
215         tmp_complexity = encControl->complexity;
216         encControl->complexity = 0;
217         for( n = 0; n < encControl->nChannelsInternal; n++ ) {
218             psEnc->state_Fxx[ n ].sCmn.controlled_since_last_payload = 0;
219             psEnc->state_Fxx[ n ].sCmn.prefillFlag = 1;
220         }
221     } else {
222         /* Only accept input lengths that are a multiple of 10 ms */
223         if( nBlocksOf10ms * encControl->API_sampleRate != 100 * nSamplesIn || nSamplesIn < 0 ) {
224             silk_assert( 0 );
225             RESTORE_STACK;
226             return SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES;
227         }
228         /* Make sure no more than one packet can be produced */
229         if( 1000 * (opus_int32)nSamplesIn > encControl->payloadSize_ms * encControl->API_sampleRate ) {
230             silk_assert( 0 );
231             RESTORE_STACK;
232             return SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES;
233         }
234     }
235
236     TargetRate_bps = silk_RSHIFT32( encControl->bitRate, encControl->nChannelsInternal - 1 );
237     for( n = 0; n < encControl->nChannelsInternal; n++ ) {
238         /* Force the side channel to the same rate as the mid */
239         opus_int force_fs_kHz = (n==1) ? psEnc->state_Fxx[0].sCmn.fs_kHz : 0;
240         if( ( ret = silk_control_encoder( &psEnc->state_Fxx[ n ], encControl, TargetRate_bps, psEnc->allowBandwidthSwitch, n, force_fs_kHz ) ) != 0 ) {
241             silk_assert( 0 );
242             RESTORE_STACK;
243             return ret;
244         }
245         if( psEnc->state_Fxx[n].sCmn.first_frame_after_reset || transition ) {
246             for( i = 0; i < psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket; i++ ) {
247                 psEnc->state_Fxx[ n ].sCmn.LBRR_flags[ i ] = 0;
248             }
249         }
250         psEnc->state_Fxx[ n ].sCmn.inDTX = psEnc->state_Fxx[ n ].sCmn.useDTX;
251     }
252     silk_assert( encControl->nChannelsInternal == 1 || psEnc->state_Fxx[ 0 ].sCmn.fs_kHz == psEnc->state_Fxx[ 1 ].sCmn.fs_kHz );
253
254     /* Input buffering/resampling and encoding */
255     nSamplesToBufferMax =
256         10 * nBlocksOf10ms * psEnc->state_Fxx[ 0 ].sCmn.fs_kHz;
257     nSamplesFromInputMax =
258         silk_DIV32_16( nSamplesToBufferMax *
259                            psEnc->state_Fxx[ 0 ].sCmn.API_fs_Hz,
260                        psEnc->state_Fxx[ 0 ].sCmn.fs_kHz * 1000 );
261     ALLOC( buf, nSamplesFromInputMax, opus_int16 );
262     while( 1 ) {
263         nSamplesToBuffer  = psEnc->state_Fxx[ 0 ].sCmn.frame_length - psEnc->state_Fxx[ 0 ].sCmn.inputBufIx;
264         nSamplesToBuffer  = silk_min( nSamplesToBuffer, nSamplesToBufferMax );
265         nSamplesFromInput = silk_DIV32_16( nSamplesToBuffer * psEnc->state_Fxx[ 0 ].sCmn.API_fs_Hz, psEnc->state_Fxx[ 0 ].sCmn.fs_kHz * 1000 );
266         /* Resample and write to buffer */
267         if( encControl->nChannelsAPI == 2 && encControl->nChannelsInternal == 2 ) {
268             opus_int id = psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded;
269             for( n = 0; n < nSamplesFromInput; n++ ) {
270                 buf[ n ] = samplesIn[ 2 * n ];
271             }
272             /* Making sure to start both resamplers from the same state when switching from mono to stereo */
273             if( psEnc->nPrevChannelsInternal == 1 && id==0 ) {
274                silk_memcpy( &psEnc->state_Fxx[ 1 ].sCmn.resampler_state, &psEnc->state_Fxx[ 0 ].sCmn.resampler_state, sizeof(psEnc->state_Fxx[ 1 ].sCmn.resampler_state));
275             }
276
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             psEnc->state_Fxx[ 0 ].sCmn.inputBufIx += nSamplesToBuffer;
280
281             nSamplesToBuffer  = psEnc->state_Fxx[ 1 ].sCmn.frame_length - psEnc->state_Fxx[ 1 ].sCmn.inputBufIx;
282             nSamplesToBuffer  = silk_min( nSamplesToBuffer, 10 * nBlocksOf10ms * psEnc->state_Fxx[ 1 ].sCmn.fs_kHz );
283             for( n = 0; n < nSamplesFromInput; n++ ) {
284                 buf[ n ] = samplesIn[ 2 * n + 1 ];
285             }
286             ret += silk_resampler( &psEnc->state_Fxx[ 1 ].sCmn.resampler_state,
287                 &psEnc->state_Fxx[ 1 ].sCmn.inputBuf[ psEnc->state_Fxx[ 1 ].sCmn.inputBufIx + 2 ], buf, nSamplesFromInput );
288
289             psEnc->state_Fxx[ 1 ].sCmn.inputBufIx += nSamplesToBuffer;
290         } else if( encControl->nChannelsAPI == 2 && encControl->nChannelsInternal == 1 ) {
291             /* Combine left and right channels before resampling */
292             for( n = 0; n < nSamplesFromInput; n++ ) {
293                 sum = samplesIn[ 2 * n ] + samplesIn[ 2 * n + 1 ];
294                 buf[ n ] = (opus_int16)silk_RSHIFT_ROUND( sum,  1 );
295             }
296             ret += silk_resampler( &psEnc->state_Fxx[ 0 ].sCmn.resampler_state,
297                 &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.inputBufIx + 2 ], buf, nSamplesFromInput );
298             /* On the first mono frame, average the results for the two resampler states  */
299             if( psEnc->nPrevChannelsInternal == 2 && psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded == 0 ) {
300                ret += silk_resampler( &psEnc->state_Fxx[ 1 ].sCmn.resampler_state,
301                    &psEnc->state_Fxx[ 1 ].sCmn.inputBuf[ psEnc->state_Fxx[ 1 ].sCmn.inputBufIx + 2 ], buf, nSamplesFromInput );
302                for( n = 0; n < psEnc->state_Fxx[ 0 ].sCmn.frame_length; n++ ) {
303                   psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.inputBufIx+n+2 ] =
304                         silk_RSHIFT(psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.inputBufIx+n+2 ]
305                                   + psEnc->state_Fxx[ 1 ].sCmn.inputBuf[ psEnc->state_Fxx[ 1 ].sCmn.inputBufIx+n+2 ], 1);
306                }
307             }
308             psEnc->state_Fxx[ 0 ].sCmn.inputBufIx += nSamplesToBuffer;
309         } else {
310             silk_assert( encControl->nChannelsAPI == 1 && encControl->nChannelsInternal == 1 );
311             silk_memcpy(buf, samplesIn, nSamplesFromInput*sizeof(opus_int16));
312             ret += silk_resampler( &psEnc->state_Fxx[ 0 ].sCmn.resampler_state,
313                 &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.inputBufIx + 2 ], buf, nSamplesFromInput );
314             psEnc->state_Fxx[ 0 ].sCmn.inputBufIx += nSamplesToBuffer;
315         }
316
317         samplesIn  += nSamplesFromInput * encControl->nChannelsAPI;
318         nSamplesIn -= nSamplesFromInput;
319
320         /* Default */
321         psEnc->allowBandwidthSwitch = 0;
322
323         /* Silk encoder */
324         if( psEnc->state_Fxx[ 0 ].sCmn.inputBufIx >= psEnc->state_Fxx[ 0 ].sCmn.frame_length ) {
325             /* Enough data in input buffer, so encode */
326             silk_assert( psEnc->state_Fxx[ 0 ].sCmn.inputBufIx == psEnc->state_Fxx[ 0 ].sCmn.frame_length );
327             silk_assert( encControl->nChannelsInternal == 1 || psEnc->state_Fxx[ 1 ].sCmn.inputBufIx == psEnc->state_Fxx[ 1 ].sCmn.frame_length );
328
329             /* Deal with LBRR data */
330             if( psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded == 0 && !prefillFlag ) {
331                 /* Create space at start of payload for VAD and FEC flags */
332                 opus_uint8 iCDF[ 2 ] = { 0, 0 };
333                 iCDF[ 0 ] = 256 - silk_RSHIFT( 256, ( psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket + 1 ) * encControl->nChannelsInternal );
334                 ec_enc_icdf( psRangeEnc, 0, iCDF, 8 );
335
336                 /* Encode any LBRR data from previous packet */
337                 /* Encode LBRR flags */
338                 for( n = 0; n < encControl->nChannelsInternal; n++ ) {
339                     LBRR_symbol = 0;
340                     for( i = 0; i < psEnc->state_Fxx[ n ].sCmn.nFramesPerPacket; i++ ) {
341                         LBRR_symbol |= silk_LSHIFT( psEnc->state_Fxx[ n ].sCmn.LBRR_flags[ i ], i );
342                     }
343                     psEnc->state_Fxx[ n ].sCmn.LBRR_flag = LBRR_symbol > 0 ? 1 : 0;
344                     if( LBRR_symbol && psEnc->state_Fxx[ n ].sCmn.nFramesPerPacket > 1 ) {
345                         ec_enc_icdf( psRangeEnc, LBRR_symbol - 1, silk_LBRR_flags_iCDF_ptr[ psEnc->state_Fxx[ n ].sCmn.nFramesPerPacket - 2 ], 8 );
346                     }
347                 }
348
349                 /* Code LBRR indices and excitation signals */
350                 for( i = 0; i < psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket; i++ ) {
351                     for( n = 0; n < encControl->nChannelsInternal; n++ ) {
352                         if( psEnc->state_Fxx[ n ].sCmn.LBRR_flags[ i ] ) {
353                             opus_int condCoding;
354
355                             if( encControl->nChannelsInternal == 2 && n == 0 ) {
356                                 silk_stereo_encode_pred( psRangeEnc, psEnc->sStereo.predIx[ i ] );
357                                 /* For LBRR data there's no need to code the mid-only flag if the side-channel LBRR flag is set */
358                                 if( psEnc->state_Fxx[ 1 ].sCmn.LBRR_flags[ i ] == 0 ) {
359                                     silk_stereo_encode_mid_only( psRangeEnc, psEnc->sStereo.mid_only_flags[ i ] );
360                                 }
361                             }
362                             /* Use conditional coding if previous frame available */
363                             if( i > 0 && psEnc->state_Fxx[ n ].sCmn.LBRR_flags[ i - 1 ] ) {
364                                 condCoding = CODE_CONDITIONALLY;
365                             } else {
366                                 condCoding = CODE_INDEPENDENTLY;
367                             }
368                             silk_encode_indices( &psEnc->state_Fxx[ n ].sCmn, psRangeEnc, i, 1, condCoding );
369                             silk_encode_pulses( psRangeEnc, psEnc->state_Fxx[ n ].sCmn.indices_LBRR[i].signalType, psEnc->state_Fxx[ n ].sCmn.indices_LBRR[i].quantOffsetType,
370                                 psEnc->state_Fxx[ n ].sCmn.pulses_LBRR[ i ], psEnc->state_Fxx[ n ].sCmn.frame_length );
371                         }
372                     }
373                 }
374
375                 /* Reset LBRR flags */
376                 for( n = 0; n < encControl->nChannelsInternal; n++ ) {
377                     silk_memset( psEnc->state_Fxx[ n ].sCmn.LBRR_flags, 0, sizeof( psEnc->state_Fxx[ n ].sCmn.LBRR_flags ) );
378                 }
379
380                 psEnc->nBitsUsedLBRR = ec_tell( psRangeEnc );
381             }
382
383             silk_HP_variable_cutoff( psEnc->state_Fxx );
384
385             /* Total target bits for packet */
386             nBits = silk_DIV32_16( silk_MUL( encControl->bitRate, encControl->payloadSize_ms ), 1000 );
387             /* Subtract bits used for LBRR */
388             if( !prefillFlag ) {
389                 nBits -= psEnc->nBitsUsedLBRR;
390             }
391             /* Divide by number of uncoded frames left in packet */
392             nBits = silk_DIV32_16( nBits, psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket );
393             /* Convert to bits/second */
394             if( encControl->payloadSize_ms == 10 ) {
395                 TargetRate_bps = silk_SMULBB( nBits, 100 );
396             } else {
397                 TargetRate_bps = silk_SMULBB( nBits, 50 );
398             }
399             /* Subtract fraction of bits in excess of target in previous frames and packets */
400             TargetRate_bps -= silk_DIV32_16( silk_MUL( psEnc->nBitsExceeded, 1000 ), BITRESERVOIR_DECAY_TIME_MS );
401             if( !prefillFlag && psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded > 0 ) {
402                 /* Compare actual vs target bits so far in this packet */
403                 opus_int32 bitsBalance = ec_tell( psRangeEnc ) - psEnc->nBitsUsedLBRR - nBits * psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded;
404                 TargetRate_bps -= silk_DIV32_16( silk_MUL( bitsBalance, 1000 ), BITRESERVOIR_DECAY_TIME_MS );
405             }
406             /* Never exceed input bitrate */
407             TargetRate_bps = silk_LIMIT( TargetRate_bps, encControl->bitRate, 5000 );
408
409             /* Convert Left/Right to Mid/Side */
410             if( encControl->nChannelsInternal == 2 ) {
411                 silk_stereo_LR_to_MS( &psEnc->sStereo, &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ 2 ], &psEnc->state_Fxx[ 1 ].sCmn.inputBuf[ 2 ],
412                     psEnc->sStereo.predIx[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ], &psEnc->sStereo.mid_only_flags[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ],
413                     MStargetRates_bps, TargetRate_bps, psEnc->state_Fxx[ 0 ].sCmn.speech_activity_Q8, encControl->toMono,
414                     psEnc->state_Fxx[ 0 ].sCmn.fs_kHz, psEnc->state_Fxx[ 0 ].sCmn.frame_length );
415                 if( psEnc->sStereo.mid_only_flags[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ] == 0 ) {
416                     /* Reset side channel encoder memory for first frame with side coding */
417                     if( psEnc->prev_decode_only_middle == 1 ) {
418                         silk_memset( &psEnc->state_Fxx[ 1 ].sShape,               0, sizeof( psEnc->state_Fxx[ 1 ].sShape ) );
419                         silk_memset( &psEnc->state_Fxx[ 1 ].sPrefilt,             0, sizeof( psEnc->state_Fxx[ 1 ].sPrefilt ) );
420                         silk_memset( &psEnc->state_Fxx[ 1 ].sCmn.sNSQ,            0, sizeof( psEnc->state_Fxx[ 1 ].sCmn.sNSQ ) );
421                         silk_memset( psEnc->state_Fxx[ 1 ].sCmn.prev_NLSFq_Q15,   0, sizeof( psEnc->state_Fxx[ 1 ].sCmn.prev_NLSFq_Q15 ) );
422                         silk_memset( &psEnc->state_Fxx[ 1 ].sCmn.sLP.In_LP_State, 0, sizeof( psEnc->state_Fxx[ 1 ].sCmn.sLP.In_LP_State ) );
423                         psEnc->state_Fxx[ 1 ].sCmn.prevLag                 = 100;
424                         psEnc->state_Fxx[ 1 ].sCmn.sNSQ.lagPrev            = 100;
425                         psEnc->state_Fxx[ 1 ].sShape.LastGainIndex         = 10;
426                         psEnc->state_Fxx[ 1 ].sCmn.prevSignalType          = TYPE_NO_VOICE_ACTIVITY;
427                         psEnc->state_Fxx[ 1 ].sCmn.sNSQ.prev_gain_Q16      = 65536;
428                         psEnc->state_Fxx[ 1 ].sCmn.first_frame_after_reset = 1;
429                     }
430                     silk_encode_do_VAD_Fxx( &psEnc->state_Fxx[ 1 ] );
431                 } else {
432                     psEnc->state_Fxx[ 1 ].sCmn.VAD_flags[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ] = 0;
433                 }
434                 if( !prefillFlag ) {
435                     silk_stereo_encode_pred( psRangeEnc, psEnc->sStereo.predIx[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ] );
436                     if( psEnc->state_Fxx[ 1 ].sCmn.VAD_flags[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ] == 0 ) {
437                         silk_stereo_encode_mid_only( psRangeEnc, psEnc->sStereo.mid_only_flags[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ] );
438                     }
439                 }
440             } else {
441                 /* Buffering */
442                 silk_memcpy( psEnc->state_Fxx[ 0 ].sCmn.inputBuf, psEnc->sStereo.sMid, 2 * sizeof( opus_int16 ) );
443                 silk_memcpy( psEnc->sStereo.sMid, &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.frame_length ], 2 * sizeof( opus_int16 ) );
444             }
445             silk_encode_do_VAD_Fxx( &psEnc->state_Fxx[ 0 ] );
446
447             /* Encode */
448             for( n = 0; n < encControl->nChannelsInternal; n++ ) {
449                 opus_int maxBits, useCBR;
450
451                 /* Handling rate constraints */
452                 maxBits = encControl->maxBits;
453                 if( tot_blocks == 2 && curr_block == 0 ) {
454                     maxBits = maxBits * 3 / 5;
455                 } else if( tot_blocks == 3 ) {
456                     if( curr_block == 0 ) {
457                         maxBits = maxBits * 2 / 5;
458                     } else if( curr_block == 1 ) {
459                         maxBits = maxBits * 3 / 4;
460                     }
461                 }
462                 useCBR = encControl->useCBR && curr_block == tot_blocks - 1;
463
464                 if( encControl->nChannelsInternal == 1 ) {
465                     channelRate_bps = TargetRate_bps;
466                 } else {
467                     channelRate_bps = MStargetRates_bps[ n ];
468                     if( n == 0 && MStargetRates_bps[ 1 ] > 0 ) {
469                         useCBR = 0;
470                         /* Give mid up to 1/2 of the max bits for that frame */
471                         maxBits -= encControl->maxBits / ( tot_blocks * 2 );
472                     }
473                 }
474
475                 if( channelRate_bps > 0 ) {
476                     opus_int condCoding;
477
478                     silk_control_SNR( &psEnc->state_Fxx[ n ].sCmn, channelRate_bps );
479
480                     /* Use independent coding if no previous frame available */
481                     if( psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded - n <= 0 ) {
482                         condCoding = CODE_INDEPENDENTLY;
483                     } else if( n > 0 && psEnc->prev_decode_only_middle ) {
484                         /* If we skipped a side frame in this packet, we don't
485                            need LTP scaling; the LTP state is well-defined. */
486                         condCoding = CODE_INDEPENDENTLY_NO_LTP_SCALING;
487                     } else {
488                         condCoding = CODE_CONDITIONALLY;
489                     }
490                     if( ( ret = silk_encode_frame_Fxx( &psEnc->state_Fxx[ n ], nBytesOut, psRangeEnc, condCoding, maxBits, useCBR ) ) != 0 ) {
491                         silk_assert( 0 );
492                     }
493                 }
494                 psEnc->state_Fxx[ n ].sCmn.controlled_since_last_payload = 0;
495                 psEnc->state_Fxx[ n ].sCmn.inputBufIx = 0;
496                 psEnc->state_Fxx[ n ].sCmn.nFramesEncoded++;
497             }
498             psEnc->prev_decode_only_middle = psEnc->sStereo.mid_only_flags[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded - 1 ];
499
500             /* Insert VAD and FEC flags at beginning of bitstream */
501             if( *nBytesOut > 0 && psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded == psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket) {
502                 flags = 0;
503                 for( n = 0; n < encControl->nChannelsInternal; n++ ) {
504                     for( i = 0; i < psEnc->state_Fxx[ n ].sCmn.nFramesPerPacket; i++ ) {
505                         flags  = silk_LSHIFT( flags, 1 );
506                         flags |= psEnc->state_Fxx[ n ].sCmn.VAD_flags[ i ];
507                     }
508                     flags  = silk_LSHIFT( flags, 1 );
509                     flags |= psEnc->state_Fxx[ n ].sCmn.LBRR_flag;
510                 }
511                 if( !prefillFlag ) {
512                     ec_enc_patch_initial_bits( psRangeEnc, flags, ( psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket + 1 ) * encControl->nChannelsInternal );
513                 }
514
515                 /* Return zero bytes if all channels DTXed */
516                 if( psEnc->state_Fxx[ 0 ].sCmn.inDTX && ( encControl->nChannelsInternal == 1 || psEnc->state_Fxx[ 1 ].sCmn.inDTX ) ) {
517                     *nBytesOut = 0;
518                 }
519
520                 psEnc->nBitsExceeded += *nBytesOut * 8;
521                 psEnc->nBitsExceeded -= silk_DIV32_16( silk_MUL( encControl->bitRate, encControl->payloadSize_ms ), 1000 );
522                 psEnc->nBitsExceeded  = silk_LIMIT( psEnc->nBitsExceeded, 0, 10000 );
523
524                 /* Update flag indicating if bandwidth switching is allowed */
525                 speech_act_thr_for_switch_Q8 = silk_SMLAWB( SILK_FIX_CONST( SPEECH_ACTIVITY_DTX_THRES, 8 ),
526                     SILK_FIX_CONST( ( 1 - SPEECH_ACTIVITY_DTX_THRES ) / MAX_BANDWIDTH_SWITCH_DELAY_MS, 16 + 8 ), psEnc->timeSinceSwitchAllowed_ms );
527                 if( psEnc->state_Fxx[ 0 ].sCmn.speech_activity_Q8 < speech_act_thr_for_switch_Q8 ) {
528                     psEnc->allowBandwidthSwitch = 1;
529                     psEnc->timeSinceSwitchAllowed_ms = 0;
530                 } else {
531                     psEnc->allowBandwidthSwitch = 0;
532                     psEnc->timeSinceSwitchAllowed_ms += encControl->payloadSize_ms;
533                 }
534             }
535
536             if( nSamplesIn == 0 ) {
537                 break;
538             }
539         } else {
540             break;
541         }
542         curr_block++;
543     }
544
545     psEnc->nPrevChannelsInternal = encControl->nChannelsInternal;
546
547     encControl->allowBandwidthSwitch = psEnc->allowBandwidthSwitch;
548     encControl->inWBmodeWithoutVariableLP = psEnc->state_Fxx[ 0 ].sCmn.fs_kHz == 16 && psEnc->state_Fxx[ 0 ].sCmn.sLP.mode == 0;
549     encControl->internalSampleRate = silk_SMULBB( psEnc->state_Fxx[ 0 ].sCmn.fs_kHz, 1000 );
550     encControl->stereoWidth_Q14 = encControl->toMono ? 0 : psEnc->sStereo.smth_width_Q14;
551     if( prefillFlag ) {
552         encControl->payloadSize_ms = tmp_payloadSize_ms;
553         encControl->complexity = tmp_complexity;
554         for( n = 0; n < encControl->nChannelsInternal; n++ ) {
555             psEnc->state_Fxx[ n ].sCmn.controlled_since_last_payload = 0;
556             psEnc->state_Fxx[ n ].sCmn.prefillFlag = 0;
557         }
558     }
559
560     encControl->signalType = psEnc->state_Fxx[0].sCmn.indices.signalType;
561     encControl->offset = silk_Quantization_Offsets_Q10
562                          [ psEnc->state_Fxx[0].sCmn.indices.signalType >> 1 ]
563                          [ psEnc->state_Fxx[0].sCmn.indices.quantOffsetType ];
564     RESTORE_STACK;
565     return ret;
566 }
567