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