27b7143bbbe7eef7d0dbbcbe638c470e2c846457
[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     int          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                = 10;
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(10));
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    int j;
766    x = (const float *)_x;
767    for (j=0;j<subframe;j++)
768       sub[j] = SCALEIN(x[(j+offset)*C+c1]);
769    if (c2>-1)
770    {
771       for (j=0;j<subframe;j++)
772          sub[j] += SCALEIN(x[(j+offset)*C+c2]);
773    } else if (c2==-2)
774    {
775       int c;
776       for (c=1;c<C;c++)
777       {
778          for (j=0;j<subframe;j++)
779             sub[j] += SCALEIN(x[(j+offset)*C+c]);
780       }
781    }
782 #ifdef FIXED_POINT
783    {
784       opus_val32 scale =(1<<SIG_SHIFT);
785       if (C==-2)
786          scale /= C;
787       else
788          scale /= 2;
789       for (j=0;j<subframe;j++)
790          sub[j] *= scale;
791    }
792 #endif
793 }
794 #endif
795
796 void downmix_int(const void *_x, opus_val32 *sub, int subframe, int offset, int c1, int c2, int C)
797 {
798    const opus_int16 *x;
799    int j;
800    x = (const opus_int16 *)_x;
801    for (j=0;j<subframe;j++)
802       sub[j] = x[(j+offset)*C+c1];
803    if (c2>-1)
804    {
805       for (j=0;j<subframe;j++)
806          sub[j] += x[(j+offset)*C+c2];
807    } else if (c2==-2)
808    {
809       int c;
810       for (c=1;c<C;c++)
811       {
812          for (j=0;j<subframe;j++)
813             sub[j] += x[(j+offset)*C+c];
814       }
815    }
816 #ifdef FIXED_POINT
817    {
818       opus_val32 scale =(1<<SIG_SHIFT);
819       if (C==-2)
820          scale /= C;
821       else
822          scale /= 2;
823       for (j=0;j<subframe;j++)
824          sub[j] *= scale;
825    }
826 #else
827    for (j=0;j<subframe;j++)
828       sub[j] *= (1.f/32768);
829 #endif
830 }
831
832 opus_int32 frame_size_select(opus_int32 frame_size, int variable_duration, opus_int32 Fs)
833 {
834    int new_size;
835    if (frame_size<Fs/400)
836       return -1;
837    if (variable_duration == OPUS_FRAMESIZE_ARG)
838       new_size = frame_size;
839    else if (variable_duration == OPUS_FRAMESIZE_VARIABLE)
840       new_size = Fs/50;
841    else if (variable_duration >= OPUS_FRAMESIZE_2_5_MS && variable_duration <= OPUS_FRAMESIZE_60_MS)
842       new_size = IMIN(3*Fs/50, (Fs/400)<<(variable_duration-OPUS_FRAMESIZE_2_5_MS));
843    else
844       return -1;
845    if (new_size>frame_size)
846       return -1;
847    if (400*new_size!=Fs && 200*new_size!=Fs && 100*new_size!=Fs &&
848             50*new_size!=Fs && 25*new_size!=Fs && 50*new_size!=3*Fs)
849       return -1;
850    return new_size;
851 }
852
853 opus_val16 compute_stereo_width(const opus_val16 *pcm, int frame_size, opus_int32 Fs, StereoWidthState *mem)
854 {
855    opus_val16 corr;
856    opus_val16 ldiff;
857    opus_val16 width;
858    opus_val32 xx, xy, yy;
859    opus_val16 sqrt_xx, sqrt_yy;
860    opus_val16 qrrt_xx, qrrt_yy;
861    int frame_rate;
862    int i;
863    opus_val16 short_alpha;
864
865    frame_rate = Fs/frame_size;
866    short_alpha = Q15ONE - 25*Q15ONE/IMAX(50,frame_rate);
867    xx=xy=yy=0;
868    for (i=0;i<frame_size;i+=4)
869    {
870       opus_val32 pxx=0;
871       opus_val32 pxy=0;
872       opus_val32 pyy=0;
873       opus_val16 x, y;
874       x = pcm[2*i];
875       y = pcm[2*i+1];
876       pxx = SHR32(MULT16_16(x,x),2);
877       pxy = SHR32(MULT16_16(x,y),2);
878       pyy = SHR32(MULT16_16(y,y),2);
879       x = pcm[2*i+2];
880       y = pcm[2*i+3];
881       pxx += SHR32(MULT16_16(x,x),2);
882       pxy += SHR32(MULT16_16(x,y),2);
883       pyy += SHR32(MULT16_16(y,y),2);
884       x = pcm[2*i+4];
885       y = pcm[2*i+5];
886       pxx += SHR32(MULT16_16(x,x),2);
887       pxy += SHR32(MULT16_16(x,y),2);
888       pyy += SHR32(MULT16_16(y,y),2);
889       x = pcm[2*i+6];
890       y = pcm[2*i+7];
891       pxx += SHR32(MULT16_16(x,x),2);
892       pxy += SHR32(MULT16_16(x,y),2);
893       pyy += SHR32(MULT16_16(y,y),2);
894
895       xx += SHR32(pxx, 10);
896       xy += SHR32(pxy, 10);
897       yy += SHR32(pyy, 10);
898    }
899    mem->XX += MULT16_32_Q15(short_alpha, xx-mem->XX);
900    mem->XY += MULT16_32_Q15(short_alpha, xy-mem->XY);
901    mem->YY += MULT16_32_Q15(short_alpha, yy-mem->YY);
902    mem->XX = MAX32(0, mem->XX);
903    mem->XY = MAX32(0, mem->XY);
904    mem->YY = MAX32(0, mem->YY);
905    if (MAX32(mem->XX, mem->YY)>QCONST16(8e-4f, 18))
906    {
907       sqrt_xx = celt_sqrt(mem->XX);
908       sqrt_yy = celt_sqrt(mem->YY);
909       qrrt_xx = celt_sqrt(sqrt_xx);
910       qrrt_yy = celt_sqrt(sqrt_yy);
911       /* Inter-channel correlation */
912       mem->XY = MIN32(mem->XY, sqrt_xx*sqrt_yy);
913       corr = SHR32(frac_div32(mem->XY,EPSILON+MULT16_16(sqrt_xx,sqrt_yy)),16);
914       /* Approximate loudness difference */
915       ldiff = Q15ONE*ABS16(qrrt_xx-qrrt_yy)/(EPSILON+qrrt_xx+qrrt_yy);
916       width = MULT16_16_Q15(celt_sqrt(QCONST32(1.f,30)-MULT16_16(corr,corr)), ldiff);
917       /* Smoothing over one second */
918       mem->smoothed_width += (width-mem->smoothed_width)/frame_rate;
919       /* Peak follower */
920       mem->max_follower = MAX16(mem->max_follower-QCONST16(.02f,15)/frame_rate, mem->smoothed_width);
921    } else {
922       width = 0;
923       corr=Q15ONE;
924       ldiff=0;
925    }
926    /*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);*/
927    return EXTRACT16(MIN32(Q15ONE,20*mem->max_follower));
928 }
929
930 opus_int32 opus_encode_native(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
931                 unsigned char *data, opus_int32 out_data_bytes, int lsb_depth,
932                 const void *analysis_pcm, int c1, int c2, int analysis_channels, downmix_func downmix)
933 {
934     void *silk_enc;
935     CELTEncoder *celt_enc;
936     int i;
937     int ret=0;
938     opus_int32 nBytes;
939     ec_enc enc;
940     int bytes_target;
941     int prefill=0;
942     int start_band = 0;
943     int redundancy = 0;
944     int redundancy_bytes = 0; /* Number of bytes to use for redundancy frame */
945     int celt_to_silk = 0;
946     VARDECL(opus_val16, pcm_buf);
947     int nb_compr_bytes;
948     int to_celt = 0;
949     opus_uint32 redundant_rng = 0;
950     int cutoff_Hz, hp_freq_smth1;
951     int voice_est; /* Probability of voice in Q7 */
952     opus_int32 equiv_rate;
953     int delay_compensation;
954     int frame_rate;
955     opus_int32 max_rate; /* Max bitrate we're allowed to use */
956     int curr_bandwidth;
957     opus_val16 HB_gain;
958     opus_int32 max_data_bytes; /* Max number of bytes we're allowed to use */
959     int total_buffer;
960     opus_val16 stereo_width;
961     const CELTMode *celt_mode;
962     AnalysisInfo analysis_info;
963     VARDECL(opus_val16, tmp_prefill);
964
965     ALLOC_STACK;
966
967     max_data_bytes = IMIN(1276, out_data_bytes);
968
969     st->rangeFinal = 0;
970     if ((!st->variable_duration && 400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
971          50*frame_size != st->Fs &&  25*frame_size != st->Fs &&  50*frame_size != 3*st->Fs)
972          || (400*frame_size < st->Fs)
973          || max_data_bytes<=0
974          )
975     {
976        RESTORE_STACK;
977        return OPUS_BAD_ARG;
978     }
979     silk_enc = (char*)st+st->silk_enc_offset;
980     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
981     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
982        delay_compensation = 0;
983     else
984        delay_compensation = st->delay_compensation;
985
986     lsb_depth = IMIN(lsb_depth, st->lsb_depth);
987
988     analysis_info.valid = 0;
989     celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
990 #ifndef DISABLE_FLOAT_API
991     if (st->silk_mode.complexity >= 7 && st->Fs==48000)
992     {
993        frame_size = run_analysis(&st->analysis, celt_mode, pcm, analysis_pcm,
994              frame_size, st->variable_duration, c1, c2, analysis_channels, st->Fs, st->bitrate_bps, delay_compensation, lsb_depth, downmix, &analysis_info);
995     } else
996 #endif
997     {
998        frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
999     }
1000     if(frame_size<0)
1001     {
1002        return OPUS_BAD_ARG;
1003     }
1004
1005
1006     st->voice_ratio = -1;
1007
1008 #ifndef DISABLE_FLOAT_API
1009     st->detected_bandwidth = 0;
1010     if (analysis_info.valid)
1011     {
1012        int analysis_bandwidth;
1013        if (st->signal_type == OPUS_AUTO)
1014           st->voice_ratio = (int)floor(.5+100*(1-analysis_info.music_prob));
1015
1016        analysis_bandwidth = analysis_info.bandwidth;
1017        if (analysis_bandwidth<=12)
1018           st->detected_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1019        else if (analysis_bandwidth<=14)
1020           st->detected_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1021        else if (analysis_bandwidth<=16)
1022           st->detected_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1023        else if (analysis_bandwidth<=18)
1024           st->detected_bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1025        else
1026           st->detected_bandwidth = OPUS_BANDWIDTH_FULLBAND;
1027     }
1028 #endif
1029
1030     if (st->channels==2 && st->force_channels!=1)
1031        stereo_width = compute_stereo_width(pcm, frame_size, st->Fs, &st->width_mem);
1032     else
1033        stereo_width = 0;
1034     total_buffer = delay_compensation;
1035     st->bitrate_bps = user_bitrate_to_bitrate(st, frame_size, max_data_bytes);
1036
1037     frame_rate = st->Fs/frame_size;
1038     if (max_data_bytes<3 || st->bitrate_bps < 3*frame_rate*8
1039        || (frame_rate<50 && (max_data_bytes*frame_rate<300 || st->bitrate_bps < 2400)))
1040     {
1041        /*If the space is too low to do something useful, emit 'PLC' frames.*/
1042        int tocmode = st->mode;
1043        int bw = st->bandwidth == 0 ? OPUS_BANDWIDTH_NARROWBAND : st->bandwidth;
1044        if (tocmode==0)
1045           tocmode = MODE_SILK_ONLY;
1046        if (frame_rate>100)
1047           tocmode = MODE_CELT_ONLY;
1048        if (frame_rate < 50)
1049           tocmode = MODE_SILK_ONLY;
1050        if(tocmode==MODE_SILK_ONLY&&bw>OPUS_BANDWIDTH_WIDEBAND)
1051           bw=OPUS_BANDWIDTH_WIDEBAND;
1052        else if (tocmode==MODE_CELT_ONLY&&bw==OPUS_BANDWIDTH_MEDIUMBAND)
1053           bw=OPUS_BANDWIDTH_NARROWBAND;
1054        else if (bw<=OPUS_BANDWIDTH_SUPERWIDEBAND)
1055           bw=OPUS_BANDWIDTH_SUPERWIDEBAND;
1056        data[0] = gen_toc(tocmode, frame_rate, bw, st->stream_channels);
1057        RESTORE_STACK;
1058        return 1;
1059     }
1060     if (!st->use_vbr)
1061     {
1062        int cbrBytes;
1063        cbrBytes = IMIN( (st->bitrate_bps + 4*frame_rate)/(8*frame_rate) , max_data_bytes);
1064        st->bitrate_bps = cbrBytes * (8*frame_rate);
1065        max_data_bytes = cbrBytes;
1066     }
1067     max_rate = frame_rate*max_data_bytes*8;
1068
1069     /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */
1070     equiv_rate = st->bitrate_bps - 60*(st->Fs/frame_size - 50);
1071
1072     if (st->signal_type == OPUS_SIGNAL_VOICE)
1073        voice_est = 127;
1074     else if (st->signal_type == OPUS_SIGNAL_MUSIC)
1075        voice_est = 0;
1076     else if (st->voice_ratio >= 0)
1077     {
1078        voice_est = st->voice_ratio*327>>8;
1079        /* For AUDIO, never be more than 90% confident of having speech */
1080        if (st->application == OPUS_APPLICATION_AUDIO)
1081           voice_est = IMIN(voice_est, 115);
1082     } else if (st->application == OPUS_APPLICATION_VOIP)
1083        voice_est = 115;
1084     else
1085        voice_est = 48;
1086
1087     if (st->force_channels!=OPUS_AUTO && st->channels == 2)
1088     {
1089         st->stream_channels = st->force_channels;
1090     } else {
1091 #ifdef FUZZING
1092        /* Random mono/stereo decision */
1093        if (st->channels == 2 && (rand()&0x1F)==0)
1094           st->stream_channels = 3-st->stream_channels;
1095 #else
1096        /* Rate-dependent mono-stereo decision */
1097        if (st->channels == 2)
1098        {
1099           opus_int32 stereo_threshold;
1100           stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14);
1101           if (st->stream_channels == 2)
1102              stereo_threshold -= 1000;
1103           else
1104              stereo_threshold += 1000;
1105           st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1;
1106        } else {
1107           st->stream_channels = st->channels;
1108        }
1109 #endif
1110     }
1111
1112     /* Mode selection depending on application and signal type */
1113     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1114     {
1115        st->mode = MODE_CELT_ONLY;
1116     } else if (st->user_forced_mode == OPUS_AUTO)
1117     {
1118 #ifdef FUZZING
1119        /* Random mode switching */
1120        if ((rand()&0xF)==0)
1121        {
1122           if ((rand()&0x1)==0)
1123              st->mode = MODE_CELT_ONLY;
1124           else
1125              st->mode = MODE_SILK_ONLY;
1126        } else {
1127           if (st->prev_mode==MODE_CELT_ONLY)
1128              st->mode = MODE_CELT_ONLY;
1129           else
1130              st->mode = MODE_SILK_ONLY;
1131        }
1132 #else
1133        opus_int32 mode_voice, mode_music;
1134        opus_int32 threshold;
1135
1136        /* Interpolate based on stereo width */
1137        mode_voice = (opus_int32)(MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[0][0])
1138              + MULT16_32_Q15(stereo_width,mode_thresholds[1][0]));
1139        mode_music = (opus_int32)(MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[1][1])
1140              + MULT16_32_Q15(stereo_width,mode_thresholds[1][1]));
1141        /* Interpolate based on speech/music probability */
1142        threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14);
1143        /* Bias towards SILK for VoIP because of some useful features */
1144        if (st->application == OPUS_APPLICATION_VOIP)
1145           threshold += 8000;
1146
1147        /*printf("%f %d\n", stereo_width/(float)Q15ONE, threshold);*/
1148        /* Hysteresis */
1149        if (st->prev_mode == MODE_CELT_ONLY)
1150            threshold -= 4000;
1151        else if (st->prev_mode>0)
1152            threshold += 4000;
1153
1154        st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY;
1155
1156        /* When FEC is enabled and there's enough packet loss, use SILK */
1157        if (st->silk_mode.useInBandFEC && st->silk_mode.packetLossPercentage > (128-voice_est)>>4)
1158           st->mode = MODE_SILK_ONLY;
1159        /* When encoding voice and DTX is enabled, set the encoder to SILK mode (at least for now) */
1160        if (st->silk_mode.useDTX && voice_est > 100)
1161           st->mode = MODE_SILK_ONLY;
1162 #endif
1163     } else {
1164        st->mode = st->user_forced_mode;
1165     }
1166
1167     /* Override the chosen mode to make sure we meet the requested frame size */
1168     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
1169        st->mode = MODE_CELT_ONLY;
1170
1171     if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0
1172           && st->mode != MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)
1173     {
1174        /* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */
1175        st->silk_mode.toMono = 1;
1176        st->stream_channels = 2;
1177     } else {
1178        st->silk_mode.toMono = 0;
1179     }
1180
1181     if (st->prev_mode > 0 &&
1182         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
1183     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
1184     {
1185         redundancy = 1;
1186         celt_to_silk = (st->mode != MODE_CELT_ONLY);
1187         if (!celt_to_silk)
1188         {
1189             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
1190             if (frame_size >= st->Fs/100)
1191             {
1192                 st->mode = st->prev_mode;
1193                 to_celt = 1;
1194             } else {
1195                 redundancy=0;
1196             }
1197         }
1198     }
1199     /* For the first frame at a new SILK bandwidth */
1200     if (st->silk_bw_switch)
1201     {
1202        redundancy = 1;
1203        celt_to_silk = 1;
1204        st->silk_bw_switch = 0;
1205        prefill=1;
1206     }
1207
1208     if (redundancy)
1209     {
1210        /* Fair share of the max size allowed */
1211        redundancy_bytes = IMIN(257, max_data_bytes*(opus_int32)(st->Fs/200)/(frame_size+st->Fs/200));
1212        /* For VBR, target the actual bitrate (subject to the limit above) */
1213        if (st->use_vbr)
1214           redundancy_bytes = IMIN(redundancy_bytes, st->bitrate_bps/1600);
1215     }
1216
1217     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
1218     {
1219         silk_EncControlStruct dummy;
1220         silk_InitEncoder( silk_enc, &dummy);
1221         prefill=1;
1222     }
1223
1224     /* Automatic (rate-dependent) bandwidth selection */
1225     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
1226     {
1227         const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds;
1228         opus_int32 bandwidth_thresholds[8];
1229         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
1230         opus_int32 equiv_rate2;
1231
1232         equiv_rate2 = equiv_rate;
1233         if (st->mode != MODE_CELT_ONLY)
1234         {
1235            /* Adjust the threshold +/- 10% depending on complexity */
1236            equiv_rate2 = equiv_rate2 * (45+st->silk_mode.complexity)/50;
1237            /* CBR is less efficient by ~1 kb/s */
1238            if (!st->use_vbr)
1239               equiv_rate2 -= 1000;
1240         }
1241         if (st->channels==2 && st->force_channels!=1)
1242         {
1243            voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds;
1244            music_bandwidth_thresholds = stereo_music_bandwidth_thresholds;
1245         } else {
1246            voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds;
1247            music_bandwidth_thresholds = mono_music_bandwidth_thresholds;
1248         }
1249         /* Interpolate bandwidth thresholds depending on voice estimation */
1250         for (i=0;i<8;i++)
1251         {
1252            bandwidth_thresholds[i] = music_bandwidth_thresholds[i]
1253                     + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14);
1254         }
1255         do {
1256             int threshold, hysteresis;
1257             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
1258             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
1259             if (!st->first)
1260             {
1261                 if (st->bandwidth >= bandwidth)
1262                     threshold -= hysteresis;
1263                 else
1264                     threshold += hysteresis;
1265             }
1266             if (equiv_rate2 >= threshold)
1267                 break;
1268         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
1269         st->bandwidth = bandwidth;
1270         /* Prevents any transition to SWB/FB until the SILK layer has fully
1271            switched to WB mode and turned the variable LP filter off */
1272         if (!st->first && st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1273             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1274     }
1275
1276     if (st->bandwidth>st->max_bandwidth)
1277        st->bandwidth = st->max_bandwidth;
1278
1279     if (st->user_bandwidth != OPUS_AUTO)
1280         st->bandwidth = st->user_bandwidth;
1281
1282     /* This prevents us from using hybrid at unsafe CBR/max rates */
1283     if (st->mode != MODE_CELT_ONLY && max_rate < 15000)
1284     {
1285        st->bandwidth = IMIN(st->bandwidth, OPUS_BANDWIDTH_WIDEBAND);
1286     }
1287
1288     /* Prevents Opus from wasting bits on frequencies that are above
1289        the Nyquist rate of the input signal */
1290     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
1291         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1292     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1293         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1294     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
1295         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1296     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
1297         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1298 #ifndef FIXED_POINT
1299     /* Use detected bandwidth to reduce the encoded bandwidth. */
1300     if (st->detected_bandwidth && st->user_bandwidth == OPUS_AUTO)
1301     {
1302        int min_detected_bandwidth;
1303        /* Makes bandwidth detection more conservative just in case the detector
1304           gets it wrong when we could have coded a high bandwidth transparently.
1305           When operating in SILK/hybrid mode, we don't go below wideband to avoid
1306           more complicated switches that require redundancy. */
1307        if (st->bitrate_bps <= 18000*st->stream_channels && st->mode == MODE_CELT_ONLY)
1308           min_detected_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1309        else if (st->bitrate_bps <= 24000*st->stream_channels && st->mode == MODE_CELT_ONLY)
1310           min_detected_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1311        else if (st->bitrate_bps <= 30000*st->stream_channels)
1312           min_detected_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1313        else if (st->bitrate_bps <= 44000*st->stream_channels)
1314           min_detected_bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1315        else
1316           min_detected_bandwidth = OPUS_BANDWIDTH_FULLBAND;
1317
1318        st->detected_bandwidth = IMAX(st->detected_bandwidth, min_detected_bandwidth);
1319        st->bandwidth = IMIN(st->bandwidth, st->detected_bandwidth);
1320     }
1321 #endif
1322     celt_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(lsb_depth));
1323
1324     /* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */
1325     if (max_data_bytes < (frame_rate > 50 ? 12000 : 8000)*frame_size / (st->Fs * 8))
1326        st->mode = MODE_CELT_ONLY;
1327
1328     /* CELT mode doesn't support mediumband, use wideband instead */
1329     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1330         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1331     if (st->lfe)
1332     {
1333        st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1334        st->mode = MODE_CELT_ONLY;
1335     }
1336
1337     /* Can't support higher than wideband for >20 ms frames */
1338     if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND))
1339     {
1340        VARDECL(unsigned char, tmp_data);
1341        int nb_frames;
1342        int bak_mode, bak_bandwidth, bak_channels, bak_to_mono;
1343        VARDECL(OpusRepacketizer, rp);
1344        opus_int32 bytes_per_frame;
1345
1346
1347        nb_frames = frame_size > st->Fs/25 ? 3 : 2;
1348        bytes_per_frame = IMIN(1276,(out_data_bytes-3)/nb_frames);
1349
1350        ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char);
1351
1352        ALLOC(rp, 1, OpusRepacketizer);
1353        opus_repacketizer_init(rp);
1354
1355        bak_mode = st->user_forced_mode;
1356        bak_bandwidth = st->user_bandwidth;
1357        bak_channels = st->force_channels;
1358
1359        st->user_forced_mode = st->mode;
1360        st->user_bandwidth = st->bandwidth;
1361        st->force_channels = st->stream_channels;
1362        bak_to_mono = st->silk_mode.toMono;
1363
1364        if (bak_to_mono)
1365           st->force_channels = 1;
1366        else
1367           st->prev_channels = st->stream_channels;
1368        for (i=0;i<nb_frames;i++)
1369        {
1370           int tmp_len;
1371           st->silk_mode.toMono = 0;
1372           /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
1373           if (to_celt && i==nb_frames-1)
1374              st->user_forced_mode = MODE_CELT_ONLY;
1375           tmp_len = opus_encode_native(st, pcm+i*(st->channels*st->Fs/50), st->Fs/50,
1376                 tmp_data+i*bytes_per_frame, bytes_per_frame, lsb_depth,
1377                 analysis_pcm, c1, c2, analysis_channels, downmix);
1378           if (tmp_len<0)
1379           {
1380              RESTORE_STACK;
1381              return OPUS_INTERNAL_ERROR;
1382           }
1383           ret = opus_repacketizer_cat(rp, tmp_data+i*bytes_per_frame, tmp_len);
1384           if (ret<0)
1385           {
1386              RESTORE_STACK;
1387              return OPUS_INTERNAL_ERROR;
1388           }
1389        }
1390        ret = opus_repacketizer_out(rp, data, out_data_bytes);
1391        if (ret<0)
1392        {
1393           RESTORE_STACK;
1394           return OPUS_INTERNAL_ERROR;
1395        }
1396        st->user_forced_mode = bak_mode;
1397        st->user_bandwidth = bak_bandwidth;
1398        st->force_channels = bak_channels;
1399        st->silk_mode.toMono = bak_to_mono;
1400        RESTORE_STACK;
1401        return ret;
1402     }
1403     curr_bandwidth = st->bandwidth;
1404
1405     /* Chooses the appropriate mode for speech
1406        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
1407     if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1408         st->mode = MODE_HYBRID;
1409     if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
1410         st->mode = MODE_SILK_ONLY;
1411
1412     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
1413     bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
1414
1415     data += 1;
1416
1417     ec_enc_init(&enc, data, max_data_bytes-1);
1418
1419     ALLOC(pcm_buf, (total_buffer+frame_size)*st->channels, opus_val16);
1420     for (i=0;i<total_buffer*st->channels;i++)
1421        pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-total_buffer)*st->channels+i];
1422
1423     if (st->mode == MODE_CELT_ONLY)
1424        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1425     else
1426        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
1427
1428     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
1429           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
1430
1431     /* convert from log scale to Hertz */
1432     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
1433
1434     if (st->application == OPUS_APPLICATION_VOIP)
1435     {
1436        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1437     } else {
1438        dc_reject(pcm, 3, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1439     }
1440
1441
1442
1443     /* SILK processing */
1444     HB_gain = Q15ONE;
1445     if (st->mode != MODE_CELT_ONLY)
1446     {
1447         opus_int32 total_bitRate, celt_rate;
1448 #ifdef FIXED_POINT
1449        const opus_int16 *pcm_silk;
1450 #else
1451        VARDECL(opus_int16, pcm_silk);
1452        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
1453 #endif
1454
1455         /* Distribute bits between SILK and CELT */
1456         total_bitRate = 8 * bytes_target * frame_rate;
1457         if( st->mode == MODE_HYBRID ) {
1458             int HB_gain_ref;
1459             /* Base rate for SILK */
1460             st->silk_mode.bitRate = st->stream_channels * ( 5000 + 1000 * ( st->Fs == 100 * frame_size ) );
1461             if( curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
1462                 /* SILK gets 2/3 of the remaining bits */
1463                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 2 / 3;
1464             } else { /* FULLBAND */
1465                 /* SILK gets 3/5 of the remaining bits */
1466                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 3 / 5;
1467             }
1468             /* Don't let SILK use more than 80% */
1469             if( st->silk_mode.bitRate > total_bitRate * 4/5 ) {
1470                 st->silk_mode.bitRate = total_bitRate * 4/5;
1471             }
1472             /* Increasingly attenuate high band when it gets allocated fewer bits */
1473             celt_rate = total_bitRate - st->silk_mode.bitRate;
1474             HB_gain_ref = (curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND) ? 3000 : 3600;
1475             HB_gain = SHL32((opus_val32)celt_rate, 9) / SHR32((opus_val32)celt_rate + st->stream_channels * HB_gain_ref, 6);
1476             HB_gain = HB_gain < Q15ONE*6/7 ? HB_gain + Q15ONE/7 : Q15ONE;
1477         } else {
1478             /* SILK gets all bits */
1479             st->silk_mode.bitRate = total_bitRate;
1480         }
1481
1482         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
1483         st->silk_mode.nChannelsAPI = st->channels;
1484         st->silk_mode.nChannelsInternal = st->stream_channels;
1485         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1486             st->silk_mode.desiredInternalSampleRate = 8000;
1487         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1488             st->silk_mode.desiredInternalSampleRate = 12000;
1489         } else {
1490             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
1491             st->silk_mode.desiredInternalSampleRate = 16000;
1492         }
1493         if( st->mode == MODE_HYBRID ) {
1494             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
1495             st->silk_mode.minInternalSampleRate = 16000;
1496         } else {
1497             st->silk_mode.minInternalSampleRate = 8000;
1498         }
1499
1500         if (st->mode == MODE_SILK_ONLY)
1501         {
1502            opus_int32 effective_max_rate = max_rate;
1503            st->silk_mode.maxInternalSampleRate = 16000;
1504            if (frame_rate > 50)
1505               effective_max_rate = effective_max_rate*2/3;
1506            if (effective_max_rate < 13000)
1507            {
1508               st->silk_mode.maxInternalSampleRate = 12000;
1509               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
1510            }
1511            if (effective_max_rate < 9600)
1512            {
1513               st->silk_mode.maxInternalSampleRate = 8000;
1514               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
1515            }
1516         } else {
1517            st->silk_mode.maxInternalSampleRate = 16000;
1518         }
1519
1520         st->silk_mode.useCBR = !st->use_vbr;
1521
1522         /* Call SILK encoder for the low band */
1523         nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes);
1524
1525         st->silk_mode.maxBits = nBytes*8;
1526         /* Only allow up to 90% of the bits for hybrid mode*/
1527         if (st->mode == MODE_HYBRID)
1528            st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
1529         if (st->silk_mode.useCBR)
1530         {
1531            st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
1532            /* Reduce the initial target to make it easier to reach the CBR rate */
1533            st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000);
1534         }
1535
1536         if (prefill)
1537         {
1538             opus_int32 zero=0;
1539             int prefill_offset;
1540             /* Use a smooth onset for the SILK prefill to avoid the encoder trying to encode
1541                a discontinuity. The exact location is what we need to avoid leaving any "gap"
1542                in the audio when mixing with the redundant CELT frame. Here we can afford to
1543                overwrite st->delay_buffer because the only thing that uses it before it gets
1544                rewritten is tmp_prefill[] and even then only the part after the ramp really
1545                gets used (rather than sent to the encoder and discarded) */
1546             prefill_offset = st->channels*(st->encoder_buffer-st->delay_compensation-st->Fs/400);
1547             gain_fade(st->delay_buffer+prefill_offset, st->delay_buffer+prefill_offset,
1548                   0, Q15ONE, celt_mode->overlap, st->Fs/400, st->channels, celt_mode->window, st->Fs);
1549             for(i=0;i<prefill_offset;i++)
1550                st->delay_buffer[i]=0;
1551 #ifdef FIXED_POINT
1552             pcm_silk = st->delay_buffer;
1553 #else
1554             for (i=0;i<st->encoder_buffer*st->channels;i++)
1555                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
1556 #endif
1557             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
1558         }
1559
1560 #ifdef FIXED_POINT
1561         pcm_silk = pcm_buf+total_buffer*st->channels;
1562 #else
1563         for (i=0;i<frame_size*st->channels;i++)
1564             pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
1565 #endif
1566         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
1567         if( ret ) {
1568             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
1569             /* Handle error */
1570            RESTORE_STACK;
1571            return OPUS_INTERNAL_ERROR;
1572         }
1573         if (nBytes==0)
1574         {
1575            st->rangeFinal = 0;
1576            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1577            RESTORE_STACK;
1578            return 1;
1579         }
1580         /* Extract SILK internal bandwidth for signaling in first byte */
1581         if( st->mode == MODE_SILK_ONLY ) {
1582             if( st->silk_mode.internalSampleRate == 8000 ) {
1583                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1584             } else if( st->silk_mode.internalSampleRate == 12000 ) {
1585                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1586             } else if( st->silk_mode.internalSampleRate == 16000 ) {
1587                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1588             }
1589         } else {
1590             silk_assert( st->silk_mode.internalSampleRate == 16000 );
1591         }
1592
1593         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
1594         /* FIXME: How do we allocate the redundancy for CBR? */
1595         if (st->silk_mode.opusCanSwitch)
1596         {
1597            redundancy = 1;
1598            celt_to_silk = 0;
1599            st->silk_bw_switch = 1;
1600         }
1601     }
1602
1603     /* CELT processing */
1604     {
1605         int endband=21;
1606
1607         switch(curr_bandwidth)
1608         {
1609             case OPUS_BANDWIDTH_NARROWBAND:
1610                 endband = 13;
1611                 break;
1612             case OPUS_BANDWIDTH_MEDIUMBAND:
1613             case OPUS_BANDWIDTH_WIDEBAND:
1614                 endband = 17;
1615                 break;
1616             case OPUS_BANDWIDTH_SUPERWIDEBAND:
1617                 endband = 19;
1618                 break;
1619             case OPUS_BANDWIDTH_FULLBAND:
1620                 endband = 21;
1621                 break;
1622         }
1623         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
1624         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
1625     }
1626     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1627     if (st->mode != MODE_SILK_ONLY)
1628     {
1629         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1630         /* Allow prediction unless we decide to disable it later */
1631         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
1632
1633         if (st->mode == MODE_HYBRID)
1634         {
1635             int len;
1636
1637             len = (ec_tell(&enc)+7)>>3;
1638             if (redundancy)
1639                len += st->mode == MODE_HYBRID ? 3 : 1;
1640             if( st->use_vbr ) {
1641                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
1642             } else {
1643                 /* check if SILK used up too much */
1644                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
1645             }
1646         } else {
1647             if (st->use_vbr)
1648             {
1649                 opus_int32 bonus=0;
1650 #ifndef DISABLE_FLOAT_API
1651                 if (st->variable_duration==OPUS_FRAMESIZE_VARIABLE && frame_size != st->Fs/50)
1652                 {
1653                    bonus = (60*st->stream_channels+40)*(st->Fs/frame_size-50);
1654                    if (analysis_info.valid)
1655                       bonus = (opus_int32)(bonus*(1.f+.5f*analysis_info.tonality));
1656                 }
1657 #endif
1658                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
1659                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
1660                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps+bonus));
1661                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
1662             } else {
1663                 nb_compr_bytes = bytes_target;
1664             }
1665         }
1666
1667     } else {
1668         nb_compr_bytes = 0;
1669     }
1670
1671     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
1672     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
1673     {
1674        for (i=0;i<st->channels*st->Fs/400;i++)
1675           tmp_prefill[i] = st->delay_buffer[(st->encoder_buffer-total_buffer-st->Fs/400)*st->channels + i];
1676     }
1677
1678     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+total_buffer));i++)
1679         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
1680     for (;i<st->encoder_buffer*st->channels;i++)
1681         st->delay_buffer[i] = pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels+i];
1682
1683     /* gain_fade() and stereo_fade() need to be after the buffer copying
1684        because we don't want any of this to affect the SILK part */
1685     if( st->prev_HB_gain < Q15ONE || HB_gain < Q15ONE ) {
1686        gain_fade(pcm_buf, pcm_buf,
1687              st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs);
1688     }
1689     st->prev_HB_gain = HB_gain;
1690     if (st->mode != MODE_HYBRID || st->stream_channels==1)
1691        st->silk_mode.stereoWidth_Q14 = IMIN((1<<14),IMAX(0,st->bitrate_bps-32000));
1692     if( !st->energy_masking && st->channels == 2 ) {
1693         /* Apply stereo width reduction (at low bitrates) */
1694         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1695             opus_val16 g1, g2;
1696             g1 = st->hybrid_stereo_width_Q14;
1697             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1698 #ifdef FIXED_POINT
1699             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
1700             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
1701 #else
1702             g1 *= (1.f/16384);
1703             g2 *= (1.f/16384);
1704 #endif
1705             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
1706                   frame_size, st->channels, celt_mode->window, st->Fs);
1707             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1708         }
1709     }
1710
1711     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
1712     {
1713         /* For SILK mode, the redundancy is inferred from the length */
1714         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
1715            ec_enc_bit_logp(&enc, redundancy, 12);
1716         if (redundancy)
1717         {
1718             int max_redundancy;
1719             ec_enc_bit_logp(&enc, celt_to_silk, 1);
1720             if (st->mode == MODE_HYBRID)
1721                max_redundancy = (max_data_bytes-1)-nb_compr_bytes-1;
1722             else
1723                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1724             /* Target the same bit-rate for redundancy as for the rest,
1725                up to a max of 257 bytes */
1726             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
1727             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
1728             if (st->mode == MODE_HYBRID)
1729                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
1730         }
1731     } else {
1732         redundancy = 0;
1733     }
1734
1735     if (!redundancy)
1736     {
1737        st->silk_bw_switch = 0;
1738        redundancy_bytes = 0;
1739     }
1740     if (st->mode != MODE_CELT_ONLY)start_band=17;
1741
1742     if (st->mode == MODE_SILK_ONLY)
1743     {
1744         ret = (ec_tell(&enc)+7)>>3;
1745         ec_enc_done(&enc);
1746         nb_compr_bytes = ret;
1747     } else {
1748        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
1749        ec_enc_shrink(&enc, nb_compr_bytes);
1750     }
1751
1752 #ifndef DISABLE_FLOAT_API
1753     if (redundancy || st->mode != MODE_SILK_ONLY)
1754        celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(&analysis_info));
1755 #endif
1756
1757     /* 5 ms redundant frame for CELT->SILK */
1758     if (redundancy && celt_to_silk)
1759     {
1760         int err;
1761         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1762         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1763         err = celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
1764         if (err < 0)
1765         {
1766            RESTORE_STACK;
1767            return OPUS_INTERNAL_ERROR;
1768         }
1769         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1770         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1771     }
1772
1773     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
1774
1775     if (st->mode != MODE_SILK_ONLY)
1776     {
1777         if (st->mode != st->prev_mode && st->prev_mode > 0)
1778         {
1779            unsigned char dummy[2];
1780            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1781
1782            /* Prefilling */
1783            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
1784            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1785         }
1786         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
1787         if (ec_tell(&enc) <= 8*nb_compr_bytes)
1788         {
1789            ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
1790            if (ret < 0)
1791            {
1792               RESTORE_STACK;
1793               return OPUS_INTERNAL_ERROR;
1794            }
1795         }
1796     }
1797
1798     /* 5 ms redundant frame for SILK->CELT */
1799     if (redundancy && !celt_to_silk)
1800     {
1801         int err;
1802         unsigned char dummy[2];
1803         int N2, N4;
1804         N2 = st->Fs/200;
1805         N4 = st->Fs/400;
1806
1807         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1808         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1809         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1810
1811         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1812         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL);
1813
1814         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1815         if (err < 0)
1816         {
1817            RESTORE_STACK;
1818            return OPUS_INTERNAL_ERROR;
1819         }
1820         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1821     }
1822
1823
1824
1825     /* Signalling the mode in the first byte */
1826     data--;
1827     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1828
1829     st->rangeFinal = enc.rng ^ redundant_rng;
1830
1831     if (to_celt)
1832         st->prev_mode = MODE_CELT_ONLY;
1833     else
1834         st->prev_mode = st->mode;
1835     st->prev_channels = st->stream_channels;
1836     st->prev_framesize = frame_size;
1837
1838     st->first = 0;
1839
1840     /* In the unlikely case that the SILK encoder busted its target, tell
1841        the decoder to call the PLC */
1842     if (ec_tell(&enc) > (max_data_bytes-1)*8)
1843     {
1844        if (max_data_bytes < 2)
1845        {
1846           RESTORE_STACK;
1847           return OPUS_BUFFER_TOO_SMALL;
1848        }
1849        data[1] = 0;
1850        ret = 1;
1851        st->rangeFinal = 0;
1852     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
1853     {
1854        /*When in LPC only mode it's perfectly
1855          reasonable to strip off trailing zero bytes as
1856          the required range decoder behavior is to
1857          fill these in. This can't be done when the MDCT
1858          modes are used because the decoder needs to know
1859          the actual length for allocation purposes.*/
1860        while(ret>2&&data[ret]==0)ret--;
1861     }
1862     /* Count ToC and redundancy */
1863     ret += 1+redundancy_bytes;
1864     if (!st->use_vbr && ret >= 3)
1865     {
1866        if (pad_frame(data, ret, max_data_bytes))
1867        {
1868           RESTORE_STACK;
1869           return OPUS_INTERNAL_ERROR;
1870        }
1871        ret = max_data_bytes;
1872     }
1873     RESTORE_STACK;
1874     return ret;
1875 }
1876
1877 #ifdef FIXED_POINT
1878
1879 #ifndef DISABLE_FLOAT_API
1880 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1881       unsigned char *data, opus_int32 max_data_bytes)
1882 {
1883    int i, ret;
1884    VARDECL(opus_int16, in);
1885    ALLOC_STACK;
1886
1887    frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1888    if(frame_size<0)
1889    {
1890       RESTORE_STACK;
1891       return OPUS_BAD_ARG;
1892    }
1893
1894    ALLOC(in, frame_size*st->channels, opus_int16);
1895
1896    for (i=0;i<frame_size*st->channels;i++)
1897       in[i] = FLOAT2INT16(pcm[i]);
1898    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16, pcm, 0, -2, st->channels, downmix_float);
1899    RESTORE_STACK;
1900    return ret;
1901 }
1902 #endif
1903
1904 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1905                 unsigned char *data, opus_int32 out_data_bytes)
1906 {
1907    frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1908    if(frame_size<0)
1909    {
1910       return OPUS_BAD_ARG;
1911    }
1912    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 16, pcm, 0, -2, st->channels, downmix_int);
1913 }
1914
1915 #else
1916 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1917       unsigned char *data, opus_int32 max_data_bytes)
1918 {
1919    int i, ret;
1920    VARDECL(float, in);
1921    ALLOC_STACK;
1922
1923    ALLOC(in, frame_size*st->channels, float);
1924
1925    for (i=0;i<frame_size*st->channels;i++)
1926       in[i] = (1.0f/32768)*pcm[i];
1927    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16, pcm, 0, -2, st->channels, downmix_int);
1928    RESTORE_STACK;
1929    return ret;
1930 }
1931 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1932                       unsigned char *data, opus_int32 out_data_bytes)
1933 {
1934    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 24, pcm, 0, -2, st->channels, downmix_float);
1935 }
1936 #endif
1937
1938
1939 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
1940 {
1941     int ret;
1942     CELTEncoder *celt_enc;
1943     va_list ap;
1944
1945     ret = OPUS_OK;
1946     va_start(ap, request);
1947
1948     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1949
1950     switch (request)
1951     {
1952         case OPUS_SET_APPLICATION_REQUEST:
1953         {
1954             opus_int32 value = va_arg(ap, opus_int32);
1955             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
1956                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1957                || (!st->first && st->application != value))
1958             {
1959                ret = OPUS_BAD_ARG;
1960                break;
1961             }
1962             st->application = value;
1963         }
1964         break;
1965         case OPUS_GET_APPLICATION_REQUEST:
1966         {
1967             opus_int32 *value = va_arg(ap, opus_int32*);
1968             if (!value)
1969             {
1970                goto bad_arg;
1971             }
1972             *value = st->application;
1973         }
1974         break;
1975         case OPUS_SET_BITRATE_REQUEST:
1976         {
1977             opus_int32 value = va_arg(ap, opus_int32);
1978             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1979             {
1980                 if (value <= 0)
1981                     goto bad_arg;
1982                 else if (value <= 500)
1983                     value = 500;
1984                 else if (value > (opus_int32)300000*st->channels)
1985                     value = (opus_int32)300000*st->channels;
1986             }
1987             st->user_bitrate_bps = value;
1988         }
1989         break;
1990         case OPUS_GET_BITRATE_REQUEST:
1991         {
1992             opus_int32 *value = va_arg(ap, opus_int32*);
1993             if (!value)
1994             {
1995                goto bad_arg;
1996             }
1997             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
1998         }
1999         break;
2000         case OPUS_SET_FORCE_CHANNELS_REQUEST:
2001         {
2002             opus_int32 value = va_arg(ap, opus_int32);
2003             if((value<1 || value>st->channels) && value != OPUS_AUTO)
2004             {
2005                goto bad_arg;
2006             }
2007             st->force_channels = value;
2008         }
2009         break;
2010         case OPUS_GET_FORCE_CHANNELS_REQUEST:
2011         {
2012             opus_int32 *value = va_arg(ap, opus_int32*);
2013             if (!value)
2014             {
2015                goto bad_arg;
2016             }
2017             *value = st->force_channels;
2018         }
2019         break;
2020         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
2021         {
2022             opus_int32 value = va_arg(ap, opus_int32);
2023             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) 
2024             {
2025                goto bad_arg;
2026             }
2027             st->max_bandwidth = value;
2028             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2029                 st->silk_mode.maxInternalSampleRate = 8000;
2030             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2031                 st->silk_mode.maxInternalSampleRate = 12000;
2032             } else {
2033                 st->silk_mode.maxInternalSampleRate = 16000;
2034             }
2035         }
2036         break;
2037         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
2038         {
2039             opus_int32 *value = va_arg(ap, opus_int32*);
2040             if (!value)
2041             {
2042                goto bad_arg;
2043             }
2044             *value = st->max_bandwidth;
2045         }
2046         break;
2047         case OPUS_SET_BANDWIDTH_REQUEST:
2048         {
2049             opus_int32 value = va_arg(ap, opus_int32);
2050             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
2051             {
2052                goto bad_arg;
2053             }
2054             st->user_bandwidth = value;
2055             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2056                 st->silk_mode.maxInternalSampleRate = 8000;
2057             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2058                 st->silk_mode.maxInternalSampleRate = 12000;
2059             } else {
2060                 st->silk_mode.maxInternalSampleRate = 16000;
2061             }
2062         }
2063         break;
2064         case OPUS_GET_BANDWIDTH_REQUEST:
2065         {
2066             opus_int32 *value = va_arg(ap, opus_int32*);
2067             if (!value)
2068             {
2069                goto bad_arg;
2070             }
2071             *value = st->bandwidth;
2072         }
2073         break;
2074         case OPUS_SET_DTX_REQUEST:
2075         {
2076             opus_int32 value = va_arg(ap, opus_int32);
2077             if(value<0 || value>1)
2078             {
2079                goto bad_arg;
2080             }
2081             st->silk_mode.useDTX = value;
2082         }
2083         break;
2084         case OPUS_GET_DTX_REQUEST:
2085         {
2086             opus_int32 *value = va_arg(ap, opus_int32*);
2087             if (!value)
2088             {
2089                goto bad_arg;
2090             }
2091             *value = st->silk_mode.useDTX;
2092         }
2093         break;
2094         case OPUS_SET_COMPLEXITY_REQUEST:
2095         {
2096             opus_int32 value = va_arg(ap, opus_int32);
2097             if(value<0 || value>10)
2098             {
2099                goto bad_arg;
2100             }
2101             st->silk_mode.complexity = value;
2102             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
2103         }
2104         break;
2105         case OPUS_GET_COMPLEXITY_REQUEST:
2106         {
2107             opus_int32 *value = va_arg(ap, opus_int32*);
2108             if (!value)
2109             {
2110                goto bad_arg;
2111             }
2112             *value = st->silk_mode.complexity;
2113         }
2114         break;
2115         case OPUS_SET_INBAND_FEC_REQUEST:
2116         {
2117             opus_int32 value = va_arg(ap, opus_int32);
2118             if(value<0 || value>1)
2119             {
2120                goto bad_arg;
2121             }
2122             st->silk_mode.useInBandFEC = value;
2123         }
2124         break;
2125         case OPUS_GET_INBAND_FEC_REQUEST:
2126         {
2127             opus_int32 *value = va_arg(ap, opus_int32*);
2128             if (!value)
2129             {
2130                goto bad_arg;
2131             }
2132             *value = st->silk_mode.useInBandFEC;
2133         }
2134         break;
2135         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
2136         {
2137             opus_int32 value = va_arg(ap, opus_int32);
2138             if (value < 0 || value > 100)
2139             {
2140                goto bad_arg;
2141             }
2142             st->silk_mode.packetLossPercentage = value;
2143             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
2144         }
2145         break;
2146         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
2147         {
2148             opus_int32 *value = va_arg(ap, opus_int32*);
2149             if (!value)
2150             {
2151                goto bad_arg;
2152             }
2153             *value = st->silk_mode.packetLossPercentage;
2154         }
2155         break;
2156         case OPUS_SET_VBR_REQUEST:
2157         {
2158             opus_int32 value = va_arg(ap, opus_int32);
2159             if(value<0 || value>1)
2160             {
2161                goto bad_arg;
2162             }
2163             st->use_vbr = value;
2164             st->silk_mode.useCBR = 1-value;
2165         }
2166         break;
2167         case OPUS_GET_VBR_REQUEST:
2168         {
2169             opus_int32 *value = va_arg(ap, opus_int32*);
2170             if (!value)
2171             {
2172                goto bad_arg;
2173             }
2174             *value = st->use_vbr;
2175         }
2176         break;
2177         case OPUS_SET_VOICE_RATIO_REQUEST:
2178         {
2179             opus_int32 value = va_arg(ap, opus_int32);
2180             if (value<-1 || value>100)
2181             {
2182                goto bad_arg;
2183             }
2184             st->voice_ratio = value;
2185         }
2186         break;
2187         case OPUS_GET_VOICE_RATIO_REQUEST:
2188         {
2189             opus_int32 *value = va_arg(ap, opus_int32*);
2190             if (!value)
2191             {
2192                goto bad_arg;
2193             }
2194             *value = st->voice_ratio;
2195         }
2196         break;
2197         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
2198         {
2199             opus_int32 value = va_arg(ap, opus_int32);
2200             if(value<0 || value>1)
2201             {
2202                goto bad_arg;
2203             }
2204             st->vbr_constraint = value;
2205         }
2206         break;
2207         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
2208         {
2209             opus_int32 *value = va_arg(ap, opus_int32*);
2210             if (!value)
2211             {
2212                goto bad_arg;
2213             }
2214             *value = st->vbr_constraint;
2215         }
2216         break;
2217         case OPUS_SET_SIGNAL_REQUEST:
2218         {
2219             opus_int32 value = va_arg(ap, opus_int32);
2220             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
2221             {
2222                goto bad_arg;
2223             }
2224             st->signal_type = value;
2225         }
2226         break;
2227         case OPUS_GET_SIGNAL_REQUEST:
2228         {
2229             opus_int32 *value = va_arg(ap, opus_int32*);
2230             if (!value)
2231             {
2232                goto bad_arg;
2233             }
2234             *value = st->signal_type;
2235         }
2236         break;
2237         case OPUS_GET_LOOKAHEAD_REQUEST:
2238         {
2239             opus_int32 *value = va_arg(ap, opus_int32*);
2240             if (!value)
2241             {
2242                goto bad_arg;
2243             }
2244             *value = st->Fs/400;
2245             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2246                 *value += st->delay_compensation;
2247         }
2248         break;
2249         case OPUS_GET_SAMPLE_RATE_REQUEST:
2250         {
2251             opus_int32 *value = va_arg(ap, opus_int32*);
2252             if (!value)
2253             {
2254                goto bad_arg;
2255             }
2256             *value = st->Fs;
2257         }
2258         break;
2259         case OPUS_GET_FINAL_RANGE_REQUEST:
2260         {
2261             opus_uint32 *value = va_arg(ap, opus_uint32*);
2262             if (!value)
2263             {
2264                goto bad_arg;
2265             }
2266             *value = st->rangeFinal;
2267         }
2268         break;
2269         case OPUS_SET_LSB_DEPTH_REQUEST:
2270         {
2271             opus_int32 value = va_arg(ap, opus_int32);
2272             if (value<8 || value>24)
2273             {
2274                goto bad_arg;
2275             }
2276             st->lsb_depth=value;
2277         }
2278         break;
2279         case OPUS_GET_LSB_DEPTH_REQUEST:
2280         {
2281             opus_int32 *value = va_arg(ap, opus_int32*);
2282             if (!value)
2283             {
2284                goto bad_arg;
2285             }
2286             *value = st->lsb_depth;
2287         }
2288         break;
2289         case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
2290         {
2291             opus_int32 value = va_arg(ap, opus_int32);
2292             if (value != OPUS_FRAMESIZE_ARG   && value != OPUS_FRAMESIZE_2_5_MS &&
2293                 value != OPUS_FRAMESIZE_5_MS  && value != OPUS_FRAMESIZE_10_MS  &&
2294                 value != OPUS_FRAMESIZE_20_MS && value != OPUS_FRAMESIZE_40_MS  &&
2295                 value != OPUS_FRAMESIZE_60_MS && value != OPUS_FRAMESIZE_VARIABLE)
2296             {
2297                goto bad_arg;
2298             }
2299             st->variable_duration = value;
2300             celt_encoder_ctl(celt_enc, OPUS_SET_EXPERT_FRAME_DURATION(value));
2301         }
2302         break;
2303         case OPUS_GET_EXPERT_FRAME_DURATION_REQUEST:
2304         {
2305             opus_int32 *value = va_arg(ap, opus_int32*);
2306             if (!value)
2307             {
2308                goto bad_arg;
2309             }
2310             *value = st->variable_duration;
2311         }
2312         break;
2313         case OPUS_RESET_STATE:
2314         {
2315            void *silk_enc;
2316            silk_EncControlStruct dummy;
2317            silk_enc = (char*)st+st->silk_enc_offset;
2318
2319            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
2320                  sizeof(OpusEncoder)-
2321                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
2322
2323            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2324            silk_InitEncoder( silk_enc, &dummy );
2325            st->stream_channels = st->channels;
2326            st->hybrid_stereo_width_Q14 = 1 << 14;
2327            st->prev_HB_gain = Q15ONE;
2328            st->first = 1;
2329            st->mode = MODE_HYBRID;
2330            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
2331            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
2332         }
2333         break;
2334         case OPUS_SET_FORCE_MODE_REQUEST:
2335         {
2336             opus_int32 value = va_arg(ap, opus_int32);
2337             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
2338             {
2339                goto bad_arg;
2340             }
2341             st->user_forced_mode = value;
2342         }
2343         break;
2344         case OPUS_SET_LFE_REQUEST:
2345         {
2346             opus_int32 value = va_arg(ap, opus_int32);
2347             st->lfe = value;
2348             ret = celt_encoder_ctl(celt_enc, OPUS_SET_LFE(value));
2349         }
2350         break;
2351         case OPUS_SET_ENERGY_MASK_REQUEST:
2352         {
2353             opus_val16 *value = va_arg(ap, opus_val16*);
2354             st->energy_masking = (value!=NULL);
2355             ret = celt_encoder_ctl(celt_enc, OPUS_SET_ENERGY_MASK(value));
2356         }
2357         break;
2358
2359         case CELT_GET_MODE_REQUEST:
2360         {
2361            const CELTMode ** value = va_arg(ap, const CELTMode**);
2362            if (!value)
2363            {
2364               goto bad_arg;
2365            }
2366            ret = celt_encoder_ctl(celt_enc, CELT_GET_MODE(value));
2367         }
2368         break;
2369         default:
2370             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
2371             ret = OPUS_UNIMPLEMENTED;
2372             break;
2373     }
2374     va_end(ap);
2375     return ret;
2376 bad_arg:
2377     va_end(ap);
2378     return OPUS_BAD_ARG;
2379 }
2380
2381 void opus_encoder_destroy(OpusEncoder *st)
2382 {
2383     opus_free(st);
2384 }