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