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