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