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