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