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