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