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