Fix uninitialized variables in decide_dtx_mode()
[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     st->analysis.application = st->application;
268 #endif
269
270     return OPUS_OK;
271 }
272
273 static unsigned char gen_toc(int mode, int framerate, int bandwidth, int channels)
274 {
275    int period;
276    unsigned char toc;
277    period = 0;
278    while (framerate < 400)
279    {
280        framerate <<= 1;
281        period++;
282    }
283    if (mode == MODE_SILK_ONLY)
284    {
285        toc = (bandwidth-OPUS_BANDWIDTH_NARROWBAND)<<5;
286        toc |= (period-2)<<3;
287    } else if (mode == MODE_CELT_ONLY)
288    {
289        int tmp = bandwidth-OPUS_BANDWIDTH_MEDIUMBAND;
290        if (tmp < 0)
291            tmp = 0;
292        toc = 0x80;
293        toc |= tmp << 5;
294        toc |= period<<3;
295    } else /* Hybrid */
296    {
297        toc = 0x60;
298        toc |= (bandwidth-OPUS_BANDWIDTH_SUPERWIDEBAND)<<4;
299        toc |= (period-2)<<3;
300    }
301    toc |= (channels==2)<<2;
302    return toc;
303 }
304
305 #ifndef FIXED_POINT
306 static void silk_biquad_float(
307     const opus_val16      *in,            /* I:    Input signal                   */
308     const opus_int32      *B_Q28,         /* I:    MA coefficients [3]            */
309     const opus_int32      *A_Q28,         /* I:    AR coefficients [2]            */
310     opus_val32            *S,             /* I/O:  State vector [2]               */
311     opus_val16            *out,           /* O:    Output signal                  */
312     const opus_int32      len,            /* I:    Signal length (must be even)   */
313     int stride
314 )
315 {
316     /* DIRECT FORM II TRANSPOSED (uses 2 element state vector) */
317     opus_int   k;
318     opus_val32 vout;
319     opus_val32 inval;
320     opus_val32 A[2], B[3];
321
322     A[0] = (opus_val32)(A_Q28[0] * (1.f/((opus_int32)1<<28)));
323     A[1] = (opus_val32)(A_Q28[1] * (1.f/((opus_int32)1<<28)));
324     B[0] = (opus_val32)(B_Q28[0] * (1.f/((opus_int32)1<<28)));
325     B[1] = (opus_val32)(B_Q28[1] * (1.f/((opus_int32)1<<28)));
326     B[2] = (opus_val32)(B_Q28[2] * (1.f/((opus_int32)1<<28)));
327
328     /* Negate A_Q28 values and split in two parts */
329
330     for( k = 0; k < len; k++ ) {
331         /* S[ 0 ], S[ 1 ]: Q12 */
332         inval = in[ k*stride ];
333         vout = S[ 0 ] + B[0]*inval;
334
335         S[ 0 ] = S[1] - vout*A[0] + B[1]*inval;
336
337         S[ 1 ] = - vout*A[1] + B[2]*inval + VERY_SMALL;
338
339         /* Scale back to Q0 and saturate */
340         out[ k*stride ] = vout;
341     }
342 }
343 #endif
344
345 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)
346 {
347    opus_int32 B_Q28[ 3 ], A_Q28[ 2 ];
348    opus_int32 Fc_Q19, r_Q28, r_Q22;
349    (void)arch;
350
351    silk_assert( cutoff_Hz <= silk_int32_MAX / SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ) );
352    Fc_Q19 = silk_DIV32_16( silk_SMULBB( SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ), cutoff_Hz ), Fs/1000 );
353    silk_assert( Fc_Q19 > 0 && Fc_Q19 < 32768 );
354
355    r_Q28 = SILK_FIX_CONST( 1.0, 28 ) - silk_MUL( SILK_FIX_CONST( 0.92, 9 ), Fc_Q19 );
356
357    /* b = r * [ 1; -2; 1 ]; */
358    /* a = [ 1; -2 * r * ( 1 - 0.5 * Fc^2 ); r^2 ]; */
359    B_Q28[ 0 ] = r_Q28;
360    B_Q28[ 1 ] = silk_LSHIFT( -r_Q28, 1 );
361    B_Q28[ 2 ] = r_Q28;
362
363    /* -r * ( 2 - Fc * Fc ); */
364    r_Q22  = silk_RSHIFT( r_Q28, 6 );
365    A_Q28[ 0 ] = silk_SMULWW( r_Q22, silk_SMULWW( Fc_Q19, Fc_Q19 ) - SILK_FIX_CONST( 2.0,  22 ) );
366    A_Q28[ 1 ] = silk_SMULWW( r_Q22, r_Q22 );
367
368 #ifdef FIXED_POINT
369    if( channels == 1 ) {
370       silk_biquad_alt_stride1( in, B_Q28, A_Q28, hp_mem, out, len );
371    } else {
372       silk_biquad_alt_stride2( in, B_Q28, A_Q28, hp_mem, out, len, arch );
373    }
374 #else
375    silk_biquad_float( in, B_Q28, A_Q28, hp_mem, out, len, channels );
376    if( channels == 2 ) {
377        silk_biquad_float( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
378    }
379 #endif
380 }
381
382 #ifdef FIXED_POINT
383 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)
384 {
385    int c, i;
386    int shift;
387
388    /* Approximates -round(log2(4.*cutoff_Hz/Fs)) */
389    shift=celt_ilog2(Fs/(cutoff_Hz*3));
390    for (c=0;c<channels;c++)
391    {
392       for (i=0;i<len;i++)
393       {
394          opus_val32 x, tmp, y;
395          x = SHL32(EXTEND32(in[channels*i+c]), 14);
396          /* First stage */
397          tmp = x-hp_mem[2*c];
398          hp_mem[2*c] = hp_mem[2*c] + PSHR32(x - hp_mem[2*c], shift);
399          /* Second stage */
400          y = tmp - hp_mem[2*c+1];
401          hp_mem[2*c+1] = hp_mem[2*c+1] + PSHR32(tmp - hp_mem[2*c+1], shift);
402          out[channels*i+c] = EXTRACT16(SATURATE(PSHR32(y, 14), 32767));
403       }
404    }
405 }
406
407 #else
408 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)
409 {
410    int i;
411    float coef, coef2;
412    coef = 4.0f*cutoff_Hz/Fs;
413    coef2 = 1-coef;
414    if (channels==2)
415    {
416       float m0, m1, m2, m3;
417       m0 = hp_mem[0];
418       m1 = hp_mem[1];
419       m2 = hp_mem[2];
420       m3 = hp_mem[3];
421       for (i=0;i<len;i++)
422       {
423          opus_val32 x0, x1, tmp0, tmp1, out0, out1;
424          x0 = in[2*i+0];
425          x1 = in[2*i+1];
426          /* First stage */
427          tmp0 = x0-m0;
428          tmp1 = x1-m2;
429          m0 = coef*x0 + VERY_SMALL + coef2*m0;
430          m2 = coef*x1 + VERY_SMALL + coef2*m2;
431          /* Second stage */
432          out0 = tmp0 - m1;
433          out1 = tmp1 - m3;
434          m1 = coef*tmp0 + VERY_SMALL + coef2*m1;
435          m3 = coef*tmp1 + VERY_SMALL + coef2*m3;
436          out[2*i+0] = out0;
437          out[2*i+1] = out1;
438       }
439       hp_mem[0] = m0;
440       hp_mem[1] = m1;
441       hp_mem[2] = m2;
442       hp_mem[3] = m3;
443    } else {
444       float m0, m1;
445       m0 = hp_mem[0];
446       m1 = hp_mem[1];
447       for (i=0;i<len;i++)
448       {
449          opus_val32 x, tmp, y;
450          x = in[i];
451          /* First stage */
452          tmp = x-m0;
453          m0 = coef*x + VERY_SMALL + coef2*m0;
454          /* Second stage */
455          y = tmp - m1;
456          m1 = coef*tmp + VERY_SMALL + coef2*m1;
457          out[i] = y;
458       }
459       hp_mem[0] = m0;
460       hp_mem[1] = m1;
461    }
462 }
463 #endif
464
465 static void stereo_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2,
466         int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
467 {
468     int i;
469     int overlap;
470     int inc;
471     inc = 48000/Fs;
472     overlap=overlap48/inc;
473     g1 = Q15ONE-g1;
474     g2 = Q15ONE-g2;
475     for (i=0;i<overlap;i++)
476     {
477        opus_val32 diff;
478        opus_val16 g, w;
479        w = MULT16_16_Q15(window[i*inc], window[i*inc]);
480        g = SHR32(MAC16_16(MULT16_16(w,g2),
481              Q15ONE-w, g1), 15);
482        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
483        diff = MULT16_16_Q15(g, diff);
484        out[i*channels] = out[i*channels] - diff;
485        out[i*channels+1] = out[i*channels+1] + diff;
486     }
487     for (;i<frame_size;i++)
488     {
489        opus_val32 diff;
490        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
491        diff = MULT16_16_Q15(g2, diff);
492        out[i*channels] = out[i*channels] - diff;
493        out[i*channels+1] = out[i*channels+1] + diff;
494     }
495 }
496
497 static void gain_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2,
498         int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
499 {
500     int i;
501     int inc;
502     int overlap;
503     int c;
504     inc = 48000/Fs;
505     overlap=overlap48/inc;
506     if (channels==1)
507     {
508        for (i=0;i<overlap;i++)
509        {
510           opus_val16 g, w;
511           w = MULT16_16_Q15(window[i*inc], window[i*inc]);
512           g = SHR32(MAC16_16(MULT16_16(w,g2),
513                 Q15ONE-w, g1), 15);
514           out[i] = MULT16_16_Q15(g, in[i]);
515        }
516     } else {
517        for (i=0;i<overlap;i++)
518        {
519           opus_val16 g, w;
520           w = MULT16_16_Q15(window[i*inc], window[i*inc]);
521           g = SHR32(MAC16_16(MULT16_16(w,g2),
522                 Q15ONE-w, g1), 15);
523           out[i*2] = MULT16_16_Q15(g, in[i*2]);
524           out[i*2+1] = MULT16_16_Q15(g, in[i*2+1]);
525        }
526     }
527     c=0;do {
528        for (i=overlap;i<frame_size;i++)
529        {
530           out[i*channels+c] = MULT16_16_Q15(g2, in[i*channels+c]);
531        }
532     }
533     while (++c<channels);
534 }
535
536 OpusEncoder *opus_encoder_create(opus_int32 Fs, int channels, int application, int *error)
537 {
538    int ret;
539    OpusEncoder *st;
540    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
541        (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
542        && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
543    {
544       if (error)
545          *error = OPUS_BAD_ARG;
546       return NULL;
547    }
548    st = (OpusEncoder *)opus_alloc(opus_encoder_get_size(channels));
549    if (st == NULL)
550    {
551       if (error)
552          *error = OPUS_ALLOC_FAIL;
553       return NULL;
554    }
555    ret = opus_encoder_init(st, Fs, channels, application);
556    if (error)
557       *error = ret;
558    if (ret != OPUS_OK)
559    {
560       opus_free(st);
561       st = NULL;
562    }
563    return st;
564 }
565
566 static opus_int32 user_bitrate_to_bitrate(OpusEncoder *st, int frame_size, int max_data_bytes)
567 {
568   if(!frame_size)frame_size=st->Fs/400;
569   if (st->user_bitrate_bps==OPUS_AUTO)
570     return 60*st->Fs/frame_size + st->Fs*st->channels;
571   else if (st->user_bitrate_bps==OPUS_BITRATE_MAX)
572     return max_data_bytes*8*st->Fs/frame_size;
573   else
574     return st->user_bitrate_bps;
575 }
576
577 #ifndef DISABLE_FLOAT_API
578 #ifdef FIXED_POINT
579 #define PCM2VAL(x) FLOAT2INT16(x)
580 #else
581 #define PCM2VAL(x) SCALEIN(x)
582 #endif
583
584 void downmix_float(const void *_x, opus_val32 *y, int subframe, int offset, int c1, int c2, int C)
585 {
586    const float *x;
587    int j;
588
589    x = (const float *)_x;
590    for (j=0;j<subframe;j++)
591       y[j] = PCM2VAL(x[(j+offset)*C+c1]);
592    if (c2>-1)
593    {
594       for (j=0;j<subframe;j++)
595          y[j] += PCM2VAL(x[(j+offset)*C+c2]);
596    } else if (c2==-2)
597    {
598       int c;
599       for (c=1;c<C;c++)
600       {
601          for (j=0;j<subframe;j++)
602             y[j] += PCM2VAL(x[(j+offset)*C+c]);
603       }
604    }
605 }
606 #endif
607
608 void downmix_int(const void *_x, opus_val32 *y, int subframe, int offset, int c1, int c2, int C)
609 {
610    const opus_int16 *x;
611    int j;
612
613    x = (const opus_int16 *)_x;
614    for (j=0;j<subframe;j++)
615       y[j] = x[(j+offset)*C+c1];
616    if (c2>-1)
617    {
618       for (j=0;j<subframe;j++)
619          y[j] += x[(j+offset)*C+c2];
620    } else if (c2==-2)
621    {
622       int c;
623       for (c=1;c<C;c++)
624       {
625          for (j=0;j<subframe;j++)
626             y[j] += x[(j+offset)*C+c];
627       }
628    }
629 }
630
631 opus_int32 frame_size_select(opus_int32 frame_size, int variable_duration, opus_int32 Fs)
632 {
633    int new_size;
634    if (frame_size<Fs/400)
635       return -1;
636    if (variable_duration == OPUS_FRAMESIZE_ARG)
637       new_size = frame_size;
638    else if (variable_duration >= OPUS_FRAMESIZE_2_5_MS && variable_duration <= OPUS_FRAMESIZE_120_MS)
639    {
640       if (variable_duration <= OPUS_FRAMESIZE_40_MS)
641          new_size = (Fs/400)<<(variable_duration-OPUS_FRAMESIZE_2_5_MS);
642       else
643          new_size = (variable_duration-OPUS_FRAMESIZE_2_5_MS-2)*Fs/50;
644    }
645    else
646       return -1;
647    if (new_size>frame_size)
648       return -1;
649    if (400*new_size!=Fs   && 200*new_size!=Fs   && 100*new_size!=Fs   &&
650         50*new_size!=Fs   &&  25*new_size!=Fs   &&  50*new_size!=3*Fs &&
651         50*new_size!=4*Fs &&  50*new_size!=5*Fs &&  50*new_size!=6*Fs)
652       return -1;
653    return new_size;
654 }
655
656 opus_val16 compute_stereo_width(const opus_val16 *pcm, int frame_size, opus_int32 Fs, StereoWidthState *mem)
657 {
658    opus_val32 xx, xy, yy;
659    opus_val16 sqrt_xx, sqrt_yy;
660    opus_val16 qrrt_xx, qrrt_yy;
661    int frame_rate;
662    int i;
663    opus_val16 short_alpha;
664
665    frame_rate = Fs/frame_size;
666    short_alpha = Q15ONE - MULT16_16(25, Q15ONE)/IMAX(50,frame_rate);
667    xx=xy=yy=0;
668    /* Unroll by 4. The frame size is always a multiple of 4 *except* for
669       2.5 ms frames at 12 kHz. Since this setting is very rare (and very
670       stupid), we just discard the last two samples. */
671    for (i=0;i<frame_size-3;i+=4)
672    {
673       opus_val32 pxx=0;
674       opus_val32 pxy=0;
675       opus_val32 pyy=0;
676       opus_val16 x, y;
677       x = pcm[2*i];
678       y = pcm[2*i+1];
679       pxx = SHR32(MULT16_16(x,x),2);
680       pxy = SHR32(MULT16_16(x,y),2);
681       pyy = SHR32(MULT16_16(y,y),2);
682       x = pcm[2*i+2];
683       y = pcm[2*i+3];
684       pxx += SHR32(MULT16_16(x,x),2);
685       pxy += SHR32(MULT16_16(x,y),2);
686       pyy += SHR32(MULT16_16(y,y),2);
687       x = pcm[2*i+4];
688       y = pcm[2*i+5];
689       pxx += SHR32(MULT16_16(x,x),2);
690       pxy += SHR32(MULT16_16(x,y),2);
691       pyy += SHR32(MULT16_16(y,y),2);
692       x = pcm[2*i+6];
693       y = pcm[2*i+7];
694       pxx += SHR32(MULT16_16(x,x),2);
695       pxy += SHR32(MULT16_16(x,y),2);
696       pyy += SHR32(MULT16_16(y,y),2);
697
698       xx += SHR32(pxx, 10);
699       xy += SHR32(pxy, 10);
700       yy += SHR32(pyy, 10);
701    }
702    mem->XX += MULT16_32_Q15(short_alpha, xx-mem->XX);
703    mem->XY += MULT16_32_Q15(short_alpha, xy-mem->XY);
704    mem->YY += MULT16_32_Q15(short_alpha, yy-mem->YY);
705    mem->XX = MAX32(0, mem->XX);
706    mem->XY = MAX32(0, mem->XY);
707    mem->YY = MAX32(0, mem->YY);
708    if (MAX32(mem->XX, mem->YY)>QCONST16(8e-4f, 18))
709    {
710       opus_val16 corr;
711       opus_val16 ldiff;
712       opus_val16 width;
713       sqrt_xx = celt_sqrt(mem->XX);
714       sqrt_yy = celt_sqrt(mem->YY);
715       qrrt_xx = celt_sqrt(sqrt_xx);
716       qrrt_yy = celt_sqrt(sqrt_yy);
717       /* Inter-channel correlation */
718       mem->XY = MIN32(mem->XY, sqrt_xx*sqrt_yy);
719       corr = SHR32(frac_div32(mem->XY,EPSILON+MULT16_16(sqrt_xx,sqrt_yy)),16);
720       /* Approximate loudness difference */
721       ldiff = MULT16_16(Q15ONE, ABS16(qrrt_xx-qrrt_yy))/(EPSILON+qrrt_xx+qrrt_yy);
722       width = MULT16_16_Q15(celt_sqrt(QCONST32(1.f,30)-MULT16_16(corr,corr)), ldiff);
723       /* Smoothing over one second */
724       mem->smoothed_width += (width-mem->smoothed_width)/frame_rate;
725       /* Peak follower */
726       mem->max_follower = MAX16(mem->max_follower-QCONST16(.02f,15)/frame_rate, mem->smoothed_width);
727    }
728    /*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);*/
729    return EXTRACT16(MIN32(Q15ONE, MULT16_16(20, mem->max_follower)));
730 }
731
732 static int decide_fec(int useInBandFEC, int PacketLoss_perc, int last_fec, int mode, int *bandwidth, opus_int32 rate)
733 {
734    int orig_bandwidth;
735    if (!useInBandFEC || PacketLoss_perc == 0 || mode == MODE_CELT_ONLY)
736       return 0;
737    orig_bandwidth = *bandwidth;
738    for (;;)
739    {
740       opus_int32 hysteresis;
741       opus_int32 LBRR_rate_thres_bps;
742       /* Compute threshold for using FEC at the current bandwidth setting */
743       LBRR_rate_thres_bps = fec_thresholds[2*(*bandwidth - OPUS_BANDWIDTH_NARROWBAND)];
744       hysteresis = fec_thresholds[2*(*bandwidth - OPUS_BANDWIDTH_NARROWBAND) + 1];
745       if (last_fec == 1) LBRR_rate_thres_bps -= hysteresis;
746       if (last_fec == 0) LBRR_rate_thres_bps += hysteresis;
747       LBRR_rate_thres_bps = silk_SMULWB( silk_MUL( LBRR_rate_thres_bps,
748             125 - silk_min( PacketLoss_perc, 25 ) ), SILK_FIX_CONST( 0.01, 16 ) );
749       /* If loss <= 5%, we look at whether we have enough rate to enable FEC.
750          If loss > 5%, we decrease the bandwidth until we can enable FEC. */
751       if (rate > LBRR_rate_thres_bps)
752          return 1;
753       else if (PacketLoss_perc <= 5)
754          return 0;
755       else if (*bandwidth > OPUS_BANDWIDTH_NARROWBAND)
756          (*bandwidth)--;
757       else
758          break;
759    }
760    /* Couldn't find any bandwidth to enable FEC, keep original bandwidth. */
761    *bandwidth = orig_bandwidth;
762    return 0;
763 }
764
765 static int compute_silk_rate_for_hybrid(int rate, int bandwidth, int frame20ms, int vbr, int fec) {
766    int entry;
767    int i;
768    int N;
769    int silk_rate;
770    static int rate_table[][5] = {
771   /*  |total| |-------- SILK------------|
772               |-- No FEC -| |--- FEC ---|
773                10ms   20ms   10ms   20ms */
774       {    0,     0,     0,     0,     0},
775       {12000, 10000, 10000, 11000, 11000},
776       {16000, 13500, 13500, 15000, 15000},
777       {20000, 16000, 16000, 18000, 18000},
778       {24000, 18000, 18000, 21000, 21000},
779       {32000, 22000, 22000, 28000, 28000},
780       {64000, 38000, 38000, 50000, 50000}
781    };
782    entry = 1 + frame20ms + 2*fec;
783    N = sizeof(rate_table)/sizeof(rate_table[0]);
784    for (i=1;i<N;i++)
785    {
786       if (rate_table[i][0] > rate) break;
787    }
788    if (i == N)
789    {
790       silk_rate = rate_table[i-1][entry];
791       /* For now, just give 50% of the extra bits to SILK. */
792       silk_rate += (rate-rate_table[i-1][0])/2;
793    } else {
794       opus_int32 lo, hi, x0, x1;
795       lo = rate_table[i-1][entry];
796       hi = rate_table[i][entry];
797       x0 = rate_table[i-1][0];
798       x1 = rate_table[i][0];
799       silk_rate = (lo*(x1-rate) + hi*(rate-x0))/(x1-x0);
800    }
801    if (!vbr)
802    {
803       /* Tiny boost to SILK for CBR. We should probably tune this better. */
804       silk_rate += 100;
805    }
806    if (bandwidth==OPUS_BANDWIDTH_SUPERWIDEBAND)
807       silk_rate += 300;
808    return silk_rate;
809 }
810
811 /* Returns the equivalent bitrate corresponding to 20 ms frames,
812    complexity 10 VBR operation. */
813 static opus_int32 compute_equiv_rate(opus_int32 bitrate, int channels,
814       int frame_rate, int vbr, int mode, int complexity, int loss)
815 {
816    opus_int32 equiv;
817    equiv = bitrate;
818    /* Take into account overhead from smaller frames. */
819    equiv -= (40*channels+20)*(frame_rate - 50);
820    /* CBR is about a 8% penalty for both SILK and CELT. */
821    if (!vbr)
822       equiv -= equiv/12;
823    /* Complexity makes about 10% difference (from 0 to 10) in general. */
824    equiv = equiv * (90+complexity)/100;
825    if (mode == MODE_SILK_ONLY || mode == MODE_HYBRID)
826    {
827       /* SILK complexity 0-1 uses the non-delayed-decision NSQ, which
828          costs about 20%. */
829       if (complexity<2)
830          equiv = equiv*4/5;
831       equiv -= equiv*loss/(6*loss + 10);
832    } else if (mode == MODE_CELT_ONLY) {
833       /* CELT complexity 0-4 doesn't have the pitch filter, which costs
834          about 10%. */
835       if (complexity<5)
836          equiv = equiv*9/10;
837    } else {
838       /* Mode not known yet */
839       /* Half the SILK loss*/
840       equiv -= equiv*loss/(12*loss + 20);
841    }
842    return equiv;
843 }
844
845 #ifndef DISABLE_FLOAT_API
846
847 static int is_digital_silence(const opus_val16* pcm, int frame_size, int channels, int lsb_depth)
848 {
849    int silence = 0;
850    opus_val32 sample_max = 0;
851 #ifdef MLP_TRAINING
852    return 0;
853 #endif
854    sample_max = celt_maxabs16(pcm, frame_size*channels);
855
856 #ifdef FIXED_POINT
857    silence = (sample_max == 0);
858    (void)lsb_depth;
859 #else
860    silence = (sample_max <= (opus_val16) 1 / (1 << lsb_depth));
861 #endif
862
863    return silence;
864 }
865
866 #ifdef FIXED_POINT
867 static opus_val32 compute_frame_energy(const opus_val16 *pcm, int frame_size, int channels, int arch)
868 {
869    int i;
870    opus_val32 sample_max;
871    int max_shift;
872    int shift;
873    opus_val32 energy = 0;
874    int len = frame_size*channels;
875    (void)arch;
876    /* Max amplitude in the signal */
877    sample_max = celt_maxabs16(pcm, len);
878
879    /* Compute the right shift required in the MAC to avoid an overflow */
880    max_shift = celt_ilog2(len);
881    shift = IMAX(0, (celt_ilog2(sample_max) << 1) + max_shift - 28);
882
883    /* Compute the energy */
884    for (i=0; i<len; i++)
885       energy += SHR32(MULT16_16(pcm[i], pcm[i]), shift);
886
887    /* Normalize energy by the frame size and left-shift back to the original position */
888    energy /= len;
889    energy = SHL32(energy, shift);
890
891    return energy;
892 }
893 #else
894 static opus_val32 compute_frame_energy(const opus_val16 *pcm, int frame_size, int channels, int arch)
895 {
896    int len = frame_size*channels;
897    return celt_inner_prod(pcm, pcm, len, arch)/len;
898 }
899 #endif
900
901 /* Decides if DTX should be turned on (=1) or off (=0) */
902 static int decide_dtx_mode(float activity_probability,    /* probability that current frame contains speech/music */
903                            int *nb_no_activity_frames,    /* number of consecutive frames with no activity */
904                            opus_val32 peak_signal_energy, /* peak energy of desired signal detected so far */
905                            const opus_val16 *pcm,         /* input pcm signal */
906                            int frame_size,                /* frame size */
907                            int channels,
908                            int is_silence,                 /* only digital silence detected in this frame */
909                            int arch
910                           )
911 {
912    opus_val32 noise_energy;
913
914    if (!is_silence)
915    {
916       if (activity_probability < DTX_ACTIVITY_THRESHOLD)  /* is noise */
917       {
918          noise_energy = compute_frame_energy(pcm, frame_size, channels, arch);
919
920          /* but is sufficiently quiet */
921          is_silence = peak_signal_energy >= (PSEUDO_SNR_THRESHOLD * noise_energy);
922       }
923    }
924
925    if (is_silence)
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 #ifndef DISABLE_FLOAT_API
2267             st->analysis.application = value;
2268 #endif
2269         }
2270         break;
2271         case OPUS_GET_APPLICATION_REQUEST:
2272         {
2273             opus_int32 *value = va_arg(ap, opus_int32*);
2274             if (!value)
2275             {
2276                goto bad_arg;
2277             }
2278             *value = st->application;
2279         }
2280         break;
2281         case OPUS_SET_BITRATE_REQUEST:
2282         {
2283             opus_int32 value = va_arg(ap, opus_int32);
2284             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
2285             {
2286                 if (value <= 0)
2287                     goto bad_arg;
2288                 else if (value <= 500)
2289                     value = 500;
2290                 else if (value > (opus_int32)300000*st->channels)
2291                     value = (opus_int32)300000*st->channels;
2292             }
2293             st->user_bitrate_bps = value;
2294         }
2295         break;
2296         case OPUS_GET_BITRATE_REQUEST:
2297         {
2298             opus_int32 *value = va_arg(ap, opus_int32*);
2299             if (!value)
2300             {
2301                goto bad_arg;
2302             }
2303             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
2304         }
2305         break;
2306         case OPUS_SET_FORCE_CHANNELS_REQUEST:
2307         {
2308             opus_int32 value = va_arg(ap, opus_int32);
2309             if((value<1 || value>st->channels) && value != OPUS_AUTO)
2310             {
2311                goto bad_arg;
2312             }
2313             st->force_channels = value;
2314         }
2315         break;
2316         case OPUS_GET_FORCE_CHANNELS_REQUEST:
2317         {
2318             opus_int32 *value = va_arg(ap, opus_int32*);
2319             if (!value)
2320             {
2321                goto bad_arg;
2322             }
2323             *value = st->force_channels;
2324         }
2325         break;
2326         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
2327         {
2328             opus_int32 value = va_arg(ap, opus_int32);
2329             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND)
2330             {
2331                goto bad_arg;
2332             }
2333             st->max_bandwidth = value;
2334             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2335                 st->silk_mode.maxInternalSampleRate = 8000;
2336             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2337                 st->silk_mode.maxInternalSampleRate = 12000;
2338             } else {
2339                 st->silk_mode.maxInternalSampleRate = 16000;
2340             }
2341         }
2342         break;
2343         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
2344         {
2345             opus_int32 *value = va_arg(ap, opus_int32*);
2346             if (!value)
2347             {
2348                goto bad_arg;
2349             }
2350             *value = st->max_bandwidth;
2351         }
2352         break;
2353         case OPUS_SET_BANDWIDTH_REQUEST:
2354         {
2355             opus_int32 value = va_arg(ap, opus_int32);
2356             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
2357             {
2358                goto bad_arg;
2359             }
2360             st->user_bandwidth = value;
2361             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2362                 st->silk_mode.maxInternalSampleRate = 8000;
2363             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2364                 st->silk_mode.maxInternalSampleRate = 12000;
2365             } else {
2366                 st->silk_mode.maxInternalSampleRate = 16000;
2367             }
2368         }
2369         break;
2370         case OPUS_GET_BANDWIDTH_REQUEST:
2371         {
2372             opus_int32 *value = va_arg(ap, opus_int32*);
2373             if (!value)
2374             {
2375                goto bad_arg;
2376             }
2377             *value = st->bandwidth;
2378         }
2379         break;
2380         case OPUS_SET_DTX_REQUEST:
2381         {
2382             opus_int32 value = va_arg(ap, opus_int32);
2383             if(value<0 || value>1)
2384             {
2385                goto bad_arg;
2386             }
2387             st->use_dtx = value;
2388         }
2389         break;
2390         case OPUS_GET_DTX_REQUEST:
2391         {
2392             opus_int32 *value = va_arg(ap, opus_int32*);
2393             if (!value)
2394             {
2395                goto bad_arg;
2396             }
2397             *value = st->use_dtx;
2398         }
2399         break;
2400         case OPUS_SET_COMPLEXITY_REQUEST:
2401         {
2402             opus_int32 value = va_arg(ap, opus_int32);
2403             if(value<0 || value>10)
2404             {
2405                goto bad_arg;
2406             }
2407             st->silk_mode.complexity = value;
2408             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
2409         }
2410         break;
2411         case OPUS_GET_COMPLEXITY_REQUEST:
2412         {
2413             opus_int32 *value = va_arg(ap, opus_int32*);
2414             if (!value)
2415             {
2416                goto bad_arg;
2417             }
2418             *value = st->silk_mode.complexity;
2419         }
2420         break;
2421         case OPUS_SET_INBAND_FEC_REQUEST:
2422         {
2423             opus_int32 value = va_arg(ap, opus_int32);
2424             if(value<0 || value>1)
2425             {
2426                goto bad_arg;
2427             }
2428             st->silk_mode.useInBandFEC = value;
2429         }
2430         break;
2431         case OPUS_GET_INBAND_FEC_REQUEST:
2432         {
2433             opus_int32 *value = va_arg(ap, opus_int32*);
2434             if (!value)
2435             {
2436                goto bad_arg;
2437             }
2438             *value = st->silk_mode.useInBandFEC;
2439         }
2440         break;
2441         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
2442         {
2443             opus_int32 value = va_arg(ap, opus_int32);
2444             if (value < 0 || value > 100)
2445             {
2446                goto bad_arg;
2447             }
2448             st->silk_mode.packetLossPercentage = value;
2449             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
2450         }
2451         break;
2452         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
2453         {
2454             opus_int32 *value = va_arg(ap, opus_int32*);
2455             if (!value)
2456             {
2457                goto bad_arg;
2458             }
2459             *value = st->silk_mode.packetLossPercentage;
2460         }
2461         break;
2462         case OPUS_SET_VBR_REQUEST:
2463         {
2464             opus_int32 value = va_arg(ap, opus_int32);
2465             if(value<0 || value>1)
2466             {
2467                goto bad_arg;
2468             }
2469             st->use_vbr = value;
2470             st->silk_mode.useCBR = 1-value;
2471         }
2472         break;
2473         case OPUS_GET_VBR_REQUEST:
2474         {
2475             opus_int32 *value = va_arg(ap, opus_int32*);
2476             if (!value)
2477             {
2478                goto bad_arg;
2479             }
2480             *value = st->use_vbr;
2481         }
2482         break;
2483         case OPUS_SET_VOICE_RATIO_REQUEST:
2484         {
2485             opus_int32 value = va_arg(ap, opus_int32);
2486             if (value<-1 || value>100)
2487             {
2488                goto bad_arg;
2489             }
2490             st->voice_ratio = value;
2491         }
2492         break;
2493         case OPUS_GET_VOICE_RATIO_REQUEST:
2494         {
2495             opus_int32 *value = va_arg(ap, opus_int32*);
2496             if (!value)
2497             {
2498                goto bad_arg;
2499             }
2500             *value = st->voice_ratio;
2501         }
2502         break;
2503         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
2504         {
2505             opus_int32 value = va_arg(ap, opus_int32);
2506             if(value<0 || value>1)
2507             {
2508                goto bad_arg;
2509             }
2510             st->vbr_constraint = value;
2511         }
2512         break;
2513         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
2514         {
2515             opus_int32 *value = va_arg(ap, opus_int32*);
2516             if (!value)
2517             {
2518                goto bad_arg;
2519             }
2520             *value = st->vbr_constraint;
2521         }
2522         break;
2523         case OPUS_SET_SIGNAL_REQUEST:
2524         {
2525             opus_int32 value = va_arg(ap, opus_int32);
2526             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
2527             {
2528                goto bad_arg;
2529             }
2530             st->signal_type = value;
2531         }
2532         break;
2533         case OPUS_GET_SIGNAL_REQUEST:
2534         {
2535             opus_int32 *value = va_arg(ap, opus_int32*);
2536             if (!value)
2537             {
2538                goto bad_arg;
2539             }
2540             *value = st->signal_type;
2541         }
2542         break;
2543         case OPUS_GET_LOOKAHEAD_REQUEST:
2544         {
2545             opus_int32 *value = va_arg(ap, opus_int32*);
2546             if (!value)
2547             {
2548                goto bad_arg;
2549             }
2550             *value = st->Fs/400;
2551             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2552                 *value += st->delay_compensation;
2553         }
2554         break;
2555         case OPUS_GET_SAMPLE_RATE_REQUEST:
2556         {
2557             opus_int32 *value = va_arg(ap, opus_int32*);
2558             if (!value)
2559             {
2560                goto bad_arg;
2561             }
2562             *value = st->Fs;
2563         }
2564         break;
2565         case OPUS_GET_FINAL_RANGE_REQUEST:
2566         {
2567             opus_uint32 *value = va_arg(ap, opus_uint32*);
2568             if (!value)
2569             {
2570                goto bad_arg;
2571             }
2572             *value = st->rangeFinal;
2573         }
2574         break;
2575         case OPUS_SET_LSB_DEPTH_REQUEST:
2576         {
2577             opus_int32 value = va_arg(ap, opus_int32);
2578             if (value<8 || value>24)
2579             {
2580                goto bad_arg;
2581             }
2582             st->lsb_depth=value;
2583         }
2584         break;
2585         case OPUS_GET_LSB_DEPTH_REQUEST:
2586         {
2587             opus_int32 *value = va_arg(ap, opus_int32*);
2588             if (!value)
2589             {
2590                goto bad_arg;
2591             }
2592             *value = st->lsb_depth;
2593         }
2594         break;
2595         case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
2596         {
2597             opus_int32 value = va_arg(ap, opus_int32);
2598             if (value != OPUS_FRAMESIZE_ARG    && value != OPUS_FRAMESIZE_2_5_MS &&
2599                 value != OPUS_FRAMESIZE_5_MS   && value != OPUS_FRAMESIZE_10_MS  &&
2600                 value != OPUS_FRAMESIZE_20_MS  && value != OPUS_FRAMESIZE_40_MS  &&
2601                 value != OPUS_FRAMESIZE_60_MS  && value != OPUS_FRAMESIZE_80_MS  &&
2602                 value != OPUS_FRAMESIZE_100_MS && value != OPUS_FRAMESIZE_120_MS)
2603             {
2604                goto bad_arg;
2605             }
2606             st->variable_duration = value;
2607             celt_encoder_ctl(celt_enc, OPUS_SET_EXPERT_FRAME_DURATION(value));
2608         }
2609         break;
2610         case OPUS_GET_EXPERT_FRAME_DURATION_REQUEST:
2611         {
2612             opus_int32 *value = va_arg(ap, opus_int32*);
2613             if (!value)
2614             {
2615                goto bad_arg;
2616             }
2617             *value = st->variable_duration;
2618         }
2619         break;
2620         case OPUS_SET_PREDICTION_DISABLED_REQUEST:
2621         {
2622            opus_int32 value = va_arg(ap, opus_int32);
2623            if (value > 1 || value < 0)
2624               goto bad_arg;
2625            st->silk_mode.reducedDependency = value;
2626         }
2627         break;
2628         case OPUS_GET_PREDICTION_DISABLED_REQUEST:
2629         {
2630            opus_int32 *value = va_arg(ap, opus_int32*);
2631            if (!value)
2632               goto bad_arg;
2633            *value = st->silk_mode.reducedDependency;
2634         }
2635         break;
2636         case OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST:
2637         {
2638             opus_int32 value = va_arg(ap, opus_int32);
2639             if(value<0 || value>1)
2640             {
2641                goto bad_arg;
2642             }
2643             celt_encoder_ctl(celt_enc, OPUS_SET_PHASE_INVERSION_DISABLED(value));
2644         }
2645         break;
2646         case OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST:
2647         {
2648             opus_int32 *value = va_arg(ap, opus_int32*);
2649             if (!value)
2650             {
2651                goto bad_arg;
2652             }
2653             celt_encoder_ctl(celt_enc, OPUS_GET_PHASE_INVERSION_DISABLED(value));
2654         }
2655         break;
2656         case OPUS_RESET_STATE:
2657         {
2658            void *silk_enc;
2659            silk_EncControlStruct dummy;
2660            char *start;
2661            silk_enc = (char*)st+st->silk_enc_offset;
2662 #ifndef DISABLE_FLOAT_API
2663            tonality_analysis_reset(&st->analysis);
2664 #endif
2665
2666            start = (char*)&st->OPUS_ENCODER_RESET_START;
2667            OPUS_CLEAR(start, sizeof(OpusEncoder) - (start - (char*)st));
2668
2669            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2670            silk_InitEncoder( silk_enc, st->arch, &dummy );
2671            st->stream_channels = st->channels;
2672            st->hybrid_stereo_width_Q14 = 1 << 14;
2673            st->prev_HB_gain = Q15ONE;
2674            st->first = 1;
2675            st->mode = MODE_HYBRID;
2676            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
2677            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
2678         }
2679         break;
2680         case OPUS_SET_FORCE_MODE_REQUEST:
2681         {
2682             opus_int32 value = va_arg(ap, opus_int32);
2683             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
2684             {
2685                goto bad_arg;
2686             }
2687             st->user_forced_mode = value;
2688         }
2689         break;
2690         case OPUS_SET_LFE_REQUEST:
2691         {
2692             opus_int32 value = va_arg(ap, opus_int32);
2693             st->lfe = value;
2694             ret = celt_encoder_ctl(celt_enc, OPUS_SET_LFE(value));
2695         }
2696         break;
2697         case OPUS_SET_ENERGY_MASK_REQUEST:
2698         {
2699             opus_val16 *value = va_arg(ap, opus_val16*);
2700             st->energy_masking = value;
2701             ret = celt_encoder_ctl(celt_enc, OPUS_SET_ENERGY_MASK(value));
2702         }
2703         break;
2704
2705         case CELT_GET_MODE_REQUEST:
2706         {
2707            const CELTMode ** value = va_arg(ap, const CELTMode**);
2708            if (!value)
2709            {
2710               goto bad_arg;
2711            }
2712            ret = celt_encoder_ctl(celt_enc, CELT_GET_MODE(value));
2713         }
2714         break;
2715         default:
2716             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
2717             ret = OPUS_UNIMPLEMENTED;
2718             break;
2719     }
2720     va_end(ap);
2721     return ret;
2722 bad_arg:
2723     va_end(ap);
2724     return OPUS_BAD_ARG;
2725 }
2726
2727 void opus_encoder_destroy(OpusEncoder *st)
2728 {
2729     opus_free(st);
2730 }