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