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