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