f484b0a425758ac9900da5f70f43d9edf5fe24cf
[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
1733     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
1734     bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
1735
1736     data += 1;
1737
1738     ec_enc_init(&enc, data, max_data_bytes-1);
1739
1740     ALLOC(pcm_buf, (total_buffer+frame_size)*st->channels, opus_val16);
1741     OPUS_COPY(pcm_buf, &st->delay_buffer[(st->encoder_buffer-total_buffer)*st->channels], total_buffer*st->channels);
1742
1743     if (st->mode == MODE_CELT_ONLY)
1744        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1745     else
1746        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
1747
1748     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
1749           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
1750
1751     /* convert from log scale to Hertz */
1752     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
1753
1754     if (st->application == OPUS_APPLICATION_VOIP)
1755     {
1756        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1757     } else {
1758        dc_reject(pcm, 3, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1759     }
1760 #ifndef FIXED_POINT
1761     if (float_api)
1762     {
1763        opus_val32 sum;
1764        sum = celt_inner_prod(&pcm_buf[total_buffer*st->channels], &pcm_buf[total_buffer*st->channels], frame_size*st->channels, st->arch);
1765        /* This should filter out both NaNs and ridiculous signals that could
1766           cause NaNs further down. */
1767        if (!(sum < 1e9f) || celt_isnan(sum))
1768        {
1769           OPUS_CLEAR(&pcm_buf[total_buffer*st->channels], frame_size*st->channels);
1770           st->hp_mem[0] = st->hp_mem[1] = st->hp_mem[2] = st->hp_mem[3] = 0;
1771        }
1772     }
1773 #endif
1774
1775
1776     /* SILK processing */
1777     HB_gain = Q15ONE;
1778     if (st->mode != MODE_CELT_ONLY)
1779     {
1780         opus_int32 total_bitRate, celt_rate;
1781 #ifdef FIXED_POINT
1782        const opus_int16 *pcm_silk;
1783 #else
1784        VARDECL(opus_int16, pcm_silk);
1785        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
1786 #endif
1787
1788         /* Distribute bits between SILK and CELT */
1789         total_bitRate = 8 * bytes_target * frame_rate;
1790         if( st->mode == MODE_HYBRID ) {
1791             /* Base rate for SILK */
1792             st->silk_mode.bitRate = compute_silk_rate_for_hybrid(total_bitRate,
1793                   curr_bandwidth, st->Fs == 50 * frame_size, st->use_vbr, st->silk_mode.LBRR_coded);
1794             if (!st->energy_masking)
1795             {
1796                /* Increasingly attenuate high band when it gets allocated fewer bits */
1797                celt_rate = total_bitRate - st->silk_mode.bitRate;
1798                HB_gain = Q15ONE - SHR32(celt_exp2(-celt_rate * QCONST16(1.f/1024, 10)), 1);
1799             }
1800         } else {
1801             /* SILK gets all bits */
1802             st->silk_mode.bitRate = total_bitRate;
1803         }
1804
1805         /* Surround masking for SILK */
1806         if (st->energy_masking && st->use_vbr && !st->lfe)
1807         {
1808            opus_val32 mask_sum=0;
1809            opus_val16 masking_depth;
1810            opus_int32 rate_offset;
1811            int c;
1812            int end = 17;
1813            opus_int16 srate = 16000;
1814            if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND)
1815            {
1816               end = 13;
1817               srate = 8000;
1818            } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1819            {
1820               end = 15;
1821               srate = 12000;
1822            }
1823            for (c=0;c<st->channels;c++)
1824            {
1825               for(i=0;i<end;i++)
1826               {
1827                  opus_val16 mask;
1828                  mask = MAX16(MIN16(st->energy_masking[21*c+i],
1829                         QCONST16(.5f, DB_SHIFT)), -QCONST16(2.0f, DB_SHIFT));
1830                  if (mask > 0)
1831                     mask = HALF16(mask);
1832                  mask_sum += mask;
1833               }
1834            }
1835            /* Conservative rate reduction, we cut the masking in half */
1836            masking_depth = mask_sum / end*st->channels;
1837            masking_depth += QCONST16(.2f, DB_SHIFT);
1838            rate_offset = (opus_int32)PSHR32(MULT16_16(srate, masking_depth), DB_SHIFT);
1839            rate_offset = MAX32(rate_offset, -2*st->silk_mode.bitRate/3);
1840            /* Split the rate change between the SILK and CELT part for hybrid. */
1841            if (st->bandwidth==OPUS_BANDWIDTH_SUPERWIDEBAND || st->bandwidth==OPUS_BANDWIDTH_FULLBAND)
1842               st->silk_mode.bitRate += 3*rate_offset/5;
1843            else
1844               st->silk_mode.bitRate += rate_offset;
1845            bytes_target += rate_offset * frame_size / (8 * st->Fs);
1846         }
1847
1848         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
1849         st->silk_mode.nChannelsAPI = st->channels;
1850         st->silk_mode.nChannelsInternal = st->stream_channels;
1851         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1852             st->silk_mode.desiredInternalSampleRate = 8000;
1853         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1854             st->silk_mode.desiredInternalSampleRate = 12000;
1855         } else {
1856             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
1857             st->silk_mode.desiredInternalSampleRate = 16000;
1858         }
1859         if( st->mode == MODE_HYBRID ) {
1860             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
1861             st->silk_mode.minInternalSampleRate = 16000;
1862         } else {
1863             st->silk_mode.minInternalSampleRate = 8000;
1864         }
1865
1866         st->silk_mode.maxInternalSampleRate = 16000;
1867         if (st->mode == MODE_SILK_ONLY)
1868         {
1869            opus_int32 effective_max_rate = max_rate;
1870            if (frame_rate > 50)
1871               effective_max_rate = effective_max_rate*2/3;
1872            if (effective_max_rate < 8000)
1873            {
1874               st->silk_mode.maxInternalSampleRate = 12000;
1875               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
1876            }
1877            if (effective_max_rate < 7000)
1878            {
1879               st->silk_mode.maxInternalSampleRate = 8000;
1880               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
1881            }
1882         }
1883
1884         st->silk_mode.useCBR = !st->use_vbr;
1885
1886         /* Call SILK encoder for the low band */
1887         nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes);
1888
1889         st->silk_mode.maxBits = nBytes*8;
1890         if (st->silk_mode.useCBR)
1891         {
1892            if (st->mode == MODE_HYBRID)
1893            {
1894               st->silk_mode.maxBits = st->silk_mode.bitRate * frame_size / st->Fs;
1895            }
1896         } else {
1897            /* Constrained VBR. */
1898            if (st->mode == MODE_HYBRID)
1899            {
1900               /* Compute SILK bitrate corresponding to the max total bits available */
1901               opus_int32 maxBitRate = compute_silk_rate_for_hybrid(nBytes*8*st->Fs / frame_size,
1902                     curr_bandwidth, st->Fs == 50 * frame_size, st->use_vbr, st->silk_mode.LBRR_coded);
1903               st->silk_mode.maxBits = maxBitRate * frame_size / st->Fs;
1904            }
1905         }
1906
1907         if (prefill)
1908         {
1909             opus_int32 zero=0;
1910             int prefill_offset;
1911             /* Use a smooth onset for the SILK prefill to avoid the encoder trying to encode
1912                a discontinuity. The exact location is what we need to avoid leaving any "gap"
1913                in the audio when mixing with the redundant CELT frame. Here we can afford to
1914                overwrite st->delay_buffer because the only thing that uses it before it gets
1915                rewritten is tmp_prefill[] and even then only the part after the ramp really
1916                gets used (rather than sent to the encoder and discarded) */
1917             prefill_offset = st->channels*(st->encoder_buffer-st->delay_compensation-st->Fs/400);
1918             gain_fade(st->delay_buffer+prefill_offset, st->delay_buffer+prefill_offset,
1919                   0, Q15ONE, celt_mode->overlap, st->Fs/400, st->channels, celt_mode->window, st->Fs);
1920             OPUS_CLEAR(st->delay_buffer, prefill_offset);
1921 #ifdef FIXED_POINT
1922             pcm_silk = st->delay_buffer;
1923 #else
1924             for (i=0;i<st->encoder_buffer*st->channels;i++)
1925                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
1926 #endif
1927             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
1928         }
1929
1930 #ifdef FIXED_POINT
1931         pcm_silk = pcm_buf+total_buffer*st->channels;
1932 #else
1933         for (i=0;i<frame_size*st->channels;i++)
1934             pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
1935 #endif
1936         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
1937         if( ret ) {
1938             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
1939             /* Handle error */
1940            RESTORE_STACK;
1941            return OPUS_INTERNAL_ERROR;
1942         }
1943         if (nBytes==0)
1944         {
1945            st->rangeFinal = 0;
1946            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1947            RESTORE_STACK;
1948            return 1;
1949         }
1950         /* Extract SILK internal bandwidth for signaling in first byte */
1951         if( st->mode == MODE_SILK_ONLY ) {
1952             if( st->silk_mode.internalSampleRate == 8000 ) {
1953                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1954             } else if( st->silk_mode.internalSampleRate == 12000 ) {
1955                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1956             } else if( st->silk_mode.internalSampleRate == 16000 ) {
1957                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1958             }
1959         } else {
1960             silk_assert( st->silk_mode.internalSampleRate == 16000 );
1961         }
1962
1963         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
1964         /* FIXME: How do we allocate the redundancy for CBR? */
1965         if (st->silk_mode.opusCanSwitch)
1966         {
1967            redundancy = 1;
1968            celt_to_silk = 0;
1969            st->silk_bw_switch = 1;
1970         }
1971     }
1972
1973     /* CELT processing */
1974     {
1975         int endband=21;
1976
1977         switch(curr_bandwidth)
1978         {
1979             case OPUS_BANDWIDTH_NARROWBAND:
1980                 endband = 13;
1981                 break;
1982             case OPUS_BANDWIDTH_MEDIUMBAND:
1983             case OPUS_BANDWIDTH_WIDEBAND:
1984                 endband = 17;
1985                 break;
1986             case OPUS_BANDWIDTH_SUPERWIDEBAND:
1987                 endband = 19;
1988                 break;
1989             case OPUS_BANDWIDTH_FULLBAND:
1990                 endband = 21;
1991                 break;
1992         }
1993         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
1994         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
1995     }
1996     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1997     if (st->mode != MODE_SILK_ONLY)
1998     {
1999         opus_val32 celt_pred=2;
2000         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
2001         /* We may still decide to disable prediction later */
2002         if (st->silk_mode.reducedDependency)
2003            celt_pred = 0;
2004         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(celt_pred));
2005
2006         if (st->mode == MODE_HYBRID)
2007         {
2008             int len;
2009
2010             len = (ec_tell(&enc)+7)>>3;
2011             if (redundancy)
2012                len += st->mode == MODE_HYBRID ? 3 : 1;
2013             if( st->use_vbr ) {
2014                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps-st->silk_mode.bitRate));
2015                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
2016                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(0));
2017             } else {
2018                 /* check if SILK used up too much */
2019                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
2020             }
2021         } else {
2022             if (st->use_vbr)
2023             {
2024                 opus_int32 bonus=0;
2025 #ifndef DISABLE_FLOAT_API
2026                 if (st->variable_duration==OPUS_FRAMESIZE_VARIABLE && frame_size != st->Fs/50)
2027                 {
2028                    bonus = (60*st->stream_channels+40)*(st->Fs/frame_size-50);
2029                    if (analysis_info.valid)
2030                       bonus = (opus_int32)(bonus*(1.f+.5f*analysis_info.tonality));
2031                 }
2032 #endif
2033                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
2034                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
2035                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps+bonus));
2036                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
2037             } else {
2038                 nb_compr_bytes = bytes_target;
2039             }
2040         }
2041
2042     } else {
2043         nb_compr_bytes = 0;
2044     }
2045
2046     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
2047     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
2048     {
2049        OPUS_COPY(tmp_prefill, &st->delay_buffer[(st->encoder_buffer-total_buffer-st->Fs/400)*st->channels], st->channels*st->Fs/400);
2050     }
2051
2052     if (st->channels*(st->encoder_buffer-(frame_size+total_buffer)) > 0)
2053     {
2054        OPUS_MOVE(st->delay_buffer, &st->delay_buffer[st->channels*frame_size], st->channels*(st->encoder_buffer-frame_size-total_buffer));
2055        OPUS_COPY(&st->delay_buffer[st->channels*(st->encoder_buffer-frame_size-total_buffer)],
2056              &pcm_buf[0],
2057              (frame_size+total_buffer)*st->channels);
2058     } else {
2059        OPUS_COPY(st->delay_buffer, &pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels], st->encoder_buffer*st->channels);
2060     }
2061     /* gain_fade() and stereo_fade() need to be after the buffer copying
2062        because we don't want any of this to affect the SILK part */
2063     if( st->prev_HB_gain < Q15ONE || HB_gain < Q15ONE ) {
2064        gain_fade(pcm_buf, pcm_buf,
2065              st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs);
2066     }
2067     st->prev_HB_gain = HB_gain;
2068     if (st->mode != MODE_HYBRID || st->stream_channels==1)
2069        st->silk_mode.stereoWidth_Q14 = IMIN((1<<14),2*IMAX(0,equiv_rate-24000));
2070     if( !st->energy_masking && st->channels == 2 ) {
2071         /* Apply stereo width reduction (at low bitrates) */
2072         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
2073             opus_val16 g1, g2;
2074             g1 = st->hybrid_stereo_width_Q14;
2075             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
2076 #ifdef FIXED_POINT
2077             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
2078             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
2079 #else
2080             g1 *= (1.f/16384);
2081             g2 *= (1.f/16384);
2082 #endif
2083             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
2084                   frame_size, st->channels, celt_mode->window, st->Fs);
2085             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
2086         }
2087     }
2088
2089     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
2090     {
2091         /* For SILK mode, the redundancy is inferred from the length */
2092         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
2093            ec_enc_bit_logp(&enc, redundancy, 12);
2094         if (redundancy)
2095         {
2096             int max_redundancy;
2097             ec_enc_bit_logp(&enc, celt_to_silk, 1);
2098             if (st->mode == MODE_HYBRID)
2099                max_redundancy = (max_data_bytes-1)-nb_compr_bytes;
2100             else
2101                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
2102             /* Target the same bit-rate for redundancy as for the rest,
2103                up to a max of 257 bytes */
2104             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
2105             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
2106             if (st->mode == MODE_HYBRID)
2107                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
2108         }
2109     } else {
2110         redundancy = 0;
2111     }
2112
2113     if (!redundancy)
2114     {
2115        st->silk_bw_switch = 0;
2116        redundancy_bytes = 0;
2117     }
2118     if (st->mode != MODE_CELT_ONLY)start_band=17;
2119
2120     if (st->mode == MODE_SILK_ONLY)
2121     {
2122         ret = (ec_tell(&enc)+7)>>3;
2123         ec_enc_done(&enc);
2124         nb_compr_bytes = ret;
2125     } else {
2126        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
2127        ec_enc_shrink(&enc, nb_compr_bytes);
2128     }
2129
2130 #ifndef DISABLE_FLOAT_API
2131     if (redundancy || st->mode != MODE_SILK_ONLY)
2132        celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(&analysis_info));
2133 #endif
2134     if (st->mode == MODE_HYBRID) {
2135        SILKInfo info;
2136        info.signalType = st->silk_mode.signalType;
2137        info.offset = st->silk_mode.offset;
2138        celt_encoder_ctl(celt_enc, CELT_SET_SILK_INFO(&info));
2139     } else {
2140        celt_encoder_ctl(celt_enc, CELT_SET_SILK_INFO((SILKInfo*)NULL));
2141     }
2142
2143     /* 5 ms redundant frame for CELT->SILK */
2144     if (redundancy && celt_to_silk)
2145     {
2146         int err;
2147         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
2148         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
2149         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
2150         err = celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
2151         if (err < 0)
2152         {
2153            RESTORE_STACK;
2154            return OPUS_INTERNAL_ERROR;
2155         }
2156         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
2157         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2158     }
2159
2160     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
2161
2162     if (st->mode != MODE_SILK_ONLY)
2163     {
2164         if (st->mode != st->prev_mode && st->prev_mode > 0)
2165         {
2166            unsigned char dummy[2];
2167            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2168
2169            /* Prefilling */
2170            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
2171            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
2172         }
2173         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
2174         if (ec_tell(&enc) <= 8*nb_compr_bytes)
2175         {
2176            /* Set the bitrate again if it was overridden in the redundancy code above*/
2177            if (redundancy && celt_to_silk && st->mode==MODE_HYBRID && st->use_vbr)
2178               celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps-st->silk_mode.bitRate));
2179            celt_encoder_ctl(celt_enc, OPUS_SET_VBR(st->use_vbr));
2180            ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
2181            if (ret < 0)
2182            {
2183               RESTORE_STACK;
2184               return OPUS_INTERNAL_ERROR;
2185            }
2186            /* Put CELT->SILK redundancy data in the right place. */
2187            if (redundancy && celt_to_silk && st->mode==MODE_HYBRID && st->use_vbr)
2188            {
2189               OPUS_COPY(data+ret, data+nb_compr_bytes, redundancy_bytes);
2190               nb_compr_bytes = nb_compr_bytes+redundancy_bytes;
2191            }
2192         }
2193     }
2194
2195     /* 5 ms redundant frame for SILK->CELT */
2196     if (redundancy && !celt_to_silk)
2197     {
2198         int err;
2199         unsigned char dummy[2];
2200         int N2, N4;
2201         N2 = st->Fs/200;
2202         N4 = st->Fs/400;
2203
2204         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2205         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
2206         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
2207         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
2208         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
2209
2210         if (st->mode == MODE_HYBRID)
2211         {
2212            /* Shrink packet to what the encoder actually used. */
2213            nb_compr_bytes = ret;
2214            ec_enc_shrink(&enc, nb_compr_bytes);
2215         }
2216         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
2217         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL);
2218
2219         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
2220         if (err < 0)
2221         {
2222            RESTORE_STACK;
2223            return OPUS_INTERNAL_ERROR;
2224         }
2225         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
2226     }
2227
2228
2229
2230     /* Signalling the mode in the first byte */
2231     data--;
2232     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
2233
2234     st->rangeFinal = enc.rng ^ redundant_rng;
2235
2236     if (to_celt)
2237         st->prev_mode = MODE_CELT_ONLY;
2238     else
2239         st->prev_mode = st->mode;
2240     st->prev_channels = st->stream_channels;
2241     st->prev_framesize = frame_size;
2242
2243     st->first = 0;
2244
2245     /* DTX decision */
2246 #ifndef DISABLE_FLOAT_API
2247     if (st->use_dtx && (analysis_info.valid || is_silence))
2248     {
2249        if (decide_dtx_mode(analysis_info.activity_probability, &st->nb_no_activity_frames,
2250              st->peak_signal_energy, pcm, frame_size, st->channels, is_silence, st->arch))
2251        {
2252           st->rangeFinal = 0;
2253           data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
2254           RESTORE_STACK;
2255           return 1;
2256        }
2257     }
2258 #endif
2259
2260     /* In the unlikely case that the SILK encoder busted its target, tell
2261        the decoder to call the PLC */
2262     if (ec_tell(&enc) > (max_data_bytes-1)*8)
2263     {
2264        if (max_data_bytes < 2)
2265        {
2266           RESTORE_STACK;
2267           return OPUS_BUFFER_TOO_SMALL;
2268        }
2269        data[1] = 0;
2270        ret = 1;
2271        st->rangeFinal = 0;
2272     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
2273     {
2274        /*When in LPC only mode it's perfectly
2275          reasonable to strip off trailing zero bytes as
2276          the required range decoder behavior is to
2277          fill these in. This can't be done when the MDCT
2278          modes are used because the decoder needs to know
2279          the actual length for allocation purposes.*/
2280        while(ret>2&&data[ret]==0)ret--;
2281     }
2282     /* Count ToC and redundancy */
2283     ret += 1+redundancy_bytes;
2284     if (!st->use_vbr)
2285     {
2286        if (opus_packet_pad(data, ret, max_data_bytes) != OPUS_OK)
2287
2288        {
2289           RESTORE_STACK;
2290           return OPUS_INTERNAL_ERROR;
2291        }
2292        ret = max_data_bytes;
2293     }
2294     RESTORE_STACK;
2295     return ret;
2296 }
2297
2298 #ifdef FIXED_POINT
2299
2300 #ifndef DISABLE_FLOAT_API
2301 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int analysis_frame_size,
2302       unsigned char *data, opus_int32 max_data_bytes)
2303 {
2304    int i, ret;
2305    int frame_size;
2306    int delay_compensation;
2307    VARDECL(opus_int16, in);
2308    ALLOC_STACK;
2309
2310    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2311       delay_compensation = 0;
2312    else
2313       delay_compensation = st->delay_compensation;
2314    frame_size = compute_frame_size(pcm, analysis_frame_size,
2315          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2316          delay_compensation, downmix_float, st->analysis.subframe_mem);
2317
2318    ALLOC(in, frame_size*st->channels, opus_int16);
2319
2320    for (i=0;i<frame_size*st->channels;i++)
2321       in[i] = FLOAT2INT16(pcm[i]);
2322    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16,
2323                             pcm, analysis_frame_size, 0, -2, st->channels, downmix_float, 1);
2324    RESTORE_STACK;
2325    return ret;
2326 }
2327 #endif
2328
2329 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int analysis_frame_size,
2330                 unsigned char *data, opus_int32 out_data_bytes)
2331 {
2332    int frame_size;
2333    int delay_compensation;
2334    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2335       delay_compensation = 0;
2336    else
2337       delay_compensation = st->delay_compensation;
2338    frame_size = compute_frame_size(pcm, analysis_frame_size,
2339          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2340          delay_compensation, downmix_int
2341 #ifndef DISABLE_FLOAT_API
2342          , st->analysis.subframe_mem
2343 #endif
2344          );
2345    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 16,
2346                              pcm, analysis_frame_size, 0, -2, st->channels, downmix_int, 0);
2347 }
2348
2349 #else
2350 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int analysis_frame_size,
2351       unsigned char *data, opus_int32 max_data_bytes)
2352 {
2353    int i, ret;
2354    int frame_size;
2355    int delay_compensation;
2356    VARDECL(float, in);
2357    ALLOC_STACK;
2358
2359    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2360       delay_compensation = 0;
2361    else
2362       delay_compensation = st->delay_compensation;
2363    frame_size = compute_frame_size(pcm, analysis_frame_size,
2364          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2365          delay_compensation, downmix_int, st->analysis.subframe_mem);
2366
2367    ALLOC(in, frame_size*st->channels, float);
2368
2369    for (i=0;i<frame_size*st->channels;i++)
2370       in[i] = (1.0f/32768)*pcm[i];
2371    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16,
2372                             pcm, analysis_frame_size, 0, -2, st->channels, downmix_int, 0);
2373    RESTORE_STACK;
2374    return ret;
2375 }
2376 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int analysis_frame_size,
2377                       unsigned char *data, opus_int32 out_data_bytes)
2378 {
2379    int frame_size;
2380    int delay_compensation;
2381    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2382       delay_compensation = 0;
2383    else
2384       delay_compensation = st->delay_compensation;
2385    frame_size = compute_frame_size(pcm, analysis_frame_size,
2386          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2387          delay_compensation, downmix_float, st->analysis.subframe_mem);
2388    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 24,
2389                              pcm, analysis_frame_size, 0, -2, st->channels, downmix_float, 1);
2390 }
2391 #endif
2392
2393
2394 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
2395 {
2396     int ret;
2397     CELTEncoder *celt_enc;
2398     va_list ap;
2399
2400     ret = OPUS_OK;
2401     va_start(ap, request);
2402
2403     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
2404
2405     switch (request)
2406     {
2407         case OPUS_SET_APPLICATION_REQUEST:
2408         {
2409             opus_int32 value = va_arg(ap, opus_int32);
2410             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
2411                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2412                || (!st->first && st->application != value))
2413             {
2414                ret = OPUS_BAD_ARG;
2415                break;
2416             }
2417             st->application = value;
2418         }
2419         break;
2420         case OPUS_GET_APPLICATION_REQUEST:
2421         {
2422             opus_int32 *value = va_arg(ap, opus_int32*);
2423             if (!value)
2424             {
2425                goto bad_arg;
2426             }
2427             *value = st->application;
2428         }
2429         break;
2430         case OPUS_SET_BITRATE_REQUEST:
2431         {
2432             opus_int32 value = va_arg(ap, opus_int32);
2433             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
2434             {
2435                 if (value <= 0)
2436                     goto bad_arg;
2437                 else if (value <= 500)
2438                     value = 500;
2439                 else if (value > (opus_int32)300000*st->channels)
2440                     value = (opus_int32)300000*st->channels;
2441             }
2442             st->user_bitrate_bps = value;
2443         }
2444         break;
2445         case OPUS_GET_BITRATE_REQUEST:
2446         {
2447             opus_int32 *value = va_arg(ap, opus_int32*);
2448             if (!value)
2449             {
2450                goto bad_arg;
2451             }
2452             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
2453         }
2454         break;
2455         case OPUS_SET_FORCE_CHANNELS_REQUEST:
2456         {
2457             opus_int32 value = va_arg(ap, opus_int32);
2458             if((value<1 || value>st->channels) && value != OPUS_AUTO)
2459             {
2460                goto bad_arg;
2461             }
2462             st->force_channels = value;
2463         }
2464         break;
2465         case OPUS_GET_FORCE_CHANNELS_REQUEST:
2466         {
2467             opus_int32 *value = va_arg(ap, opus_int32*);
2468             if (!value)
2469             {
2470                goto bad_arg;
2471             }
2472             *value = st->force_channels;
2473         }
2474         break;
2475         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
2476         {
2477             opus_int32 value = va_arg(ap, opus_int32);
2478             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND)
2479             {
2480                goto bad_arg;
2481             }
2482             st->max_bandwidth = value;
2483             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2484                 st->silk_mode.maxInternalSampleRate = 8000;
2485             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2486                 st->silk_mode.maxInternalSampleRate = 12000;
2487             } else {
2488                 st->silk_mode.maxInternalSampleRate = 16000;
2489             }
2490         }
2491         break;
2492         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
2493         {
2494             opus_int32 *value = va_arg(ap, opus_int32*);
2495             if (!value)
2496             {
2497                goto bad_arg;
2498             }
2499             *value = st->max_bandwidth;
2500         }
2501         break;
2502         case OPUS_SET_BANDWIDTH_REQUEST:
2503         {
2504             opus_int32 value = va_arg(ap, opus_int32);
2505             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
2506             {
2507                goto bad_arg;
2508             }
2509             st->user_bandwidth = value;
2510             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2511                 st->silk_mode.maxInternalSampleRate = 8000;
2512             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2513                 st->silk_mode.maxInternalSampleRate = 12000;
2514             } else {
2515                 st->silk_mode.maxInternalSampleRate = 16000;
2516             }
2517         }
2518         break;
2519         case OPUS_GET_BANDWIDTH_REQUEST:
2520         {
2521             opus_int32 *value = va_arg(ap, opus_int32*);
2522             if (!value)
2523             {
2524                goto bad_arg;
2525             }
2526             *value = st->bandwidth;
2527         }
2528         break;
2529         case OPUS_SET_DTX_REQUEST:
2530         {
2531             opus_int32 value = va_arg(ap, opus_int32);
2532             if(value<0 || value>1)
2533             {
2534                goto bad_arg;
2535             }
2536             st->use_dtx = value;
2537         }
2538         break;
2539         case OPUS_GET_DTX_REQUEST:
2540         {
2541             opus_int32 *value = va_arg(ap, opus_int32*);
2542             if (!value)
2543             {
2544                goto bad_arg;
2545             }
2546             *value = st->use_dtx;
2547         }
2548         break;
2549         case OPUS_SET_COMPLEXITY_REQUEST:
2550         {
2551             opus_int32 value = va_arg(ap, opus_int32);
2552             if(value<0 || value>10)
2553             {
2554                goto bad_arg;
2555             }
2556             st->silk_mode.complexity = value;
2557             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
2558         }
2559         break;
2560         case OPUS_GET_COMPLEXITY_REQUEST:
2561         {
2562             opus_int32 *value = va_arg(ap, opus_int32*);
2563             if (!value)
2564             {
2565                goto bad_arg;
2566             }
2567             *value = st->silk_mode.complexity;
2568         }
2569         break;
2570         case OPUS_SET_INBAND_FEC_REQUEST:
2571         {
2572             opus_int32 value = va_arg(ap, opus_int32);
2573             if(value<0 || value>1)
2574             {
2575                goto bad_arg;
2576             }
2577             st->silk_mode.useInBandFEC = value;
2578         }
2579         break;
2580         case OPUS_GET_INBAND_FEC_REQUEST:
2581         {
2582             opus_int32 *value = va_arg(ap, opus_int32*);
2583             if (!value)
2584             {
2585                goto bad_arg;
2586             }
2587             *value = st->silk_mode.useInBandFEC;
2588         }
2589         break;
2590         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
2591         {
2592             opus_int32 value = va_arg(ap, opus_int32);
2593             if (value < 0 || value > 100)
2594             {
2595                goto bad_arg;
2596             }
2597             st->silk_mode.packetLossPercentage = value;
2598             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
2599         }
2600         break;
2601         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
2602         {
2603             opus_int32 *value = va_arg(ap, opus_int32*);
2604             if (!value)
2605             {
2606                goto bad_arg;
2607             }
2608             *value = st->silk_mode.packetLossPercentage;
2609         }
2610         break;
2611         case OPUS_SET_VBR_REQUEST:
2612         {
2613             opus_int32 value = va_arg(ap, opus_int32);
2614             if(value<0 || value>1)
2615             {
2616                goto bad_arg;
2617             }
2618             st->use_vbr = value;
2619             st->silk_mode.useCBR = 1-value;
2620         }
2621         break;
2622         case OPUS_GET_VBR_REQUEST:
2623         {
2624             opus_int32 *value = va_arg(ap, opus_int32*);
2625             if (!value)
2626             {
2627                goto bad_arg;
2628             }
2629             *value = st->use_vbr;
2630         }
2631         break;
2632         case OPUS_SET_VOICE_RATIO_REQUEST:
2633         {
2634             opus_int32 value = va_arg(ap, opus_int32);
2635             if (value<-1 || value>100)
2636             {
2637                goto bad_arg;
2638             }
2639             st->voice_ratio = value;
2640         }
2641         break;
2642         case OPUS_GET_VOICE_RATIO_REQUEST:
2643         {
2644             opus_int32 *value = va_arg(ap, opus_int32*);
2645             if (!value)
2646             {
2647                goto bad_arg;
2648             }
2649             *value = st->voice_ratio;
2650         }
2651         break;
2652         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
2653         {
2654             opus_int32 value = va_arg(ap, opus_int32);
2655             if(value<0 || value>1)
2656             {
2657                goto bad_arg;
2658             }
2659             st->vbr_constraint = value;
2660         }
2661         break;
2662         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
2663         {
2664             opus_int32 *value = va_arg(ap, opus_int32*);
2665             if (!value)
2666             {
2667                goto bad_arg;
2668             }
2669             *value = st->vbr_constraint;
2670         }
2671         break;
2672         case OPUS_SET_SIGNAL_REQUEST:
2673         {
2674             opus_int32 value = va_arg(ap, opus_int32);
2675             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
2676             {
2677                goto bad_arg;
2678             }
2679             st->signal_type = value;
2680         }
2681         break;
2682         case OPUS_GET_SIGNAL_REQUEST:
2683         {
2684             opus_int32 *value = va_arg(ap, opus_int32*);
2685             if (!value)
2686             {
2687                goto bad_arg;
2688             }
2689             *value = st->signal_type;
2690         }
2691         break;
2692         case OPUS_GET_LOOKAHEAD_REQUEST:
2693         {
2694             opus_int32 *value = va_arg(ap, opus_int32*);
2695             if (!value)
2696             {
2697                goto bad_arg;
2698             }
2699             *value = st->Fs/400;
2700             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2701                 *value += st->delay_compensation;
2702         }
2703         break;
2704         case OPUS_GET_SAMPLE_RATE_REQUEST:
2705         {
2706             opus_int32 *value = va_arg(ap, opus_int32*);
2707             if (!value)
2708             {
2709                goto bad_arg;
2710             }
2711             *value = st->Fs;
2712         }
2713         break;
2714         case OPUS_GET_FINAL_RANGE_REQUEST:
2715         {
2716             opus_uint32 *value = va_arg(ap, opus_uint32*);
2717             if (!value)
2718             {
2719                goto bad_arg;
2720             }
2721             *value = st->rangeFinal;
2722         }
2723         break;
2724         case OPUS_SET_LSB_DEPTH_REQUEST:
2725         {
2726             opus_int32 value = va_arg(ap, opus_int32);
2727             if (value<8 || value>24)
2728             {
2729                goto bad_arg;
2730             }
2731             st->lsb_depth=value;
2732         }
2733         break;
2734         case OPUS_GET_LSB_DEPTH_REQUEST:
2735         {
2736             opus_int32 *value = va_arg(ap, opus_int32*);
2737             if (!value)
2738             {
2739                goto bad_arg;
2740             }
2741             *value = st->lsb_depth;
2742         }
2743         break;
2744         case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
2745         {
2746             opus_int32 value = va_arg(ap, opus_int32);
2747             if (value != OPUS_FRAMESIZE_ARG   && value != OPUS_FRAMESIZE_2_5_MS &&
2748                 value != OPUS_FRAMESIZE_5_MS  && value != OPUS_FRAMESIZE_10_MS  &&
2749                 value != OPUS_FRAMESIZE_20_MS && value != OPUS_FRAMESIZE_40_MS  &&
2750                 value != OPUS_FRAMESIZE_60_MS && value != OPUS_FRAMESIZE_VARIABLE)
2751             {
2752                goto bad_arg;
2753             }
2754             st->variable_duration = value;
2755             celt_encoder_ctl(celt_enc, OPUS_SET_EXPERT_FRAME_DURATION(value));
2756         }
2757         break;
2758         case OPUS_GET_EXPERT_FRAME_DURATION_REQUEST:
2759         {
2760             opus_int32 *value = va_arg(ap, opus_int32*);
2761             if (!value)
2762             {
2763                goto bad_arg;
2764             }
2765             *value = st->variable_duration;
2766         }
2767         break;
2768         case OPUS_SET_PREDICTION_DISABLED_REQUEST:
2769         {
2770            opus_int32 value = va_arg(ap, opus_int32);
2771            if (value > 1 || value < 0)
2772               goto bad_arg;
2773            st->silk_mode.reducedDependency = value;
2774         }
2775         break;
2776         case OPUS_GET_PREDICTION_DISABLED_REQUEST:
2777         {
2778            opus_int32 *value = va_arg(ap, opus_int32*);
2779            if (!value)
2780               goto bad_arg;
2781            *value = st->silk_mode.reducedDependency;
2782         }
2783         break;
2784         case OPUS_RESET_STATE:
2785         {
2786            void *silk_enc;
2787            silk_EncControlStruct dummy;
2788            char *start;
2789            silk_enc = (char*)st+st->silk_enc_offset;
2790 #ifndef DISABLE_FLOAT_API
2791            tonality_analysis_reset(&st->analysis);
2792 #endif
2793
2794            start = (char*)&st->OPUS_ENCODER_RESET_START;
2795            OPUS_CLEAR(start, sizeof(OpusEncoder) - (start - (char*)st));
2796
2797            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2798            silk_InitEncoder( silk_enc, st->arch, &dummy );
2799            st->stream_channels = st->channels;
2800            st->hybrid_stereo_width_Q14 = 1 << 14;
2801            st->prev_HB_gain = Q15ONE;
2802            st->first = 1;
2803            st->mode = MODE_HYBRID;
2804            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
2805            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
2806         }
2807         break;
2808         case OPUS_SET_FORCE_MODE_REQUEST:
2809         {
2810             opus_int32 value = va_arg(ap, opus_int32);
2811             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
2812             {
2813                goto bad_arg;
2814             }
2815             st->user_forced_mode = value;
2816         }
2817         break;
2818         case OPUS_SET_LFE_REQUEST:
2819         {
2820             opus_int32 value = va_arg(ap, opus_int32);
2821             st->lfe = value;
2822             ret = celt_encoder_ctl(celt_enc, OPUS_SET_LFE(value));
2823         }
2824         break;
2825         case OPUS_SET_ENERGY_MASK_REQUEST:
2826         {
2827             opus_val16 *value = va_arg(ap, opus_val16*);
2828             st->energy_masking = value;
2829             ret = celt_encoder_ctl(celt_enc, OPUS_SET_ENERGY_MASK(value));
2830         }
2831         break;
2832
2833         case CELT_GET_MODE_REQUEST:
2834         {
2835            const CELTMode ** value = va_arg(ap, const CELTMode**);
2836            if (!value)
2837            {
2838               goto bad_arg;
2839            }
2840            ret = celt_encoder_ctl(celt_enc, CELT_GET_MODE(value));
2841         }
2842         break;
2843         default:
2844             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
2845             ret = OPUS_UNIMPLEMENTED;
2846             break;
2847     }
2848     va_end(ap);
2849     return ret;
2850 bad_arg:
2851     va_end(ap);
2852     return OPUS_BAD_ARG;
2853 }
2854
2855 void opus_encoder_destroy(OpusEncoder *st)
2856 {
2857     opus_free(st);
2858 }