Fix crash on bad encoder frame_size argument
[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 #ifdef FIXED_POINT
576 #define PCM2VAL(x) FLOAT2INT16(x)
577 #else
578 #define PCM2VAL(x) SCALEIN(x)
579 #endif
580 void downmix_float(const void *_x, opus_val32 *sub, int subframe, int offset, int c1, int c2, int C)
581 {
582    const float *x;
583    opus_val32 scale;
584    int j;
585    x = (const float *)_x;
586    for (j=0;j<subframe;j++)
587       sub[j] = PCM2VAL(x[(j+offset)*C+c1]);
588    if (c2>-1)
589    {
590       for (j=0;j<subframe;j++)
591          sub[j] += PCM2VAL(x[(j+offset)*C+c2]);
592    } else if (c2==-2)
593    {
594       int c;
595       for (c=1;c<C;c++)
596       {
597          for (j=0;j<subframe;j++)
598             sub[j] += PCM2VAL(x[(j+offset)*C+c]);
599       }
600    }
601 #ifdef FIXED_POINT
602    scale = (1<<SIG_SHIFT);
603 #else
604    scale = 1.f;
605 #endif
606    if (c2==-2)
607       scale /= C;
608    else if (c2>-1)
609       scale /= 2;
610    for (j=0;j<subframe;j++)
611       sub[j] *= scale;
612 }
613 #endif
614
615 void downmix_int(const void *_x, opus_val32 *sub, int subframe, int offset, int c1, int c2, int C)
616 {
617    const opus_int16 *x;
618    opus_val32 scale;
619    int j;
620    x = (const opus_int16 *)_x;
621    for (j=0;j<subframe;j++)
622       sub[j] = x[(j+offset)*C+c1];
623    if (c2>-1)
624    {
625       for (j=0;j<subframe;j++)
626          sub[j] += x[(j+offset)*C+c2];
627    } else if (c2==-2)
628    {
629       int c;
630       for (c=1;c<C;c++)
631       {
632          for (j=0;j<subframe;j++)
633             sub[j] += x[(j+offset)*C+c];
634       }
635    }
636 #ifdef FIXED_POINT
637    scale = (1<<SIG_SHIFT);
638 #else
639    scale = 1.f/32768;
640 #endif
641    if (c2==-2)
642       scale /= C;
643    else if (c2>-1)
644       scale /= 2;
645    for (j=0;j<subframe;j++)
646       sub[j] *= scale;
647 }
648
649 opus_int32 frame_size_select(opus_int32 frame_size, int variable_duration, opus_int32 Fs)
650 {
651    int new_size;
652    if (frame_size<Fs/400)
653       return -1;
654    if (variable_duration == OPUS_FRAMESIZE_ARG)
655       new_size = frame_size;
656    else if (variable_duration >= OPUS_FRAMESIZE_2_5_MS && variable_duration <= OPUS_FRAMESIZE_120_MS)
657    {
658       if (variable_duration <= OPUS_FRAMESIZE_40_MS)
659          new_size = (Fs/400)<<(variable_duration-OPUS_FRAMESIZE_2_5_MS);
660       else
661          new_size = (variable_duration-OPUS_FRAMESIZE_2_5_MS-2)*Fs/50;
662    }
663    else
664       return -1;
665    if (new_size>frame_size)
666       return -1;
667    if (400*new_size!=Fs   && 200*new_size!=Fs   && 100*new_size!=Fs   &&
668         50*new_size!=Fs   &&  25*new_size!=Fs   &&  50*new_size!=3*Fs &&
669         50*new_size!=4*Fs &&  50*new_size!=5*Fs &&  50*new_size!=6*Fs)
670       return -1;
671    return new_size;
672 }
673
674 opus_val16 compute_stereo_width(const opus_val16 *pcm, int frame_size, opus_int32 Fs, StereoWidthState *mem)
675 {
676    opus_val32 xx, xy, yy;
677    opus_val16 sqrt_xx, sqrt_yy;
678    opus_val16 qrrt_xx, qrrt_yy;
679    int frame_rate;
680    int i;
681    opus_val16 short_alpha;
682
683    frame_rate = Fs/frame_size;
684    short_alpha = Q15ONE - MULT16_16(25, Q15ONE)/IMAX(50,frame_rate);
685    xx=xy=yy=0;
686    /* Unroll by 4. The frame size is always a multiple of 4 *except* for
687       2.5 ms frames at 12 kHz. Since this setting is very rare (and very
688       stupid), we just discard the last two samples. */
689    for (i=0;i<frame_size-3;i+=4)
690    {
691       opus_val32 pxx=0;
692       opus_val32 pxy=0;
693       opus_val32 pyy=0;
694       opus_val16 x, y;
695       x = pcm[2*i];
696       y = pcm[2*i+1];
697       pxx = SHR32(MULT16_16(x,x),2);
698       pxy = SHR32(MULT16_16(x,y),2);
699       pyy = SHR32(MULT16_16(y,y),2);
700       x = pcm[2*i+2];
701       y = pcm[2*i+3];
702       pxx += SHR32(MULT16_16(x,x),2);
703       pxy += SHR32(MULT16_16(x,y),2);
704       pyy += SHR32(MULT16_16(y,y),2);
705       x = pcm[2*i+4];
706       y = pcm[2*i+5];
707       pxx += SHR32(MULT16_16(x,x),2);
708       pxy += SHR32(MULT16_16(x,y),2);
709       pyy += SHR32(MULT16_16(y,y),2);
710       x = pcm[2*i+6];
711       y = pcm[2*i+7];
712       pxx += SHR32(MULT16_16(x,x),2);
713       pxy += SHR32(MULT16_16(x,y),2);
714       pyy += SHR32(MULT16_16(y,y),2);
715
716       xx += SHR32(pxx, 10);
717       xy += SHR32(pxy, 10);
718       yy += SHR32(pyy, 10);
719    }
720    mem->XX += MULT16_32_Q15(short_alpha, xx-mem->XX);
721    mem->XY += MULT16_32_Q15(short_alpha, xy-mem->XY);
722    mem->YY += MULT16_32_Q15(short_alpha, yy-mem->YY);
723    mem->XX = MAX32(0, mem->XX);
724    mem->XY = MAX32(0, mem->XY);
725    mem->YY = MAX32(0, mem->YY);
726    if (MAX32(mem->XX, mem->YY)>QCONST16(8e-4f, 18))
727    {
728       opus_val16 corr;
729       opus_val16 ldiff;
730       opus_val16 width;
731       sqrt_xx = celt_sqrt(mem->XX);
732       sqrt_yy = celt_sqrt(mem->YY);
733       qrrt_xx = celt_sqrt(sqrt_xx);
734       qrrt_yy = celt_sqrt(sqrt_yy);
735       /* Inter-channel correlation */
736       mem->XY = MIN32(mem->XY, sqrt_xx*sqrt_yy);
737       corr = SHR32(frac_div32(mem->XY,EPSILON+MULT16_16(sqrt_xx,sqrt_yy)),16);
738       /* Approximate loudness difference */
739       ldiff = MULT16_16(Q15ONE, ABS16(qrrt_xx-qrrt_yy))/(EPSILON+qrrt_xx+qrrt_yy);
740       width = MULT16_16_Q15(celt_sqrt(QCONST32(1.f,30)-MULT16_16(corr,corr)), ldiff);
741       /* Smoothing over one second */
742       mem->smoothed_width += (width-mem->smoothed_width)/frame_rate;
743       /* Peak follower */
744       mem->max_follower = MAX16(mem->max_follower-QCONST16(.02f,15)/frame_rate, mem->smoothed_width);
745    }
746    /*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);*/
747    return EXTRACT16(MIN32(Q15ONE, MULT16_16(20, mem->max_follower)));
748 }
749
750 static int decide_fec(int useInBandFEC, int PacketLoss_perc, int last_fec, int mode, int *bandwidth, opus_int32 rate)
751 {
752    int orig_bandwidth;
753    if (!useInBandFEC || PacketLoss_perc == 0 || mode == MODE_CELT_ONLY)
754       return 0;
755    orig_bandwidth = *bandwidth;
756    for (;;)
757    {
758       opus_int32 hysteresis;
759       opus_int32 LBRR_rate_thres_bps;
760       /* Compute threshold for using FEC at the current bandwidth setting */
761       LBRR_rate_thres_bps = fec_thresholds[2*(*bandwidth - OPUS_BANDWIDTH_NARROWBAND)];
762       hysteresis = fec_thresholds[2*(*bandwidth - OPUS_BANDWIDTH_NARROWBAND) + 1];
763       if (last_fec == 1) LBRR_rate_thres_bps -= hysteresis;
764       if (last_fec == 0) LBRR_rate_thres_bps += hysteresis;
765       LBRR_rate_thres_bps = silk_SMULWB( silk_MUL( LBRR_rate_thres_bps,
766             125 - silk_min( PacketLoss_perc, 25 ) ), SILK_FIX_CONST( 0.01, 16 ) );
767       /* If loss <= 5%, we look at whether we have enough rate to enable FEC.
768          If loss > 5%, we decrease the bandwidth until we can enable FEC. */
769       if (rate > LBRR_rate_thres_bps)
770          return 1;
771       else if (PacketLoss_perc <= 5)
772          return 0;
773       else if (*bandwidth > OPUS_BANDWIDTH_NARROWBAND)
774          (*bandwidth)--;
775       else
776          break;
777    }
778    /* Couldn't find any bandwidth to enable FEC, keep original bandwidth. */
779    *bandwidth = orig_bandwidth;
780    return 0;
781 }
782
783 static int compute_silk_rate_for_hybrid(int rate, int bandwidth, int frame20ms, int vbr, int fec) {
784    int entry;
785    int i;
786    int N;
787    int silk_rate;
788    static int rate_table[][5] = {
789   /*  |total| |-------- SILK------------|
790               |-- No FEC -| |--- FEC ---|
791                10ms   20ms   10ms   20ms */
792       {    0,     0,     0,     0,     0},
793       {12000, 10000, 10000, 11000, 11000},
794       {16000, 13500, 13500, 15000, 15000},
795       {20000, 16000, 16000, 18000, 18000},
796       {24000, 18000, 18000, 21000, 21000},
797       {32000, 22000, 22000, 28000, 28000},
798       {64000, 38000, 38000, 50000, 50000}
799    };
800    entry = 1 + frame20ms + 2*fec;
801    N = sizeof(rate_table)/sizeof(rate_table[0]);
802    for (i=1;i<N;i++)
803    {
804       if (rate_table[i][0] > rate) break;
805    }
806    if (i == N)
807    {
808       silk_rate = rate_table[i-1][entry];
809       /* For now, just give 50% of the extra bits to SILK. */
810       silk_rate += (rate-rate_table[i-1][0])/2;
811    } else {
812       opus_int32 lo, hi, x0, x1;
813       lo = rate_table[i-1][entry];
814       hi = rate_table[i][entry];
815       x0 = rate_table[i-1][0];
816       x1 = rate_table[i][0];
817       silk_rate = (lo*(x1-rate) + hi*(rate-x0))/(x1-x0);
818    }
819    if (!vbr)
820    {
821       /* Tiny boost to SILK for CBR. We should probably tune this better. */
822       silk_rate += 100;
823    }
824    if (bandwidth==OPUS_BANDWIDTH_SUPERWIDEBAND)
825       silk_rate += 300;
826    return silk_rate;
827 }
828
829 /* Returns the equivalent bitrate corresponding to 20 ms frames,
830    complexity 10 VBR operation. */
831 static opus_int32 compute_equiv_rate(opus_int32 bitrate, int channels,
832       int frame_rate, int vbr, int mode, int complexity, int loss)
833 {
834    opus_int32 equiv;
835    equiv = bitrate;
836    /* Take into account overhead from smaller frames. */
837    equiv -= (40*channels+20)*(frame_rate - 50);
838    /* CBR is about a 8% penalty for both SILK and CELT. */
839    if (!vbr)
840       equiv -= equiv/12;
841    /* Complexity makes about 10% difference (from 0 to 10) in general. */
842    equiv = equiv * (90+complexity)/100;
843    if (mode == MODE_SILK_ONLY || mode == MODE_HYBRID)
844    {
845       /* SILK complexity 0-1 uses the non-delayed-decision NSQ, which
846          costs about 20%. */
847       if (complexity<2)
848          equiv = equiv*4/5;
849       equiv -= equiv*loss/(6*loss + 10);
850    } else if (mode == MODE_CELT_ONLY) {
851       /* CELT complexity 0-4 doesn't have the pitch filter, which costs
852          about 10%. */
853       if (complexity<5)
854          equiv = equiv*9/10;
855    } else {
856       /* Mode not known yet */
857       /* Half the SILK loss*/
858       equiv -= equiv*loss/(12*loss + 20);
859    }
860    return equiv;
861 }
862
863 #ifndef DISABLE_FLOAT_API
864
865 static int is_digital_silence(const opus_val16* pcm, int frame_size, int channels, int lsb_depth)
866 {
867    int silence = 0;
868    opus_val32 sample_max = 0;
869
870    sample_max = celt_maxabs16(pcm, frame_size*channels);
871
872 #ifdef FIXED_POINT
873    silence = (sample_max == 0);
874    (void)lsb_depth;
875 #else
876    silence = (sample_max <= (opus_val16) 1 / (1 << lsb_depth));
877 #endif
878
879    return silence;
880 }
881
882 #ifdef FIXED_POINT
883 static opus_val32 compute_frame_energy(const opus_val16 *pcm, int frame_size, int channels, int arch)
884 {
885    int i;
886    opus_val32 sample_max;
887    int max_shift;
888    int shift;
889    opus_val32 energy = 0;
890    int len = frame_size*channels;
891    (void)arch;
892    /* Max amplitude in the signal */
893    sample_max = celt_maxabs16(pcm, len);
894
895    /* Compute the right shift required in the MAC to avoid an overflow */
896    max_shift = celt_ilog2(len);
897    shift = IMAX(0, (celt_ilog2(sample_max) << 1) + max_shift - 28);
898
899    /* Compute the energy */
900    for (i=0; i<len; i++)
901       energy += SHR32(MULT16_16(pcm[i], pcm[i]), shift);
902
903    /* Normalize energy by the frame size and left-shift back to the original position */
904    energy /= len;
905    energy = SHL32(energy, shift);
906
907    return energy;
908 }
909 #else
910 static opus_val32 compute_frame_energy(const opus_val16 *pcm, int frame_size, int channels, int arch)
911 {
912    int len = frame_size*channels;
913    return celt_inner_prod(pcm, pcm, len, arch)/len;
914 }
915 #endif
916
917 /* Decides if DTX should be turned on (=1) or off (=0) */
918 static int decide_dtx_mode(float activity_probability,    /* probability that current frame contains speech/music */
919                            int *nb_no_activity_frames,    /* number of consecutive frames with no activity */
920                            opus_val32 peak_signal_energy, /* peak energy of desired signal detected so far */
921                            const opus_val16 *pcm,         /* input pcm signal */
922                            int frame_size,                /* frame size */
923                            int channels,
924                            int is_silence,                 /* only digital silence detected in this frame */
925                            int arch
926                           )
927 {
928    int is_noise;
929    opus_val32 noise_energy;
930    int is_sufficiently_quiet;
931
932    if (!is_silence)
933    {
934       is_noise = activity_probability < DTX_ACTIVITY_THRESHOLD;
935       if (is_noise)
936       {
937          noise_energy = compute_frame_energy(pcm, frame_size, channels, arch);
938          is_sufficiently_quiet = peak_signal_energy >= (PSEUDO_SNR_THRESHOLD * noise_energy);
939       }
940    }
941
942    if (is_silence || (is_noise && is_sufficiently_quiet))
943    {
944       /* The number of consecutive DTX frames should be within the allowed bounds */
945       (*nb_no_activity_frames)++;
946
947       if (*nb_no_activity_frames > NB_SPEECH_FRAMES_BEFORE_DTX)
948       {
949          if (*nb_no_activity_frames <= (NB_SPEECH_FRAMES_BEFORE_DTX + MAX_CONSECUTIVE_DTX))
950             /* Valid frame for DTX! */
951             return 1;
952          else
953             (*nb_no_activity_frames) = NB_SPEECH_FRAMES_BEFORE_DTX;
954       }
955    } else
956       (*nb_no_activity_frames) = 0;
957
958    return 0;
959 }
960
961 #endif
962
963 static opus_int32 encode_multiframe_packet(OpusEncoder *st,
964                                            const opus_val16 *pcm,
965                                            int nb_frames,
966                                            int frame_size,
967                                            unsigned char *data,
968                                            opus_int32 out_data_bytes,
969                                            int to_celt,
970                                            int lsb_depth,
971                                            int float_api)
972 {
973    int i;
974    int ret = 0;
975    VARDECL(unsigned char, tmp_data);
976    int bak_mode, bak_bandwidth, bak_channels, bak_to_mono;
977    VARDECL(OpusRepacketizer, rp);
978    int max_header_bytes;
979    opus_int32 bytes_per_frame;
980    opus_int32 cbr_bytes;
981    opus_int32 repacketize_len;
982    int tmp_len;
983    ALLOC_STACK;
984
985    /* Worst cases:
986     * 2 frames: Code 2 with different compressed sizes
987     * >2 frames: Code 3 VBR */
988    max_header_bytes = nb_frames == 2 ? 3 : (2+(nb_frames-1)*2);
989
990    if (st->use_vbr || st->user_bitrate_bps==OPUS_BITRATE_MAX)
991       repacketize_len = out_data_bytes;
992    else {
993       cbr_bytes = 3*st->bitrate_bps/(3*8*st->Fs/(frame_size*nb_frames));
994       repacketize_len = IMIN(cbr_bytes, out_data_bytes);
995    }
996    bytes_per_frame = IMIN(1276, 1+(repacketize_len-max_header_bytes)/nb_frames);
997
998    ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char);
999    ALLOC(rp, 1, OpusRepacketizer);
1000    opus_repacketizer_init(rp);
1001
1002    bak_mode = st->user_forced_mode;
1003    bak_bandwidth = st->user_bandwidth;
1004    bak_channels = st->force_channels;
1005
1006    st->user_forced_mode = st->mode;
1007    st->user_bandwidth = st->bandwidth;
1008    st->force_channels = st->stream_channels;
1009
1010    bak_to_mono = st->silk_mode.toMono;
1011    if (bak_to_mono)
1012       st->force_channels = 1;
1013    else
1014       st->prev_channels = st->stream_channels;
1015
1016    for (i=0;i<nb_frames;i++)
1017    {
1018       st->silk_mode.toMono = 0;
1019       st->nonfinal_frame = i<(nb_frames-1);
1020
1021       /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
1022       if (to_celt && i==nb_frames-1)
1023          st->user_forced_mode = MODE_CELT_ONLY;
1024
1025       tmp_len = opus_encode_native(st, pcm+i*(st->channels*frame_size), frame_size,
1026          tmp_data+i*bytes_per_frame, bytes_per_frame, lsb_depth, NULL, 0, 0, 0, 0,
1027          NULL, float_api);
1028
1029       if (tmp_len<0)
1030       {
1031          RESTORE_STACK;
1032          return OPUS_INTERNAL_ERROR;
1033       }
1034
1035       ret = opus_repacketizer_cat(rp, tmp_data+i*bytes_per_frame, tmp_len);
1036
1037       if (ret<0)
1038       {
1039          RESTORE_STACK;
1040          return OPUS_INTERNAL_ERROR;
1041       }
1042    }
1043
1044    ret = opus_repacketizer_out_range_impl(rp, 0, nb_frames, data, repacketize_len, 0, !st->use_vbr);
1045
1046    if (ret<0)
1047    {
1048       RESTORE_STACK;
1049       return OPUS_INTERNAL_ERROR;
1050    }
1051
1052    /* Discard configs that were forced locally for the purpose of repacketization */
1053    st->user_forced_mode = bak_mode;
1054    st->user_bandwidth = bak_bandwidth;
1055    st->force_channels = bak_channels;
1056    st->silk_mode.toMono = bak_to_mono;
1057
1058    RESTORE_STACK;
1059    return ret;
1060 }
1061
1062 opus_int32 opus_encode_native(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
1063                 unsigned char *data, opus_int32 out_data_bytes, int lsb_depth,
1064                 const void *analysis_pcm, opus_int32 analysis_size, int c1, int c2,
1065                 int analysis_channels, downmix_func downmix, int float_api)
1066 {
1067     void *silk_enc;
1068     CELTEncoder *celt_enc;
1069     int i;
1070     int ret=0;
1071     opus_int32 nBytes;
1072     ec_enc enc;
1073     int bytes_target;
1074     int prefill=0;
1075     int start_band = 0;
1076     int redundancy = 0;
1077     int redundancy_bytes = 0; /* Number of bytes to use for redundancy frame */
1078     int celt_to_silk = 0;
1079     VARDECL(opus_val16, pcm_buf);
1080     int nb_compr_bytes;
1081     int to_celt = 0;
1082     opus_uint32 redundant_rng = 0;
1083     int cutoff_Hz, hp_freq_smth1;
1084     int voice_est; /* Probability of voice in Q7 */
1085     opus_int32 equiv_rate;
1086     int delay_compensation;
1087     int frame_rate;
1088     opus_int32 max_rate; /* Max bitrate we're allowed to use */
1089     int curr_bandwidth;
1090     opus_val16 HB_gain;
1091     opus_int32 max_data_bytes; /* Max number of bytes we're allowed to use */
1092     int total_buffer;
1093     opus_val16 stereo_width;
1094     const CELTMode *celt_mode;
1095 #ifndef DISABLE_FLOAT_API
1096     AnalysisInfo analysis_info;
1097     int analysis_read_pos_bak=-1;
1098     int analysis_read_subframe_bak=-1;
1099     int is_silence = 0;
1100 #endif
1101     VARDECL(opus_val16, tmp_prefill);
1102
1103     ALLOC_STACK;
1104
1105     max_data_bytes = IMIN(1276, out_data_bytes);
1106
1107     st->rangeFinal = 0;
1108     if ((!st->variable_duration && 400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
1109          50*frame_size != st->Fs && 25*frame_size != st->Fs && 50*frame_size != 3*st->Fs && 50*frame_size != 4*st->Fs &&
1110          50*frame_size != 5*st->Fs && 50*frame_size != 6*st->Fs)
1111          || (400*frame_size < st->Fs)
1112          || max_data_bytes<=0
1113          )
1114     {
1115        RESTORE_STACK;
1116        return OPUS_BAD_ARG;
1117     }
1118
1119     /* Cannot encode 100 ms in 1 byte */
1120     if (max_data_bytes==1 && st->Fs==(frame_size*10))
1121     {
1122       RESTORE_STACK;
1123       return OPUS_BUFFER_TOO_SMALL;
1124     }
1125
1126     silk_enc = (char*)st+st->silk_enc_offset;
1127     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1128     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1129        delay_compensation = 0;
1130     else
1131        delay_compensation = st->delay_compensation;
1132
1133     lsb_depth = IMIN(lsb_depth, st->lsb_depth);
1134
1135     celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1136 #ifndef DISABLE_FLOAT_API
1137     analysis_info.valid = 0;
1138 #ifdef FIXED_POINT
1139     if (st->silk_mode.complexity >= 10 && st->Fs==48000)
1140 #else
1141     if (st->silk_mode.complexity >= 7 && st->Fs==48000)
1142 #endif
1143     {
1144        if (is_digital_silence(pcm, frame_size, st->channels, lsb_depth))
1145        {
1146           is_silence = 1;
1147        } else {
1148           analysis_read_pos_bak = st->analysis.read_pos;
1149           analysis_read_subframe_bak = st->analysis.read_subframe;
1150           run_analysis(&st->analysis, celt_mode, analysis_pcm, analysis_size, frame_size,
1151                 c1, c2, analysis_channels, st->Fs,
1152                 lsb_depth, downmix, &analysis_info);
1153        }
1154
1155        /* Track the peak signal energy */
1156        if (!is_silence && analysis_info.activity_probability > DTX_ACTIVITY_THRESHOLD)
1157           st->peak_signal_energy = MAX32(MULT16_32_Q15(QCONST16(0.999, 15), st->peak_signal_energy),
1158                 compute_frame_energy(pcm, frame_size, st->channels, st->arch));
1159     }
1160 #else
1161     (void)analysis_pcm;
1162     (void)analysis_size;
1163 #endif
1164
1165 #ifndef DISABLE_FLOAT_API
1166     /* Reset voice_ratio if this frame is not silent or if analysis is disabled.
1167      * Otherwise, preserve voice_ratio from the last non-silent frame */
1168     if (!is_silence)
1169       st->voice_ratio = -1;
1170
1171     st->detected_bandwidth = 0;
1172     if (analysis_info.valid)
1173     {
1174        int analysis_bandwidth;
1175        if (st->signal_type == OPUS_AUTO)
1176           st->voice_ratio = (int)floor(.5+100*(1-analysis_info.music_prob));
1177
1178        analysis_bandwidth = analysis_info.bandwidth;
1179        if (analysis_bandwidth<=12)
1180           st->detected_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1181        else if (analysis_bandwidth<=14)
1182           st->detected_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1183        else if (analysis_bandwidth<=16)
1184           st->detected_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1185        else if (analysis_bandwidth<=18)
1186           st->detected_bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1187        else
1188           st->detected_bandwidth = OPUS_BANDWIDTH_FULLBAND;
1189     }
1190 #else
1191     st->voice_ratio = -1;
1192 #endif
1193
1194     if (st->channels==2 && st->force_channels!=1)
1195        stereo_width = compute_stereo_width(pcm, frame_size, st->Fs, &st->width_mem);
1196     else
1197        stereo_width = 0;
1198     total_buffer = delay_compensation;
1199     st->bitrate_bps = user_bitrate_to_bitrate(st, frame_size, max_data_bytes);
1200
1201     frame_rate = st->Fs/frame_size;
1202     if (!st->use_vbr)
1203     {
1204        int cbrBytes;
1205        /* Multiply by 12 to make sure the division is exact. */
1206        int frame_rate12 = 12*st->Fs/frame_size;
1207        /* We need to make sure that "int" values always fit in 16 bits. */
1208        cbrBytes = IMIN( (12*st->bitrate_bps/8 + frame_rate12/2)/frame_rate12, max_data_bytes);
1209        st->bitrate_bps = cbrBytes*(opus_int32)frame_rate12*8/12;
1210        /* Make sure we provide at least one byte to avoid failing. */
1211        max_data_bytes = IMAX(1, cbrBytes);
1212     }
1213     if (max_data_bytes<3 || st->bitrate_bps < 3*frame_rate*8
1214        || (frame_rate<50 && (max_data_bytes*frame_rate<300 || st->bitrate_bps < 2400)))
1215     {
1216        /*If the space is too low to do something useful, emit 'PLC' frames.*/
1217        int tocmode = st->mode;
1218        int bw = st->bandwidth == 0 ? OPUS_BANDWIDTH_NARROWBAND : st->bandwidth;
1219        int packet_code = 0;
1220        int num_multiframes = 0;
1221
1222        if (tocmode==0)
1223           tocmode = MODE_SILK_ONLY;
1224        if (frame_rate>100)
1225           tocmode = MODE_CELT_ONLY;
1226        /* 40 ms -> 2 x 20 ms if in CELT_ONLY or HYBRID mode */
1227        if (frame_rate==25 && tocmode!=MODE_SILK_ONLY)
1228        {
1229           frame_rate = 50;
1230           packet_code = 1;
1231        }
1232
1233        /* >= 60 ms frames */
1234        if (frame_rate<=16)
1235        {
1236           /* 1 x 60 ms, 2 x 40 ms, 2 x 60 ms */
1237           if (out_data_bytes==1 || (tocmode==MODE_SILK_ONLY && frame_rate!=10))
1238           {
1239              tocmode = MODE_SILK_ONLY;
1240
1241              packet_code = frame_rate <= 12;
1242              frame_rate = frame_rate == 12 ? 25 : 16;
1243           }
1244           else
1245           {
1246              num_multiframes = 50/frame_rate;
1247              frame_rate = 50;
1248              packet_code = 3;
1249           }
1250        }
1251
1252        if(tocmode==MODE_SILK_ONLY&&bw>OPUS_BANDWIDTH_WIDEBAND)
1253           bw=OPUS_BANDWIDTH_WIDEBAND;
1254        else if (tocmode==MODE_CELT_ONLY&&bw==OPUS_BANDWIDTH_MEDIUMBAND)
1255           bw=OPUS_BANDWIDTH_NARROWBAND;
1256        else if (tocmode==MODE_HYBRID&&bw<=OPUS_BANDWIDTH_SUPERWIDEBAND)
1257           bw=OPUS_BANDWIDTH_SUPERWIDEBAND;
1258
1259        data[0] = gen_toc(tocmode, frame_rate, bw, st->stream_channels);
1260        data[0] |= packet_code;
1261
1262        ret = packet_code <= 1 ? 1 : 2;
1263
1264        max_data_bytes = IMAX(max_data_bytes, ret);
1265
1266        if (packet_code==3)
1267           data[1] = num_multiframes;
1268
1269        if (!st->use_vbr)
1270        {
1271           ret = opus_packet_pad(data, ret, max_data_bytes);
1272           if (ret == OPUS_OK)
1273              ret = max_data_bytes;
1274           else
1275              ret = OPUS_INTERNAL_ERROR;
1276        }
1277        RESTORE_STACK;
1278        return ret;
1279     }
1280     max_rate = frame_rate*max_data_bytes*8;
1281
1282     /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */
1283     equiv_rate = compute_equiv_rate(st->bitrate_bps, st->channels, st->Fs/frame_size,
1284           st->use_vbr, 0, st->silk_mode.complexity, st->silk_mode.packetLossPercentage);
1285
1286     if (st->signal_type == OPUS_SIGNAL_VOICE)
1287        voice_est = 127;
1288     else if (st->signal_type == OPUS_SIGNAL_MUSIC)
1289        voice_est = 0;
1290     else if (st->voice_ratio >= 0)
1291     {
1292        voice_est = st->voice_ratio*327>>8;
1293        /* For AUDIO, never be more than 90% confident of having speech */
1294        if (st->application == OPUS_APPLICATION_AUDIO)
1295           voice_est = IMIN(voice_est, 115);
1296     } else if (st->application == OPUS_APPLICATION_VOIP)
1297        voice_est = 115;
1298     else
1299        voice_est = 48;
1300
1301     if (st->force_channels!=OPUS_AUTO && st->channels == 2)
1302     {
1303         st->stream_channels = st->force_channels;
1304     } else {
1305 #ifdef FUZZING
1306        /* Random mono/stereo decision */
1307        if (st->channels == 2 && (rand()&0x1F)==0)
1308           st->stream_channels = 3-st->stream_channels;
1309 #else
1310        /* Rate-dependent mono-stereo decision */
1311        if (st->channels == 2)
1312        {
1313           opus_int32 stereo_threshold;
1314           stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14);
1315           if (st->stream_channels == 2)
1316              stereo_threshold -= 1000;
1317           else
1318              stereo_threshold += 1000;
1319           st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1;
1320        } else {
1321           st->stream_channels = st->channels;
1322        }
1323 #endif
1324     }
1325     /* Update equivalent rate for channels decision. */
1326     equiv_rate = compute_equiv_rate(st->bitrate_bps, st->stream_channels, st->Fs/frame_size,
1327           st->use_vbr, 0, st->silk_mode.complexity, st->silk_mode.packetLossPercentage);
1328
1329     /* Mode selection depending on application and signal type */
1330     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1331     {
1332        st->mode = MODE_CELT_ONLY;
1333     } else if (st->user_forced_mode == OPUS_AUTO)
1334     {
1335 #ifdef FUZZING
1336        /* Random mode switching */
1337        if ((rand()&0xF)==0)
1338        {
1339           if ((rand()&0x1)==0)
1340              st->mode = MODE_CELT_ONLY;
1341           else
1342              st->mode = MODE_SILK_ONLY;
1343        } else {
1344           if (st->prev_mode==MODE_CELT_ONLY)
1345              st->mode = MODE_CELT_ONLY;
1346           else
1347              st->mode = MODE_SILK_ONLY;
1348        }
1349 #else
1350        opus_int32 mode_voice, mode_music;
1351        opus_int32 threshold;
1352
1353        /* Interpolate based on stereo width */
1354        mode_voice = (opus_int32)(MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[0][0])
1355              + MULT16_32_Q15(stereo_width,mode_thresholds[1][0]));
1356        mode_music = (opus_int32)(MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[1][1])
1357              + MULT16_32_Q15(stereo_width,mode_thresholds[1][1]));
1358        /* Interpolate based on speech/music probability */
1359        threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14);
1360        /* Bias towards SILK for VoIP because of some useful features */
1361        if (st->application == OPUS_APPLICATION_VOIP)
1362           threshold += 8000;
1363
1364        /*printf("%f %d\n", stereo_width/(float)Q15ONE, threshold);*/
1365        /* Hysteresis */
1366        if (st->prev_mode == MODE_CELT_ONLY)
1367            threshold -= 4000;
1368        else if (st->prev_mode>0)
1369            threshold += 4000;
1370
1371        st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY;
1372
1373        /* When FEC is enabled and there's enough packet loss, use SILK */
1374        if (st->silk_mode.useInBandFEC && st->silk_mode.packetLossPercentage > (128-voice_est)>>4)
1375           st->mode = MODE_SILK_ONLY;
1376        /* When encoding voice and DTX is enabled but the generalized DTX cannot be used,
1377           because of complexity and sampling frequency settings, switch to SILK DTX and
1378           set the encoder to SILK mode */
1379 #ifndef DISABLE_FLOAT_API
1380        st->silk_mode.useDTX = st->use_dtx && !(analysis_info.valid || is_silence);
1381 #else
1382        st->silk_mode.useDTX = st->use_dtx;
1383 #endif
1384        if (st->silk_mode.useDTX && voice_est > 100)
1385           st->mode = MODE_SILK_ONLY;
1386 #endif
1387
1388        /* If max_data_bytes represents less than 6 kb/s, switch to CELT-only mode */
1389        if (max_data_bytes < (frame_rate > 50 ? 9000 : 6000)*frame_size / (st->Fs * 8))
1390           st->mode = MODE_CELT_ONLY;
1391     } else {
1392        st->mode = st->user_forced_mode;
1393     }
1394
1395     /* Override the chosen mode to make sure we meet the requested frame size */
1396     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
1397        st->mode = MODE_CELT_ONLY;
1398     if (st->lfe)
1399        st->mode = MODE_CELT_ONLY;
1400
1401     if (st->prev_mode > 0 &&
1402         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
1403     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
1404     {
1405         redundancy = 1;
1406         celt_to_silk = (st->mode != MODE_CELT_ONLY);
1407         if (!celt_to_silk)
1408         {
1409             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
1410             if (frame_size >= st->Fs/100)
1411             {
1412                 st->mode = st->prev_mode;
1413                 to_celt = 1;
1414             } else {
1415                 redundancy=0;
1416             }
1417         }
1418     }
1419
1420     /* When encoding multiframes, we can ask for a switch to CELT only in the last frame. This switch
1421      * is processed above as the requested mode shouldn't interrupt stereo->mono transition. */
1422     if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0
1423           && st->mode != MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)
1424     {
1425        /* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */
1426        st->silk_mode.toMono = 1;
1427        st->stream_channels = 2;
1428     } else {
1429        st->silk_mode.toMono = 0;
1430     }
1431
1432     /* Update equivalent rate with mode decision. */
1433     equiv_rate = compute_equiv_rate(st->bitrate_bps, st->stream_channels, st->Fs/frame_size,
1434           st->use_vbr, st->mode, st->silk_mode.complexity, st->silk_mode.packetLossPercentage);
1435
1436     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
1437     {
1438         silk_EncControlStruct dummy;
1439         silk_InitEncoder( silk_enc, st->arch, &dummy);
1440         prefill=1;
1441     }
1442
1443     /* Automatic (rate-dependent) bandwidth selection */
1444     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
1445     {
1446         const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds;
1447         opus_int32 bandwidth_thresholds[8];
1448         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
1449
1450         if (st->channels==2 && st->force_channels!=1)
1451         {
1452            voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds;
1453            music_bandwidth_thresholds = stereo_music_bandwidth_thresholds;
1454         } else {
1455            voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds;
1456            music_bandwidth_thresholds = mono_music_bandwidth_thresholds;
1457         }
1458         /* Interpolate bandwidth thresholds depending on voice estimation */
1459         for (i=0;i<8;i++)
1460         {
1461            bandwidth_thresholds[i] = music_bandwidth_thresholds[i]
1462                     + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14);
1463         }
1464         do {
1465             int threshold, hysteresis;
1466             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
1467             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
1468             if (!st->first)
1469             {
1470                 if (st->auto_bandwidth >= bandwidth)
1471                     threshold -= hysteresis;
1472                 else
1473                     threshold += hysteresis;
1474             }
1475             if (equiv_rate >= threshold)
1476                 break;
1477         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
1478         st->bandwidth = st->auto_bandwidth = bandwidth;
1479         /* Prevents any transition to SWB/FB until the SILK layer has fully
1480            switched to WB mode and turned the variable LP filter off */
1481         if (!st->first && st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1482             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1483     }
1484
1485     if (st->bandwidth>st->max_bandwidth)
1486        st->bandwidth = st->max_bandwidth;
1487
1488     if (st->user_bandwidth != OPUS_AUTO)
1489         st->bandwidth = st->user_bandwidth;
1490
1491     /* This prevents us from using hybrid at unsafe CBR/max rates */
1492     if (st->mode != MODE_CELT_ONLY && max_rate < 15000)
1493     {
1494        st->bandwidth = IMIN(st->bandwidth, OPUS_BANDWIDTH_WIDEBAND);
1495     }
1496
1497     /* Prevents Opus from wasting bits on frequencies that are above
1498        the Nyquist rate of the input signal */
1499     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
1500         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1501     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1502         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1503     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
1504         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1505     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
1506         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1507 #ifndef DISABLE_FLOAT_API
1508     /* Use detected bandwidth to reduce the encoded bandwidth. */
1509     if (st->detected_bandwidth && st->user_bandwidth == OPUS_AUTO)
1510     {
1511        int min_detected_bandwidth;
1512        /* Makes bandwidth detection more conservative just in case the detector
1513           gets it wrong when we could have coded a high bandwidth transparently.
1514           When operating in SILK/hybrid mode, we don't go below wideband to avoid
1515           more complicated switches that require redundancy. */
1516        if (equiv_rate <= 18000*st->stream_channels && st->mode == MODE_CELT_ONLY)
1517           min_detected_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1518        else if (equiv_rate <= 24000*st->stream_channels && st->mode == MODE_CELT_ONLY)
1519           min_detected_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1520        else if (equiv_rate <= 30000*st->stream_channels)
1521           min_detected_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1522        else if (equiv_rate <= 44000*st->stream_channels)
1523           min_detected_bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1524        else
1525           min_detected_bandwidth = OPUS_BANDWIDTH_FULLBAND;
1526
1527        st->detected_bandwidth = IMAX(st->detected_bandwidth, min_detected_bandwidth);
1528        st->bandwidth = IMIN(st->bandwidth, st->detected_bandwidth);
1529     }
1530 #endif
1531     st->silk_mode.LBRR_coded = decide_fec(st->silk_mode.useInBandFEC, st->silk_mode.packetLossPercentage,
1532           st->silk_mode.LBRR_coded, st->mode, &st->bandwidth, equiv_rate);
1533     celt_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(lsb_depth));
1534
1535     /* CELT mode doesn't support mediumband, use wideband instead */
1536     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1537         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1538     if (st->lfe)
1539        st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1540
1541     curr_bandwidth = st->bandwidth;
1542
1543     /* Chooses the appropriate mode for speech
1544        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
1545     if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1546         st->mode = MODE_HYBRID;
1547     if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
1548         st->mode = MODE_SILK_ONLY;
1549
1550     /* Can't support higher than >60 ms frames, and >20 ms when in Hybrid or CELT-only modes */
1551     if ((frame_size > st->Fs/50 && (st->mode != MODE_SILK_ONLY)) || frame_size > 3*st->Fs/50)
1552     {
1553        int enc_frame_size;
1554        int nb_frames;
1555
1556        if (st->mode == MODE_SILK_ONLY)
1557        {
1558          if (frame_size == 2*st->Fs/25)  /* 80 ms -> 2x 40 ms */
1559            enc_frame_size = st->Fs/25;
1560          if (frame_size == 3*st->Fs/25)  /* 120 ms -> 2x 60 ms */
1561            enc_frame_size = 3*st->Fs/50;
1562          else                            /* 100 ms -> 5x 20 ms */
1563            enc_frame_size = st->Fs/50;
1564        }
1565        else
1566          enc_frame_size = st->Fs/50;
1567
1568        nb_frames = frame_size/enc_frame_size;
1569
1570 #ifndef DISABLE_FLOAT_API
1571        if (analysis_read_pos_bak!= -1)
1572        {
1573           st->analysis.read_pos = analysis_read_pos_bak;
1574           st->analysis.read_subframe = analysis_read_subframe_bak;
1575        }
1576 #endif
1577
1578        ret = encode_multiframe_packet(st, pcm, nb_frames, enc_frame_size, data,
1579                                       out_data_bytes, to_celt, lsb_depth, float_api);
1580
1581        RESTORE_STACK;
1582        return ret;
1583     }
1584
1585     /* For the first frame at a new SILK bandwidth */
1586     if (st->silk_bw_switch)
1587     {
1588        redundancy = 1;
1589        celt_to_silk = 1;
1590        st->silk_bw_switch = 0;
1591        prefill=1;
1592     }
1593
1594     /* If we decided to go with CELT, make sure redundancy is off, no matter what
1595        we decided earlier. */
1596     if (st->mode == MODE_CELT_ONLY)
1597         redundancy = 0;
1598
1599     if (redundancy)
1600     {
1601        /* Fair share of the max size allowed */
1602        redundancy_bytes = IMIN(257, max_data_bytes*(opus_int32)(st->Fs/200)/(frame_size+st->Fs/200));
1603        /* For VBR, target the actual bitrate (subject to the limit above) */
1604        if (st->use_vbr)
1605           redundancy_bytes = IMIN(redundancy_bytes, st->bitrate_bps/1600);
1606     }
1607
1608     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
1609     bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
1610
1611     data += 1;
1612
1613     ec_enc_init(&enc, data, max_data_bytes-1);
1614
1615     ALLOC(pcm_buf, (total_buffer+frame_size)*st->channels, opus_val16);
1616     OPUS_COPY(pcm_buf, &st->delay_buffer[(st->encoder_buffer-total_buffer)*st->channels], total_buffer*st->channels);
1617
1618     if (st->mode == MODE_CELT_ONLY)
1619        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1620     else
1621        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
1622
1623     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
1624           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
1625
1626     /* convert from log scale to Hertz */
1627     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
1628
1629     if (st->application == OPUS_APPLICATION_VOIP)
1630     {
1631        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1632     } else {
1633        dc_reject(pcm, 3, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1634     }
1635 #ifndef FIXED_POINT
1636     if (float_api)
1637     {
1638        opus_val32 sum;
1639        sum = celt_inner_prod(&pcm_buf[total_buffer*st->channels], &pcm_buf[total_buffer*st->channels], frame_size*st->channels, st->arch);
1640        /* This should filter out both NaNs and ridiculous signals that could
1641           cause NaNs further down. */
1642        if (!(sum < 1e9f) || celt_isnan(sum))
1643        {
1644           OPUS_CLEAR(&pcm_buf[total_buffer*st->channels], frame_size*st->channels);
1645           st->hp_mem[0] = st->hp_mem[1] = st->hp_mem[2] = st->hp_mem[3] = 0;
1646        }
1647     }
1648 #endif
1649
1650
1651     /* SILK processing */
1652     HB_gain = Q15ONE;
1653     if (st->mode != MODE_CELT_ONLY)
1654     {
1655         opus_int32 total_bitRate, celt_rate;
1656 #ifdef FIXED_POINT
1657        const opus_int16 *pcm_silk;
1658 #else
1659        VARDECL(opus_int16, pcm_silk);
1660        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
1661 #endif
1662
1663         /* Distribute bits between SILK and CELT */
1664         total_bitRate = 8 * bytes_target * frame_rate;
1665         if( st->mode == MODE_HYBRID ) {
1666             /* Base rate for SILK */
1667             st->silk_mode.bitRate = compute_silk_rate_for_hybrid(total_bitRate,
1668                   curr_bandwidth, st->Fs == 50 * frame_size, st->use_vbr, st->silk_mode.LBRR_coded);
1669             if (!st->energy_masking)
1670             {
1671                /* Increasingly attenuate high band when it gets allocated fewer bits */
1672                celt_rate = total_bitRate - st->silk_mode.bitRate;
1673                HB_gain = Q15ONE - SHR32(celt_exp2(-celt_rate * QCONST16(1.f/1024, 10)), 1);
1674             }
1675         } else {
1676             /* SILK gets all bits */
1677             st->silk_mode.bitRate = total_bitRate;
1678         }
1679
1680         /* Surround masking for SILK */
1681         if (st->energy_masking && st->use_vbr && !st->lfe)
1682         {
1683            opus_val32 mask_sum=0;
1684            opus_val16 masking_depth;
1685            opus_int32 rate_offset;
1686            int c;
1687            int end = 17;
1688            opus_int16 srate = 16000;
1689            if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND)
1690            {
1691               end = 13;
1692               srate = 8000;
1693            } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1694            {
1695               end = 15;
1696               srate = 12000;
1697            }
1698            for (c=0;c<st->channels;c++)
1699            {
1700               for(i=0;i<end;i++)
1701               {
1702                  opus_val16 mask;
1703                  mask = MAX16(MIN16(st->energy_masking[21*c+i],
1704                         QCONST16(.5f, DB_SHIFT)), -QCONST16(2.0f, DB_SHIFT));
1705                  if (mask > 0)
1706                     mask = HALF16(mask);
1707                  mask_sum += mask;
1708               }
1709            }
1710            /* Conservative rate reduction, we cut the masking in half */
1711            masking_depth = mask_sum / end*st->channels;
1712            masking_depth += QCONST16(.2f, DB_SHIFT);
1713            rate_offset = (opus_int32)PSHR32(MULT16_16(srate, masking_depth), DB_SHIFT);
1714            rate_offset = MAX32(rate_offset, -2*st->silk_mode.bitRate/3);
1715            /* Split the rate change between the SILK and CELT part for hybrid. */
1716            if (st->bandwidth==OPUS_BANDWIDTH_SUPERWIDEBAND || st->bandwidth==OPUS_BANDWIDTH_FULLBAND)
1717               st->silk_mode.bitRate += 3*rate_offset/5;
1718            else
1719               st->silk_mode.bitRate += rate_offset;
1720         }
1721
1722         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
1723         st->silk_mode.nChannelsAPI = st->channels;
1724         st->silk_mode.nChannelsInternal = st->stream_channels;
1725         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1726             st->silk_mode.desiredInternalSampleRate = 8000;
1727         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1728             st->silk_mode.desiredInternalSampleRate = 12000;
1729         } else {
1730             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
1731             st->silk_mode.desiredInternalSampleRate = 16000;
1732         }
1733         if( st->mode == MODE_HYBRID ) {
1734             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
1735             st->silk_mode.minInternalSampleRate = 16000;
1736         } else {
1737             st->silk_mode.minInternalSampleRate = 8000;
1738         }
1739
1740         st->silk_mode.maxInternalSampleRate = 16000;
1741         if (st->mode == MODE_SILK_ONLY)
1742         {
1743            opus_int32 effective_max_rate = max_rate;
1744            if (frame_rate > 50)
1745               effective_max_rate = effective_max_rate*2/3;
1746            if (effective_max_rate < 8000)
1747            {
1748               st->silk_mode.maxInternalSampleRate = 12000;
1749               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
1750            }
1751            if (effective_max_rate < 7000)
1752            {
1753               st->silk_mode.maxInternalSampleRate = 8000;
1754               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
1755            }
1756         }
1757
1758         st->silk_mode.useCBR = !st->use_vbr;
1759
1760         /* Call SILK encoder for the low band */
1761
1762         /* Max bits for SILK, counting ToC, redundancy bytes, and optionally redundancy. */
1763         st->silk_mode.maxBits = (max_data_bytes-1)*8;
1764         if (redundancy && redundancy_bytes >= 2)
1765         {
1766            /* Counting 1 bit for redundancy position and 20 bits for flag+size (only for hybrid). */
1767            st->silk_mode.maxBits -= redundancy_bytes*8 + 1;
1768            if (st->mode == MODE_HYBRID)
1769               st->silk_mode.maxBits -= 20;
1770         }
1771         if (st->silk_mode.useCBR)
1772         {
1773            if (st->mode == MODE_HYBRID)
1774            {
1775               st->silk_mode.maxBits = IMIN(st->silk_mode.maxBits, st->silk_mode.bitRate * frame_size / st->Fs);
1776            }
1777         } else {
1778            /* Constrained VBR. */
1779            if (st->mode == MODE_HYBRID)
1780            {
1781               /* Compute SILK bitrate corresponding to the max total bits available */
1782               opus_int32 maxBitRate = compute_silk_rate_for_hybrid(st->silk_mode.maxBits*st->Fs / frame_size,
1783                     curr_bandwidth, st->Fs == 50 * frame_size, st->use_vbr, st->silk_mode.LBRR_coded);
1784               st->silk_mode.maxBits = maxBitRate * frame_size / st->Fs;
1785            }
1786         }
1787
1788         if (prefill)
1789         {
1790             opus_int32 zero=0;
1791             int prefill_offset;
1792             /* Use a smooth onset for the SILK prefill to avoid the encoder trying to encode
1793                a discontinuity. The exact location is what we need to avoid leaving any "gap"
1794                in the audio when mixing with the redundant CELT frame. Here we can afford to
1795                overwrite st->delay_buffer because the only thing that uses it before it gets
1796                rewritten is tmp_prefill[] and even then only the part after the ramp really
1797                gets used (rather than sent to the encoder and discarded) */
1798             prefill_offset = st->channels*(st->encoder_buffer-st->delay_compensation-st->Fs/400);
1799             gain_fade(st->delay_buffer+prefill_offset, st->delay_buffer+prefill_offset,
1800                   0, Q15ONE, celt_mode->overlap, st->Fs/400, st->channels, celt_mode->window, st->Fs);
1801             OPUS_CLEAR(st->delay_buffer, prefill_offset);
1802 #ifdef FIXED_POINT
1803             pcm_silk = st->delay_buffer;
1804 #else
1805             for (i=0;i<st->encoder_buffer*st->channels;i++)
1806                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
1807 #endif
1808             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
1809         }
1810
1811 #ifdef FIXED_POINT
1812         pcm_silk = pcm_buf+total_buffer*st->channels;
1813 #else
1814         for (i=0;i<frame_size*st->channels;i++)
1815             pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
1816 #endif
1817         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
1818         if( ret ) {
1819             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
1820             /* Handle error */
1821            RESTORE_STACK;
1822            return OPUS_INTERNAL_ERROR;
1823         }
1824
1825         /* Extract SILK internal bandwidth for signaling in first byte */
1826         if( st->mode == MODE_SILK_ONLY ) {
1827             if( st->silk_mode.internalSampleRate == 8000 ) {
1828                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1829             } else if( st->silk_mode.internalSampleRate == 12000 ) {
1830                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1831             } else if( st->silk_mode.internalSampleRate == 16000 ) {
1832                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1833             }
1834         } else {
1835             silk_assert( st->silk_mode.internalSampleRate == 16000 );
1836         }
1837
1838         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady && !st->nonfinal_frame;
1839
1840         if (nBytes==0)
1841         {
1842            st->rangeFinal = 0;
1843            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1844            RESTORE_STACK;
1845            return 1;
1846         }
1847
1848         /* FIXME: How do we allocate the redundancy for CBR? */
1849         if (st->silk_mode.opusCanSwitch)
1850         {
1851            redundancy = 1;
1852            celt_to_silk = 0;
1853            st->silk_bw_switch = 1;
1854         }
1855     }
1856
1857     /* CELT processing */
1858     {
1859         int endband=21;
1860
1861         switch(curr_bandwidth)
1862         {
1863             case OPUS_BANDWIDTH_NARROWBAND:
1864                 endband = 13;
1865                 break;
1866             case OPUS_BANDWIDTH_MEDIUMBAND:
1867             case OPUS_BANDWIDTH_WIDEBAND:
1868                 endband = 17;
1869                 break;
1870             case OPUS_BANDWIDTH_SUPERWIDEBAND:
1871                 endband = 19;
1872                 break;
1873             case OPUS_BANDWIDTH_FULLBAND:
1874                 endband = 21;
1875                 break;
1876         }
1877         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
1878         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
1879     }
1880     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1881     if (st->mode != MODE_SILK_ONLY)
1882     {
1883         opus_val32 celt_pred=2;
1884         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1885         /* We may still decide to disable prediction later */
1886         if (st->silk_mode.reducedDependency)
1887            celt_pred = 0;
1888         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(celt_pred));
1889
1890         if (st->mode == MODE_HYBRID)
1891         {
1892             if( st->use_vbr ) {
1893                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps-st->silk_mode.bitRate));
1894                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(0));
1895             }
1896         } else {
1897             if (st->use_vbr)
1898             {
1899                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
1900                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
1901                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps));
1902             }
1903         }
1904     }
1905
1906     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
1907     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
1908     {
1909        OPUS_COPY(tmp_prefill, &st->delay_buffer[(st->encoder_buffer-total_buffer-st->Fs/400)*st->channels], st->channels*st->Fs/400);
1910     }
1911
1912     if (st->channels*(st->encoder_buffer-(frame_size+total_buffer)) > 0)
1913     {
1914        OPUS_MOVE(st->delay_buffer, &st->delay_buffer[st->channels*frame_size], st->channels*(st->encoder_buffer-frame_size-total_buffer));
1915        OPUS_COPY(&st->delay_buffer[st->channels*(st->encoder_buffer-frame_size-total_buffer)],
1916              &pcm_buf[0],
1917              (frame_size+total_buffer)*st->channels);
1918     } else {
1919        OPUS_COPY(st->delay_buffer, &pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels], st->encoder_buffer*st->channels);
1920     }
1921     /* gain_fade() and stereo_fade() need to be after the buffer copying
1922        because we don't want any of this to affect the SILK part */
1923     if( st->prev_HB_gain < Q15ONE || HB_gain < Q15ONE ) {
1924        gain_fade(pcm_buf, pcm_buf,
1925              st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs);
1926     }
1927     st->prev_HB_gain = HB_gain;
1928     if (st->mode != MODE_HYBRID || st->stream_channels==1)
1929        st->silk_mode.stereoWidth_Q14 = IMIN((1<<14),2*IMAX(0,equiv_rate-24000));
1930     if( !st->energy_masking && st->channels == 2 ) {
1931         /* Apply stereo width reduction (at low bitrates) */
1932         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1933             opus_val16 g1, g2;
1934             g1 = st->hybrid_stereo_width_Q14;
1935             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1936 #ifdef FIXED_POINT
1937             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
1938             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
1939 #else
1940             g1 *= (1.f/16384);
1941             g2 *= (1.f/16384);
1942 #endif
1943             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
1944                   frame_size, st->channels, celt_mode->window, st->Fs);
1945             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1946         }
1947     }
1948
1949     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
1950     {
1951         /* For SILK mode, the redundancy is inferred from the length */
1952         if (st->mode == MODE_HYBRID)
1953            ec_enc_bit_logp(&enc, redundancy, 12);
1954         if (redundancy)
1955         {
1956             int max_redundancy;
1957             ec_enc_bit_logp(&enc, celt_to_silk, 1);
1958             if (st->mode == MODE_HYBRID)
1959             {
1960                /* Reserve the 8 bits needed for the redundancy length,
1961                   and at least a few bits for CELT if possible */
1962                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+8+3+7)>>3);
1963                max_redundancy = IMIN(max_redundancy, redundancy_bytes);
1964             }
1965             else
1966                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1967             /* Target the same bit-rate for redundancy as for the rest,
1968                up to a max of 257 bytes */
1969             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
1970             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
1971             if (st->mode == MODE_HYBRID)
1972                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
1973         }
1974     } else {
1975         redundancy = 0;
1976     }
1977
1978     if (!redundancy)
1979     {
1980        st->silk_bw_switch = 0;
1981        redundancy_bytes = 0;
1982     }
1983     if (st->mode != MODE_CELT_ONLY)start_band=17;
1984
1985     if (st->mode == MODE_SILK_ONLY)
1986     {
1987         ret = (ec_tell(&enc)+7)>>3;
1988         ec_enc_done(&enc);
1989         nb_compr_bytes = ret;
1990     } else {
1991        nb_compr_bytes = (max_data_bytes-1)-redundancy_bytes;
1992        ec_enc_shrink(&enc, nb_compr_bytes);
1993     }
1994
1995 #ifndef DISABLE_FLOAT_API
1996     if (redundancy || st->mode != MODE_SILK_ONLY)
1997        celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(&analysis_info));
1998 #endif
1999     if (st->mode == MODE_HYBRID) {
2000        SILKInfo info;
2001        info.signalType = st->silk_mode.signalType;
2002        info.offset = st->silk_mode.offset;
2003        celt_encoder_ctl(celt_enc, CELT_SET_SILK_INFO(&info));
2004     } else {
2005        celt_encoder_ctl(celt_enc, CELT_SET_SILK_INFO((SILKInfo*)NULL));
2006     }
2007
2008     /* 5 ms redundant frame for CELT->SILK */
2009     if (redundancy && celt_to_silk)
2010     {
2011         int err;
2012         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
2013         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
2014         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
2015         err = celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
2016         if (err < 0)
2017         {
2018            RESTORE_STACK;
2019            return OPUS_INTERNAL_ERROR;
2020         }
2021         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
2022         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2023     }
2024
2025     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
2026
2027     if (st->mode != MODE_SILK_ONLY)
2028     {
2029         if (st->mode != st->prev_mode && st->prev_mode > 0)
2030         {
2031            unsigned char dummy[2];
2032            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2033
2034            /* Prefilling */
2035            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
2036            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
2037         }
2038         /* If false, we already busted the budget and we'll end up with a "PLC frame" */
2039         if (ec_tell(&enc) <= 8*nb_compr_bytes)
2040         {
2041            /* Set the bitrate again if it was overridden in the redundancy code above*/
2042            if (redundancy && celt_to_silk && st->mode==MODE_HYBRID && st->use_vbr)
2043               celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps-st->silk_mode.bitRate));
2044            celt_encoder_ctl(celt_enc, OPUS_SET_VBR(st->use_vbr));
2045            ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
2046            if (ret < 0)
2047            {
2048               RESTORE_STACK;
2049               return OPUS_INTERNAL_ERROR;
2050            }
2051            /* Put CELT->SILK redundancy data in the right place. */
2052            if (redundancy && celt_to_silk && st->mode==MODE_HYBRID && st->use_vbr)
2053            {
2054               OPUS_MOVE(data+ret, data+nb_compr_bytes, redundancy_bytes);
2055               nb_compr_bytes = nb_compr_bytes+redundancy_bytes;
2056            }
2057         }
2058     }
2059
2060     /* 5 ms redundant frame for SILK->CELT */
2061     if (redundancy && !celt_to_silk)
2062     {
2063         int err;
2064         unsigned char dummy[2];
2065         int N2, N4;
2066         N2 = st->Fs/200;
2067         N4 = st->Fs/400;
2068
2069         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2070         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
2071         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
2072         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
2073         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
2074
2075         if (st->mode == MODE_HYBRID)
2076         {
2077            /* Shrink packet to what the encoder actually used. */
2078            nb_compr_bytes = ret;
2079            ec_enc_shrink(&enc, nb_compr_bytes);
2080         }
2081         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
2082         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL);
2083
2084         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
2085         if (err < 0)
2086         {
2087            RESTORE_STACK;
2088            return OPUS_INTERNAL_ERROR;
2089         }
2090         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
2091     }
2092
2093
2094
2095     /* Signalling the mode in the first byte */
2096     data--;
2097     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
2098
2099     st->rangeFinal = enc.rng ^ redundant_rng;
2100
2101     if (to_celt)
2102         st->prev_mode = MODE_CELT_ONLY;
2103     else
2104         st->prev_mode = st->mode;
2105     st->prev_channels = st->stream_channels;
2106     st->prev_framesize = frame_size;
2107
2108     st->first = 0;
2109
2110     /* DTX decision */
2111 #ifndef DISABLE_FLOAT_API
2112     if (st->use_dtx && (analysis_info.valid || is_silence))
2113     {
2114        if (decide_dtx_mode(analysis_info.activity_probability, &st->nb_no_activity_frames,
2115              st->peak_signal_energy, pcm, frame_size, st->channels, is_silence, st->arch))
2116        {
2117           st->rangeFinal = 0;
2118           data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
2119           RESTORE_STACK;
2120           return 1;
2121        }
2122     }
2123 #endif
2124
2125     /* In the unlikely case that the SILK encoder busted its target, tell
2126        the decoder to call the PLC */
2127     if (ec_tell(&enc) > (max_data_bytes-1)*8)
2128     {
2129        if (max_data_bytes < 2)
2130        {
2131           RESTORE_STACK;
2132           return OPUS_BUFFER_TOO_SMALL;
2133        }
2134        data[1] = 0;
2135        ret = 1;
2136        st->rangeFinal = 0;
2137     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
2138     {
2139        /*When in LPC only mode it's perfectly
2140          reasonable to strip off trailing zero bytes as
2141          the required range decoder behavior is to
2142          fill these in. This can't be done when the MDCT
2143          modes are used because the decoder needs to know
2144          the actual length for allocation purposes.*/
2145        while(ret>2&&data[ret]==0)ret--;
2146     }
2147     /* Count ToC and redundancy */
2148     ret += 1+redundancy_bytes;
2149     if (!st->use_vbr)
2150     {
2151        if (opus_packet_pad(data, ret, max_data_bytes) != OPUS_OK)
2152        {
2153           RESTORE_STACK;
2154           return OPUS_INTERNAL_ERROR;
2155        }
2156        ret = max_data_bytes;
2157     }
2158     RESTORE_STACK;
2159     return ret;
2160 }
2161
2162 #ifdef FIXED_POINT
2163
2164 #ifndef DISABLE_FLOAT_API
2165 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int analysis_frame_size,
2166       unsigned char *data, opus_int32 max_data_bytes)
2167 {
2168    int i, ret;
2169    int frame_size;
2170    VARDECL(opus_int16, in);
2171    ALLOC_STACK;
2172
2173    frame_size = frame_size_select(analysis_frame_size, st->variable_duration, st->Fs);
2174    if (frame_size <= 0)
2175    {
2176       RESTORE_STACK;
2177       return OPUS_BAD_ARG;
2178    }
2179    ALLOC(in, frame_size*st->channels, opus_int16);
2180
2181    for (i=0;i<frame_size*st->channels;i++)
2182       in[i] = FLOAT2INT16(pcm[i]);
2183    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16,
2184                             pcm, analysis_frame_size, 0, -2, st->channels, downmix_float, 1);
2185    RESTORE_STACK;
2186    return ret;
2187 }
2188 #endif
2189
2190 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int analysis_frame_size,
2191                 unsigned char *data, opus_int32 out_data_bytes)
2192 {
2193    int frame_size;
2194    frame_size = frame_size_select(analysis_frame_size, st->variable_duration, st->Fs);
2195    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 16,
2196                              pcm, analysis_frame_size, 0, -2, st->channels, downmix_int, 0);
2197 }
2198
2199 #else
2200 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int analysis_frame_size,
2201       unsigned char *data, opus_int32 max_data_bytes)
2202 {
2203    int i, ret;
2204    int frame_size;
2205    VARDECL(float, in);
2206    ALLOC_STACK;
2207
2208    frame_size = frame_size_select(analysis_frame_size, st->variable_duration, st->Fs);
2209    if (frame_size <= 0)
2210    {
2211       RESTORE_STACK;
2212       return OPUS_BAD_ARG;
2213    }
2214    ALLOC(in, frame_size*st->channels, float);
2215
2216    for (i=0;i<frame_size*st->channels;i++)
2217       in[i] = (1.0f/32768)*pcm[i];
2218    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16,
2219                             pcm, analysis_frame_size, 0, -2, st->channels, downmix_int, 0);
2220    RESTORE_STACK;
2221    return ret;
2222 }
2223 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int analysis_frame_size,
2224                       unsigned char *data, opus_int32 out_data_bytes)
2225 {
2226    int frame_size;
2227    frame_size = frame_size_select(analysis_frame_size, st->variable_duration, st->Fs);
2228    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 24,
2229                              pcm, analysis_frame_size, 0, -2, st->channels, downmix_float, 1);
2230 }
2231 #endif
2232
2233
2234 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
2235 {
2236     int ret;
2237     CELTEncoder *celt_enc;
2238     va_list ap;
2239
2240     ret = OPUS_OK;
2241     va_start(ap, request);
2242
2243     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
2244
2245     switch (request)
2246     {
2247         case OPUS_SET_APPLICATION_REQUEST:
2248         {
2249             opus_int32 value = va_arg(ap, opus_int32);
2250             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
2251                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2252                || (!st->first && st->application != value))
2253             {
2254                ret = OPUS_BAD_ARG;
2255                break;
2256             }
2257             st->application = value;
2258         }
2259         break;
2260         case OPUS_GET_APPLICATION_REQUEST:
2261         {
2262             opus_int32 *value = va_arg(ap, opus_int32*);
2263             if (!value)
2264             {
2265                goto bad_arg;
2266             }
2267             *value = st->application;
2268         }
2269         break;
2270         case OPUS_SET_BITRATE_REQUEST:
2271         {
2272             opus_int32 value = va_arg(ap, opus_int32);
2273             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
2274             {
2275                 if (value <= 0)
2276                     goto bad_arg;
2277                 else if (value <= 500)
2278                     value = 500;
2279                 else if (value > (opus_int32)300000*st->channels)
2280                     value = (opus_int32)300000*st->channels;
2281             }
2282             st->user_bitrate_bps = value;
2283         }
2284         break;
2285         case OPUS_GET_BITRATE_REQUEST:
2286         {
2287             opus_int32 *value = va_arg(ap, opus_int32*);
2288             if (!value)
2289             {
2290                goto bad_arg;
2291             }
2292             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
2293         }
2294         break;
2295         case OPUS_SET_FORCE_CHANNELS_REQUEST:
2296         {
2297             opus_int32 value = va_arg(ap, opus_int32);
2298             if((value<1 || value>st->channels) && value != OPUS_AUTO)
2299             {
2300                goto bad_arg;
2301             }
2302             st->force_channels = value;
2303         }
2304         break;
2305         case OPUS_GET_FORCE_CHANNELS_REQUEST:
2306         {
2307             opus_int32 *value = va_arg(ap, opus_int32*);
2308             if (!value)
2309             {
2310                goto bad_arg;
2311             }
2312             *value = st->force_channels;
2313         }
2314         break;
2315         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
2316         {
2317             opus_int32 value = va_arg(ap, opus_int32);
2318             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND)
2319             {
2320                goto bad_arg;
2321             }
2322             st->max_bandwidth = value;
2323             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2324                 st->silk_mode.maxInternalSampleRate = 8000;
2325             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2326                 st->silk_mode.maxInternalSampleRate = 12000;
2327             } else {
2328                 st->silk_mode.maxInternalSampleRate = 16000;
2329             }
2330         }
2331         break;
2332         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
2333         {
2334             opus_int32 *value = va_arg(ap, opus_int32*);
2335             if (!value)
2336             {
2337                goto bad_arg;
2338             }
2339             *value = st->max_bandwidth;
2340         }
2341         break;
2342         case OPUS_SET_BANDWIDTH_REQUEST:
2343         {
2344             opus_int32 value = va_arg(ap, opus_int32);
2345             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
2346             {
2347                goto bad_arg;
2348             }
2349             st->user_bandwidth = value;
2350             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2351                 st->silk_mode.maxInternalSampleRate = 8000;
2352             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2353                 st->silk_mode.maxInternalSampleRate = 12000;
2354             } else {
2355                 st->silk_mode.maxInternalSampleRate = 16000;
2356             }
2357         }
2358         break;
2359         case OPUS_GET_BANDWIDTH_REQUEST:
2360         {
2361             opus_int32 *value = va_arg(ap, opus_int32*);
2362             if (!value)
2363             {
2364                goto bad_arg;
2365             }
2366             *value = st->bandwidth;
2367         }
2368         break;
2369         case OPUS_SET_DTX_REQUEST:
2370         {
2371             opus_int32 value = va_arg(ap, opus_int32);
2372             if(value<0 || value>1)
2373             {
2374                goto bad_arg;
2375             }
2376             st->use_dtx = value;
2377         }
2378         break;
2379         case OPUS_GET_DTX_REQUEST:
2380         {
2381             opus_int32 *value = va_arg(ap, opus_int32*);
2382             if (!value)
2383             {
2384                goto bad_arg;
2385             }
2386             *value = st->use_dtx;
2387         }
2388         break;
2389         case OPUS_SET_COMPLEXITY_REQUEST:
2390         {
2391             opus_int32 value = va_arg(ap, opus_int32);
2392             if(value<0 || value>10)
2393             {
2394                goto bad_arg;
2395             }
2396             st->silk_mode.complexity = value;
2397             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
2398         }
2399         break;
2400         case OPUS_GET_COMPLEXITY_REQUEST:
2401         {
2402             opus_int32 *value = va_arg(ap, opus_int32*);
2403             if (!value)
2404             {
2405                goto bad_arg;
2406             }
2407             *value = st->silk_mode.complexity;
2408         }
2409         break;
2410         case OPUS_SET_INBAND_FEC_REQUEST:
2411         {
2412             opus_int32 value = va_arg(ap, opus_int32);
2413             if(value<0 || value>1)
2414             {
2415                goto bad_arg;
2416             }
2417             st->silk_mode.useInBandFEC = value;
2418         }
2419         break;
2420         case OPUS_GET_INBAND_FEC_REQUEST:
2421         {
2422             opus_int32 *value = va_arg(ap, opus_int32*);
2423             if (!value)
2424             {
2425                goto bad_arg;
2426             }
2427             *value = st->silk_mode.useInBandFEC;
2428         }
2429         break;
2430         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
2431         {
2432             opus_int32 value = va_arg(ap, opus_int32);
2433             if (value < 0 || value > 100)
2434             {
2435                goto bad_arg;
2436             }
2437             st->silk_mode.packetLossPercentage = value;
2438             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
2439         }
2440         break;
2441         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
2442         {
2443             opus_int32 *value = va_arg(ap, opus_int32*);
2444             if (!value)
2445             {
2446                goto bad_arg;
2447             }
2448             *value = st->silk_mode.packetLossPercentage;
2449         }
2450         break;
2451         case OPUS_SET_VBR_REQUEST:
2452         {
2453             opus_int32 value = va_arg(ap, opus_int32);
2454             if(value<0 || value>1)
2455             {
2456                goto bad_arg;
2457             }
2458             st->use_vbr = value;
2459             st->silk_mode.useCBR = 1-value;
2460         }
2461         break;
2462         case OPUS_GET_VBR_REQUEST:
2463         {
2464             opus_int32 *value = va_arg(ap, opus_int32*);
2465             if (!value)
2466             {
2467                goto bad_arg;
2468             }
2469             *value = st->use_vbr;
2470         }
2471         break;
2472         case OPUS_SET_VOICE_RATIO_REQUEST:
2473         {
2474             opus_int32 value = va_arg(ap, opus_int32);
2475             if (value<-1 || value>100)
2476             {
2477                goto bad_arg;
2478             }
2479             st->voice_ratio = value;
2480         }
2481         break;
2482         case OPUS_GET_VOICE_RATIO_REQUEST:
2483         {
2484             opus_int32 *value = va_arg(ap, opus_int32*);
2485             if (!value)
2486             {
2487                goto bad_arg;
2488             }
2489             *value = st->voice_ratio;
2490         }
2491         break;
2492         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
2493         {
2494             opus_int32 value = va_arg(ap, opus_int32);
2495             if(value<0 || value>1)
2496             {
2497                goto bad_arg;
2498             }
2499             st->vbr_constraint = value;
2500         }
2501         break;
2502         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
2503         {
2504             opus_int32 *value = va_arg(ap, opus_int32*);
2505             if (!value)
2506             {
2507                goto bad_arg;
2508             }
2509             *value = st->vbr_constraint;
2510         }
2511         break;
2512         case OPUS_SET_SIGNAL_REQUEST:
2513         {
2514             opus_int32 value = va_arg(ap, opus_int32);
2515             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
2516             {
2517                goto bad_arg;
2518             }
2519             st->signal_type = value;
2520         }
2521         break;
2522         case OPUS_GET_SIGNAL_REQUEST:
2523         {
2524             opus_int32 *value = va_arg(ap, opus_int32*);
2525             if (!value)
2526             {
2527                goto bad_arg;
2528             }
2529             *value = st->signal_type;
2530         }
2531         break;
2532         case OPUS_GET_LOOKAHEAD_REQUEST:
2533         {
2534             opus_int32 *value = va_arg(ap, opus_int32*);
2535             if (!value)
2536             {
2537                goto bad_arg;
2538             }
2539             *value = st->Fs/400;
2540             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2541                 *value += st->delay_compensation;
2542         }
2543         break;
2544         case OPUS_GET_SAMPLE_RATE_REQUEST:
2545         {
2546             opus_int32 *value = va_arg(ap, opus_int32*);
2547             if (!value)
2548             {
2549                goto bad_arg;
2550             }
2551             *value = st->Fs;
2552         }
2553         break;
2554         case OPUS_GET_FINAL_RANGE_REQUEST:
2555         {
2556             opus_uint32 *value = va_arg(ap, opus_uint32*);
2557             if (!value)
2558             {
2559                goto bad_arg;
2560             }
2561             *value = st->rangeFinal;
2562         }
2563         break;
2564         case OPUS_SET_LSB_DEPTH_REQUEST:
2565         {
2566             opus_int32 value = va_arg(ap, opus_int32);
2567             if (value<8 || value>24)
2568             {
2569                goto bad_arg;
2570             }
2571             st->lsb_depth=value;
2572         }
2573         break;
2574         case OPUS_GET_LSB_DEPTH_REQUEST:
2575         {
2576             opus_int32 *value = va_arg(ap, opus_int32*);
2577             if (!value)
2578             {
2579                goto bad_arg;
2580             }
2581             *value = st->lsb_depth;
2582         }
2583         break;
2584         case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
2585         {
2586             opus_int32 value = va_arg(ap, opus_int32);
2587             if (value != OPUS_FRAMESIZE_ARG    && value != OPUS_FRAMESIZE_2_5_MS &&
2588                 value != OPUS_FRAMESIZE_5_MS   && value != OPUS_FRAMESIZE_10_MS  &&
2589                 value != OPUS_FRAMESIZE_20_MS  && value != OPUS_FRAMESIZE_40_MS  &&
2590                 value != OPUS_FRAMESIZE_60_MS  && value != OPUS_FRAMESIZE_80_MS  &&
2591                 value != OPUS_FRAMESIZE_100_MS && value != OPUS_FRAMESIZE_120_MS)
2592             {
2593                goto bad_arg;
2594             }
2595             st->variable_duration = value;
2596             celt_encoder_ctl(celt_enc, OPUS_SET_EXPERT_FRAME_DURATION(value));
2597         }
2598         break;
2599         case OPUS_GET_EXPERT_FRAME_DURATION_REQUEST:
2600         {
2601             opus_int32 *value = va_arg(ap, opus_int32*);
2602             if (!value)
2603             {
2604                goto bad_arg;
2605             }
2606             *value = st->variable_duration;
2607         }
2608         break;
2609         case OPUS_SET_PREDICTION_DISABLED_REQUEST:
2610         {
2611            opus_int32 value = va_arg(ap, opus_int32);
2612            if (value > 1 || value < 0)
2613               goto bad_arg;
2614            st->silk_mode.reducedDependency = value;
2615         }
2616         break;
2617         case OPUS_GET_PREDICTION_DISABLED_REQUEST:
2618         {
2619            opus_int32 *value = va_arg(ap, opus_int32*);
2620            if (!value)
2621               goto bad_arg;
2622            *value = st->silk_mode.reducedDependency;
2623         }
2624         break;
2625         case OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST:
2626         {
2627             opus_int32 value = va_arg(ap, opus_int32);
2628             if(value<0 || value>1)
2629             {
2630                goto bad_arg;
2631             }
2632             celt_encoder_ctl(celt_enc, OPUS_SET_PHASE_INVERSION_DISABLED(value));
2633         }
2634         break;
2635         case OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST:
2636         {
2637             opus_int32 *value = va_arg(ap, opus_int32*);
2638             if (!value)
2639             {
2640                goto bad_arg;
2641             }
2642             celt_encoder_ctl(celt_enc, OPUS_GET_PHASE_INVERSION_DISABLED(value));
2643         }
2644         break;
2645         case OPUS_RESET_STATE:
2646         {
2647            void *silk_enc;
2648            silk_EncControlStruct dummy;
2649            char *start;
2650            silk_enc = (char*)st+st->silk_enc_offset;
2651 #ifndef DISABLE_FLOAT_API
2652            tonality_analysis_reset(&st->analysis);
2653 #endif
2654
2655            start = (char*)&st->OPUS_ENCODER_RESET_START;
2656            OPUS_CLEAR(start, sizeof(OpusEncoder) - (start - (char*)st));
2657
2658            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2659            silk_InitEncoder( silk_enc, st->arch, &dummy );
2660            st->stream_channels = st->channels;
2661            st->hybrid_stereo_width_Q14 = 1 << 14;
2662            st->prev_HB_gain = Q15ONE;
2663            st->first = 1;
2664            st->mode = MODE_HYBRID;
2665            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
2666            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
2667         }
2668         break;
2669         case OPUS_SET_FORCE_MODE_REQUEST:
2670         {
2671             opus_int32 value = va_arg(ap, opus_int32);
2672             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
2673             {
2674                goto bad_arg;
2675             }
2676             st->user_forced_mode = value;
2677         }
2678         break;
2679         case OPUS_SET_LFE_REQUEST:
2680         {
2681             opus_int32 value = va_arg(ap, opus_int32);
2682             st->lfe = value;
2683             ret = celt_encoder_ctl(celt_enc, OPUS_SET_LFE(value));
2684         }
2685         break;
2686         case OPUS_SET_ENERGY_MASK_REQUEST:
2687         {
2688             opus_val16 *value = va_arg(ap, opus_val16*);
2689             st->energy_masking = value;
2690             ret = celt_encoder_ctl(celt_enc, OPUS_SET_ENERGY_MASK(value));
2691         }
2692         break;
2693
2694         case CELT_GET_MODE_REQUEST:
2695         {
2696            const CELTMode ** value = va_arg(ap, const CELTMode**);
2697            if (!value)
2698            {
2699               goto bad_arg;
2700            }
2701            ret = celt_encoder_ctl(celt_enc, CELT_GET_MODE(value));
2702         }
2703         break;
2704         default:
2705             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
2706             ret = OPUS_UNIMPLEMENTED;
2707             break;
2708     }
2709     va_end(ap);
2710     return ret;
2711 bad_arg:
2712     va_end(ap);
2713     return OPUS_BAD_ARG;
2714 }
2715
2716 void opus_encoder_destroy(OpusEncoder *st)
2717 {
2718     opus_free(st);
2719 }