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