Fixing failure due to CBR allocating zero byte to a stream
[opus.git] / src / opus_encoder.c
1 /* Copyright (c) 2010-2011 Xiph.Org Foundation, Skype Limited
2    Written by Jean-Marc Valin and Koen Vos */
3 /*
4    Redistribution and use in source and binary forms, with or without
5    modification, are permitted provided that the following conditions
6    are met:
7
8    - Redistributions of source code must retain the above copyright
9    notice, this list of conditions and the following disclaimer.
10
11    - Redistributions in binary form must reproduce the above copyright
12    notice, this list of conditions and the following disclaimer in the
13    documentation and/or other materials provided with the distribution.
14
15    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
18    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
19    OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
23    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
24    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #ifdef HAVE_CONFIG_H
29 #include "config.h"
30 #endif
31
32 #include <stdarg.h>
33 #include "celt.h"
34 #include "entenc.h"
35 #include "modes.h"
36 #include "API.h"
37 #include "stack_alloc.h"
38 #include "float_cast.h"
39 #include "opus.h"
40 #include "arch.h"
41 #include "pitch.h"
42 #include "opus_private.h"
43 #include "os_support.h"
44 #include "cpu_support.h"
45 #include "analysis.h"
46 #include "mathops.h"
47 #include "tuning_parameters.h"
48 #ifdef FIXED_POINT
49 #include "fixed/structs_FIX.h"
50 #else
51 #include "float/structs_FLP.h"
52 #endif
53
54 #define MAX_ENCODER_BUFFER 480
55
56 #ifndef DISABLE_FLOAT_API
57 #define PSEUDO_SNR_THRESHOLD 316.23f    /* 10^(25/10) */
58 #endif
59
60 typedef struct {
61    opus_val32 XX, XY, YY;
62    opus_val16 smoothed_width;
63    opus_val16 max_follower;
64 } StereoWidthState;
65
66 struct OpusEncoder {
67     int          celt_enc_offset;
68     int          silk_enc_offset;
69     silk_EncControlStruct silk_mode;
70     int          application;
71     int          channels;
72     int          delay_compensation;
73     int          force_channels;
74     int          signal_type;
75     int          user_bandwidth;
76     int          max_bandwidth;
77     int          user_forced_mode;
78     int          voice_ratio;
79     opus_int32   Fs;
80     int          use_vbr;
81     int          vbr_constraint;
82     int          variable_duration;
83     opus_int32   bitrate_bps;
84     opus_int32   user_bitrate_bps;
85     int          lsb_depth;
86     int          encoder_buffer;
87     int          lfe;
88     int          arch;
89     int          use_dtx;                 /* general DTX for both SILK and CELT */
90 #ifndef DISABLE_FLOAT_API
91     TonalityAnalysisState analysis;
92 #endif
93
94 #define OPUS_ENCODER_RESET_START stream_channels
95     int          stream_channels;
96     opus_int16   hybrid_stereo_width_Q14;
97     opus_int32   variable_HP_smth2_Q15;
98     opus_val16   prev_HB_gain;
99     opus_val32   hp_mem[4];
100     int          mode;
101     int          prev_mode;
102     int          prev_channels;
103     int          prev_framesize;
104     int          bandwidth;
105     /* Bandwidth determined automatically from the rate (before any other adjustment) */
106     int          auto_bandwidth;
107     int          silk_bw_switch;
108     /* Sampling rate (at the API level) */
109     int          first;
110     opus_val16 * energy_masking;
111     StereoWidthState width_mem;
112     opus_val16   delay_buffer[MAX_ENCODER_BUFFER*2];
113 #ifndef DISABLE_FLOAT_API
114     int          detected_bandwidth;
115     int          nb_no_activity_frames;
116     opus_val32   peak_signal_energy;
117 #endif
118     opus_uint32  rangeFinal;
119 };
120
121 /* Transition tables for the voice and music. First column is the
122    middle (memoriless) threshold. The second column is the hysteresis
123    (difference with the middle) */
124 static const opus_int32 mono_voice_bandwidth_thresholds[8] = {
125         10000, 1000, /* NB<->MB */
126         11000, 1000, /* MB<->WB */
127         13500, 1000, /* WB<->SWB */
128         14000, 2000, /* SWB<->FB */
129 };
130 static const opus_int32 mono_music_bandwidth_thresholds[8] = {
131         10000, 1000, /* NB<->MB */
132         11000, 1000, /* MB<->WB */
133         13500, 1000, /* WB<->SWB */
134         14000, 2000, /* SWB<->FB */
135 };
136 static const opus_int32 stereo_voice_bandwidth_thresholds[8] = {
137         10000, 1000, /* NB<->MB */
138         11000, 1000, /* MB<->WB */
139         13500, 1000, /* WB<->SWB */
140         14000, 2000, /* SWB<->FB */
141 };
142 static const opus_int32 stereo_music_bandwidth_thresholds[8] = {
143         10000, 1000, /* NB<->MB */
144         11000, 1000, /* MB<->WB */
145         13500, 1000, /* WB<->SWB */
146         14000, 2000, /* SWB<->FB */
147 };
148 /* Threshold bit-rates for switching between mono and stereo */
149 static const opus_int32 stereo_voice_threshold = 24000;
150 static const opus_int32 stereo_music_threshold = 24000;
151
152 /* Threshold bit-rate for switching between SILK/hybrid and CELT-only */
153 static const opus_int32 mode_thresholds[2][2] = {
154       /* voice */ /* music */
155       {  64000,      16000}, /* mono */
156       {  36000,      16000}, /* stereo */
157 };
158
159 static const opus_int32 fec_thresholds[] = {
160         12000, 1000, /* NB */
161         14000, 1000, /* MB */
162         16000, 1000, /* WB */
163         20000, 1000, /* SWB */
164         22000, 1000, /* FB */
165 };
166
167 int opus_encoder_get_size(int channels)
168 {
169     int silkEncSizeBytes, celtEncSizeBytes;
170     int ret;
171     if (channels<1 || channels > 2)
172         return 0;
173     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
174     if (ret)
175         return 0;
176     silkEncSizeBytes = align(silkEncSizeBytes);
177     celtEncSizeBytes = celt_encoder_get_size(channels);
178     return align(sizeof(OpusEncoder))+silkEncSizeBytes+celtEncSizeBytes;
179 }
180
181 int opus_encoder_init(OpusEncoder* st, opus_int32 Fs, int channels, int application)
182 {
183     void *silk_enc;
184     CELTEncoder *celt_enc;
185     int err;
186     int ret, silkEncSizeBytes;
187
188    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
189         (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
190         && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
191         return OPUS_BAD_ARG;
192
193     OPUS_CLEAR((char*)st, opus_encoder_get_size(channels));
194     /* Create SILK encoder */
195     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
196     if (ret)
197         return OPUS_BAD_ARG;
198     silkEncSizeBytes = align(silkEncSizeBytes);
199     st->silk_enc_offset = align(sizeof(OpusEncoder));
200     st->celt_enc_offset = st->silk_enc_offset+silkEncSizeBytes;
201     silk_enc = (char*)st+st->silk_enc_offset;
202     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
203
204     st->stream_channels = st->channels = channels;
205
206     st->Fs = Fs;
207
208     st->arch = opus_select_arch();
209
210     ret = silk_InitEncoder( silk_enc, st->arch, &st->silk_mode );
211     if(ret)return OPUS_INTERNAL_ERROR;
212
213     /* default SILK parameters */
214     st->silk_mode.nChannelsAPI              = channels;
215     st->silk_mode.nChannelsInternal         = channels;
216     st->silk_mode.API_sampleRate            = st->Fs;
217     st->silk_mode.maxInternalSampleRate     = 16000;
218     st->silk_mode.minInternalSampleRate     = 8000;
219     st->silk_mode.desiredInternalSampleRate = 16000;
220     st->silk_mode.payloadSize_ms            = 20;
221     st->silk_mode.bitRate                   = 25000;
222     st->silk_mode.packetLossPercentage      = 0;
223     st->silk_mode.complexity                = 9;
224     st->silk_mode.useInBandFEC              = 0;
225     st->silk_mode.useDTX                    = 0;
226     st->silk_mode.useCBR                    = 0;
227     st->silk_mode.reducedDependency         = 0;
228
229     /* Create CELT encoder */
230     /* Initialize CELT encoder */
231     err = celt_encoder_init(celt_enc, Fs, channels, st->arch);
232     if(err!=OPUS_OK)return OPUS_INTERNAL_ERROR;
233
234     celt_encoder_ctl(celt_enc, CELT_SET_SIGNALLING(0));
235     celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(st->silk_mode.complexity));
236
237     st->use_vbr = 1;
238     /* Makes constrained VBR the default (safer for real-time use) */
239     st->vbr_constraint = 1;
240     st->user_bitrate_bps = OPUS_AUTO;
241     st->bitrate_bps = 3000+Fs*channels;
242     st->application = application;
243     st->signal_type = OPUS_AUTO;
244     st->user_bandwidth = OPUS_AUTO;
245     st->max_bandwidth = OPUS_BANDWIDTH_FULLBAND;
246     st->force_channels = OPUS_AUTO;
247     st->user_forced_mode = OPUS_AUTO;
248     st->voice_ratio = -1;
249     st->encoder_buffer = st->Fs/100;
250     st->lsb_depth = 24;
251     st->variable_duration = OPUS_FRAMESIZE_ARG;
252
253     /* Delay compensation of 4 ms (2.5 ms for SILK's extra look-ahead
254        + 1.5 ms for SILK resamplers and stereo prediction) */
255     st->delay_compensation = st->Fs/250;
256
257     st->hybrid_stereo_width_Q14 = 1 << 14;
258     st->prev_HB_gain = Q15ONE;
259     st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
260     st->first = 1;
261     st->mode = MODE_HYBRID;
262     st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
263
264 #ifndef DISABLE_FLOAT_API
265     tonality_analysis_init(&st->analysis);
266 #endif
267
268     return OPUS_OK;
269 }
270
271 static unsigned char gen_toc(int mode, int framerate, int bandwidth, int channels)
272 {
273    int period;
274    unsigned char toc;
275    period = 0;
276    while (framerate < 400)
277    {
278        framerate <<= 1;
279        period++;
280    }
281    if (mode == MODE_SILK_ONLY)
282    {
283        toc = (bandwidth-OPUS_BANDWIDTH_NARROWBAND)<<5;
284        toc |= (period-2)<<3;
285    } else if (mode == MODE_CELT_ONLY)
286    {
287        int tmp = bandwidth-OPUS_BANDWIDTH_MEDIUMBAND;
288        if (tmp < 0)
289            tmp = 0;
290        toc = 0x80;
291        toc |= tmp << 5;
292        toc |= period<<3;
293    } else /* Hybrid */
294    {
295        toc = 0x60;
296        toc |= (bandwidth-OPUS_BANDWIDTH_SUPERWIDEBAND)<<4;
297        toc |= (period-2)<<3;
298    }
299    toc |= (channels==2)<<2;
300    return toc;
301 }
302
303 #ifndef FIXED_POINT
304 static void silk_biquad_float(
305     const opus_val16      *in,            /* I:    Input signal                   */
306     const opus_int32      *B_Q28,         /* I:    MA coefficients [3]            */
307     const opus_int32      *A_Q28,         /* I:    AR coefficients [2]            */
308     opus_val32            *S,             /* I/O:  State vector [2]               */
309     opus_val16            *out,           /* O:    Output signal                  */
310     const opus_int32      len,            /* I:    Signal length (must be even)   */
311     int stride
312 )
313 {
314     /* DIRECT FORM II TRANSPOSED (uses 2 element state vector) */
315     opus_int   k;
316     opus_val32 vout;
317     opus_val32 inval;
318     opus_val32 A[2], B[3];
319
320     A[0] = (opus_val32)(A_Q28[0] * (1.f/((opus_int32)1<<28)));
321     A[1] = (opus_val32)(A_Q28[1] * (1.f/((opus_int32)1<<28)));
322     B[0] = (opus_val32)(B_Q28[0] * (1.f/((opus_int32)1<<28)));
323     B[1] = (opus_val32)(B_Q28[1] * (1.f/((opus_int32)1<<28)));
324     B[2] = (opus_val32)(B_Q28[2] * (1.f/((opus_int32)1<<28)));
325
326     /* Negate A_Q28 values and split in two parts */
327
328     for( k = 0; k < len; k++ ) {
329         /* S[ 0 ], S[ 1 ]: Q12 */
330         inval = in[ k*stride ];
331         vout = S[ 0 ] + B[0]*inval;
332
333         S[ 0 ] = S[1] - vout*A[0] + B[1]*inval;
334
335         S[ 1 ] = - vout*A[1] + B[2]*inval + VERY_SMALL;
336
337         /* Scale back to Q0 and saturate */
338         out[ k*stride ] = vout;
339     }
340 }
341 #endif
342
343 static void hp_cutoff(const opus_val16 *in, opus_int32 cutoff_Hz, opus_val16 *out, opus_val32 *hp_mem, int len, int channels, opus_int32 Fs)
344 {
345    opus_int32 B_Q28[ 3 ], A_Q28[ 2 ];
346    opus_int32 Fc_Q19, r_Q28, r_Q22;
347
348    silk_assert( cutoff_Hz <= silk_int32_MAX / SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ) );
349    Fc_Q19 = silk_DIV32_16( silk_SMULBB( SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ), cutoff_Hz ), Fs/1000 );
350    silk_assert( Fc_Q19 > 0 && Fc_Q19 < 32768 );
351
352    r_Q28 = SILK_FIX_CONST( 1.0, 28 ) - silk_MUL( SILK_FIX_CONST( 0.92, 9 ), Fc_Q19 );
353
354    /* b = r * [ 1; -2; 1 ]; */
355    /* a = [ 1; -2 * r * ( 1 - 0.5 * Fc^2 ); r^2 ]; */
356    B_Q28[ 0 ] = r_Q28;
357    B_Q28[ 1 ] = silk_LSHIFT( -r_Q28, 1 );
358    B_Q28[ 2 ] = r_Q28;
359
360    /* -r * ( 2 - Fc * Fc ); */
361    r_Q22  = silk_RSHIFT( r_Q28, 6 );
362    A_Q28[ 0 ] = silk_SMULWW( r_Q22, silk_SMULWW( Fc_Q19, Fc_Q19 ) - SILK_FIX_CONST( 2.0,  22 ) );
363    A_Q28[ 1 ] = silk_SMULWW( r_Q22, r_Q22 );
364
365 #ifdef FIXED_POINT
366    silk_biquad_alt( in, B_Q28, A_Q28, hp_mem, out, len, channels );
367    if( channels == 2 ) {
368        silk_biquad_alt( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
369    }
370 #else
371    silk_biquad_float( in, B_Q28, A_Q28, hp_mem, out, len, channels );
372    if( channels == 2 ) {
373        silk_biquad_float( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
374    }
375 #endif
376 }
377
378 #ifdef FIXED_POINT
379 static void dc_reject(const opus_val16 *in, opus_int32 cutoff_Hz, opus_val16 *out, opus_val32 *hp_mem, int len, int channels, opus_int32 Fs)
380 {
381    int c, i;
382    int shift;
383
384    /* Approximates -round(log2(4.*cutoff_Hz/Fs)) */
385    shift=celt_ilog2(Fs/(cutoff_Hz*3));
386    for (c=0;c<channels;c++)
387    {
388       for (i=0;i<len;i++)
389       {
390          opus_val32 x, tmp, y;
391          x = SHL32(EXTEND32(in[channels*i+c]), 14);
392          /* First stage */
393          tmp = x-hp_mem[2*c];
394          hp_mem[2*c] = hp_mem[2*c] + PSHR32(x - hp_mem[2*c], shift);
395          /* Second stage */
396          y = tmp - hp_mem[2*c+1];
397          hp_mem[2*c+1] = hp_mem[2*c+1] + PSHR32(tmp - hp_mem[2*c+1], shift);
398          out[channels*i+c] = EXTRACT16(SATURATE(PSHR32(y, 14), 32767));
399       }
400    }
401 }
402
403 #else
404 static void dc_reject(const opus_val16 *in, opus_int32 cutoff_Hz, opus_val16 *out, opus_val32 *hp_mem, int len, int channels, opus_int32 Fs)
405 {
406    int i;
407    float coef, coef2;
408    coef = 4.0f*cutoff_Hz/Fs;
409    coef2 = 1-coef;
410    if (channels==2)
411    {
412       float m0, m1, m2, m3;
413       m0 = hp_mem[0];
414       m1 = hp_mem[1];
415       m2 = hp_mem[2];
416       m3 = hp_mem[3];
417       for (i=0;i<len;i++)
418       {
419          opus_val32 x0, x1, tmp0, tmp1, y0, y1;
420          x0 = in[2*i+0];
421          x1 = in[2*i+1];
422          /* First stage */
423          tmp0 = x0-m0;
424          tmp1 = x1-m2;
425          m0 = coef*x0 + VERY_SMALL + coef2*m0;
426          m2 = coef*x1 + VERY_SMALL + coef2*m2;
427          /* Second stage */
428          y0 = tmp0 - m1;
429          y1 = tmp1 - m3;
430          m1 = coef*tmp0 + VERY_SMALL + coef2*m1;
431          m3 = coef*tmp1 + VERY_SMALL + coef2*m3;
432          out[2*i+0] = y0;
433          out[2*i+1] = y1;
434       }
435       hp_mem[0] = m0;
436       hp_mem[1] = m1;
437       hp_mem[2] = m2;
438       hp_mem[3] = m3;
439    } else {
440       float m0, m1;
441       m0 = hp_mem[0];
442       m1 = hp_mem[1];
443       for (i=0;i<len;i++)
444       {
445          opus_val32 x, tmp, y;
446          x = in[i];
447          /* First stage */
448          tmp = x-m0;
449          m0 = coef*x + VERY_SMALL + coef2*m0;
450          /* Second stage */
451          y = tmp - m1;
452          m1 = coef*tmp + VERY_SMALL + coef2*m1;
453          out[i] = y;
454       }
455       hp_mem[0] = m0;
456       hp_mem[1] = m1;
457    }
458 }
459 #endif
460
461 static void stereo_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2,
462         int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
463 {
464     int i;
465     int overlap;
466     int inc;
467     inc = 48000/Fs;
468     overlap=overlap48/inc;
469     g1 = Q15ONE-g1;
470     g2 = Q15ONE-g2;
471     for (i=0;i<overlap;i++)
472     {
473        opus_val32 diff;
474        opus_val16 g, w;
475        w = MULT16_16_Q15(window[i*inc], window[i*inc]);
476        g = SHR32(MAC16_16(MULT16_16(w,g2),
477              Q15ONE-w, g1), 15);
478        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
479        diff = MULT16_16_Q15(g, diff);
480        out[i*channels] = out[i*channels] - diff;
481        out[i*channels+1] = out[i*channels+1] + diff;
482     }
483     for (;i<frame_size;i++)
484     {
485        opus_val32 diff;
486        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
487        diff = MULT16_16_Q15(g2, diff);
488        out[i*channels] = out[i*channels] - diff;
489        out[i*channels+1] = out[i*channels+1] + diff;
490     }
491 }
492
493 static void gain_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2,
494         int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
495 {
496     int i;
497     int inc;
498     int overlap;
499     int c;
500     inc = 48000/Fs;
501     overlap=overlap48/inc;
502     if (channels==1)
503     {
504        for (i=0;i<overlap;i++)
505        {
506           opus_val16 g, w;
507           w = MULT16_16_Q15(window[i*inc], window[i*inc]);
508           g = SHR32(MAC16_16(MULT16_16(w,g2),
509                 Q15ONE-w, g1), 15);
510           out[i] = MULT16_16_Q15(g, in[i]);
511        }
512     } else {
513        for (i=0;i<overlap;i++)
514        {
515           opus_val16 g, w;
516           w = MULT16_16_Q15(window[i*inc], window[i*inc]);
517           g = SHR32(MAC16_16(MULT16_16(w,g2),
518                 Q15ONE-w, g1), 15);
519           out[i*2] = MULT16_16_Q15(g, in[i*2]);
520           out[i*2+1] = MULT16_16_Q15(g, in[i*2+1]);
521        }
522     }
523     c=0;do {
524        for (i=overlap;i<frame_size;i++)
525        {
526           out[i*channels+c] = MULT16_16_Q15(g2, in[i*channels+c]);
527        }
528     }
529     while (++c<channels);
530 }
531
532 OpusEncoder *opus_encoder_create(opus_int32 Fs, int channels, int application, int *error)
533 {
534    int ret;
535    OpusEncoder *st;
536    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
537        (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
538        && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
539    {
540       if (error)
541          *error = OPUS_BAD_ARG;
542       return NULL;
543    }
544    st = (OpusEncoder *)opus_alloc(opus_encoder_get_size(channels));
545    if (st == NULL)
546    {
547       if (error)
548          *error = OPUS_ALLOC_FAIL;
549       return NULL;
550    }
551    ret = opus_encoder_init(st, Fs, channels, application);
552    if (error)
553       *error = ret;
554    if (ret != OPUS_OK)
555    {
556       opus_free(st);
557       st = NULL;
558    }
559    return st;
560 }
561
562 static opus_int32 user_bitrate_to_bitrate(OpusEncoder *st, int frame_size, int max_data_bytes)
563 {
564   if(!frame_size)frame_size=st->Fs/400;
565   if (st->user_bitrate_bps==OPUS_AUTO)
566     return 60*st->Fs/frame_size + st->Fs*st->channels;
567   else if (st->user_bitrate_bps==OPUS_BITRATE_MAX)
568     return max_data_bytes*8*st->Fs/frame_size;
569   else
570     return st->user_bitrate_bps;
571 }
572
573 #ifndef DISABLE_FLOAT_API
574 /* Don't use more than 60 ms for the frame size analysis */
575 #define MAX_DYNAMIC_FRAMESIZE 24
576 /* Estimates how much the bitrate will be boosted based on the sub-frame energy */
577 static float transient_boost(const float *E, const float *E_1, int LM, int maxM)
578 {
579    int i;
580    int M;
581    float sumE=0, sumE_1=0;
582    float metric;
583
584    M = IMIN(maxM, (1<<LM)+1);
585    for (i=0;i<M;i++)
586    {
587       sumE += E[i];
588       sumE_1 += E_1[i];
589    }
590    metric = sumE*sumE_1/(M*M);
591    /*if (LM==3)
592       printf("%f\n", metric);*/
593    /*return metric>10 ? 1 : 0;*/
594    /*return MAX16(0,1-exp(-.25*(metric-2.)));*/
595    return MIN16(1,(float)sqrt(MAX16(0,.05f*(metric-2))));
596 }
597
598 /* Viterbi decoding trying to find the best frame size combination using look-ahead
599
600    State numbering:
601     0: unused
602     1:  2.5 ms
603     2:  5 ms (#1)
604     3:  5 ms (#2)
605     4: 10 ms (#1)
606     5: 10 ms (#2)
607     6: 10 ms (#3)
608     7: 10 ms (#4)
609     8: 20 ms (#1)
610     9: 20 ms (#2)
611    10: 20 ms (#3)
612    11: 20 ms (#4)
613    12: 20 ms (#5)
614    13: 20 ms (#6)
615    14: 20 ms (#7)
616    15: 20 ms (#8)
617 */
618 static int transient_viterbi(const float *E, const float *E_1, int N, int frame_cost, int rate)
619 {
620    int i;
621    float cost[MAX_DYNAMIC_FRAMESIZE][16];
622    int states[MAX_DYNAMIC_FRAMESIZE][16];
623    float best_cost;
624    int best_state;
625    float factor;
626    /* Take into account that we damp VBR in the 32 kb/s to 64 kb/s range. */
627    if (rate<80)
628       factor=0;
629    else if (rate>160)
630       factor=1;
631    else
632       factor = (rate-80.f)/80.f;
633    /* Makes variable framesize less aggressive at lower bitrates, but I can't
634       find any valid theoretical justification for this (other than it seems
635       to help) */
636    for (i=0;i<16;i++)
637    {
638       /* Impossible state */
639       states[0][i] = -1;
640       cost[0][i] = 1e10;
641    }
642    for (i=0;i<4;i++)
643    {
644       cost[0][1<<i] = (frame_cost + rate*(1<<i))*(1+factor*transient_boost(E, E_1, i, N+1));
645       states[0][1<<i] = i;
646    }
647    for (i=1;i<N;i++)
648    {
649       int j;
650
651       /* Follow continuations */
652       for (j=2;j<16;j++)
653       {
654          cost[i][j] = cost[i-1][j-1];
655          states[i][j] = j-1;
656       }
657
658       /* New frames */
659       for(j=0;j<4;j++)
660       {
661          int k;
662          float min_cost;
663          float curr_cost;
664          states[i][1<<j] = 1;
665          min_cost = cost[i-1][1];
666          for(k=1;k<4;k++)
667          {
668             float tmp = cost[i-1][(1<<(k+1))-1];
669             if (tmp < min_cost)
670             {
671                states[i][1<<j] = (1<<(k+1))-1;
672                min_cost = tmp;
673             }
674          }
675          curr_cost = (frame_cost + rate*(1<<j))*(1+factor*transient_boost(E+i, E_1+i, j, N-i+1));
676          cost[i][1<<j] = min_cost;
677          /* If part of the frame is outside the analysis window, only count part of the cost */
678          if (N-i < (1<<j))
679             cost[i][1<<j] += curr_cost*(float)(N-i)/(1<<j);
680          else
681             cost[i][1<<j] += curr_cost;
682       }
683    }
684
685    best_state=1;
686    best_cost = cost[N-1][1];
687    /* Find best end state (doesn't force a frame to end at N-1) */
688    for (i=2;i<16;i++)
689    {
690       if (cost[N-1][i]<best_cost)
691       {
692          best_cost = cost[N-1][i];
693          best_state = i;
694       }
695    }
696
697    /* Follow transitions back */
698    for (i=N-1;i>=0;i--)
699    {
700       /*printf("%d ", best_state);*/
701       best_state = states[i][best_state];
702    }
703    /*printf("%d\n", best_state);*/
704    return best_state;
705 }
706
707 static int optimize_framesize(const void *x, int len, int C, opus_int32 Fs,
708                 int bitrate, opus_val16 tonality, float *mem, int buffering,
709                 downmix_func downmix)
710 {
711    int N;
712    int i;
713    float e[MAX_DYNAMIC_FRAMESIZE+4];
714    float e_1[MAX_DYNAMIC_FRAMESIZE+3];
715    opus_val32 memx;
716    int bestLM=0;
717    int subframe;
718    int pos;
719    int offset;
720    VARDECL(opus_val32, sub);
721
722    subframe = Fs/400;
723    ALLOC(sub, subframe, opus_val32);
724    e[0]=mem[0];
725    e_1[0]=1.f/(EPSILON+mem[0]);
726    if (buffering)
727    {
728       /* Consider the CELT delay when not in restricted-lowdelay */
729       /* We assume the buffering is between 2.5 and 5 ms */
730       offset = 2*subframe - buffering;
731       celt_assert(offset>=0 && offset <= subframe);
732       len -= offset;
733       e[1]=mem[1];
734       e_1[1]=1.f/(EPSILON+mem[1]);
735       e[2]=mem[2];
736       e_1[2]=1.f/(EPSILON+mem[2]);
737       pos = 3;
738    } else {
739       pos=1;
740       offset=0;
741    }
742    N=IMIN(len/subframe, MAX_DYNAMIC_FRAMESIZE);
743    /* Just silencing a warning, it's really initialized later */
744    memx = 0;
745    for (i=0;i<N;i++)
746    {
747       float tmp;
748       opus_val32 tmpx;
749       int j;
750       tmp=EPSILON;
751
752       downmix(x, sub, subframe, i*subframe+offset, 0, -2, C);
753       if (i==0)
754          memx = sub[0];
755       for (j=0;j<subframe;j++)
756       {
757          tmpx = sub[j];
758          tmp += (tmpx-memx)*(float)(tmpx-memx);
759          memx = tmpx;
760       }
761       e[i+pos] = tmp;
762       e_1[i+pos] = 1.f/tmp;
763    }
764    /* Hack to get 20 ms working with APPLICATION_AUDIO
765       The real problem is that the corresponding memory needs to use 1.5 ms
766       from this frame and 1 ms from the next frame */
767    e[i+pos] = e[i+pos-1];
768    if (buffering)
769       N=IMIN(MAX_DYNAMIC_FRAMESIZE, N+2);
770    bestLM = transient_viterbi(e, e_1, N, (int)((1.f+.5f*tonality)*(60*C+40)), bitrate/400);
771    mem[0] = e[1<<bestLM];
772    if (buffering)
773    {
774       mem[1] = e[(1<<bestLM)+1];
775       mem[2] = e[(1<<bestLM)+2];
776    }
777    return bestLM;
778 }
779
780 #endif
781
782 #ifndef DISABLE_FLOAT_API
783 #ifdef FIXED_POINT
784 #define PCM2VAL(x) FLOAT2INT16(x)
785 #else
786 #define PCM2VAL(x) SCALEIN(x)
787 #endif
788 void downmix_float(const void *_x, opus_val32 *sub, int subframe, int offset, int c1, int c2, int C)
789 {
790    const float *x;
791    opus_val32 scale;
792    int j;
793    x = (const float *)_x;
794    for (j=0;j<subframe;j++)
795       sub[j] = PCM2VAL(x[(j+offset)*C+c1]);
796    if (c2>-1)
797    {
798       for (j=0;j<subframe;j++)
799          sub[j] += PCM2VAL(x[(j+offset)*C+c2]);
800    } else if (c2==-2)
801    {
802       int c;
803       for (c=1;c<C;c++)
804       {
805          for (j=0;j<subframe;j++)
806             sub[j] += PCM2VAL(x[(j+offset)*C+c]);
807       }
808    }
809 #ifdef FIXED_POINT
810    scale = (1<<SIG_SHIFT);
811 #else
812    scale = 1.f;
813 #endif
814    if (c2==-2)
815       scale /= C;
816    else if (c2>-1)
817       scale /= 2;
818    for (j=0;j<subframe;j++)
819       sub[j] *= scale;
820 }
821 #endif
822
823 void downmix_int(const void *_x, opus_val32 *sub, int subframe, int offset, int c1, int c2, int C)
824 {
825    const opus_int16 *x;
826    opus_val32 scale;
827    int j;
828    x = (const opus_int16 *)_x;
829    for (j=0;j<subframe;j++)
830       sub[j] = x[(j+offset)*C+c1];
831    if (c2>-1)
832    {
833       for (j=0;j<subframe;j++)
834          sub[j] += x[(j+offset)*C+c2];
835    } else if (c2==-2)
836    {
837       int c;
838       for (c=1;c<C;c++)
839       {
840          for (j=0;j<subframe;j++)
841             sub[j] += x[(j+offset)*C+c];
842       }
843    }
844 #ifdef FIXED_POINT
845    scale = (1<<SIG_SHIFT);
846 #else
847    scale = 1.f/32768;
848 #endif
849    if (c2==-2)
850       scale /= C;
851    else if (c2>-1)
852       scale /= 2;
853    for (j=0;j<subframe;j++)
854       sub[j] *= scale;
855 }
856
857 opus_int32 frame_size_select(opus_int32 frame_size, int variable_duration, opus_int32 Fs)
858 {
859    int new_size;
860    if (frame_size<Fs/400)
861       return -1;
862    if (variable_duration == OPUS_FRAMESIZE_ARG)
863       new_size = frame_size;
864    else if (variable_duration == OPUS_FRAMESIZE_VARIABLE)
865       new_size = Fs/50;
866    else if (variable_duration >= OPUS_FRAMESIZE_2_5_MS && variable_duration <= OPUS_FRAMESIZE_60_MS)
867       new_size = IMIN(3*Fs/50, (Fs/400)<<(variable_duration-OPUS_FRAMESIZE_2_5_MS));
868    else
869       return -1;
870    if (new_size>frame_size)
871       return -1;
872    if (400*new_size!=Fs && 200*new_size!=Fs && 100*new_size!=Fs &&
873             50*new_size!=Fs && 25*new_size!=Fs && 50*new_size!=3*Fs)
874       return -1;
875    return new_size;
876 }
877
878 opus_int32 compute_frame_size(const void *analysis_pcm, int frame_size,
879       int variable_duration, int C, opus_int32 Fs, int bitrate_bps,
880       int delay_compensation, downmix_func downmix
881 #ifndef DISABLE_FLOAT_API
882       , float *subframe_mem
883 #endif
884       )
885 {
886 #ifndef DISABLE_FLOAT_API
887    if (variable_duration == OPUS_FRAMESIZE_VARIABLE && frame_size >= Fs/200)
888    {
889       int LM = 3;
890       LM = optimize_framesize(analysis_pcm, frame_size, C, Fs, bitrate_bps,
891             0, subframe_mem, delay_compensation, downmix);
892       while ((Fs/400<<LM)>frame_size)
893          LM--;
894       frame_size = (Fs/400<<LM);
895    } else
896 #else
897    (void)analysis_pcm;
898    (void)C;
899    (void)bitrate_bps;
900    (void)delay_compensation;
901    (void)downmix;
902 #endif
903    {
904       frame_size = frame_size_select(frame_size, variable_duration, Fs);
905    }
906    if (frame_size<0)
907       return -1;
908    return frame_size;
909 }
910
911 opus_val16 compute_stereo_width(const opus_val16 *pcm, int frame_size, opus_int32 Fs, StereoWidthState *mem)
912 {
913    opus_val32 xx, xy, yy;
914    opus_val16 sqrt_xx, sqrt_yy;
915    opus_val16 qrrt_xx, qrrt_yy;
916    int frame_rate;
917    int i;
918    opus_val16 short_alpha;
919
920    frame_rate = Fs/frame_size;
921    short_alpha = Q15ONE - MULT16_16(25, Q15ONE)/IMAX(50,frame_rate);
922    xx=xy=yy=0;
923    /* Unroll by 4. The frame size is always a multiple of 4 *except* for
924       2.5 ms frames at 12 kHz. Since this setting is very rare (and very
925       stupid), we just discard the last two samples. */
926    for (i=0;i<frame_size-3;i+=4)
927    {
928       opus_val32 pxx=0;
929       opus_val32 pxy=0;
930       opus_val32 pyy=0;
931       opus_val16 x, y;
932       x = pcm[2*i];
933       y = pcm[2*i+1];
934       pxx = SHR32(MULT16_16(x,x),2);
935       pxy = SHR32(MULT16_16(x,y),2);
936       pyy = SHR32(MULT16_16(y,y),2);
937       x = pcm[2*i+2];
938       y = pcm[2*i+3];
939       pxx += SHR32(MULT16_16(x,x),2);
940       pxy += SHR32(MULT16_16(x,y),2);
941       pyy += SHR32(MULT16_16(y,y),2);
942       x = pcm[2*i+4];
943       y = pcm[2*i+5];
944       pxx += SHR32(MULT16_16(x,x),2);
945       pxy += SHR32(MULT16_16(x,y),2);
946       pyy += SHR32(MULT16_16(y,y),2);
947       x = pcm[2*i+6];
948       y = pcm[2*i+7];
949       pxx += SHR32(MULT16_16(x,x),2);
950       pxy += SHR32(MULT16_16(x,y),2);
951       pyy += SHR32(MULT16_16(y,y),2);
952
953       xx += SHR32(pxx, 10);
954       xy += SHR32(pxy, 10);
955       yy += SHR32(pyy, 10);
956    }
957    mem->XX += MULT16_32_Q15(short_alpha, xx-mem->XX);
958    mem->XY += MULT16_32_Q15(short_alpha, xy-mem->XY);
959    mem->YY += MULT16_32_Q15(short_alpha, yy-mem->YY);
960    mem->XX = MAX32(0, mem->XX);
961    mem->XY = MAX32(0, mem->XY);
962    mem->YY = MAX32(0, mem->YY);
963    if (MAX32(mem->XX, mem->YY)>QCONST16(8e-4f, 18))
964    {
965       opus_val16 corr;
966       opus_val16 ldiff;
967       opus_val16 width;
968       sqrt_xx = celt_sqrt(mem->XX);
969       sqrt_yy = celt_sqrt(mem->YY);
970       qrrt_xx = celt_sqrt(sqrt_xx);
971       qrrt_yy = celt_sqrt(sqrt_yy);
972       /* Inter-channel correlation */
973       mem->XY = MIN32(mem->XY, sqrt_xx*sqrt_yy);
974       corr = SHR32(frac_div32(mem->XY,EPSILON+MULT16_16(sqrt_xx,sqrt_yy)),16);
975       /* Approximate loudness difference */
976       ldiff = MULT16_16(Q15ONE, ABS16(qrrt_xx-qrrt_yy))/(EPSILON+qrrt_xx+qrrt_yy);
977       width = MULT16_16_Q15(celt_sqrt(QCONST32(1.f,30)-MULT16_16(corr,corr)), ldiff);
978       /* Smoothing over one second */
979       mem->smoothed_width += (width-mem->smoothed_width)/frame_rate;
980       /* Peak follower */
981       mem->max_follower = MAX16(mem->max_follower-QCONST16(.02f,15)/frame_rate, mem->smoothed_width);
982    }
983    /*printf("%f %f %f %f %f ", corr/(float)Q15ONE, ldiff/(float)Q15ONE, width/(float)Q15ONE, mem->smoothed_width/(float)Q15ONE, mem->max_follower/(float)Q15ONE);*/
984    return EXTRACT16(MIN32(Q15ONE, MULT16_16(20, mem->max_follower)));
985 }
986
987 static int decide_fec(int useInBandFEC, int PacketLoss_perc, int last_fec, int mode, int *bandwidth, opus_int32 rate)
988 {
989    int orig_bandwidth;
990    if (!useInBandFEC || PacketLoss_perc == 0 || mode == MODE_CELT_ONLY)
991       return 0;
992    orig_bandwidth = *bandwidth;
993    for (;;)
994    {
995       opus_int32 hysteresis;
996       opus_int32 LBRR_rate_thres_bps;
997       /* Compute threshold for using FEC at the current bandwidth setting */
998       LBRR_rate_thres_bps = fec_thresholds[2*(*bandwidth - OPUS_BANDWIDTH_NARROWBAND)];
999       hysteresis = fec_thresholds[2*(*bandwidth - OPUS_BANDWIDTH_NARROWBAND) + 1];
1000       if (last_fec == 1) LBRR_rate_thres_bps -= hysteresis;
1001       if (last_fec == 0) LBRR_rate_thres_bps += hysteresis;
1002       LBRR_rate_thres_bps = silk_SMULWB( silk_MUL( LBRR_rate_thres_bps,
1003             125 - silk_min( PacketLoss_perc, 25 ) ), SILK_FIX_CONST( 0.01, 16 ) );
1004       /* If loss <= 5%, we look at whether we have enough rate to enable FEC.
1005          If loss > 5%, we decrease the bandwidth until we can enable FEC. */
1006       if (rate > LBRR_rate_thres_bps)
1007          return 1;
1008       else if (PacketLoss_perc <= 5)
1009          return 0;
1010       else if (*bandwidth > OPUS_BANDWIDTH_NARROWBAND)
1011          (*bandwidth)--;
1012       else
1013          break;
1014    }
1015    /* Couldn't find any bandwidth to enable FEC, keep original bandwidth. */
1016    *bandwidth = orig_bandwidth;
1017    return 0;
1018 }
1019
1020 static int compute_silk_rate_for_hybrid(int rate, int bandwidth, int frame20ms, int vbr, int fec) {
1021    int entry;
1022    int i;
1023    int N;
1024    int silk_rate;
1025    static int rate_table[][5] = {
1026   /*  |total| |-------- SILK------------|
1027               |-- No FEC -| |--- FEC ---|
1028                10ms   20ms   10ms   20ms */
1029       {    0,     0,     0,     0,     0},
1030       {12000, 10000, 10000, 11000, 11000},
1031       {16000, 13500, 13500, 15000, 15000},
1032       {20000, 16000, 16000, 18000, 18000},
1033       {24000, 18000, 18000, 21000, 21000},
1034       {32000, 22000, 22000, 28000, 28000},
1035       {64000, 38000, 38000, 50000, 50000}
1036    };
1037    entry = 1 + frame20ms + 2*fec;
1038    N = sizeof(rate_table)/sizeof(rate_table[0]);
1039    for (i=1;i<N;i++)
1040    {
1041       if (rate_table[i][0] > rate) break;
1042    }
1043    if (i == N)
1044    {
1045       silk_rate = rate_table[i-1][entry];
1046       /* For now, just give 50% of the extra bits to SILK. */
1047       silk_rate += (rate-rate_table[i-1][0])/2;
1048    } else {
1049       opus_int32 lo, hi, x0, x1;
1050       lo = rate_table[i-1][entry];
1051       hi = rate_table[i][entry];
1052       x0 = rate_table[i-1][0];
1053       x1 = rate_table[i][0];
1054       silk_rate = (lo*(x1-rate) + hi*(rate-x0))/(x1-x0);
1055    }
1056    if (!vbr)
1057    {
1058       /* Tiny boost to SILK for CBR. We should probably tune this better. */
1059       silk_rate += 100;
1060    }
1061    if (bandwidth==OPUS_BANDWIDTH_SUPERWIDEBAND)
1062       silk_rate += 300;
1063    return silk_rate;
1064 }
1065
1066 /* Returns the equivalent bitrate corresponding to 20 ms frames,
1067    complexity 10 VBR operation. */
1068 static opus_int32 compute_equiv_rate(opus_int32 bitrate, int channels,
1069       int frame_rate, int vbr, int mode, int complexity, int loss)
1070 {
1071    opus_int32 equiv;
1072    equiv = bitrate;
1073    /* Take into account overhead from smaller frames. */
1074    equiv -= (40*channels+20)*(frame_rate - 50);
1075    /* CBR is about a 8% penalty for both SILK and CELT. */
1076    if (!vbr)
1077       equiv -= equiv/12;
1078    /* Complexity makes about 10% difference (from 0 to 10) in general. */
1079    equiv = equiv * (90+complexity)/100;
1080    if (mode == MODE_SILK_ONLY || mode == MODE_HYBRID)
1081    {
1082       /* SILK complexity 0-1 uses the non-delayed-decision NSQ, which
1083          costs about 20%. */
1084       if (complexity<2)
1085          equiv = equiv*4/5;
1086       equiv -= equiv*loss/(6*loss + 10);
1087    } else if (mode == MODE_CELT_ONLY) {
1088       /* CELT complexity 0-4 doesn't have the pitch filter, which costs
1089          about 10%. */
1090       if (complexity<5)
1091          equiv = equiv*9/10;
1092    } else {
1093       /* Mode not known yet */
1094       /* Half the SILK loss*/
1095       equiv -= equiv*loss/(12*loss + 20);
1096    }
1097    return equiv;
1098 }
1099
1100 #ifndef DISABLE_FLOAT_API
1101
1102 static int is_digital_silence(const opus_val16* pcm, int frame_size, int channels, int lsb_depth)
1103 {
1104    int silence = 0;
1105    opus_val32 sample_max = 0;
1106
1107    sample_max = celt_maxabs16(pcm, frame_size*channels);
1108
1109 #ifdef FIXED_POINT
1110    silence = (sample_max == 0);
1111    (void)lsb_depth;
1112 #else
1113    silence = (sample_max <= (opus_val16) 1 / (1 << lsb_depth));
1114 #endif
1115
1116    return silence;
1117 }
1118
1119 #ifdef FIXED_POINT
1120 static opus_val32 compute_frame_energy(const opus_val16 *pcm, int frame_size, int channels, int arch)
1121 {
1122    int i;
1123    opus_val32 sample_max;
1124    int max_shift;
1125    int shift;
1126    opus_val32 energy = 0;
1127    int len = frame_size*channels;
1128    (void)arch;
1129    /* Max amplitude in the signal */
1130    sample_max = celt_maxabs16(pcm, len);
1131
1132    /* Compute the right shift required in the MAC to avoid an overflow */
1133    max_shift = celt_ilog2(len);
1134    shift = IMAX(0, (celt_ilog2(sample_max) << 1) + max_shift - 28);
1135
1136    /* Compute the energy */
1137    for (i=0; i<len; i++)
1138       energy += SHR32(MULT16_16(pcm[i], pcm[i]), shift);
1139
1140    /* Normalize energy by the frame size and left-shift back to the original position */
1141    energy /= len;
1142    energy = SHL32(energy, shift);
1143
1144    return energy;
1145 }
1146 #else
1147 static opus_val32 compute_frame_energy(const opus_val16 *pcm, int frame_size, int channels, int arch)
1148 {
1149    int len = frame_size*channels;
1150    return celt_inner_prod(pcm, pcm, len, arch)/len;
1151 }
1152 #endif
1153
1154 /* Decides if DTX should be turned on (=1) or off (=0) */
1155 static int decide_dtx_mode(float activity_probability,    /* probability that current frame contains speech/music */
1156                            int *nb_no_activity_frames,    /* number of consecutive frames with no activity */
1157                            opus_val32 peak_signal_energy, /* peak energy of desired signal detected so far */
1158                            const opus_val16 *pcm,         /* input pcm signal */
1159                            int frame_size,                /* frame size */
1160                            int channels,
1161                            int is_silence,                 /* only digital silence detected in this frame */
1162                            int arch
1163                           )
1164 {
1165    int is_noise;
1166    opus_val32 noise_energy;
1167    int is_sufficiently_quiet;
1168
1169    if (!is_silence)
1170    {
1171       is_noise = activity_probability < DTX_ACTIVITY_THRESHOLD;
1172       if (is_noise)
1173       {
1174          noise_energy = compute_frame_energy(pcm, frame_size, channels, arch);
1175          is_sufficiently_quiet = peak_signal_energy >= (PSEUDO_SNR_THRESHOLD * noise_energy);
1176       }
1177    }
1178
1179    if (is_silence || (is_noise && is_sufficiently_quiet))
1180    {
1181       /* The number of consecutive DTX frames should be within the allowed bounds */
1182       (*nb_no_activity_frames)++;
1183
1184       if (*nb_no_activity_frames > NB_SPEECH_FRAMES_BEFORE_DTX)
1185       {
1186          if (*nb_no_activity_frames <= (NB_SPEECH_FRAMES_BEFORE_DTX + MAX_CONSECUTIVE_DTX))
1187             /* Valid frame for DTX! */
1188             return 1;
1189          else
1190             (*nb_no_activity_frames) = NB_SPEECH_FRAMES_BEFORE_DTX;
1191       }
1192    } else
1193       (*nb_no_activity_frames) = 0;
1194
1195    return 0;
1196 }
1197
1198 #endif
1199
1200 opus_int32 opus_encode_native(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
1201                 unsigned char *data, opus_int32 out_data_bytes, int lsb_depth,
1202                 const void *analysis_pcm, opus_int32 analysis_size, int c1, int c2,
1203                 int analysis_channels, downmix_func downmix, int float_api)
1204 {
1205     void *silk_enc;
1206     CELTEncoder *celt_enc;
1207     int i;
1208     int ret=0;
1209     opus_int32 nBytes;
1210     ec_enc enc;
1211     int bytes_target;
1212     int prefill=0;
1213     int start_band = 0;
1214     int redundancy = 0;
1215     int redundancy_bytes = 0; /* Number of bytes to use for redundancy frame */
1216     int celt_to_silk = 0;
1217     VARDECL(opus_val16, pcm_buf);
1218     int nb_compr_bytes;
1219     int to_celt = 0;
1220     opus_uint32 redundant_rng = 0;
1221     int cutoff_Hz, hp_freq_smth1;
1222     int voice_est; /* Probability of voice in Q7 */
1223     opus_int32 equiv_rate;
1224     int delay_compensation;
1225     int frame_rate;
1226     opus_int32 max_rate; /* Max bitrate we're allowed to use */
1227     int curr_bandwidth;
1228     opus_val16 HB_gain;
1229     opus_int32 max_data_bytes; /* Max number of bytes we're allowed to use */
1230     int total_buffer;
1231     opus_val16 stereo_width;
1232     const CELTMode *celt_mode;
1233 #ifndef DISABLE_FLOAT_API
1234     AnalysisInfo analysis_info;
1235     int analysis_read_pos_bak=-1;
1236     int analysis_read_subframe_bak=-1;
1237     int is_silence = 0;
1238 #endif
1239     VARDECL(opus_val16, tmp_prefill);
1240
1241     ALLOC_STACK;
1242
1243     max_data_bytes = IMIN(1276, out_data_bytes);
1244
1245     st->rangeFinal = 0;
1246     if ((!st->variable_duration && 400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
1247          50*frame_size != st->Fs &&  25*frame_size != st->Fs &&  50*frame_size != 3*st->Fs)
1248          || (400*frame_size < st->Fs)
1249          || max_data_bytes<=0
1250          )
1251     {
1252        RESTORE_STACK;
1253        return OPUS_BAD_ARG;
1254     }
1255     silk_enc = (char*)st+st->silk_enc_offset;
1256     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1257     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1258        delay_compensation = 0;
1259     else
1260        delay_compensation = st->delay_compensation;
1261
1262     lsb_depth = IMIN(lsb_depth, st->lsb_depth);
1263
1264     celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1265 #ifndef DISABLE_FLOAT_API
1266     analysis_info.valid = 0;
1267 #ifdef FIXED_POINT
1268     if (st->silk_mode.complexity >= 10 && st->Fs==48000)
1269 #else
1270     if (st->silk_mode.complexity >= 7 && st->Fs==48000)
1271 #endif
1272     {
1273        if (is_digital_silence(pcm, frame_size, st->channels, lsb_depth))
1274        {
1275           is_silence = 1;
1276        } else {
1277           analysis_read_pos_bak = st->analysis.read_pos;
1278           analysis_read_subframe_bak = st->analysis.read_subframe;
1279           run_analysis(&st->analysis, celt_mode, analysis_pcm, analysis_size, frame_size,
1280                 c1, c2, analysis_channels, st->Fs,
1281                 lsb_depth, downmix, &analysis_info);
1282        }
1283
1284        /* Track the peak signal energy */
1285        if (!is_silence && analysis_info.activity_probability > DTX_ACTIVITY_THRESHOLD)
1286           st->peak_signal_energy = MAX32(MULT16_32_Q15(QCONST16(0.999, 15), st->peak_signal_energy),
1287                 compute_frame_energy(pcm, frame_size, st->channels, st->arch));
1288     }
1289 #else
1290     (void)analysis_pcm;
1291     (void)analysis_size;
1292 #endif
1293
1294 #ifndef DISABLE_FLOAT_API
1295     /* Reset voice_ratio if this frame is not silent or if analysis is disabled.
1296      * Otherwise, preserve voice_ratio from the last non-silent frame */
1297     if (!is_silence)
1298       st->voice_ratio = -1;
1299
1300     st->detected_bandwidth = 0;
1301     if (analysis_info.valid)
1302     {
1303        int analysis_bandwidth;
1304        if (st->signal_type == OPUS_AUTO)
1305           st->voice_ratio = (int)floor(.5+100*(1-analysis_info.music_prob));
1306
1307        analysis_bandwidth = analysis_info.bandwidth;
1308        if (analysis_bandwidth<=12)
1309           st->detected_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1310        else if (analysis_bandwidth<=14)
1311           st->detected_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1312        else if (analysis_bandwidth<=16)
1313           st->detected_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1314        else if (analysis_bandwidth<=18)
1315           st->detected_bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1316        else
1317           st->detected_bandwidth = OPUS_BANDWIDTH_FULLBAND;
1318     }
1319 #else
1320     st->voice_ratio = -1;
1321 #endif
1322
1323     if (st->channels==2 && st->force_channels!=1)
1324        stereo_width = compute_stereo_width(pcm, frame_size, st->Fs, &st->width_mem);
1325     else
1326        stereo_width = 0;
1327     total_buffer = delay_compensation;
1328     st->bitrate_bps = user_bitrate_to_bitrate(st, frame_size, max_data_bytes);
1329
1330     frame_rate = st->Fs/frame_size;
1331     if (!st->use_vbr)
1332     {
1333        int cbrBytes;
1334        /* Multiply by 3 to make sure the division is exact. */
1335        int frame_rate3 = 3*st->Fs/frame_size;
1336        /* We need to make sure that "int" values always fit in 16 bits. */
1337        cbrBytes = IMIN( (3*st->bitrate_bps/8 + frame_rate3/2)/frame_rate3, max_data_bytes);
1338        st->bitrate_bps = cbrBytes*(opus_int32)frame_rate3*8/3;
1339        /* Make sure we provide at least one byte to avoid failing. */
1340        max_data_bytes = IMAX(1, cbrBytes);
1341     }
1342     if (max_data_bytes<3 || st->bitrate_bps < 3*frame_rate*8
1343        || (frame_rate<50 && (max_data_bytes*frame_rate<300 || st->bitrate_bps < 2400)))
1344     {
1345        /*If the space is too low to do something useful, emit 'PLC' frames.*/
1346        int tocmode = st->mode;
1347        int bw = st->bandwidth == 0 ? OPUS_BANDWIDTH_NARROWBAND : st->bandwidth;
1348        if (tocmode==0)
1349           tocmode = MODE_SILK_ONLY;
1350        if (frame_rate>100)
1351           tocmode = MODE_CELT_ONLY;
1352        if (frame_rate < 50)
1353           tocmode = MODE_SILK_ONLY;
1354        if(tocmode==MODE_SILK_ONLY&&bw>OPUS_BANDWIDTH_WIDEBAND)
1355           bw=OPUS_BANDWIDTH_WIDEBAND;
1356        else if (tocmode==MODE_CELT_ONLY&&bw==OPUS_BANDWIDTH_MEDIUMBAND)
1357           bw=OPUS_BANDWIDTH_NARROWBAND;
1358        else if (tocmode==MODE_HYBRID&&bw<=OPUS_BANDWIDTH_SUPERWIDEBAND)
1359           bw=OPUS_BANDWIDTH_SUPERWIDEBAND;
1360        data[0] = gen_toc(tocmode, frame_rate, bw, st->stream_channels);
1361        ret = 1;
1362        if (!st->use_vbr)
1363        {
1364           ret = opus_packet_pad(data, ret, max_data_bytes);
1365           if (ret == OPUS_OK)
1366              ret = max_data_bytes;
1367           else
1368              ret = OPUS_INTERNAL_ERROR;
1369        }
1370        RESTORE_STACK;
1371        return ret;
1372     }
1373     max_rate = frame_rate*max_data_bytes*8;
1374
1375     /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */
1376     equiv_rate = compute_equiv_rate(st->bitrate_bps, st->channels, st->Fs/frame_size,
1377           st->use_vbr, 0, st->silk_mode.complexity, st->silk_mode.packetLossPercentage);
1378
1379     if (st->signal_type == OPUS_SIGNAL_VOICE)
1380        voice_est = 127;
1381     else if (st->signal_type == OPUS_SIGNAL_MUSIC)
1382        voice_est = 0;
1383     else if (st->voice_ratio >= 0)
1384     {
1385        voice_est = st->voice_ratio*327>>8;
1386        /* For AUDIO, never be more than 90% confident of having speech */
1387        if (st->application == OPUS_APPLICATION_AUDIO)
1388           voice_est = IMIN(voice_est, 115);
1389     } else if (st->application == OPUS_APPLICATION_VOIP)
1390        voice_est = 115;
1391     else
1392        voice_est = 48;
1393
1394     if (st->force_channels!=OPUS_AUTO && st->channels == 2)
1395     {
1396         st->stream_channels = st->force_channels;
1397     } else {
1398 #ifdef FUZZING
1399        /* Random mono/stereo decision */
1400        if (st->channels == 2 && (rand()&0x1F)==0)
1401           st->stream_channels = 3-st->stream_channels;
1402 #else
1403        /* Rate-dependent mono-stereo decision */
1404        if (st->channels == 2)
1405        {
1406           opus_int32 stereo_threshold;
1407           stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14);
1408           if (st->stream_channels == 2)
1409              stereo_threshold -= 1000;
1410           else
1411              stereo_threshold += 1000;
1412           st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1;
1413        } else {
1414           st->stream_channels = st->channels;
1415        }
1416 #endif
1417     }
1418     /* Update equivalent rate for channels decision. */
1419     equiv_rate = compute_equiv_rate(st->bitrate_bps, st->stream_channels, st->Fs/frame_size,
1420           st->use_vbr, 0, st->silk_mode.complexity, st->silk_mode.packetLossPercentage);
1421
1422     /* Mode selection depending on application and signal type */
1423     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1424     {
1425        st->mode = MODE_CELT_ONLY;
1426     } else if (st->user_forced_mode == OPUS_AUTO)
1427     {
1428 #ifdef FUZZING
1429        /* Random mode switching */
1430        if ((rand()&0xF)==0)
1431        {
1432           if ((rand()&0x1)==0)
1433              st->mode = MODE_CELT_ONLY;
1434           else
1435              st->mode = MODE_SILK_ONLY;
1436        } else {
1437           if (st->prev_mode==MODE_CELT_ONLY)
1438              st->mode = MODE_CELT_ONLY;
1439           else
1440              st->mode = MODE_SILK_ONLY;
1441        }
1442 #else
1443        opus_int32 mode_voice, mode_music;
1444        opus_int32 threshold;
1445
1446        /* Interpolate based on stereo width */
1447        mode_voice = (opus_int32)(MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[0][0])
1448              + MULT16_32_Q15(stereo_width,mode_thresholds[1][0]));
1449        mode_music = (opus_int32)(MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[1][1])
1450              + MULT16_32_Q15(stereo_width,mode_thresholds[1][1]));
1451        /* Interpolate based on speech/music probability */
1452        threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14);
1453        /* Bias towards SILK for VoIP because of some useful features */
1454        if (st->application == OPUS_APPLICATION_VOIP)
1455           threshold += 8000;
1456
1457        /*printf("%f %d\n", stereo_width/(float)Q15ONE, threshold);*/
1458        /* Hysteresis */
1459        if (st->prev_mode == MODE_CELT_ONLY)
1460            threshold -= 4000;
1461        else if (st->prev_mode>0)
1462            threshold += 4000;
1463
1464        st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY;
1465
1466        /* When FEC is enabled and there's enough packet loss, use SILK */
1467        if (st->silk_mode.useInBandFEC && st->silk_mode.packetLossPercentage > (128-voice_est)>>4)
1468           st->mode = MODE_SILK_ONLY;
1469        /* When encoding voice and DTX is enabled but the generalized DTX cannot be used,
1470           because of complexity and sampling frequency settings, switch to SILK DTX and
1471           set the encoder to SILK mode */
1472 #ifndef DISABLE_FLOAT_API
1473        st->silk_mode.useDTX = st->use_dtx && !(analysis_info.valid || is_silence);
1474 #else
1475        st->silk_mode.useDTX = st->use_dtx;
1476 #endif
1477        if (st->silk_mode.useDTX && voice_est > 100)
1478           st->mode = MODE_SILK_ONLY;
1479 #endif
1480     } else {
1481        st->mode = st->user_forced_mode;
1482     }
1483
1484     /* Override the chosen mode to make sure we meet the requested frame size */
1485     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
1486        st->mode = MODE_CELT_ONLY;
1487     if (st->lfe)
1488        st->mode = MODE_CELT_ONLY;
1489     /* If max_data_bytes represents less than 6 kb/s, switch to CELT-only mode */
1490     if (max_data_bytes < (frame_rate > 50 ? 9000 : 6000)*frame_size / (st->Fs * 8))
1491        st->mode = MODE_CELT_ONLY;
1492
1493     if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0
1494           && st->mode != MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)
1495     {
1496        /* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */
1497        st->silk_mode.toMono = 1;
1498        st->stream_channels = 2;
1499     } else {
1500        st->silk_mode.toMono = 0;
1501     }
1502
1503     if (st->prev_mode > 0 &&
1504         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
1505     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
1506     {
1507         redundancy = 1;
1508         celt_to_silk = (st->mode != MODE_CELT_ONLY);
1509         if (!celt_to_silk)
1510         {
1511             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
1512             if (frame_size >= st->Fs/100)
1513             {
1514                 st->mode = st->prev_mode;
1515                 to_celt = 1;
1516             } else {
1517                 redundancy=0;
1518             }
1519         }
1520     }
1521
1522     /* Update equivalent rate with mode decision. */
1523     equiv_rate = compute_equiv_rate(st->bitrate_bps, st->stream_channels, st->Fs/frame_size,
1524           st->use_vbr, st->mode, st->silk_mode.complexity, st->silk_mode.packetLossPercentage);
1525
1526     /* For the first frame at a new SILK bandwidth */
1527     if (st->silk_bw_switch)
1528     {
1529        redundancy = 1;
1530        celt_to_silk = 1;
1531        st->silk_bw_switch = 0;
1532        prefill=1;
1533     }
1534
1535     if (redundancy)
1536     {
1537        /* Fair share of the max size allowed */
1538        redundancy_bytes = IMIN(257, max_data_bytes*(opus_int32)(st->Fs/200)/(frame_size+st->Fs/200));
1539        /* For VBR, target the actual bitrate (subject to the limit above) */
1540        if (st->use_vbr)
1541           redundancy_bytes = IMIN(redundancy_bytes, st->bitrate_bps/1600);
1542     }
1543
1544     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
1545     {
1546         silk_EncControlStruct dummy;
1547         silk_InitEncoder( silk_enc, st->arch, &dummy);
1548         prefill=1;
1549     }
1550
1551     /* Automatic (rate-dependent) bandwidth selection */
1552     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
1553     {
1554         const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds;
1555         opus_int32 bandwidth_thresholds[8];
1556         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
1557
1558         if (st->channels==2 && st->force_channels!=1)
1559         {
1560            voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds;
1561            music_bandwidth_thresholds = stereo_music_bandwidth_thresholds;
1562         } else {
1563            voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds;
1564            music_bandwidth_thresholds = mono_music_bandwidth_thresholds;
1565         }
1566         /* Interpolate bandwidth thresholds depending on voice estimation */
1567         for (i=0;i<8;i++)
1568         {
1569            bandwidth_thresholds[i] = music_bandwidth_thresholds[i]
1570                     + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14);
1571         }
1572         do {
1573             int threshold, hysteresis;
1574             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
1575             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
1576             if (!st->first)
1577             {
1578                 if (st->auto_bandwidth >= bandwidth)
1579                     threshold -= hysteresis;
1580                 else
1581                     threshold += hysteresis;
1582             }
1583             if (equiv_rate >= threshold)
1584                 break;
1585         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
1586         st->bandwidth = st->auto_bandwidth = bandwidth;
1587         /* Prevents any transition to SWB/FB until the SILK layer has fully
1588            switched to WB mode and turned the variable LP filter off */
1589         if (!st->first && st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1590             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1591     }
1592
1593     if (st->bandwidth>st->max_bandwidth)
1594        st->bandwidth = st->max_bandwidth;
1595
1596     if (st->user_bandwidth != OPUS_AUTO)
1597         st->bandwidth = st->user_bandwidth;
1598
1599     /* This prevents us from using hybrid at unsafe CBR/max rates */
1600     if (st->mode != MODE_CELT_ONLY && max_rate < 15000)
1601     {
1602        st->bandwidth = IMIN(st->bandwidth, OPUS_BANDWIDTH_WIDEBAND);
1603     }
1604
1605     /* Prevents Opus from wasting bits on frequencies that are above
1606        the Nyquist rate of the input signal */
1607     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
1608         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1609     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1610         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1611     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
1612         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1613     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
1614         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1615 #ifndef DISABLE_FLOAT_API
1616     /* Use detected bandwidth to reduce the encoded bandwidth. */
1617     if (st->detected_bandwidth && st->user_bandwidth == OPUS_AUTO)
1618     {
1619        int min_detected_bandwidth;
1620        /* Makes bandwidth detection more conservative just in case the detector
1621           gets it wrong when we could have coded a high bandwidth transparently.
1622           When operating in SILK/hybrid mode, we don't go below wideband to avoid
1623           more complicated switches that require redundancy. */
1624        if (equiv_rate <= 18000*st->stream_channels && st->mode == MODE_CELT_ONLY)
1625           min_detected_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1626        else if (equiv_rate <= 24000*st->stream_channels && st->mode == MODE_CELT_ONLY)
1627           min_detected_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1628        else if (equiv_rate <= 30000*st->stream_channels)
1629           min_detected_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1630        else if (equiv_rate <= 44000*st->stream_channels)
1631           min_detected_bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1632        else
1633           min_detected_bandwidth = OPUS_BANDWIDTH_FULLBAND;
1634
1635        st->detected_bandwidth = IMAX(st->detected_bandwidth, min_detected_bandwidth);
1636        st->bandwidth = IMIN(st->bandwidth, st->detected_bandwidth);
1637     }
1638 #endif
1639     st->silk_mode.LBRR_coded = decide_fec(st->silk_mode.useInBandFEC, st->silk_mode.packetLossPercentage,
1640           st->silk_mode.LBRR_coded, st->mode, &st->bandwidth, equiv_rate);
1641     celt_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(lsb_depth));
1642
1643     /* CELT mode doesn't support mediumband, use wideband instead */
1644     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1645         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1646     if (st->lfe)
1647        st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1648
1649     /* Can't support higher than wideband for >20 ms frames */
1650     if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND))
1651     {
1652        VARDECL(unsigned char, tmp_data);
1653        int nb_frames;
1654        int bak_mode, bak_bandwidth, bak_channels, bak_to_mono;
1655        VARDECL(OpusRepacketizer, rp);
1656        opus_int32 bytes_per_frame;
1657        opus_int32 repacketize_len;
1658
1659 #ifndef DISABLE_FLOAT_API
1660        if (analysis_read_pos_bak!= -1)
1661        {
1662           st->analysis.read_pos = analysis_read_pos_bak;
1663           st->analysis.read_subframe = analysis_read_subframe_bak;
1664        }
1665 #endif
1666
1667        nb_frames = frame_size > st->Fs/25 ? 3 : 2;
1668        bytes_per_frame = IMIN(1276,(out_data_bytes-3)/nb_frames);
1669
1670        ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char);
1671
1672        ALLOC(rp, 1, OpusRepacketizer);
1673        opus_repacketizer_init(rp);
1674
1675        bak_mode = st->user_forced_mode;
1676        bak_bandwidth = st->user_bandwidth;
1677        bak_channels = st->force_channels;
1678
1679        st->user_forced_mode = st->mode;
1680        st->user_bandwidth = st->bandwidth;
1681        st->force_channels = st->stream_channels;
1682        bak_to_mono = st->silk_mode.toMono;
1683
1684        if (bak_to_mono)
1685           st->force_channels = 1;
1686        else
1687           st->prev_channels = st->stream_channels;
1688        for (i=0;i<nb_frames;i++)
1689        {
1690           int tmp_len;
1691           st->silk_mode.toMono = 0;
1692           /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
1693           if (to_celt && i==nb_frames-1)
1694              st->user_forced_mode = MODE_CELT_ONLY;
1695           tmp_len = opus_encode_native(st, pcm+i*(st->channels*st->Fs/50), st->Fs/50,
1696                 tmp_data+i*bytes_per_frame, bytes_per_frame, lsb_depth,
1697                 NULL, 0, c1, c2, analysis_channels, downmix, float_api);
1698           if (tmp_len<0)
1699           {
1700              RESTORE_STACK;
1701              return OPUS_INTERNAL_ERROR;
1702           }
1703           ret = opus_repacketizer_cat(rp, tmp_data+i*bytes_per_frame, tmp_len);
1704           if (ret<0)
1705           {
1706              RESTORE_STACK;
1707              return OPUS_INTERNAL_ERROR;
1708           }
1709        }
1710        if (st->use_vbr)
1711           repacketize_len = out_data_bytes;
1712        else
1713           repacketize_len = IMIN(3*st->bitrate_bps/(3*8*50/nb_frames), out_data_bytes);
1714        ret = opus_repacketizer_out_range_impl(rp, 0, nb_frames, data, repacketize_len, 0, !st->use_vbr);
1715        if (ret<0)
1716        {
1717           RESTORE_STACK;
1718           return OPUS_INTERNAL_ERROR;
1719        }
1720        st->user_forced_mode = bak_mode;
1721        st->user_bandwidth = bak_bandwidth;
1722        st->force_channels = bak_channels;
1723        st->silk_mode.toMono = bak_to_mono;
1724        RESTORE_STACK;
1725        return ret;
1726     }
1727     curr_bandwidth = st->bandwidth;
1728
1729     /* Chooses the appropriate mode for speech
1730        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
1731     if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1732         st->mode = MODE_HYBRID;
1733     if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
1734         st->mode = MODE_SILK_ONLY;
1735     /* If we decided to go with CELT, make sure redundancy is off, no matter what
1736        we decided earlier. */
1737     if (st->mode == MODE_CELT_ONLY)
1738     {
1739         redundancy = 0;
1740         redundancy_bytes = 0;
1741     }
1742
1743     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
1744     bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
1745
1746     data += 1;
1747
1748     ec_enc_init(&enc, data, max_data_bytes-1);
1749
1750     ALLOC(pcm_buf, (total_buffer+frame_size)*st->channels, opus_val16);
1751     OPUS_COPY(pcm_buf, &st->delay_buffer[(st->encoder_buffer-total_buffer)*st->channels], total_buffer*st->channels);
1752
1753     if (st->mode == MODE_CELT_ONLY)
1754        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1755     else
1756        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
1757
1758     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
1759           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
1760
1761     /* convert from log scale to Hertz */
1762     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
1763
1764     if (st->application == OPUS_APPLICATION_VOIP)
1765     {
1766        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1767     } else {
1768        dc_reject(pcm, 3, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1769     }
1770 #ifndef FIXED_POINT
1771     if (float_api)
1772     {
1773        opus_val32 sum;
1774        sum = celt_inner_prod(&pcm_buf[total_buffer*st->channels], &pcm_buf[total_buffer*st->channels], frame_size*st->channels, st->arch);
1775        /* This should filter out both NaNs and ridiculous signals that could
1776           cause NaNs further down. */
1777        if (!(sum < 1e9f) || celt_isnan(sum))
1778        {
1779           OPUS_CLEAR(&pcm_buf[total_buffer*st->channels], frame_size*st->channels);
1780           st->hp_mem[0] = st->hp_mem[1] = st->hp_mem[2] = st->hp_mem[3] = 0;
1781        }
1782     }
1783 #endif
1784
1785
1786     /* SILK processing */
1787     HB_gain = Q15ONE;
1788     if (st->mode != MODE_CELT_ONLY)
1789     {
1790         opus_int32 total_bitRate, celt_rate;
1791 #ifdef FIXED_POINT
1792        const opus_int16 *pcm_silk;
1793 #else
1794        VARDECL(opus_int16, pcm_silk);
1795        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
1796 #endif
1797
1798         /* Distribute bits between SILK and CELT */
1799         total_bitRate = 8 * bytes_target * frame_rate;
1800         if( st->mode == MODE_HYBRID ) {
1801             /* Base rate for SILK */
1802             st->silk_mode.bitRate = compute_silk_rate_for_hybrid(total_bitRate,
1803                   curr_bandwidth, st->Fs == 50 * frame_size, st->use_vbr, st->silk_mode.LBRR_coded);
1804             if (!st->energy_masking)
1805             {
1806                /* Increasingly attenuate high band when it gets allocated fewer bits */
1807                celt_rate = total_bitRate - st->silk_mode.bitRate;
1808                HB_gain = Q15ONE - SHR32(celt_exp2(-celt_rate * QCONST16(1.f/1024, 10)), 1);
1809             }
1810         } else {
1811             /* SILK gets all bits */
1812             st->silk_mode.bitRate = total_bitRate;
1813         }
1814
1815         /* Surround masking for SILK */
1816         if (st->energy_masking && st->use_vbr && !st->lfe)
1817         {
1818            opus_val32 mask_sum=0;
1819            opus_val16 masking_depth;
1820            opus_int32 rate_offset;
1821            int c;
1822            int end = 17;
1823            opus_int16 srate = 16000;
1824            if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND)
1825            {
1826               end = 13;
1827               srate = 8000;
1828            } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1829            {
1830               end = 15;
1831               srate = 12000;
1832            }
1833            for (c=0;c<st->channels;c++)
1834            {
1835               for(i=0;i<end;i++)
1836               {
1837                  opus_val16 mask;
1838                  mask = MAX16(MIN16(st->energy_masking[21*c+i],
1839                         QCONST16(.5f, DB_SHIFT)), -QCONST16(2.0f, DB_SHIFT));
1840                  if (mask > 0)
1841                     mask = HALF16(mask);
1842                  mask_sum += mask;
1843               }
1844            }
1845            /* Conservative rate reduction, we cut the masking in half */
1846            masking_depth = mask_sum / end*st->channels;
1847            masking_depth += QCONST16(.2f, DB_SHIFT);
1848            rate_offset = (opus_int32)PSHR32(MULT16_16(srate, masking_depth), DB_SHIFT);
1849            rate_offset = MAX32(rate_offset, -2*st->silk_mode.bitRate/3);
1850            /* Split the rate change between the SILK and CELT part for hybrid. */
1851            if (st->bandwidth==OPUS_BANDWIDTH_SUPERWIDEBAND || st->bandwidth==OPUS_BANDWIDTH_FULLBAND)
1852               st->silk_mode.bitRate += 3*rate_offset/5;
1853            else
1854               st->silk_mode.bitRate += rate_offset;
1855            bytes_target += rate_offset * frame_size / (8 * st->Fs);
1856         }
1857
1858         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
1859         st->silk_mode.nChannelsAPI = st->channels;
1860         st->silk_mode.nChannelsInternal = st->stream_channels;
1861         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1862             st->silk_mode.desiredInternalSampleRate = 8000;
1863         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1864             st->silk_mode.desiredInternalSampleRate = 12000;
1865         } else {
1866             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
1867             st->silk_mode.desiredInternalSampleRate = 16000;
1868         }
1869         if( st->mode == MODE_HYBRID ) {
1870             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
1871             st->silk_mode.minInternalSampleRate = 16000;
1872         } else {
1873             st->silk_mode.minInternalSampleRate = 8000;
1874         }
1875
1876         st->silk_mode.maxInternalSampleRate = 16000;
1877         if (st->mode == MODE_SILK_ONLY)
1878         {
1879            opus_int32 effective_max_rate = max_rate;
1880            if (frame_rate > 50)
1881               effective_max_rate = effective_max_rate*2/3;
1882            if (effective_max_rate < 8000)
1883            {
1884               st->silk_mode.maxInternalSampleRate = 12000;
1885               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
1886            }
1887            if (effective_max_rate < 7000)
1888            {
1889               st->silk_mode.maxInternalSampleRate = 8000;
1890               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
1891            }
1892         }
1893
1894         st->silk_mode.useCBR = !st->use_vbr;
1895
1896         /* Call SILK encoder for the low band */
1897         nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes);
1898
1899         st->silk_mode.maxBits = nBytes*8;
1900         if (st->silk_mode.useCBR)
1901         {
1902            if (st->mode == MODE_HYBRID)
1903            {
1904               st->silk_mode.maxBits = st->silk_mode.bitRate * frame_size / st->Fs;
1905            }
1906         } else {
1907            /* Constrained VBR. */
1908            if (st->mode == MODE_HYBRID)
1909            {
1910               /* Compute SILK bitrate corresponding to the max total bits available */
1911               opus_int32 maxBitRate = compute_silk_rate_for_hybrid(nBytes*8*st->Fs / frame_size,
1912                     curr_bandwidth, st->Fs == 50 * frame_size, st->use_vbr, st->silk_mode.LBRR_coded);
1913               st->silk_mode.maxBits = maxBitRate * frame_size / st->Fs;
1914            }
1915         }
1916
1917         if (prefill)
1918         {
1919             opus_int32 zero=0;
1920             int prefill_offset;
1921             /* Use a smooth onset for the SILK prefill to avoid the encoder trying to encode
1922                a discontinuity. The exact location is what we need to avoid leaving any "gap"
1923                in the audio when mixing with the redundant CELT frame. Here we can afford to
1924                overwrite st->delay_buffer because the only thing that uses it before it gets
1925                rewritten is tmp_prefill[] and even then only the part after the ramp really
1926                gets used (rather than sent to the encoder and discarded) */
1927             prefill_offset = st->channels*(st->encoder_buffer-st->delay_compensation-st->Fs/400);
1928             gain_fade(st->delay_buffer+prefill_offset, st->delay_buffer+prefill_offset,
1929                   0, Q15ONE, celt_mode->overlap, st->Fs/400, st->channels, celt_mode->window, st->Fs);
1930             OPUS_CLEAR(st->delay_buffer, prefill_offset);
1931 #ifdef FIXED_POINT
1932             pcm_silk = st->delay_buffer;
1933 #else
1934             for (i=0;i<st->encoder_buffer*st->channels;i++)
1935                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
1936 #endif
1937             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
1938         }
1939
1940 #ifdef FIXED_POINT
1941         pcm_silk = pcm_buf+total_buffer*st->channels;
1942 #else
1943         for (i=0;i<frame_size*st->channels;i++)
1944             pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
1945 #endif
1946         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
1947         if( ret ) {
1948             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
1949             /* Handle error */
1950            RESTORE_STACK;
1951            return OPUS_INTERNAL_ERROR;
1952         }
1953         if (nBytes==0)
1954         {
1955            st->rangeFinal = 0;
1956            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1957            RESTORE_STACK;
1958            return 1;
1959         }
1960         /* Extract SILK internal bandwidth for signaling in first byte */
1961         if( st->mode == MODE_SILK_ONLY ) {
1962             if( st->silk_mode.internalSampleRate == 8000 ) {
1963                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1964             } else if( st->silk_mode.internalSampleRate == 12000 ) {
1965                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1966             } else if( st->silk_mode.internalSampleRate == 16000 ) {
1967                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1968             }
1969         } else {
1970             silk_assert( st->silk_mode.internalSampleRate == 16000 );
1971         }
1972
1973         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
1974         /* FIXME: How do we allocate the redundancy for CBR? */
1975         if (st->silk_mode.opusCanSwitch)
1976         {
1977            redundancy = 1;
1978            celt_to_silk = 0;
1979            st->silk_bw_switch = 1;
1980         }
1981     }
1982
1983     /* CELT processing */
1984     {
1985         int endband=21;
1986
1987         switch(curr_bandwidth)
1988         {
1989             case OPUS_BANDWIDTH_NARROWBAND:
1990                 endband = 13;
1991                 break;
1992             case OPUS_BANDWIDTH_MEDIUMBAND:
1993             case OPUS_BANDWIDTH_WIDEBAND:
1994                 endband = 17;
1995                 break;
1996             case OPUS_BANDWIDTH_SUPERWIDEBAND:
1997                 endband = 19;
1998                 break;
1999             case OPUS_BANDWIDTH_FULLBAND:
2000                 endband = 21;
2001                 break;
2002         }
2003         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
2004         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
2005     }
2006     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
2007     if (st->mode != MODE_SILK_ONLY)
2008     {
2009         opus_val32 celt_pred=2;
2010         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
2011         /* We may still decide to disable prediction later */
2012         if (st->silk_mode.reducedDependency)
2013            celt_pred = 0;
2014         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(celt_pred));
2015
2016         if (st->mode == MODE_HYBRID)
2017         {
2018             int len;
2019
2020             len = (ec_tell(&enc)+7)>>3;
2021             if (redundancy)
2022                len += st->mode == MODE_HYBRID ? 3 : 1;
2023             if( st->use_vbr ) {
2024                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps-st->silk_mode.bitRate));
2025                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
2026                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(0));
2027             } else {
2028                 /* check if SILK used up too much */
2029                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
2030             }
2031         } else {
2032             if (st->use_vbr)
2033             {
2034                 opus_int32 bonus=0;
2035 #ifndef DISABLE_FLOAT_API
2036                 if (st->variable_duration==OPUS_FRAMESIZE_VARIABLE && frame_size != st->Fs/50)
2037                 {
2038                    bonus = (60*st->stream_channels+40)*(st->Fs/frame_size-50);
2039                    if (analysis_info.valid)
2040                       bonus = (opus_int32)(bonus*(1.f+.5f*analysis_info.tonality));
2041                 }
2042 #endif
2043                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
2044                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
2045                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps+bonus));
2046                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
2047             } else {
2048                 nb_compr_bytes = bytes_target;
2049             }
2050         }
2051
2052     } else {
2053         nb_compr_bytes = 0;
2054     }
2055
2056     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
2057     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
2058     {
2059        OPUS_COPY(tmp_prefill, &st->delay_buffer[(st->encoder_buffer-total_buffer-st->Fs/400)*st->channels], st->channels*st->Fs/400);
2060     }
2061
2062     if (st->channels*(st->encoder_buffer-(frame_size+total_buffer)) > 0)
2063     {
2064        OPUS_MOVE(st->delay_buffer, &st->delay_buffer[st->channels*frame_size], st->channels*(st->encoder_buffer-frame_size-total_buffer));
2065        OPUS_COPY(&st->delay_buffer[st->channels*(st->encoder_buffer-frame_size-total_buffer)],
2066              &pcm_buf[0],
2067              (frame_size+total_buffer)*st->channels);
2068     } else {
2069        OPUS_COPY(st->delay_buffer, &pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels], st->encoder_buffer*st->channels);
2070     }
2071     /* gain_fade() and stereo_fade() need to be after the buffer copying
2072        because we don't want any of this to affect the SILK part */
2073     if( st->prev_HB_gain < Q15ONE || HB_gain < Q15ONE ) {
2074        gain_fade(pcm_buf, pcm_buf,
2075              st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs);
2076     }
2077     st->prev_HB_gain = HB_gain;
2078     if (st->mode != MODE_HYBRID || st->stream_channels==1)
2079        st->silk_mode.stereoWidth_Q14 = IMIN((1<<14),2*IMAX(0,equiv_rate-24000));
2080     if( !st->energy_masking && st->channels == 2 ) {
2081         /* Apply stereo width reduction (at low bitrates) */
2082         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
2083             opus_val16 g1, g2;
2084             g1 = st->hybrid_stereo_width_Q14;
2085             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
2086 #ifdef FIXED_POINT
2087             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
2088             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
2089 #else
2090             g1 *= (1.f/16384);
2091             g2 *= (1.f/16384);
2092 #endif
2093             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
2094                   frame_size, st->channels, celt_mode->window, st->Fs);
2095             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
2096         }
2097     }
2098
2099     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
2100     {
2101         /* For SILK mode, the redundancy is inferred from the length */
2102         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
2103            ec_enc_bit_logp(&enc, redundancy, 12);
2104         if (redundancy)
2105         {
2106             int max_redundancy;
2107             ec_enc_bit_logp(&enc, celt_to_silk, 1);
2108             if (st->mode == MODE_HYBRID)
2109                max_redundancy = (max_data_bytes-1)-nb_compr_bytes;
2110             else
2111                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
2112             /* Target the same bit-rate for redundancy as for the rest,
2113                up to a max of 257 bytes */
2114             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
2115             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
2116             if (st->mode == MODE_HYBRID)
2117                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
2118         }
2119     } else {
2120         redundancy = 0;
2121     }
2122
2123     if (!redundancy)
2124     {
2125        st->silk_bw_switch = 0;
2126        redundancy_bytes = 0;
2127     }
2128     if (st->mode != MODE_CELT_ONLY)start_band=17;
2129
2130     if (st->mode == MODE_SILK_ONLY)
2131     {
2132         ret = (ec_tell(&enc)+7)>>3;
2133         ec_enc_done(&enc);
2134         nb_compr_bytes = ret;
2135     } else {
2136        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
2137        ec_enc_shrink(&enc, nb_compr_bytes);
2138     }
2139
2140 #ifndef DISABLE_FLOAT_API
2141     if (redundancy || st->mode != MODE_SILK_ONLY)
2142        celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(&analysis_info));
2143 #endif
2144     if (st->mode == MODE_HYBRID) {
2145        SILKInfo info;
2146        info.signalType = st->silk_mode.signalType;
2147        info.offset = st->silk_mode.offset;
2148        celt_encoder_ctl(celt_enc, CELT_SET_SILK_INFO(&info));
2149     } else {
2150        celt_encoder_ctl(celt_enc, CELT_SET_SILK_INFO((SILKInfo*)NULL));
2151     }
2152
2153     /* 5 ms redundant frame for CELT->SILK */
2154     if (redundancy && celt_to_silk)
2155     {
2156         int err;
2157         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
2158         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
2159         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
2160         err = celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
2161         if (err < 0)
2162         {
2163            RESTORE_STACK;
2164            return OPUS_INTERNAL_ERROR;
2165         }
2166         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
2167         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2168     }
2169
2170     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
2171
2172     if (st->mode != MODE_SILK_ONLY)
2173     {
2174         if (st->mode != st->prev_mode && st->prev_mode > 0)
2175         {
2176            unsigned char dummy[2];
2177            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2178
2179            /* Prefilling */
2180            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
2181            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
2182         }
2183         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
2184         if (ec_tell(&enc) <= 8*nb_compr_bytes)
2185         {
2186            /* Set the bitrate again if it was overridden in the redundancy code above*/
2187            if (redundancy && celt_to_silk && st->mode==MODE_HYBRID && st->use_vbr)
2188               celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps-st->silk_mode.bitRate));
2189            celt_encoder_ctl(celt_enc, OPUS_SET_VBR(st->use_vbr));
2190            ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
2191            if (ret < 0)
2192            {
2193               RESTORE_STACK;
2194               return OPUS_INTERNAL_ERROR;
2195            }
2196            /* Put CELT->SILK redundancy data in the right place. */
2197            if (redundancy && celt_to_silk && st->mode==MODE_HYBRID && st->use_vbr)
2198            {
2199               OPUS_COPY(data+ret, data+nb_compr_bytes, redundancy_bytes);
2200               nb_compr_bytes = nb_compr_bytes+redundancy_bytes;
2201            }
2202         }
2203     }
2204
2205     /* 5 ms redundant frame for SILK->CELT */
2206     if (redundancy && !celt_to_silk)
2207     {
2208         int err;
2209         unsigned char dummy[2];
2210         int N2, N4;
2211         N2 = st->Fs/200;
2212         N4 = st->Fs/400;
2213
2214         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2215         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
2216         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
2217         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
2218         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
2219
2220         if (st->mode == MODE_HYBRID)
2221         {
2222            /* Shrink packet to what the encoder actually used. */
2223            nb_compr_bytes = ret;
2224            ec_enc_shrink(&enc, nb_compr_bytes);
2225         }
2226         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
2227         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL);
2228
2229         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
2230         if (err < 0)
2231         {
2232            RESTORE_STACK;
2233            return OPUS_INTERNAL_ERROR;
2234         }
2235         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
2236     }
2237
2238
2239
2240     /* Signalling the mode in the first byte */
2241     data--;
2242     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
2243
2244     st->rangeFinal = enc.rng ^ redundant_rng;
2245
2246     if (to_celt)
2247         st->prev_mode = MODE_CELT_ONLY;
2248     else
2249         st->prev_mode = st->mode;
2250     st->prev_channels = st->stream_channels;
2251     st->prev_framesize = frame_size;
2252
2253     st->first = 0;
2254
2255     /* DTX decision */
2256 #ifndef DISABLE_FLOAT_API
2257     if (st->use_dtx && (analysis_info.valid || is_silence))
2258     {
2259        if (decide_dtx_mode(analysis_info.activity_probability, &st->nb_no_activity_frames,
2260              st->peak_signal_energy, pcm, frame_size, st->channels, is_silence, st->arch))
2261        {
2262           st->rangeFinal = 0;
2263           data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
2264           RESTORE_STACK;
2265           return 1;
2266        }
2267     }
2268 #endif
2269
2270     /* In the unlikely case that the SILK encoder busted its target, tell
2271        the decoder to call the PLC */
2272     if (ec_tell(&enc) > (max_data_bytes-1)*8)
2273     {
2274        if (max_data_bytes < 2)
2275        {
2276           RESTORE_STACK;
2277           return OPUS_BUFFER_TOO_SMALL;
2278        }
2279        data[1] = 0;
2280        ret = 1;
2281        st->rangeFinal = 0;
2282     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
2283     {
2284        /*When in LPC only mode it's perfectly
2285          reasonable to strip off trailing zero bytes as
2286          the required range decoder behavior is to
2287          fill these in. This can't be done when the MDCT
2288          modes are used because the decoder needs to know
2289          the actual length for allocation purposes.*/
2290        while(ret>2&&data[ret]==0)ret--;
2291     }
2292     /* Count ToC and redundancy */
2293     ret += 1+redundancy_bytes;
2294     if (!st->use_vbr)
2295     {
2296        if (opus_packet_pad(data, ret, max_data_bytes) != OPUS_OK)
2297
2298        {
2299           RESTORE_STACK;
2300           return OPUS_INTERNAL_ERROR;
2301        }
2302        ret = max_data_bytes;
2303     }
2304     RESTORE_STACK;
2305     return ret;
2306 }
2307
2308 #ifdef FIXED_POINT
2309
2310 #ifndef DISABLE_FLOAT_API
2311 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int analysis_frame_size,
2312       unsigned char *data, opus_int32 max_data_bytes)
2313 {
2314    int i, ret;
2315    int frame_size;
2316    int delay_compensation;
2317    VARDECL(opus_int16, in);
2318    ALLOC_STACK;
2319
2320    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2321       delay_compensation = 0;
2322    else
2323       delay_compensation = st->delay_compensation;
2324    frame_size = compute_frame_size(pcm, analysis_frame_size,
2325          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2326          delay_compensation, downmix_float, st->analysis.subframe_mem);
2327
2328    ALLOC(in, frame_size*st->channels, opus_int16);
2329
2330    for (i=0;i<frame_size*st->channels;i++)
2331       in[i] = FLOAT2INT16(pcm[i]);
2332    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16,
2333                             pcm, analysis_frame_size, 0, -2, st->channels, downmix_float, 1);
2334    RESTORE_STACK;
2335    return ret;
2336 }
2337 #endif
2338
2339 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int analysis_frame_size,
2340                 unsigned char *data, opus_int32 out_data_bytes)
2341 {
2342    int frame_size;
2343    int delay_compensation;
2344    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2345       delay_compensation = 0;
2346    else
2347       delay_compensation = st->delay_compensation;
2348    frame_size = compute_frame_size(pcm, analysis_frame_size,
2349          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2350          delay_compensation, downmix_int
2351 #ifndef DISABLE_FLOAT_API
2352          , st->analysis.subframe_mem
2353 #endif
2354          );
2355    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 16,
2356                              pcm, analysis_frame_size, 0, -2, st->channels, downmix_int, 0);
2357 }
2358
2359 #else
2360 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int analysis_frame_size,
2361       unsigned char *data, opus_int32 max_data_bytes)
2362 {
2363    int i, ret;
2364    int frame_size;
2365    int delay_compensation;
2366    VARDECL(float, in);
2367    ALLOC_STACK;
2368
2369    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2370       delay_compensation = 0;
2371    else
2372       delay_compensation = st->delay_compensation;
2373    frame_size = compute_frame_size(pcm, analysis_frame_size,
2374          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2375          delay_compensation, downmix_int, st->analysis.subframe_mem);
2376
2377    ALLOC(in, frame_size*st->channels, float);
2378
2379    for (i=0;i<frame_size*st->channels;i++)
2380       in[i] = (1.0f/32768)*pcm[i];
2381    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16,
2382                             pcm, analysis_frame_size, 0, -2, st->channels, downmix_int, 0);
2383    RESTORE_STACK;
2384    return ret;
2385 }
2386 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int analysis_frame_size,
2387                       unsigned char *data, opus_int32 out_data_bytes)
2388 {
2389    int frame_size;
2390    int delay_compensation;
2391    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2392       delay_compensation = 0;
2393    else
2394       delay_compensation = st->delay_compensation;
2395    frame_size = compute_frame_size(pcm, analysis_frame_size,
2396          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2397          delay_compensation, downmix_float, st->analysis.subframe_mem);
2398    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 24,
2399                              pcm, analysis_frame_size, 0, -2, st->channels, downmix_float, 1);
2400 }
2401 #endif
2402
2403
2404 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
2405 {
2406     int ret;
2407     CELTEncoder *celt_enc;
2408     va_list ap;
2409
2410     ret = OPUS_OK;
2411     va_start(ap, request);
2412
2413     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
2414
2415     switch (request)
2416     {
2417         case OPUS_SET_APPLICATION_REQUEST:
2418         {
2419             opus_int32 value = va_arg(ap, opus_int32);
2420             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
2421                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2422                || (!st->first && st->application != value))
2423             {
2424                ret = OPUS_BAD_ARG;
2425                break;
2426             }
2427             st->application = value;
2428         }
2429         break;
2430         case OPUS_GET_APPLICATION_REQUEST:
2431         {
2432             opus_int32 *value = va_arg(ap, opus_int32*);
2433             if (!value)
2434             {
2435                goto bad_arg;
2436             }
2437             *value = st->application;
2438         }
2439         break;
2440         case OPUS_SET_BITRATE_REQUEST:
2441         {
2442             opus_int32 value = va_arg(ap, opus_int32);
2443             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
2444             {
2445                 if (value <= 0)
2446                     goto bad_arg;
2447                 else if (value <= 500)
2448                     value = 500;
2449                 else if (value > (opus_int32)300000*st->channels)
2450                     value = (opus_int32)300000*st->channels;
2451             }
2452             st->user_bitrate_bps = value;
2453         }
2454         break;
2455         case OPUS_GET_BITRATE_REQUEST:
2456         {
2457             opus_int32 *value = va_arg(ap, opus_int32*);
2458             if (!value)
2459             {
2460                goto bad_arg;
2461             }
2462             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
2463         }
2464         break;
2465         case OPUS_SET_FORCE_CHANNELS_REQUEST:
2466         {
2467             opus_int32 value = va_arg(ap, opus_int32);
2468             if((value<1 || value>st->channels) && value != OPUS_AUTO)
2469             {
2470                goto bad_arg;
2471             }
2472             st->force_channels = value;
2473         }
2474         break;
2475         case OPUS_GET_FORCE_CHANNELS_REQUEST:
2476         {
2477             opus_int32 *value = va_arg(ap, opus_int32*);
2478             if (!value)
2479             {
2480                goto bad_arg;
2481             }
2482             *value = st->force_channels;
2483         }
2484         break;
2485         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
2486         {
2487             opus_int32 value = va_arg(ap, opus_int32);
2488             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND)
2489             {
2490                goto bad_arg;
2491             }
2492             st->max_bandwidth = value;
2493             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2494                 st->silk_mode.maxInternalSampleRate = 8000;
2495             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2496                 st->silk_mode.maxInternalSampleRate = 12000;
2497             } else {
2498                 st->silk_mode.maxInternalSampleRate = 16000;
2499             }
2500         }
2501         break;
2502         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
2503         {
2504             opus_int32 *value = va_arg(ap, opus_int32*);
2505             if (!value)
2506             {
2507                goto bad_arg;
2508             }
2509             *value = st->max_bandwidth;
2510         }
2511         break;
2512         case OPUS_SET_BANDWIDTH_REQUEST:
2513         {
2514             opus_int32 value = va_arg(ap, opus_int32);
2515             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
2516             {
2517                goto bad_arg;
2518             }
2519             st->user_bandwidth = value;
2520             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2521                 st->silk_mode.maxInternalSampleRate = 8000;
2522             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2523                 st->silk_mode.maxInternalSampleRate = 12000;
2524             } else {
2525                 st->silk_mode.maxInternalSampleRate = 16000;
2526             }
2527         }
2528         break;
2529         case OPUS_GET_BANDWIDTH_REQUEST:
2530         {
2531             opus_int32 *value = va_arg(ap, opus_int32*);
2532             if (!value)
2533             {
2534                goto bad_arg;
2535             }
2536             *value = st->bandwidth;
2537         }
2538         break;
2539         case OPUS_SET_DTX_REQUEST:
2540         {
2541             opus_int32 value = va_arg(ap, opus_int32);
2542             if(value<0 || value>1)
2543             {
2544                goto bad_arg;
2545             }
2546             st->use_dtx = value;
2547         }
2548         break;
2549         case OPUS_GET_DTX_REQUEST:
2550         {
2551             opus_int32 *value = va_arg(ap, opus_int32*);
2552             if (!value)
2553             {
2554                goto bad_arg;
2555             }
2556             *value = st->use_dtx;
2557         }
2558         break;
2559         case OPUS_SET_COMPLEXITY_REQUEST:
2560         {
2561             opus_int32 value = va_arg(ap, opus_int32);
2562             if(value<0 || value>10)
2563             {
2564                goto bad_arg;
2565             }
2566             st->silk_mode.complexity = value;
2567             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
2568         }
2569         break;
2570         case OPUS_GET_COMPLEXITY_REQUEST:
2571         {
2572             opus_int32 *value = va_arg(ap, opus_int32*);
2573             if (!value)
2574             {
2575                goto bad_arg;
2576             }
2577             *value = st->silk_mode.complexity;
2578         }
2579         break;
2580         case OPUS_SET_INBAND_FEC_REQUEST:
2581         {
2582             opus_int32 value = va_arg(ap, opus_int32);
2583             if(value<0 || value>1)
2584             {
2585                goto bad_arg;
2586             }
2587             st->silk_mode.useInBandFEC = value;
2588         }
2589         break;
2590         case OPUS_GET_INBAND_FEC_REQUEST:
2591         {
2592             opus_int32 *value = va_arg(ap, opus_int32*);
2593             if (!value)
2594             {
2595                goto bad_arg;
2596             }
2597             *value = st->silk_mode.useInBandFEC;
2598         }
2599         break;
2600         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
2601         {
2602             opus_int32 value = va_arg(ap, opus_int32);
2603             if (value < 0 || value > 100)
2604             {
2605                goto bad_arg;
2606             }
2607             st->silk_mode.packetLossPercentage = value;
2608             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
2609         }
2610         break;
2611         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
2612         {
2613             opus_int32 *value = va_arg(ap, opus_int32*);
2614             if (!value)
2615             {
2616                goto bad_arg;
2617             }
2618             *value = st->silk_mode.packetLossPercentage;
2619         }
2620         break;
2621         case OPUS_SET_VBR_REQUEST:
2622         {
2623             opus_int32 value = va_arg(ap, opus_int32);
2624             if(value<0 || value>1)
2625             {
2626                goto bad_arg;
2627             }
2628             st->use_vbr = value;
2629             st->silk_mode.useCBR = 1-value;
2630         }
2631         break;
2632         case OPUS_GET_VBR_REQUEST:
2633         {
2634             opus_int32 *value = va_arg(ap, opus_int32*);
2635             if (!value)
2636             {
2637                goto bad_arg;
2638             }
2639             *value = st->use_vbr;
2640         }
2641         break;
2642         case OPUS_SET_VOICE_RATIO_REQUEST:
2643         {
2644             opus_int32 value = va_arg(ap, opus_int32);
2645             if (value<-1 || value>100)
2646             {
2647                goto bad_arg;
2648             }
2649             st->voice_ratio = value;
2650         }
2651         break;
2652         case OPUS_GET_VOICE_RATIO_REQUEST:
2653         {
2654             opus_int32 *value = va_arg(ap, opus_int32*);
2655             if (!value)
2656             {
2657                goto bad_arg;
2658             }
2659             *value = st->voice_ratio;
2660         }
2661         break;
2662         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
2663         {
2664             opus_int32 value = va_arg(ap, opus_int32);
2665             if(value<0 || value>1)
2666             {
2667                goto bad_arg;
2668             }
2669             st->vbr_constraint = value;
2670         }
2671         break;
2672         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
2673         {
2674             opus_int32 *value = va_arg(ap, opus_int32*);
2675             if (!value)
2676             {
2677                goto bad_arg;
2678             }
2679             *value = st->vbr_constraint;
2680         }
2681         break;
2682         case OPUS_SET_SIGNAL_REQUEST:
2683         {
2684             opus_int32 value = va_arg(ap, opus_int32);
2685             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
2686             {
2687                goto bad_arg;
2688             }
2689             st->signal_type = value;
2690         }
2691         break;
2692         case OPUS_GET_SIGNAL_REQUEST:
2693         {
2694             opus_int32 *value = va_arg(ap, opus_int32*);
2695             if (!value)
2696             {
2697                goto bad_arg;
2698             }
2699             *value = st->signal_type;
2700         }
2701         break;
2702         case OPUS_GET_LOOKAHEAD_REQUEST:
2703         {
2704             opus_int32 *value = va_arg(ap, opus_int32*);
2705             if (!value)
2706             {
2707                goto bad_arg;
2708             }
2709             *value = st->Fs/400;
2710             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2711                 *value += st->delay_compensation;
2712         }
2713         break;
2714         case OPUS_GET_SAMPLE_RATE_REQUEST:
2715         {
2716             opus_int32 *value = va_arg(ap, opus_int32*);
2717             if (!value)
2718             {
2719                goto bad_arg;
2720             }
2721             *value = st->Fs;
2722         }
2723         break;
2724         case OPUS_GET_FINAL_RANGE_REQUEST:
2725         {
2726             opus_uint32 *value = va_arg(ap, opus_uint32*);
2727             if (!value)
2728             {
2729                goto bad_arg;
2730             }
2731             *value = st->rangeFinal;
2732         }
2733         break;
2734         case OPUS_SET_LSB_DEPTH_REQUEST:
2735         {
2736             opus_int32 value = va_arg(ap, opus_int32);
2737             if (value<8 || value>24)
2738             {
2739                goto bad_arg;
2740             }
2741             st->lsb_depth=value;
2742         }
2743         break;
2744         case OPUS_GET_LSB_DEPTH_REQUEST:
2745         {
2746             opus_int32 *value = va_arg(ap, opus_int32*);
2747             if (!value)
2748             {
2749                goto bad_arg;
2750             }
2751             *value = st->lsb_depth;
2752         }
2753         break;
2754         case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
2755         {
2756             opus_int32 value = va_arg(ap, opus_int32);
2757             if (value != OPUS_FRAMESIZE_ARG   && value != OPUS_FRAMESIZE_2_5_MS &&
2758                 value != OPUS_FRAMESIZE_5_MS  && value != OPUS_FRAMESIZE_10_MS  &&
2759                 value != OPUS_FRAMESIZE_20_MS && value != OPUS_FRAMESIZE_40_MS  &&
2760                 value != OPUS_FRAMESIZE_60_MS && value != OPUS_FRAMESIZE_VARIABLE)
2761             {
2762                goto bad_arg;
2763             }
2764             st->variable_duration = value;
2765             celt_encoder_ctl(celt_enc, OPUS_SET_EXPERT_FRAME_DURATION(value));
2766         }
2767         break;
2768         case OPUS_GET_EXPERT_FRAME_DURATION_REQUEST:
2769         {
2770             opus_int32 *value = va_arg(ap, opus_int32*);
2771             if (!value)
2772             {
2773                goto bad_arg;
2774             }
2775             *value = st->variable_duration;
2776         }
2777         break;
2778         case OPUS_SET_PREDICTION_DISABLED_REQUEST:
2779         {
2780            opus_int32 value = va_arg(ap, opus_int32);
2781            if (value > 1 || value < 0)
2782               goto bad_arg;
2783            st->silk_mode.reducedDependency = value;
2784         }
2785         break;
2786         case OPUS_GET_PREDICTION_DISABLED_REQUEST:
2787         {
2788            opus_int32 *value = va_arg(ap, opus_int32*);
2789            if (!value)
2790               goto bad_arg;
2791            *value = st->silk_mode.reducedDependency;
2792         }
2793         break;
2794         case OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST:
2795         {
2796             opus_int32 value = va_arg(ap, opus_int32);
2797             if(value<0 || value>1)
2798             {
2799                goto bad_arg;
2800             }
2801             celt_encoder_ctl(celt_enc, OPUS_SET_PHASE_INVERSION_DISABLED(value));
2802         }
2803         break;
2804         case OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST:
2805         {
2806             opus_int32 *value = va_arg(ap, opus_int32*);
2807             if (!value)
2808             {
2809                goto bad_arg;
2810             }
2811             celt_encoder_ctl(celt_enc, OPUS_GET_PHASE_INVERSION_DISABLED(value));
2812         }
2813         break;
2814         case OPUS_RESET_STATE:
2815         {
2816            void *silk_enc;
2817            silk_EncControlStruct dummy;
2818            char *start;
2819            silk_enc = (char*)st+st->silk_enc_offset;
2820 #ifndef DISABLE_FLOAT_API
2821            tonality_analysis_reset(&st->analysis);
2822 #endif
2823
2824            start = (char*)&st->OPUS_ENCODER_RESET_START;
2825            OPUS_CLEAR(start, sizeof(OpusEncoder) - (start - (char*)st));
2826
2827            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2828            silk_InitEncoder( silk_enc, st->arch, &dummy );
2829            st->stream_channels = st->channels;
2830            st->hybrid_stereo_width_Q14 = 1 << 14;
2831            st->prev_HB_gain = Q15ONE;
2832            st->first = 1;
2833            st->mode = MODE_HYBRID;
2834            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
2835            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
2836         }
2837         break;
2838         case OPUS_SET_FORCE_MODE_REQUEST:
2839         {
2840             opus_int32 value = va_arg(ap, opus_int32);
2841             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
2842             {
2843                goto bad_arg;
2844             }
2845             st->user_forced_mode = value;
2846         }
2847         break;
2848         case OPUS_SET_LFE_REQUEST:
2849         {
2850             opus_int32 value = va_arg(ap, opus_int32);
2851             st->lfe = value;
2852             ret = celt_encoder_ctl(celt_enc, OPUS_SET_LFE(value));
2853         }
2854         break;
2855         case OPUS_SET_ENERGY_MASK_REQUEST:
2856         {
2857             opus_val16 *value = va_arg(ap, opus_val16*);
2858             st->energy_masking = value;
2859             ret = celt_encoder_ctl(celt_enc, OPUS_SET_ENERGY_MASK(value));
2860         }
2861         break;
2862
2863         case CELT_GET_MODE_REQUEST:
2864         {
2865            const CELTMode ** value = va_arg(ap, const CELTMode**);
2866            if (!value)
2867            {
2868               goto bad_arg;
2869            }
2870            ret = celt_encoder_ctl(celt_enc, CELT_GET_MODE(value));
2871         }
2872         break;
2873         default:
2874             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
2875             ret = OPUS_UNIMPLEMENTED;
2876             break;
2877     }
2878     va_end(ap);
2879     return ret;
2880 bad_arg:
2881     va_end(ap);
2882     return OPUS_BAD_ARG;
2883 }
2884
2885 void opus_encoder_destroy(OpusEncoder *st)
2886 {
2887     opus_free(st);
2888 }