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