Fixes an internal error in the Opus encoder
[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        max_data_bytes = cbrBytes;
1340     }
1341     if (max_data_bytes<3 || st->bitrate_bps < 3*frame_rate*8
1342        || (frame_rate<50 && (max_data_bytes*frame_rate<300 || st->bitrate_bps < 2400)))
1343     {
1344        /*If the space is too low to do something useful, emit 'PLC' frames.*/
1345        int tocmode = st->mode;
1346        int bw = st->bandwidth == 0 ? OPUS_BANDWIDTH_NARROWBAND : st->bandwidth;
1347        if (tocmode==0)
1348           tocmode = MODE_SILK_ONLY;
1349        if (frame_rate>100)
1350           tocmode = MODE_CELT_ONLY;
1351        if (frame_rate < 50)
1352           tocmode = MODE_SILK_ONLY;
1353        if(tocmode==MODE_SILK_ONLY&&bw>OPUS_BANDWIDTH_WIDEBAND)
1354           bw=OPUS_BANDWIDTH_WIDEBAND;
1355        else if (tocmode==MODE_CELT_ONLY&&bw==OPUS_BANDWIDTH_MEDIUMBAND)
1356           bw=OPUS_BANDWIDTH_NARROWBAND;
1357        else if (tocmode==MODE_HYBRID&&bw<=OPUS_BANDWIDTH_SUPERWIDEBAND)
1358           bw=OPUS_BANDWIDTH_SUPERWIDEBAND;
1359        data[0] = gen_toc(tocmode, frame_rate, bw, st->stream_channels);
1360        ret = 1;
1361        if (!st->use_vbr)
1362        {
1363           ret = opus_packet_pad(data, ret, max_data_bytes);
1364           if (ret == OPUS_OK)
1365              ret = max_data_bytes;
1366        }
1367        RESTORE_STACK;
1368        return ret;
1369     }
1370     max_rate = frame_rate*max_data_bytes*8;
1371
1372     /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */
1373     equiv_rate = compute_equiv_rate(st->bitrate_bps, st->channels, st->Fs/frame_size,
1374           st->use_vbr, 0, st->silk_mode.complexity, st->silk_mode.packetLossPercentage);
1375
1376     if (st->signal_type == OPUS_SIGNAL_VOICE)
1377        voice_est = 127;
1378     else if (st->signal_type == OPUS_SIGNAL_MUSIC)
1379        voice_est = 0;
1380     else if (st->voice_ratio >= 0)
1381     {
1382        voice_est = st->voice_ratio*327>>8;
1383        /* For AUDIO, never be more than 90% confident of having speech */
1384        if (st->application == OPUS_APPLICATION_AUDIO)
1385           voice_est = IMIN(voice_est, 115);
1386     } else if (st->application == OPUS_APPLICATION_VOIP)
1387        voice_est = 115;
1388     else
1389        voice_est = 48;
1390
1391     if (st->force_channels!=OPUS_AUTO && st->channels == 2)
1392     {
1393         st->stream_channels = st->force_channels;
1394     } else {
1395 #ifdef FUZZING
1396        /* Random mono/stereo decision */
1397        if (st->channels == 2 && (rand()&0x1F)==0)
1398           st->stream_channels = 3-st->stream_channels;
1399 #else
1400        /* Rate-dependent mono-stereo decision */
1401        if (st->channels == 2)
1402        {
1403           opus_int32 stereo_threshold;
1404           stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14);
1405           if (st->stream_channels == 2)
1406              stereo_threshold -= 1000;
1407           else
1408              stereo_threshold += 1000;
1409           st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1;
1410        } else {
1411           st->stream_channels = st->channels;
1412        }
1413 #endif
1414     }
1415     /* Update equivalent rate for channels decision. */
1416     equiv_rate = compute_equiv_rate(st->bitrate_bps, st->stream_channels, st->Fs/frame_size,
1417           st->use_vbr, 0, st->silk_mode.complexity, st->silk_mode.packetLossPercentage);
1418
1419     /* Mode selection depending on application and signal type */
1420     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1421     {
1422        st->mode = MODE_CELT_ONLY;
1423     } else if (st->user_forced_mode == OPUS_AUTO)
1424     {
1425 #ifdef FUZZING
1426        /* Random mode switching */
1427        if ((rand()&0xF)==0)
1428        {
1429           if ((rand()&0x1)==0)
1430              st->mode = MODE_CELT_ONLY;
1431           else
1432              st->mode = MODE_SILK_ONLY;
1433        } else {
1434           if (st->prev_mode==MODE_CELT_ONLY)
1435              st->mode = MODE_CELT_ONLY;
1436           else
1437              st->mode = MODE_SILK_ONLY;
1438        }
1439 #else
1440        opus_int32 mode_voice, mode_music;
1441        opus_int32 threshold;
1442
1443        /* Interpolate based on stereo width */
1444        mode_voice = (opus_int32)(MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[0][0])
1445              + MULT16_32_Q15(stereo_width,mode_thresholds[1][0]));
1446        mode_music = (opus_int32)(MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[1][1])
1447              + MULT16_32_Q15(stereo_width,mode_thresholds[1][1]));
1448        /* Interpolate based on speech/music probability */
1449        threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14);
1450        /* Bias towards SILK for VoIP because of some useful features */
1451        if (st->application == OPUS_APPLICATION_VOIP)
1452           threshold += 8000;
1453
1454        /*printf("%f %d\n", stereo_width/(float)Q15ONE, threshold);*/
1455        /* Hysteresis */
1456        if (st->prev_mode == MODE_CELT_ONLY)
1457            threshold -= 4000;
1458        else if (st->prev_mode>0)
1459            threshold += 4000;
1460
1461        st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY;
1462
1463        /* When FEC is enabled and there's enough packet loss, use SILK */
1464        if (st->silk_mode.useInBandFEC && st->silk_mode.packetLossPercentage > (128-voice_est)>>4)
1465           st->mode = MODE_SILK_ONLY;
1466        /* When encoding voice and DTX is enabled but the generalized DTX cannot be used,
1467           because of complexity and sampling frequency settings, switch to SILK DTX and
1468           set the encoder to SILK mode */
1469 #ifndef DISABLE_FLOAT_API
1470        st->silk_mode.useDTX = st->use_dtx && !(analysis_info.valid || is_silence);
1471 #else
1472        st->silk_mode.useDTX = st->use_dtx;
1473 #endif
1474        if (st->silk_mode.useDTX && voice_est > 100)
1475           st->mode = MODE_SILK_ONLY;
1476 #endif
1477     } else {
1478        st->mode = st->user_forced_mode;
1479     }
1480
1481     /* Override the chosen mode to make sure we meet the requested frame size */
1482     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
1483        st->mode = MODE_CELT_ONLY;
1484     if (st->lfe)
1485        st->mode = MODE_CELT_ONLY;
1486     /* If max_data_bytes represents less than 6 kb/s, switch to CELT-only mode */
1487     if (max_data_bytes < (frame_rate > 50 ? 9000 : 6000)*frame_size / (st->Fs * 8))
1488        st->mode = MODE_CELT_ONLY;
1489
1490     if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0
1491           && st->mode != MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)
1492     {
1493        /* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */
1494        st->silk_mode.toMono = 1;
1495        st->stream_channels = 2;
1496     } else {
1497        st->silk_mode.toMono = 0;
1498     }
1499
1500     if (st->prev_mode > 0 &&
1501         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
1502     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
1503     {
1504         redundancy = 1;
1505         celt_to_silk = (st->mode != MODE_CELT_ONLY);
1506         if (!celt_to_silk)
1507         {
1508             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
1509             if (frame_size >= st->Fs/100)
1510             {
1511                 st->mode = st->prev_mode;
1512                 to_celt = 1;
1513             } else {
1514                 redundancy=0;
1515             }
1516         }
1517     }
1518
1519     /* Update equivalent rate with mode decision. */
1520     equiv_rate = compute_equiv_rate(st->bitrate_bps, st->stream_channels, st->Fs/frame_size,
1521           st->use_vbr, st->mode, st->silk_mode.complexity, st->silk_mode.packetLossPercentage);
1522
1523     /* For the first frame at a new SILK bandwidth */
1524     if (st->silk_bw_switch)
1525     {
1526        redundancy = 1;
1527        celt_to_silk = 1;
1528        st->silk_bw_switch = 0;
1529        prefill=1;
1530     }
1531
1532     if (redundancy)
1533     {
1534        /* Fair share of the max size allowed */
1535        redundancy_bytes = IMIN(257, max_data_bytes*(opus_int32)(st->Fs/200)/(frame_size+st->Fs/200));
1536        /* For VBR, target the actual bitrate (subject to the limit above) */
1537        if (st->use_vbr)
1538           redundancy_bytes = IMIN(redundancy_bytes, st->bitrate_bps/1600);
1539     }
1540
1541     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
1542     {
1543         silk_EncControlStruct dummy;
1544         silk_InitEncoder( silk_enc, st->arch, &dummy);
1545         prefill=1;
1546     }
1547
1548     /* Automatic (rate-dependent) bandwidth selection */
1549     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
1550     {
1551         const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds;
1552         opus_int32 bandwidth_thresholds[8];
1553         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
1554
1555         if (st->channels==2 && st->force_channels!=1)
1556         {
1557            voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds;
1558            music_bandwidth_thresholds = stereo_music_bandwidth_thresholds;
1559         } else {
1560            voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds;
1561            music_bandwidth_thresholds = mono_music_bandwidth_thresholds;
1562         }
1563         /* Interpolate bandwidth thresholds depending on voice estimation */
1564         for (i=0;i<8;i++)
1565         {
1566            bandwidth_thresholds[i] = music_bandwidth_thresholds[i]
1567                     + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14);
1568         }
1569         do {
1570             int threshold, hysteresis;
1571             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
1572             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
1573             if (!st->first)
1574             {
1575                 if (st->auto_bandwidth >= bandwidth)
1576                     threshold -= hysteresis;
1577                 else
1578                     threshold += hysteresis;
1579             }
1580             if (equiv_rate >= threshold)
1581                 break;
1582         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
1583         st->bandwidth = st->auto_bandwidth = bandwidth;
1584         /* Prevents any transition to SWB/FB until the SILK layer has fully
1585            switched to WB mode and turned the variable LP filter off */
1586         if (!st->first && st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1587             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1588     }
1589
1590     if (st->bandwidth>st->max_bandwidth)
1591        st->bandwidth = st->max_bandwidth;
1592
1593     if (st->user_bandwidth != OPUS_AUTO)
1594         st->bandwidth = st->user_bandwidth;
1595
1596     /* This prevents us from using hybrid at unsafe CBR/max rates */
1597     if (st->mode != MODE_CELT_ONLY && max_rate < 15000)
1598     {
1599        st->bandwidth = IMIN(st->bandwidth, OPUS_BANDWIDTH_WIDEBAND);
1600     }
1601
1602     /* Prevents Opus from wasting bits on frequencies that are above
1603        the Nyquist rate of the input signal */
1604     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
1605         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1606     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1607         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1608     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
1609         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1610     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
1611         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1612 #ifndef DISABLE_FLOAT_API
1613     /* Use detected bandwidth to reduce the encoded bandwidth. */
1614     if (st->detected_bandwidth && st->user_bandwidth == OPUS_AUTO)
1615     {
1616        int min_detected_bandwidth;
1617        /* Makes bandwidth detection more conservative just in case the detector
1618           gets it wrong when we could have coded a high bandwidth transparently.
1619           When operating in SILK/hybrid mode, we don't go below wideband to avoid
1620           more complicated switches that require redundancy. */
1621        if (equiv_rate <= 18000*st->stream_channels && st->mode == MODE_CELT_ONLY)
1622           min_detected_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1623        else if (equiv_rate <= 24000*st->stream_channels && st->mode == MODE_CELT_ONLY)
1624           min_detected_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1625        else if (equiv_rate <= 30000*st->stream_channels)
1626           min_detected_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1627        else if (equiv_rate <= 44000*st->stream_channels)
1628           min_detected_bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1629        else
1630           min_detected_bandwidth = OPUS_BANDWIDTH_FULLBAND;
1631
1632        st->detected_bandwidth = IMAX(st->detected_bandwidth, min_detected_bandwidth);
1633        st->bandwidth = IMIN(st->bandwidth, st->detected_bandwidth);
1634     }
1635 #endif
1636     st->silk_mode.LBRR_coded = decide_fec(st->silk_mode.useInBandFEC, st->silk_mode.packetLossPercentage,
1637           st->silk_mode.LBRR_coded, st->mode, &st->bandwidth, equiv_rate);
1638     celt_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(lsb_depth));
1639
1640     /* CELT mode doesn't support mediumband, use wideband instead */
1641     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1642         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1643     if (st->lfe)
1644        st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1645
1646     /* Can't support higher than wideband for >20 ms frames */
1647     if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND))
1648     {
1649        VARDECL(unsigned char, tmp_data);
1650        int nb_frames;
1651        int bak_mode, bak_bandwidth, bak_channels, bak_to_mono;
1652        VARDECL(OpusRepacketizer, rp);
1653        opus_int32 bytes_per_frame;
1654        opus_int32 repacketize_len;
1655
1656 #ifndef DISABLE_FLOAT_API
1657        if (analysis_read_pos_bak!= -1)
1658        {
1659           st->analysis.read_pos = analysis_read_pos_bak;
1660           st->analysis.read_subframe = analysis_read_subframe_bak;
1661        }
1662 #endif
1663
1664        nb_frames = frame_size > st->Fs/25 ? 3 : 2;
1665        bytes_per_frame = IMIN(1276,(out_data_bytes-3)/nb_frames);
1666
1667        ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char);
1668
1669        ALLOC(rp, 1, OpusRepacketizer);
1670        opus_repacketizer_init(rp);
1671
1672        bak_mode = st->user_forced_mode;
1673        bak_bandwidth = st->user_bandwidth;
1674        bak_channels = st->force_channels;
1675
1676        st->user_forced_mode = st->mode;
1677        st->user_bandwidth = st->bandwidth;
1678        st->force_channels = st->stream_channels;
1679        bak_to_mono = st->silk_mode.toMono;
1680
1681        if (bak_to_mono)
1682           st->force_channels = 1;
1683        else
1684           st->prev_channels = st->stream_channels;
1685        for (i=0;i<nb_frames;i++)
1686        {
1687           int tmp_len;
1688           st->silk_mode.toMono = 0;
1689           /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
1690           if (to_celt && i==nb_frames-1)
1691              st->user_forced_mode = MODE_CELT_ONLY;
1692           tmp_len = opus_encode_native(st, pcm+i*(st->channels*st->Fs/50), st->Fs/50,
1693                 tmp_data+i*bytes_per_frame, bytes_per_frame, lsb_depth,
1694                 NULL, 0, c1, c2, analysis_channels, downmix, float_api);
1695           if (tmp_len<0)
1696           {
1697              RESTORE_STACK;
1698              return OPUS_INTERNAL_ERROR;
1699           }
1700           ret = opus_repacketizer_cat(rp, tmp_data+i*bytes_per_frame, tmp_len);
1701           if (ret<0)
1702           {
1703              RESTORE_STACK;
1704              return OPUS_INTERNAL_ERROR;
1705           }
1706        }
1707        if (st->use_vbr)
1708           repacketize_len = out_data_bytes;
1709        else
1710           repacketize_len = IMIN(3*st->bitrate_bps/(3*8*50/nb_frames), out_data_bytes);
1711        ret = opus_repacketizer_out_range_impl(rp, 0, nb_frames, data, repacketize_len, 0, !st->use_vbr);
1712        if (ret<0)
1713        {
1714           RESTORE_STACK;
1715           return OPUS_INTERNAL_ERROR;
1716        }
1717        st->user_forced_mode = bak_mode;
1718        st->user_bandwidth = bak_bandwidth;
1719        st->force_channels = bak_channels;
1720        st->silk_mode.toMono = bak_to_mono;
1721        RESTORE_STACK;
1722        return ret;
1723     }
1724     curr_bandwidth = st->bandwidth;
1725
1726     /* Chooses the appropriate mode for speech
1727        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
1728     if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1729         st->mode = MODE_HYBRID;
1730     if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
1731         st->mode = MODE_SILK_ONLY;
1732     /* If we decided to go with CELT, make sure redundancy is off, no matter what
1733        we decided earlier. */
1734     if (st->mode == MODE_CELT_ONLY)
1735     {
1736         redundancy = 0;
1737         redundancy_bytes = 0;
1738     }
1739
1740     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
1741     bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
1742
1743     data += 1;
1744
1745     ec_enc_init(&enc, data, max_data_bytes-1);
1746
1747     ALLOC(pcm_buf, (total_buffer+frame_size)*st->channels, opus_val16);
1748     OPUS_COPY(pcm_buf, &st->delay_buffer[(st->encoder_buffer-total_buffer)*st->channels], total_buffer*st->channels);
1749
1750     if (st->mode == MODE_CELT_ONLY)
1751        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1752     else
1753        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
1754
1755     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
1756           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
1757
1758     /* convert from log scale to Hertz */
1759     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
1760
1761     if (st->application == OPUS_APPLICATION_VOIP)
1762     {
1763        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1764     } else {
1765        dc_reject(pcm, 3, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1766     }
1767 #ifndef FIXED_POINT
1768     if (float_api)
1769     {
1770        opus_val32 sum;
1771        sum = celt_inner_prod(&pcm_buf[total_buffer*st->channels], &pcm_buf[total_buffer*st->channels], frame_size*st->channels, st->arch);
1772        /* This should filter out both NaNs and ridiculous signals that could
1773           cause NaNs further down. */
1774        if (!(sum < 1e9f) || celt_isnan(sum))
1775        {
1776           OPUS_CLEAR(&pcm_buf[total_buffer*st->channels], frame_size*st->channels);
1777           st->hp_mem[0] = st->hp_mem[1] = st->hp_mem[2] = st->hp_mem[3] = 0;
1778        }
1779     }
1780 #endif
1781
1782
1783     /* SILK processing */
1784     HB_gain = Q15ONE;
1785     if (st->mode != MODE_CELT_ONLY)
1786     {
1787         opus_int32 total_bitRate, celt_rate;
1788 #ifdef FIXED_POINT
1789        const opus_int16 *pcm_silk;
1790 #else
1791        VARDECL(opus_int16, pcm_silk);
1792        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
1793 #endif
1794
1795         /* Distribute bits between SILK and CELT */
1796         total_bitRate = 8 * bytes_target * frame_rate;
1797         if( st->mode == MODE_HYBRID ) {
1798             /* Base rate for SILK */
1799             st->silk_mode.bitRate = compute_silk_rate_for_hybrid(total_bitRate,
1800                   curr_bandwidth, st->Fs == 50 * frame_size, st->use_vbr, st->silk_mode.LBRR_coded);
1801             if (!st->energy_masking)
1802             {
1803                /* Increasingly attenuate high band when it gets allocated fewer bits */
1804                celt_rate = total_bitRate - st->silk_mode.bitRate;
1805                HB_gain = Q15ONE - SHR32(celt_exp2(-celt_rate * QCONST16(1.f/1024, 10)), 1);
1806             }
1807         } else {
1808             /* SILK gets all bits */
1809             st->silk_mode.bitRate = total_bitRate;
1810         }
1811
1812         /* Surround masking for SILK */
1813         if (st->energy_masking && st->use_vbr && !st->lfe)
1814         {
1815            opus_val32 mask_sum=0;
1816            opus_val16 masking_depth;
1817            opus_int32 rate_offset;
1818            int c;
1819            int end = 17;
1820            opus_int16 srate = 16000;
1821            if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND)
1822            {
1823               end = 13;
1824               srate = 8000;
1825            } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1826            {
1827               end = 15;
1828               srate = 12000;
1829            }
1830            for (c=0;c<st->channels;c++)
1831            {
1832               for(i=0;i<end;i++)
1833               {
1834                  opus_val16 mask;
1835                  mask = MAX16(MIN16(st->energy_masking[21*c+i],
1836                         QCONST16(.5f, DB_SHIFT)), -QCONST16(2.0f, DB_SHIFT));
1837                  if (mask > 0)
1838                     mask = HALF16(mask);
1839                  mask_sum += mask;
1840               }
1841            }
1842            /* Conservative rate reduction, we cut the masking in half */
1843            masking_depth = mask_sum / end*st->channels;
1844            masking_depth += QCONST16(.2f, DB_SHIFT);
1845            rate_offset = (opus_int32)PSHR32(MULT16_16(srate, masking_depth), DB_SHIFT);
1846            rate_offset = MAX32(rate_offset, -2*st->silk_mode.bitRate/3);
1847            /* Split the rate change between the SILK and CELT part for hybrid. */
1848            if (st->bandwidth==OPUS_BANDWIDTH_SUPERWIDEBAND || st->bandwidth==OPUS_BANDWIDTH_FULLBAND)
1849               st->silk_mode.bitRate += 3*rate_offset/5;
1850            else
1851               st->silk_mode.bitRate += rate_offset;
1852            bytes_target += rate_offset * frame_size / (8 * st->Fs);
1853         }
1854
1855         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
1856         st->silk_mode.nChannelsAPI = st->channels;
1857         st->silk_mode.nChannelsInternal = st->stream_channels;
1858         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1859             st->silk_mode.desiredInternalSampleRate = 8000;
1860         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1861             st->silk_mode.desiredInternalSampleRate = 12000;
1862         } else {
1863             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
1864             st->silk_mode.desiredInternalSampleRate = 16000;
1865         }
1866         if( st->mode == MODE_HYBRID ) {
1867             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
1868             st->silk_mode.minInternalSampleRate = 16000;
1869         } else {
1870             st->silk_mode.minInternalSampleRate = 8000;
1871         }
1872
1873         st->silk_mode.maxInternalSampleRate = 16000;
1874         if (st->mode == MODE_SILK_ONLY)
1875         {
1876            opus_int32 effective_max_rate = max_rate;
1877            if (frame_rate > 50)
1878               effective_max_rate = effective_max_rate*2/3;
1879            if (effective_max_rate < 8000)
1880            {
1881               st->silk_mode.maxInternalSampleRate = 12000;
1882               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
1883            }
1884            if (effective_max_rate < 7000)
1885            {
1886               st->silk_mode.maxInternalSampleRate = 8000;
1887               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
1888            }
1889         }
1890
1891         st->silk_mode.useCBR = !st->use_vbr;
1892
1893         /* Call SILK encoder for the low band */
1894         nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes);
1895
1896         st->silk_mode.maxBits = nBytes*8;
1897         if (st->silk_mode.useCBR)
1898         {
1899            if (st->mode == MODE_HYBRID)
1900            {
1901               st->silk_mode.maxBits = st->silk_mode.bitRate * frame_size / st->Fs;
1902            }
1903         } else {
1904            /* Constrained VBR. */
1905            if (st->mode == MODE_HYBRID)
1906            {
1907               /* Compute SILK bitrate corresponding to the max total bits available */
1908               opus_int32 maxBitRate = compute_silk_rate_for_hybrid(nBytes*8*st->Fs / frame_size,
1909                     curr_bandwidth, st->Fs == 50 * frame_size, st->use_vbr, st->silk_mode.LBRR_coded);
1910               st->silk_mode.maxBits = maxBitRate * frame_size / st->Fs;
1911            }
1912         }
1913
1914         if (prefill)
1915         {
1916             opus_int32 zero=0;
1917             int prefill_offset;
1918             /* Use a smooth onset for the SILK prefill to avoid the encoder trying to encode
1919                a discontinuity. The exact location is what we need to avoid leaving any "gap"
1920                in the audio when mixing with the redundant CELT frame. Here we can afford to
1921                overwrite st->delay_buffer because the only thing that uses it before it gets
1922                rewritten is tmp_prefill[] and even then only the part after the ramp really
1923                gets used (rather than sent to the encoder and discarded) */
1924             prefill_offset = st->channels*(st->encoder_buffer-st->delay_compensation-st->Fs/400);
1925             gain_fade(st->delay_buffer+prefill_offset, st->delay_buffer+prefill_offset,
1926                   0, Q15ONE, celt_mode->overlap, st->Fs/400, st->channels, celt_mode->window, st->Fs);
1927             OPUS_CLEAR(st->delay_buffer, prefill_offset);
1928 #ifdef FIXED_POINT
1929             pcm_silk = st->delay_buffer;
1930 #else
1931             for (i=0;i<st->encoder_buffer*st->channels;i++)
1932                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
1933 #endif
1934             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
1935         }
1936
1937 #ifdef FIXED_POINT
1938         pcm_silk = pcm_buf+total_buffer*st->channels;
1939 #else
1940         for (i=0;i<frame_size*st->channels;i++)
1941             pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
1942 #endif
1943         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
1944         if( ret ) {
1945             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
1946             /* Handle error */
1947            RESTORE_STACK;
1948            return OPUS_INTERNAL_ERROR;
1949         }
1950         if (nBytes==0)
1951         {
1952            st->rangeFinal = 0;
1953            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1954            RESTORE_STACK;
1955            return 1;
1956         }
1957         /* Extract SILK internal bandwidth for signaling in first byte */
1958         if( st->mode == MODE_SILK_ONLY ) {
1959             if( st->silk_mode.internalSampleRate == 8000 ) {
1960                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1961             } else if( st->silk_mode.internalSampleRate == 12000 ) {
1962                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1963             } else if( st->silk_mode.internalSampleRate == 16000 ) {
1964                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1965             }
1966         } else {
1967             silk_assert( st->silk_mode.internalSampleRate == 16000 );
1968         }
1969
1970         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
1971         /* FIXME: How do we allocate the redundancy for CBR? */
1972         if (st->silk_mode.opusCanSwitch)
1973         {
1974            redundancy = 1;
1975            celt_to_silk = 0;
1976            st->silk_bw_switch = 1;
1977         }
1978     }
1979
1980     /* CELT processing */
1981     {
1982         int endband=21;
1983
1984         switch(curr_bandwidth)
1985         {
1986             case OPUS_BANDWIDTH_NARROWBAND:
1987                 endband = 13;
1988                 break;
1989             case OPUS_BANDWIDTH_MEDIUMBAND:
1990             case OPUS_BANDWIDTH_WIDEBAND:
1991                 endband = 17;
1992                 break;
1993             case OPUS_BANDWIDTH_SUPERWIDEBAND:
1994                 endband = 19;
1995                 break;
1996             case OPUS_BANDWIDTH_FULLBAND:
1997                 endband = 21;
1998                 break;
1999         }
2000         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
2001         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
2002     }
2003     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
2004     if (st->mode != MODE_SILK_ONLY)
2005     {
2006         opus_val32 celt_pred=2;
2007         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
2008         /* We may still decide to disable prediction later */
2009         if (st->silk_mode.reducedDependency)
2010            celt_pred = 0;
2011         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(celt_pred));
2012
2013         if (st->mode == MODE_HYBRID)
2014         {
2015             int len;
2016
2017             len = (ec_tell(&enc)+7)>>3;
2018             if (redundancy)
2019                len += st->mode == MODE_HYBRID ? 3 : 1;
2020             if( st->use_vbr ) {
2021                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps-st->silk_mode.bitRate));
2022                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
2023                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(0));
2024             } else {
2025                 /* check if SILK used up too much */
2026                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
2027             }
2028         } else {
2029             if (st->use_vbr)
2030             {
2031                 opus_int32 bonus=0;
2032 #ifndef DISABLE_FLOAT_API
2033                 if (st->variable_duration==OPUS_FRAMESIZE_VARIABLE && frame_size != st->Fs/50)
2034                 {
2035                    bonus = (60*st->stream_channels+40)*(st->Fs/frame_size-50);
2036                    if (analysis_info.valid)
2037                       bonus = (opus_int32)(bonus*(1.f+.5f*analysis_info.tonality));
2038                 }
2039 #endif
2040                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
2041                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
2042                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps+bonus));
2043                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
2044             } else {
2045                 nb_compr_bytes = bytes_target;
2046             }
2047         }
2048
2049     } else {
2050         nb_compr_bytes = 0;
2051     }
2052
2053     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
2054     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
2055     {
2056        OPUS_COPY(tmp_prefill, &st->delay_buffer[(st->encoder_buffer-total_buffer-st->Fs/400)*st->channels], st->channels*st->Fs/400);
2057     }
2058
2059     if (st->channels*(st->encoder_buffer-(frame_size+total_buffer)) > 0)
2060     {
2061        OPUS_MOVE(st->delay_buffer, &st->delay_buffer[st->channels*frame_size], st->channels*(st->encoder_buffer-frame_size-total_buffer));
2062        OPUS_COPY(&st->delay_buffer[st->channels*(st->encoder_buffer-frame_size-total_buffer)],
2063              &pcm_buf[0],
2064              (frame_size+total_buffer)*st->channels);
2065     } else {
2066        OPUS_COPY(st->delay_buffer, &pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels], st->encoder_buffer*st->channels);
2067     }
2068     /* gain_fade() and stereo_fade() need to be after the buffer copying
2069        because we don't want any of this to affect the SILK part */
2070     if( st->prev_HB_gain < Q15ONE || HB_gain < Q15ONE ) {
2071        gain_fade(pcm_buf, pcm_buf,
2072              st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs);
2073     }
2074     st->prev_HB_gain = HB_gain;
2075     if (st->mode != MODE_HYBRID || st->stream_channels==1)
2076        st->silk_mode.stereoWidth_Q14 = IMIN((1<<14),2*IMAX(0,equiv_rate-24000));
2077     if( !st->energy_masking && st->channels == 2 ) {
2078         /* Apply stereo width reduction (at low bitrates) */
2079         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
2080             opus_val16 g1, g2;
2081             g1 = st->hybrid_stereo_width_Q14;
2082             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
2083 #ifdef FIXED_POINT
2084             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
2085             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
2086 #else
2087             g1 *= (1.f/16384);
2088             g2 *= (1.f/16384);
2089 #endif
2090             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
2091                   frame_size, st->channels, celt_mode->window, st->Fs);
2092             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
2093         }
2094     }
2095
2096     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
2097     {
2098         /* For SILK mode, the redundancy is inferred from the length */
2099         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
2100            ec_enc_bit_logp(&enc, redundancy, 12);
2101         if (redundancy)
2102         {
2103             int max_redundancy;
2104             ec_enc_bit_logp(&enc, celt_to_silk, 1);
2105             if (st->mode == MODE_HYBRID)
2106                max_redundancy = (max_data_bytes-1)-nb_compr_bytes;
2107             else
2108                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
2109             /* Target the same bit-rate for redundancy as for the rest,
2110                up to a max of 257 bytes */
2111             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
2112             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
2113             if (st->mode == MODE_HYBRID)
2114                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
2115         }
2116     } else {
2117         redundancy = 0;
2118     }
2119
2120     if (!redundancy)
2121     {
2122        st->silk_bw_switch = 0;
2123        redundancy_bytes = 0;
2124     }
2125     if (st->mode != MODE_CELT_ONLY)start_band=17;
2126
2127     if (st->mode == MODE_SILK_ONLY)
2128     {
2129         ret = (ec_tell(&enc)+7)>>3;
2130         ec_enc_done(&enc);
2131         nb_compr_bytes = ret;
2132     } else {
2133        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
2134        ec_enc_shrink(&enc, nb_compr_bytes);
2135     }
2136
2137 #ifndef DISABLE_FLOAT_API
2138     if (redundancy || st->mode != MODE_SILK_ONLY)
2139        celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(&analysis_info));
2140 #endif
2141     if (st->mode == MODE_HYBRID) {
2142        SILKInfo info;
2143        info.signalType = st->silk_mode.signalType;
2144        info.offset = st->silk_mode.offset;
2145        celt_encoder_ctl(celt_enc, CELT_SET_SILK_INFO(&info));
2146     } else {
2147        celt_encoder_ctl(celt_enc, CELT_SET_SILK_INFO((SILKInfo*)NULL));
2148     }
2149
2150     /* 5 ms redundant frame for CELT->SILK */
2151     if (redundancy && celt_to_silk)
2152     {
2153         int err;
2154         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
2155         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
2156         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
2157         err = celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
2158         if (err < 0)
2159         {
2160            RESTORE_STACK;
2161            return OPUS_INTERNAL_ERROR;
2162         }
2163         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
2164         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2165     }
2166
2167     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
2168
2169     if (st->mode != MODE_SILK_ONLY)
2170     {
2171         if (st->mode != st->prev_mode && st->prev_mode > 0)
2172         {
2173            unsigned char dummy[2];
2174            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2175
2176            /* Prefilling */
2177            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
2178            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
2179         }
2180         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
2181         if (ec_tell(&enc) <= 8*nb_compr_bytes)
2182         {
2183            /* Set the bitrate again if it was overridden in the redundancy code above*/
2184            if (redundancy && celt_to_silk && st->mode==MODE_HYBRID && st->use_vbr)
2185               celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps-st->silk_mode.bitRate));
2186            celt_encoder_ctl(celt_enc, OPUS_SET_VBR(st->use_vbr));
2187            ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
2188            if (ret < 0)
2189            {
2190               RESTORE_STACK;
2191               return OPUS_INTERNAL_ERROR;
2192            }
2193            /* Put CELT->SILK redundancy data in the right place. */
2194            if (redundancy && celt_to_silk && st->mode==MODE_HYBRID && st->use_vbr)
2195            {
2196               OPUS_COPY(data+ret, data+nb_compr_bytes, redundancy_bytes);
2197               nb_compr_bytes = nb_compr_bytes+redundancy_bytes;
2198            }
2199         }
2200     }
2201
2202     /* 5 ms redundant frame for SILK->CELT */
2203     if (redundancy && !celt_to_silk)
2204     {
2205         int err;
2206         unsigned char dummy[2];
2207         int N2, N4;
2208         N2 = st->Fs/200;
2209         N4 = st->Fs/400;
2210
2211         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2212         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
2213         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
2214         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
2215         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
2216
2217         if (st->mode == MODE_HYBRID)
2218         {
2219            /* Shrink packet to what the encoder actually used. */
2220            nb_compr_bytes = ret;
2221            ec_enc_shrink(&enc, nb_compr_bytes);
2222         }
2223         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
2224         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL);
2225
2226         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
2227         if (err < 0)
2228         {
2229            RESTORE_STACK;
2230            return OPUS_INTERNAL_ERROR;
2231         }
2232         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
2233     }
2234
2235
2236
2237     /* Signalling the mode in the first byte */
2238     data--;
2239     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
2240
2241     st->rangeFinal = enc.rng ^ redundant_rng;
2242
2243     if (to_celt)
2244         st->prev_mode = MODE_CELT_ONLY;
2245     else
2246         st->prev_mode = st->mode;
2247     st->prev_channels = st->stream_channels;
2248     st->prev_framesize = frame_size;
2249
2250     st->first = 0;
2251
2252     /* DTX decision */
2253 #ifndef DISABLE_FLOAT_API
2254     if (st->use_dtx && (analysis_info.valid || is_silence))
2255     {
2256        if (decide_dtx_mode(analysis_info.activity_probability, &st->nb_no_activity_frames,
2257              st->peak_signal_energy, pcm, frame_size, st->channels, is_silence, st->arch))
2258        {
2259           st->rangeFinal = 0;
2260           data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
2261           RESTORE_STACK;
2262           return 1;
2263        }
2264     }
2265 #endif
2266
2267     /* In the unlikely case that the SILK encoder busted its target, tell
2268        the decoder to call the PLC */
2269     if (ec_tell(&enc) > (max_data_bytes-1)*8)
2270     {
2271        if (max_data_bytes < 2)
2272        {
2273           RESTORE_STACK;
2274           return OPUS_BUFFER_TOO_SMALL;
2275        }
2276        data[1] = 0;
2277        ret = 1;
2278        st->rangeFinal = 0;
2279     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
2280     {
2281        /*When in LPC only mode it's perfectly
2282          reasonable to strip off trailing zero bytes as
2283          the required range decoder behavior is to
2284          fill these in. This can't be done when the MDCT
2285          modes are used because the decoder needs to know
2286          the actual length for allocation purposes.*/
2287        while(ret>2&&data[ret]==0)ret--;
2288     }
2289     /* Count ToC and redundancy */
2290     ret += 1+redundancy_bytes;
2291     if (!st->use_vbr)
2292     {
2293        if (opus_packet_pad(data, ret, max_data_bytes) != OPUS_OK)
2294
2295        {
2296           RESTORE_STACK;
2297           return OPUS_INTERNAL_ERROR;
2298        }
2299        ret = max_data_bytes;
2300     }
2301     RESTORE_STACK;
2302     return ret;
2303 }
2304
2305 #ifdef FIXED_POINT
2306
2307 #ifndef DISABLE_FLOAT_API
2308 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int analysis_frame_size,
2309       unsigned char *data, opus_int32 max_data_bytes)
2310 {
2311    int i, ret;
2312    int frame_size;
2313    int delay_compensation;
2314    VARDECL(opus_int16, in);
2315    ALLOC_STACK;
2316
2317    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2318       delay_compensation = 0;
2319    else
2320       delay_compensation = st->delay_compensation;
2321    frame_size = compute_frame_size(pcm, analysis_frame_size,
2322          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2323          delay_compensation, downmix_float, st->analysis.subframe_mem);
2324
2325    ALLOC(in, frame_size*st->channels, opus_int16);
2326
2327    for (i=0;i<frame_size*st->channels;i++)
2328       in[i] = FLOAT2INT16(pcm[i]);
2329    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16,
2330                             pcm, analysis_frame_size, 0, -2, st->channels, downmix_float, 1);
2331    RESTORE_STACK;
2332    return ret;
2333 }
2334 #endif
2335
2336 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int analysis_frame_size,
2337                 unsigned char *data, opus_int32 out_data_bytes)
2338 {
2339    int frame_size;
2340    int delay_compensation;
2341    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2342       delay_compensation = 0;
2343    else
2344       delay_compensation = st->delay_compensation;
2345    frame_size = compute_frame_size(pcm, analysis_frame_size,
2346          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2347          delay_compensation, downmix_int
2348 #ifndef DISABLE_FLOAT_API
2349          , st->analysis.subframe_mem
2350 #endif
2351          );
2352    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 16,
2353                              pcm, analysis_frame_size, 0, -2, st->channels, downmix_int, 0);
2354 }
2355
2356 #else
2357 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int analysis_frame_size,
2358       unsigned char *data, opus_int32 max_data_bytes)
2359 {
2360    int i, ret;
2361    int frame_size;
2362    int delay_compensation;
2363    VARDECL(float, in);
2364    ALLOC_STACK;
2365
2366    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2367       delay_compensation = 0;
2368    else
2369       delay_compensation = st->delay_compensation;
2370    frame_size = compute_frame_size(pcm, analysis_frame_size,
2371          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2372          delay_compensation, downmix_int, st->analysis.subframe_mem);
2373
2374    ALLOC(in, frame_size*st->channels, float);
2375
2376    for (i=0;i<frame_size*st->channels;i++)
2377       in[i] = (1.0f/32768)*pcm[i];
2378    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16,
2379                             pcm, analysis_frame_size, 0, -2, st->channels, downmix_int, 0);
2380    RESTORE_STACK;
2381    return ret;
2382 }
2383 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int analysis_frame_size,
2384                       unsigned char *data, opus_int32 out_data_bytes)
2385 {
2386    int frame_size;
2387    int delay_compensation;
2388    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2389       delay_compensation = 0;
2390    else
2391       delay_compensation = st->delay_compensation;
2392    frame_size = compute_frame_size(pcm, analysis_frame_size,
2393          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2394          delay_compensation, downmix_float, st->analysis.subframe_mem);
2395    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 24,
2396                              pcm, analysis_frame_size, 0, -2, st->channels, downmix_float, 1);
2397 }
2398 #endif
2399
2400
2401 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
2402 {
2403     int ret;
2404     CELTEncoder *celt_enc;
2405     va_list ap;
2406
2407     ret = OPUS_OK;
2408     va_start(ap, request);
2409
2410     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
2411
2412     switch (request)
2413     {
2414         case OPUS_SET_APPLICATION_REQUEST:
2415         {
2416             opus_int32 value = va_arg(ap, opus_int32);
2417             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
2418                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2419                || (!st->first && st->application != value))
2420             {
2421                ret = OPUS_BAD_ARG;
2422                break;
2423             }
2424             st->application = value;
2425         }
2426         break;
2427         case OPUS_GET_APPLICATION_REQUEST:
2428         {
2429             opus_int32 *value = va_arg(ap, opus_int32*);
2430             if (!value)
2431             {
2432                goto bad_arg;
2433             }
2434             *value = st->application;
2435         }
2436         break;
2437         case OPUS_SET_BITRATE_REQUEST:
2438         {
2439             opus_int32 value = va_arg(ap, opus_int32);
2440             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
2441             {
2442                 if (value <= 0)
2443                     goto bad_arg;
2444                 else if (value <= 500)
2445                     value = 500;
2446                 else if (value > (opus_int32)300000*st->channels)
2447                     value = (opus_int32)300000*st->channels;
2448             }
2449             st->user_bitrate_bps = value;
2450         }
2451         break;
2452         case OPUS_GET_BITRATE_REQUEST:
2453         {
2454             opus_int32 *value = va_arg(ap, opus_int32*);
2455             if (!value)
2456             {
2457                goto bad_arg;
2458             }
2459             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
2460         }
2461         break;
2462         case OPUS_SET_FORCE_CHANNELS_REQUEST:
2463         {
2464             opus_int32 value = va_arg(ap, opus_int32);
2465             if((value<1 || value>st->channels) && value != OPUS_AUTO)
2466             {
2467                goto bad_arg;
2468             }
2469             st->force_channels = value;
2470         }
2471         break;
2472         case OPUS_GET_FORCE_CHANNELS_REQUEST:
2473         {
2474             opus_int32 *value = va_arg(ap, opus_int32*);
2475             if (!value)
2476             {
2477                goto bad_arg;
2478             }
2479             *value = st->force_channels;
2480         }
2481         break;
2482         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
2483         {
2484             opus_int32 value = va_arg(ap, opus_int32);
2485             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND)
2486             {
2487                goto bad_arg;
2488             }
2489             st->max_bandwidth = value;
2490             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2491                 st->silk_mode.maxInternalSampleRate = 8000;
2492             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2493                 st->silk_mode.maxInternalSampleRate = 12000;
2494             } else {
2495                 st->silk_mode.maxInternalSampleRate = 16000;
2496             }
2497         }
2498         break;
2499         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
2500         {
2501             opus_int32 *value = va_arg(ap, opus_int32*);
2502             if (!value)
2503             {
2504                goto bad_arg;
2505             }
2506             *value = st->max_bandwidth;
2507         }
2508         break;
2509         case OPUS_SET_BANDWIDTH_REQUEST:
2510         {
2511             opus_int32 value = va_arg(ap, opus_int32);
2512             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
2513             {
2514                goto bad_arg;
2515             }
2516             st->user_bandwidth = value;
2517             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2518                 st->silk_mode.maxInternalSampleRate = 8000;
2519             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2520                 st->silk_mode.maxInternalSampleRate = 12000;
2521             } else {
2522                 st->silk_mode.maxInternalSampleRate = 16000;
2523             }
2524         }
2525         break;
2526         case OPUS_GET_BANDWIDTH_REQUEST:
2527         {
2528             opus_int32 *value = va_arg(ap, opus_int32*);
2529             if (!value)
2530             {
2531                goto bad_arg;
2532             }
2533             *value = st->bandwidth;
2534         }
2535         break;
2536         case OPUS_SET_DTX_REQUEST:
2537         {
2538             opus_int32 value = va_arg(ap, opus_int32);
2539             if(value<0 || value>1)
2540             {
2541                goto bad_arg;
2542             }
2543             st->use_dtx = value;
2544         }
2545         break;
2546         case OPUS_GET_DTX_REQUEST:
2547         {
2548             opus_int32 *value = va_arg(ap, opus_int32*);
2549             if (!value)
2550             {
2551                goto bad_arg;
2552             }
2553             *value = st->use_dtx;
2554         }
2555         break;
2556         case OPUS_SET_COMPLEXITY_REQUEST:
2557         {
2558             opus_int32 value = va_arg(ap, opus_int32);
2559             if(value<0 || value>10)
2560             {
2561                goto bad_arg;
2562             }
2563             st->silk_mode.complexity = value;
2564             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
2565         }
2566         break;
2567         case OPUS_GET_COMPLEXITY_REQUEST:
2568         {
2569             opus_int32 *value = va_arg(ap, opus_int32*);
2570             if (!value)
2571             {
2572                goto bad_arg;
2573             }
2574             *value = st->silk_mode.complexity;
2575         }
2576         break;
2577         case OPUS_SET_INBAND_FEC_REQUEST:
2578         {
2579             opus_int32 value = va_arg(ap, opus_int32);
2580             if(value<0 || value>1)
2581             {
2582                goto bad_arg;
2583             }
2584             st->silk_mode.useInBandFEC = value;
2585         }
2586         break;
2587         case OPUS_GET_INBAND_FEC_REQUEST:
2588         {
2589             opus_int32 *value = va_arg(ap, opus_int32*);
2590             if (!value)
2591             {
2592                goto bad_arg;
2593             }
2594             *value = st->silk_mode.useInBandFEC;
2595         }
2596         break;
2597         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
2598         {
2599             opus_int32 value = va_arg(ap, opus_int32);
2600             if (value < 0 || value > 100)
2601             {
2602                goto bad_arg;
2603             }
2604             st->silk_mode.packetLossPercentage = value;
2605             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
2606         }
2607         break;
2608         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
2609         {
2610             opus_int32 *value = va_arg(ap, opus_int32*);
2611             if (!value)
2612             {
2613                goto bad_arg;
2614             }
2615             *value = st->silk_mode.packetLossPercentage;
2616         }
2617         break;
2618         case OPUS_SET_VBR_REQUEST:
2619         {
2620             opus_int32 value = va_arg(ap, opus_int32);
2621             if(value<0 || value>1)
2622             {
2623                goto bad_arg;
2624             }
2625             st->use_vbr = value;
2626             st->silk_mode.useCBR = 1-value;
2627         }
2628         break;
2629         case OPUS_GET_VBR_REQUEST:
2630         {
2631             opus_int32 *value = va_arg(ap, opus_int32*);
2632             if (!value)
2633             {
2634                goto bad_arg;
2635             }
2636             *value = st->use_vbr;
2637         }
2638         break;
2639         case OPUS_SET_VOICE_RATIO_REQUEST:
2640         {
2641             opus_int32 value = va_arg(ap, opus_int32);
2642             if (value<-1 || value>100)
2643             {
2644                goto bad_arg;
2645             }
2646             st->voice_ratio = value;
2647         }
2648         break;
2649         case OPUS_GET_VOICE_RATIO_REQUEST:
2650         {
2651             opus_int32 *value = va_arg(ap, opus_int32*);
2652             if (!value)
2653             {
2654                goto bad_arg;
2655             }
2656             *value = st->voice_ratio;
2657         }
2658         break;
2659         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
2660         {
2661             opus_int32 value = va_arg(ap, opus_int32);
2662             if(value<0 || value>1)
2663             {
2664                goto bad_arg;
2665             }
2666             st->vbr_constraint = value;
2667         }
2668         break;
2669         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
2670         {
2671             opus_int32 *value = va_arg(ap, opus_int32*);
2672             if (!value)
2673             {
2674                goto bad_arg;
2675             }
2676             *value = st->vbr_constraint;
2677         }
2678         break;
2679         case OPUS_SET_SIGNAL_REQUEST:
2680         {
2681             opus_int32 value = va_arg(ap, opus_int32);
2682             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
2683             {
2684                goto bad_arg;
2685             }
2686             st->signal_type = value;
2687         }
2688         break;
2689         case OPUS_GET_SIGNAL_REQUEST:
2690         {
2691             opus_int32 *value = va_arg(ap, opus_int32*);
2692             if (!value)
2693             {
2694                goto bad_arg;
2695             }
2696             *value = st->signal_type;
2697         }
2698         break;
2699         case OPUS_GET_LOOKAHEAD_REQUEST:
2700         {
2701             opus_int32 *value = va_arg(ap, opus_int32*);
2702             if (!value)
2703             {
2704                goto bad_arg;
2705             }
2706             *value = st->Fs/400;
2707             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2708                 *value += st->delay_compensation;
2709         }
2710         break;
2711         case OPUS_GET_SAMPLE_RATE_REQUEST:
2712         {
2713             opus_int32 *value = va_arg(ap, opus_int32*);
2714             if (!value)
2715             {
2716                goto bad_arg;
2717             }
2718             *value = st->Fs;
2719         }
2720         break;
2721         case OPUS_GET_FINAL_RANGE_REQUEST:
2722         {
2723             opus_uint32 *value = va_arg(ap, opus_uint32*);
2724             if (!value)
2725             {
2726                goto bad_arg;
2727             }
2728             *value = st->rangeFinal;
2729         }
2730         break;
2731         case OPUS_SET_LSB_DEPTH_REQUEST:
2732         {
2733             opus_int32 value = va_arg(ap, opus_int32);
2734             if (value<8 || value>24)
2735             {
2736                goto bad_arg;
2737             }
2738             st->lsb_depth=value;
2739         }
2740         break;
2741         case OPUS_GET_LSB_DEPTH_REQUEST:
2742         {
2743             opus_int32 *value = va_arg(ap, opus_int32*);
2744             if (!value)
2745             {
2746                goto bad_arg;
2747             }
2748             *value = st->lsb_depth;
2749         }
2750         break;
2751         case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
2752         {
2753             opus_int32 value = va_arg(ap, opus_int32);
2754             if (value != OPUS_FRAMESIZE_ARG   && value != OPUS_FRAMESIZE_2_5_MS &&
2755                 value != OPUS_FRAMESIZE_5_MS  && value != OPUS_FRAMESIZE_10_MS  &&
2756                 value != OPUS_FRAMESIZE_20_MS && value != OPUS_FRAMESIZE_40_MS  &&
2757                 value != OPUS_FRAMESIZE_60_MS && value != OPUS_FRAMESIZE_VARIABLE)
2758             {
2759                goto bad_arg;
2760             }
2761             st->variable_duration = value;
2762             celt_encoder_ctl(celt_enc, OPUS_SET_EXPERT_FRAME_DURATION(value));
2763         }
2764         break;
2765         case OPUS_GET_EXPERT_FRAME_DURATION_REQUEST:
2766         {
2767             opus_int32 *value = va_arg(ap, opus_int32*);
2768             if (!value)
2769             {
2770                goto bad_arg;
2771             }
2772             *value = st->variable_duration;
2773         }
2774         break;
2775         case OPUS_SET_PREDICTION_DISABLED_REQUEST:
2776         {
2777            opus_int32 value = va_arg(ap, opus_int32);
2778            if (value > 1 || value < 0)
2779               goto bad_arg;
2780            st->silk_mode.reducedDependency = value;
2781         }
2782         break;
2783         case OPUS_GET_PREDICTION_DISABLED_REQUEST:
2784         {
2785            opus_int32 *value = va_arg(ap, opus_int32*);
2786            if (!value)
2787               goto bad_arg;
2788            *value = st->silk_mode.reducedDependency;
2789         }
2790         break;
2791         case OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST:
2792         {
2793             opus_int32 value = va_arg(ap, opus_int32);
2794             if(value<0 || value>1)
2795             {
2796                goto bad_arg;
2797             }
2798             celt_encoder_ctl(celt_enc, OPUS_SET_PHASE_INVERSION_DISABLED(value));
2799         }
2800         break;
2801         case OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST:
2802         {
2803             opus_int32 *value = va_arg(ap, opus_int32*);
2804             if (!value)
2805             {
2806                goto bad_arg;
2807             }
2808             celt_encoder_ctl(celt_enc, OPUS_GET_PHASE_INVERSION_DISABLED(value));
2809         }
2810         break;
2811         case OPUS_RESET_STATE:
2812         {
2813            void *silk_enc;
2814            silk_EncControlStruct dummy;
2815            char *start;
2816            silk_enc = (char*)st+st->silk_enc_offset;
2817 #ifndef DISABLE_FLOAT_API
2818            tonality_analysis_reset(&st->analysis);
2819 #endif
2820
2821            start = (char*)&st->OPUS_ENCODER_RESET_START;
2822            OPUS_CLEAR(start, sizeof(OpusEncoder) - (start - (char*)st));
2823
2824            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2825            silk_InitEncoder( silk_enc, st->arch, &dummy );
2826            st->stream_channels = st->channels;
2827            st->hybrid_stereo_width_Q14 = 1 << 14;
2828            st->prev_HB_gain = Q15ONE;
2829            st->first = 1;
2830            st->mode = MODE_HYBRID;
2831            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
2832            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
2833         }
2834         break;
2835         case OPUS_SET_FORCE_MODE_REQUEST:
2836         {
2837             opus_int32 value = va_arg(ap, opus_int32);
2838             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
2839             {
2840                goto bad_arg;
2841             }
2842             st->user_forced_mode = value;
2843         }
2844         break;
2845         case OPUS_SET_LFE_REQUEST:
2846         {
2847             opus_int32 value = va_arg(ap, opus_int32);
2848             st->lfe = value;
2849             ret = celt_encoder_ctl(celt_enc, OPUS_SET_LFE(value));
2850         }
2851         break;
2852         case OPUS_SET_ENERGY_MASK_REQUEST:
2853         {
2854             opus_val16 *value = va_arg(ap, opus_val16*);
2855             st->energy_masking = value;
2856             ret = celt_encoder_ctl(celt_enc, OPUS_SET_ENERGY_MASK(value));
2857         }
2858         break;
2859
2860         case CELT_GET_MODE_REQUEST:
2861         {
2862            const CELTMode ** value = va_arg(ap, const CELTMode**);
2863            if (!value)
2864            {
2865               goto bad_arg;
2866            }
2867            ret = celt_encoder_ctl(celt_enc, CELT_GET_MODE(value));
2868         }
2869         break;
2870         default:
2871             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
2872             ret = OPUS_UNIMPLEMENTED;
2873             break;
2874     }
2875     va_end(ap);
2876     return ret;
2877 bad_arg:
2878     va_end(ap);
2879     return OPUS_BAD_ARG;
2880 }
2881
2882 void opus_encoder_destroy(OpusEncoder *st)
2883 {
2884     opus_free(st);
2885 }