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