Avoids symbol clashes with Speex (pitch_xcorr) and libm (y1)
[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,.05*(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./(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./(EPSILON+mem[1]);
742       e[2]=mem[2];
743       e_1[2]=1./(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+.5*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 = MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[0][0]) + MULT16_32_Q15(stereo_width,mode_thresholds[1][0]);
1076        mode_music = MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[1][1]) + MULT16_32_Q15(stereo_width,mode_thresholds[1][1]);
1077        /* Interpolate based on speech/music probability */
1078        threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14);
1079        /* Bias towards SILK for VoIP because of some useful features */
1080        if (st->application == OPUS_APPLICATION_VOIP)
1081           threshold += 8000;
1082
1083        /*printf("%f %d\n", stereo_width/(float)Q15ONE, threshold);*/
1084        /* Hysteresis */
1085        if (st->prev_mode == MODE_CELT_ONLY)
1086            threshold -= 4000;
1087        else if (st->prev_mode>0)
1088            threshold += 4000;
1089
1090        st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY;
1091
1092        /* When FEC is enabled and there's enough packet loss, use SILK */
1093        if (st->silk_mode.useInBandFEC && st->silk_mode.packetLossPercentage > (128-voice_est)>>4)
1094           st->mode = MODE_SILK_ONLY;
1095        /* When encoding voice and DTX is enabled, set the encoder to SILK mode (at least for now) */
1096        if (st->silk_mode.useDTX && voice_est > 100)
1097           st->mode = MODE_SILK_ONLY;
1098 #endif
1099     } else {
1100        st->mode = st->user_forced_mode;
1101     }
1102
1103     /* Override the chosen mode to make sure we meet the requested frame size */
1104     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
1105        st->mode = MODE_CELT_ONLY;
1106
1107     if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0
1108           && st->mode != MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)
1109     {
1110        /* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */
1111        st->silk_mode.toMono = 1;
1112        st->stream_channels = 2;
1113     } else {
1114        st->silk_mode.toMono = 0;
1115     }
1116
1117     if (st->prev_mode > 0 &&
1118         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
1119     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
1120     {
1121         redundancy = 1;
1122         celt_to_silk = (st->mode != MODE_CELT_ONLY);
1123         if (!celt_to_silk)
1124         {
1125             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
1126             if (frame_size >= st->Fs/100)
1127             {
1128                 st->mode = st->prev_mode;
1129                 to_celt = 1;
1130             } else {
1131                 redundancy=0;
1132             }
1133         }
1134     }
1135     /* For the first frame at a new SILK bandwidth */
1136     if (st->silk_bw_switch)
1137     {
1138        redundancy = 1;
1139        celt_to_silk = 1;
1140        st->silk_bw_switch = 0;
1141        prefill=1;
1142     }
1143
1144     if (redundancy)
1145     {
1146        /* Fair share of the max size allowed */
1147        redundancy_bytes = IMIN(257, max_data_bytes*(opus_int32)(st->Fs/200)/(frame_size+st->Fs/200));
1148        /* For VBR, target the actual bitrate (subject to the limit above) */
1149        if (st->use_vbr)
1150           redundancy_bytes = IMIN(redundancy_bytes, st->bitrate_bps/1600);
1151     }
1152
1153     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
1154     {
1155         silk_EncControlStruct dummy;
1156         silk_InitEncoder( silk_enc, &dummy);
1157         prefill=1;
1158     }
1159
1160     /* Automatic (rate-dependent) bandwidth selection */
1161     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
1162     {
1163         const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds;
1164         opus_int32 bandwidth_thresholds[8];
1165         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
1166         opus_int32 equiv_rate2;
1167
1168         equiv_rate2 = equiv_rate;
1169         if (st->mode != MODE_CELT_ONLY)
1170         {
1171            /* Adjust the threshold +/- 10% depending on complexity */
1172            equiv_rate2 = equiv_rate2 * (45+st->silk_mode.complexity)/50;
1173            /* CBR is less efficient by ~1 kb/s */
1174            if (!st->use_vbr)
1175               equiv_rate2 -= 1000;
1176         }
1177         if (st->channels==2 && st->force_channels!=1)
1178         {
1179            voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds;
1180            music_bandwidth_thresholds = stereo_music_bandwidth_thresholds;
1181         } else {
1182            voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds;
1183            music_bandwidth_thresholds = mono_music_bandwidth_thresholds;
1184         }
1185         /* Interpolate bandwidth thresholds depending on voice estimation */
1186         for (i=0;i<8;i++)
1187         {
1188            bandwidth_thresholds[i] = music_bandwidth_thresholds[i]
1189                     + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14);
1190         }
1191         do {
1192             int threshold, hysteresis;
1193             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
1194             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
1195             if (!st->first)
1196             {
1197                 if (st->bandwidth >= bandwidth)
1198                     threshold -= hysteresis;
1199                 else
1200                     threshold += hysteresis;
1201             }
1202             if (equiv_rate2 >= threshold)
1203                 break;
1204         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
1205         st->bandwidth = bandwidth;
1206         /* Prevents any transition to SWB/FB until the SILK layer has fully
1207            switched to WB mode and turned the variable LP filter off */
1208         if (!st->first && st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1209             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1210     }
1211
1212     if (st->bandwidth>st->max_bandwidth)
1213        st->bandwidth = st->max_bandwidth;
1214
1215     if (st->user_bandwidth != OPUS_AUTO)
1216         st->bandwidth = st->user_bandwidth;
1217
1218     /* This prevents us from using hybrid at unsafe CBR/max rates */
1219     if (st->mode != MODE_CELT_ONLY && max_rate < 15000)
1220     {
1221        st->bandwidth = IMIN(st->bandwidth, OPUS_BANDWIDTH_WIDEBAND);
1222     }
1223
1224     /* Prevents Opus from wasting bits on frequencies that are above
1225        the Nyquist rate of the input signal */
1226     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
1227         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1228     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1229         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1230     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
1231         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1232     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
1233         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1234 #ifndef FIXED_POINT
1235     /* Use detected bandwidth to reduce the encoded bandwidth. */
1236     if (st->detected_bandwidth && st->user_bandwidth == OPUS_AUTO)
1237     {
1238        int min_detected_bandwidth;
1239        /* Makes bandwidth detection more conservative just in case the detector
1240           gets it wrong when we could have coded a high bandwidth transparently.
1241           When operating in SILK/hybrid mode, we don't go below wideband to avoid
1242           more complicated switches that require redundancy. */
1243        if (st->bitrate_bps <= 18000*st->stream_channels && st->mode == MODE_CELT_ONLY)
1244           min_detected_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1245        else if (st->bitrate_bps <= 24000*st->stream_channels && st->mode == MODE_CELT_ONLY)
1246           min_detected_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1247        else if (st->bitrate_bps <= 30000*st->stream_channels)
1248           min_detected_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1249        else if (st->bitrate_bps <= 44000*st->stream_channels)
1250           min_detected_bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1251        else
1252           min_detected_bandwidth = OPUS_BANDWIDTH_FULLBAND;
1253
1254        st->detected_bandwidth = IMAX(st->detected_bandwidth, min_detected_bandwidth);
1255        st->bandwidth = IMIN(st->bandwidth, st->detected_bandwidth);
1256     }
1257 #endif
1258     celt_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(lsb_depth));
1259
1260     /* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */
1261     if (max_data_bytes < (frame_rate > 50 ? 12000 : 8000)*frame_size / (st->Fs * 8))
1262        st->mode = MODE_CELT_ONLY;
1263
1264     /* CELT mode doesn't support mediumband, use wideband instead */
1265     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1266         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1267     if (st->lfe)
1268     {
1269        st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1270        st->mode = MODE_CELT_ONLY;
1271     }
1272
1273     /* Can't support higher than wideband for >20 ms frames */
1274     if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND))
1275     {
1276        VARDECL(unsigned char, tmp_data);
1277        int nb_frames;
1278        int bak_mode, bak_bandwidth, bak_channels, bak_to_mono;
1279        VARDECL(OpusRepacketizer, rp);
1280        opus_int32 bytes_per_frame;
1281
1282
1283        nb_frames = frame_size > st->Fs/25 ? 3 : 2;
1284        bytes_per_frame = IMIN(1276,(out_data_bytes-3)/nb_frames);
1285
1286        ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char);
1287
1288        ALLOC(rp, 1, OpusRepacketizer);
1289        opus_repacketizer_init(rp);
1290
1291        bak_mode = st->user_forced_mode;
1292        bak_bandwidth = st->user_bandwidth;
1293        bak_channels = st->force_channels;
1294
1295        st->user_forced_mode = st->mode;
1296        st->user_bandwidth = st->bandwidth;
1297        st->force_channels = st->stream_channels;
1298        bak_to_mono = st->silk_mode.toMono;
1299
1300        if (bak_to_mono)
1301           st->force_channels = 1;
1302        else
1303           st->prev_channels = st->stream_channels;
1304        for (i=0;i<nb_frames;i++)
1305        {
1306           int tmp_len;
1307           st->silk_mode.toMono = 0;
1308           /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
1309           if (to_celt && i==nb_frames-1)
1310              st->user_forced_mode = MODE_CELT_ONLY;
1311           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
1312 #ifndef FIXED_POINT
1313                 , analysis_info
1314 #endif
1315                 );
1316           if (tmp_len<0)
1317           {
1318              RESTORE_STACK;
1319              return OPUS_INTERNAL_ERROR;
1320           }
1321           ret = opus_repacketizer_cat(rp, tmp_data+i*bytes_per_frame, tmp_len);
1322           if (ret<0)
1323           {
1324              RESTORE_STACK;
1325              return OPUS_INTERNAL_ERROR;
1326           }
1327        }
1328        ret = opus_repacketizer_out(rp, data, out_data_bytes);
1329        if (ret<0)
1330        {
1331           RESTORE_STACK;
1332           return OPUS_INTERNAL_ERROR;
1333        }
1334        st->user_forced_mode = bak_mode;
1335        st->user_bandwidth = bak_bandwidth;
1336        st->force_channels = bak_channels;
1337        st->silk_mode.toMono = bak_to_mono;
1338        RESTORE_STACK;
1339        return ret;
1340     }
1341     curr_bandwidth = st->bandwidth;
1342
1343     /* Chooses the appropriate mode for speech
1344        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
1345     if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1346         st->mode = MODE_HYBRID;
1347     if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
1348         st->mode = MODE_SILK_ONLY;
1349
1350     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
1351     bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
1352
1353     data += 1;
1354
1355     ec_enc_init(&enc, data, max_data_bytes-1);
1356
1357     ALLOC(pcm_buf, (total_buffer+frame_size)*st->channels, opus_val16);
1358     for (i=0;i<total_buffer*st->channels;i++)
1359        pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-total_buffer)*st->channels+i];
1360
1361     if (st->mode == MODE_CELT_ONLY)
1362        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1363     else
1364        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
1365
1366     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
1367           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
1368
1369     /* convert from log scale to Hertz */
1370     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
1371
1372     if (st->application == OPUS_APPLICATION_VOIP)
1373     {
1374        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1375     } else {
1376        dc_reject(pcm, 3, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1377     }
1378
1379
1380
1381     /* SILK processing */
1382     HB_gain = Q15ONE;
1383     if (st->mode != MODE_CELT_ONLY)
1384     {
1385         opus_int32 total_bitRate, celt_rate;
1386 #ifdef FIXED_POINT
1387        const opus_int16 *pcm_silk;
1388 #else
1389        VARDECL(opus_int16, pcm_silk);
1390        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
1391 #endif
1392
1393         /* Distribute bits between SILK and CELT */
1394         total_bitRate = 8 * bytes_target * frame_rate;
1395         if( st->mode == MODE_HYBRID ) {
1396             int HB_gain_ref;
1397             /* Base rate for SILK */
1398             st->silk_mode.bitRate = st->stream_channels * ( 5000 + 1000 * ( st->Fs == 100 * frame_size ) );
1399             if( curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
1400                 /* SILK gets 2/3 of the remaining bits */
1401                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 2 / 3;
1402             } else { /* FULLBAND */
1403                 /* SILK gets 3/5 of the remaining bits */
1404                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 3 / 5;
1405             }
1406             /* Don't let SILK use more than 80% */
1407             if( st->silk_mode.bitRate > total_bitRate * 4/5 ) {
1408                 st->silk_mode.bitRate = total_bitRate * 4/5;
1409             }
1410             /* Increasingly attenuate high band when it gets allocated fewer bits */
1411             celt_rate = total_bitRate - st->silk_mode.bitRate;
1412             HB_gain_ref = (curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND) ? 3000 : 3600;
1413             HB_gain = SHL32((opus_val32)celt_rate, 9) / SHR32((opus_val32)celt_rate + st->stream_channels * HB_gain_ref, 6);
1414             HB_gain = HB_gain < Q15ONE*6/7 ? HB_gain + Q15ONE/7 : Q15ONE;
1415         } else {
1416             /* SILK gets all bits */
1417             st->silk_mode.bitRate = total_bitRate;
1418         }
1419
1420         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
1421         st->silk_mode.nChannelsAPI = st->channels;
1422         st->silk_mode.nChannelsInternal = st->stream_channels;
1423         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1424             st->silk_mode.desiredInternalSampleRate = 8000;
1425         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1426             st->silk_mode.desiredInternalSampleRate = 12000;
1427         } else {
1428             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
1429             st->silk_mode.desiredInternalSampleRate = 16000;
1430         }
1431         if( st->mode == MODE_HYBRID ) {
1432             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
1433             st->silk_mode.minInternalSampleRate = 16000;
1434         } else {
1435             st->silk_mode.minInternalSampleRate = 8000;
1436         }
1437
1438         if (st->mode == MODE_SILK_ONLY)
1439         {
1440            opus_int32 effective_max_rate = max_rate;
1441            st->silk_mode.maxInternalSampleRate = 16000;
1442            if (frame_rate > 50)
1443               effective_max_rate = effective_max_rate*2/3;
1444            if (effective_max_rate < 13000)
1445            {
1446               st->silk_mode.maxInternalSampleRate = 12000;
1447               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
1448            }
1449            if (effective_max_rate < 9600)
1450            {
1451               st->silk_mode.maxInternalSampleRate = 8000;
1452               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
1453            }
1454         } else {
1455            st->silk_mode.maxInternalSampleRate = 16000;
1456         }
1457
1458         st->silk_mode.useCBR = !st->use_vbr;
1459
1460         /* Call SILK encoder for the low band */
1461         nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes);
1462
1463         st->silk_mode.maxBits = nBytes*8;
1464         /* Only allow up to 90% of the bits for hybrid mode*/
1465         if (st->mode == MODE_HYBRID)
1466            st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
1467         if (st->silk_mode.useCBR)
1468         {
1469            st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
1470            /* Reduce the initial target to make it easier to reach the CBR rate */
1471            st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000);
1472         }
1473
1474         if (prefill)
1475         {
1476             opus_int32 zero=0;
1477             const CELTMode *celt_mode;
1478             int prefill_offset;
1479             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1480             /* Use a smooth onset for the SILK prefill to avoid the encoder trying to encode
1481                a discontinuity. The exact location is what we need to avoid leaving any "gap"
1482                in the audio when mixing with the redundant CELT frame. Here we can afford to
1483                overwrite st->delay_buffer because the only thing that uses it before it gets
1484                rewritten is tmp_prefill[] and even then only the part after the ramp really
1485                gets used (rather than sent to the encoder and discarded) */
1486             prefill_offset = st->channels*(st->encoder_buffer-st->delay_compensation-st->Fs/400);
1487             gain_fade(st->delay_buffer+prefill_offset, st->delay_buffer+prefill_offset,
1488                   0, Q15ONE, celt_mode->overlap, st->Fs/400, st->channels, celt_mode->window, st->Fs);
1489             for(i=0;i<prefill_offset;i++)
1490                st->delay_buffer[i]=0;
1491 #ifdef FIXED_POINT
1492             pcm_silk = st->delay_buffer;
1493 #else
1494             for (i=0;i<st->encoder_buffer*st->channels;i++)
1495                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
1496 #endif
1497             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
1498         }
1499
1500 #ifdef FIXED_POINT
1501         pcm_silk = pcm_buf+total_buffer*st->channels;
1502 #else
1503         for (i=0;i<frame_size*st->channels;i++)
1504             pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
1505 #endif
1506         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
1507         if( ret ) {
1508             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
1509             /* Handle error */
1510            RESTORE_STACK;
1511            return OPUS_INTERNAL_ERROR;
1512         }
1513         if (nBytes==0)
1514         {
1515            st->rangeFinal = 0;
1516            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1517            RESTORE_STACK;
1518            return 1;
1519         }
1520         /* Extract SILK internal bandwidth for signaling in first byte */
1521         if( st->mode == MODE_SILK_ONLY ) {
1522             if( st->silk_mode.internalSampleRate == 8000 ) {
1523                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1524             } else if( st->silk_mode.internalSampleRate == 12000 ) {
1525                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1526             } else if( st->silk_mode.internalSampleRate == 16000 ) {
1527                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1528             }
1529         } else {
1530             silk_assert( st->silk_mode.internalSampleRate == 16000 );
1531         }
1532
1533         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
1534         /* FIXME: How do we allocate the redundancy for CBR? */
1535         if (st->silk_mode.opusCanSwitch)
1536         {
1537            redundancy = 1;
1538            celt_to_silk = 0;
1539            st->silk_bw_switch = 1;
1540         }
1541     }
1542
1543     /* CELT processing */
1544     {
1545         int endband=21;
1546
1547         switch(curr_bandwidth)
1548         {
1549             case OPUS_BANDWIDTH_NARROWBAND:
1550                 endband = 13;
1551                 break;
1552             case OPUS_BANDWIDTH_MEDIUMBAND:
1553             case OPUS_BANDWIDTH_WIDEBAND:
1554                 endband = 17;
1555                 break;
1556             case OPUS_BANDWIDTH_SUPERWIDEBAND:
1557                 endband = 19;
1558                 break;
1559             case OPUS_BANDWIDTH_FULLBAND:
1560                 endband = 21;
1561                 break;
1562         }
1563         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
1564         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
1565     }
1566     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1567     if (st->mode != MODE_SILK_ONLY)
1568     {
1569         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1570         /* Allow prediction unless we decide to disable it later */
1571         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
1572
1573         if (st->mode == MODE_HYBRID)
1574         {
1575             int len;
1576
1577             len = (ec_tell(&enc)+7)>>3;
1578             if (redundancy)
1579                len += st->mode == MODE_HYBRID ? 3 : 1;
1580             if( st->use_vbr ) {
1581                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
1582             } else {
1583                 /* check if SILK used up too much */
1584                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
1585             }
1586         } else {
1587             if (st->use_vbr)
1588             {
1589                 opus_int32 bonus=0;
1590 #ifndef FIXED_POINT
1591                 if (st->variable_duration==OPUS_FRAMESIZE_VARIABLE && frame_size != st->Fs/50)
1592                 {
1593                    bonus = (60*st->stream_channels+40)*(st->Fs/frame_size-50);
1594                    if (analysis_info->valid)
1595                       bonus = bonus*(1.f+.5*analysis_info->tonality);
1596                 }
1597 #endif
1598                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
1599                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
1600                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps+bonus));
1601                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
1602             } else {
1603                 nb_compr_bytes = bytes_target;
1604             }
1605         }
1606
1607     } else {
1608         nb_compr_bytes = 0;
1609     }
1610
1611     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
1612     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
1613     {
1614        for (i=0;i<st->channels*st->Fs/400;i++)
1615           tmp_prefill[i] = st->delay_buffer[(st->encoder_buffer-total_buffer-st->Fs/400)*st->channels + i];
1616     }
1617
1618     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+total_buffer));i++)
1619         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
1620     for (;i<st->encoder_buffer*st->channels;i++)
1621         st->delay_buffer[i] = pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels+i];
1622
1623     /* gain_fade() and stereo_fade() need to be after the buffer copying
1624        because we don't want any of this to affect the SILK part */
1625     if( st->prev_HB_gain < Q15ONE || HB_gain < Q15ONE ) {
1626        const CELTMode *celt_mode;
1627
1628        celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1629        gain_fade(pcm_buf, pcm_buf,
1630              st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs);
1631     }
1632     st->prev_HB_gain = HB_gain;
1633     if (st->mode != MODE_HYBRID || st->stream_channels==1)
1634        st->silk_mode.stereoWidth_Q14 = IMIN((1<<14),IMAX(0,st->bitrate_bps-32000));
1635     if( !st->energy_masking && st->channels == 2 ) {
1636         /* Apply stereo width reduction (at low bitrates) */
1637         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1638             opus_val16 g1, g2;
1639             const CELTMode *celt_mode;
1640
1641             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1642             g1 = st->hybrid_stereo_width_Q14;
1643             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1644 #ifdef FIXED_POINT
1645             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
1646             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
1647 #else
1648             g1 *= (1.f/16384);
1649             g2 *= (1.f/16384);
1650 #endif
1651             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
1652                   frame_size, st->channels, celt_mode->window, st->Fs);
1653             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1654         }
1655     }
1656
1657     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
1658     {
1659         /* For SILK mode, the redundancy is inferred from the length */
1660         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
1661            ec_enc_bit_logp(&enc, redundancy, 12);
1662         if (redundancy)
1663         {
1664             int max_redundancy;
1665             ec_enc_bit_logp(&enc, celt_to_silk, 1);
1666             if (st->mode == MODE_HYBRID)
1667                max_redundancy = (max_data_bytes-1)-nb_compr_bytes-1;
1668             else
1669                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1670             /* Target the same bit-rate for redundancy as for the rest,
1671                up to a max of 257 bytes */
1672             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
1673             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
1674             if (st->mode == MODE_HYBRID)
1675                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
1676         }
1677     } else {
1678         redundancy = 0;
1679     }
1680
1681     if (!redundancy)
1682     {
1683        st->silk_bw_switch = 0;
1684        redundancy_bytes = 0;
1685     }
1686     if (st->mode != MODE_CELT_ONLY)start_band=17;
1687
1688     if (st->mode == MODE_SILK_ONLY)
1689     {
1690         ret = (ec_tell(&enc)+7)>>3;
1691         ec_enc_done(&enc);
1692         nb_compr_bytes = ret;
1693     } else {
1694        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
1695        ec_enc_shrink(&enc, nb_compr_bytes);
1696     }
1697
1698 #ifndef FIXED_POINT
1699     if (redundancy || st->mode != MODE_SILK_ONLY)
1700        celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(analysis_info));
1701 #endif
1702
1703     /* 5 ms redundant frame for CELT->SILK */
1704     if (redundancy && celt_to_silk)
1705     {
1706         int err;
1707         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1708         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1709         err = celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
1710         if (err < 0)
1711         {
1712            RESTORE_STACK;
1713            return OPUS_INTERNAL_ERROR;
1714         }
1715         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1716         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1717     }
1718
1719     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
1720
1721     if (st->mode != MODE_SILK_ONLY)
1722     {
1723         if (st->mode != st->prev_mode && st->prev_mode > 0)
1724         {
1725            unsigned char dummy[2];
1726            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1727
1728            /* Prefilling */
1729            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
1730            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1731         }
1732         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
1733         if (ec_tell(&enc) <= 8*nb_compr_bytes)
1734         {
1735            ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
1736            if (ret < 0)
1737            {
1738               RESTORE_STACK;
1739               return OPUS_INTERNAL_ERROR;
1740            }
1741         }
1742     }
1743
1744     /* 5 ms redundant frame for SILK->CELT */
1745     if (redundancy && !celt_to_silk)
1746     {
1747         int err;
1748         unsigned char dummy[2];
1749         int N2, N4;
1750         N2 = st->Fs/200;
1751         N4 = st->Fs/400;
1752
1753         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1754         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1755         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1756
1757         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1758         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL);
1759
1760         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1761         if (err < 0)
1762         {
1763            RESTORE_STACK;
1764            return OPUS_INTERNAL_ERROR;
1765         }
1766         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1767     }
1768
1769
1770
1771     /* Signalling the mode in the first byte */
1772     data--;
1773     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1774
1775     st->rangeFinal = enc.rng ^ redundant_rng;
1776
1777     if (to_celt)
1778         st->prev_mode = MODE_CELT_ONLY;
1779     else
1780         st->prev_mode = st->mode;
1781     st->prev_channels = st->stream_channels;
1782     st->prev_framesize = frame_size;
1783
1784     st->first = 0;
1785
1786     /* In the unlikely case that the SILK encoder busted its target, tell
1787        the decoder to call the PLC */
1788     if (ec_tell(&enc) > (max_data_bytes-1)*8)
1789     {
1790        if (max_data_bytes < 2)
1791        {
1792           RESTORE_STACK;
1793           return OPUS_BUFFER_TOO_SMALL;
1794        }
1795        data[1] = 0;
1796        ret = 1;
1797        st->rangeFinal = 0;
1798     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
1799     {
1800        /*When in LPC only mode it's perfectly
1801          reasonable to strip off trailing zero bytes as
1802          the required range decoder behavior is to
1803          fill these in. This can't be done when the MDCT
1804          modes are used because the decoder needs to know
1805          the actual length for allocation purposes.*/
1806        while(ret>2&&data[ret]==0)ret--;
1807     }
1808     /* Count ToC and redundancy */
1809     ret += 1+redundancy_bytes;
1810     if (!st->use_vbr && ret >= 3)
1811     {
1812        if (pad_frame(data, ret, max_data_bytes))
1813        {
1814           RESTORE_STACK;
1815           return OPUS_INTERNAL_ERROR;
1816        }
1817        ret = max_data_bytes;
1818     }
1819     RESTORE_STACK;
1820     return ret;
1821 }
1822
1823 #ifdef FIXED_POINT
1824
1825 #ifndef DISABLE_FLOAT_API
1826 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1827       unsigned char *data, opus_int32 max_data_bytes)
1828 {
1829    int i, ret;
1830    VARDECL(opus_int16, in);
1831    ALLOC_STACK;
1832
1833    frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1834    if(frame_size<0)
1835    {
1836       RESTORE_STACK;
1837       return OPUS_BAD_ARG;
1838    }
1839
1840    ALLOC(in, frame_size*st->channels, opus_int16);
1841
1842    for (i=0;i<frame_size*st->channels;i++)
1843       in[i] = FLOAT2INT16(pcm[i]);
1844    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16);
1845    RESTORE_STACK;
1846    return ret;
1847 }
1848 #endif
1849
1850 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1851                 unsigned char *data, opus_int32 out_data_bytes)
1852 {
1853    frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1854    if(frame_size<0)
1855    {
1856       return OPUS_BAD_ARG;
1857    }
1858    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 16);
1859 }
1860
1861 #else
1862 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1863       unsigned char *data, opus_int32 max_data_bytes)
1864 {
1865    int i, ret;
1866    const CELTMode *celt_mode;
1867    int delay_compensation;
1868    int lsb_depth;
1869    VARDECL(float, in);
1870    AnalysisInfo analysis_info;
1871    ALLOC_STACK;
1872
1873    opus_encoder_ctl(st, CELT_GET_MODE(&celt_mode));
1874    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1875       delay_compensation = 0;
1876    else
1877       delay_compensation = st->delay_compensation;
1878
1879    lsb_depth = IMIN(16, st->lsb_depth);
1880
1881    analysis_info.valid = 0;
1882    if (st->silk_mode.complexity >= 7 && st->Fs==48000)
1883    {
1884       frame_size = run_analysis(&st->analysis, celt_mode, pcm, pcm+st->channels*st->analysis.analysis_offset,
1885             frame_size, st->variable_duration, st->channels, st->Fs, st->bitrate_bps, delay_compensation, lsb_depth, downmix_int, &analysis_info);
1886    } else {
1887       frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1888    }
1889    if(frame_size<0)
1890    {
1891       RESTORE_STACK;
1892       return OPUS_BAD_ARG;
1893    }
1894
1895    ALLOC(in, frame_size*st->channels, float);
1896
1897    for (i=0;i<frame_size*st->channels;i++)
1898       in[i] = (1.0f/32768)*pcm[i];
1899    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16, &analysis_info);
1900    RESTORE_STACK;
1901    return ret;
1902 }
1903 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1904                       unsigned char *data, opus_int32 out_data_bytes)
1905 {
1906    const CELTMode *celt_mode;
1907    int delay_compensation;
1908    int lsb_depth;
1909    AnalysisInfo analysis_info;
1910
1911    opus_encoder_ctl(st, CELT_GET_MODE(&celt_mode));
1912    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1913       delay_compensation = 0;
1914    else
1915       delay_compensation = st->delay_compensation;
1916
1917    lsb_depth = IMIN(24, st->lsb_depth);
1918
1919    analysis_info.valid = 0;
1920    if (st->silk_mode.complexity >= 7 && st->Fs==48000)
1921    {
1922       frame_size = run_analysis(&st->analysis, celt_mode, pcm, pcm+st->channels*st->analysis.analysis_offset,
1923             frame_size, st->variable_duration, st->channels, st->Fs, st->bitrate_bps, delay_compensation, lsb_depth, downmix_float, &analysis_info);
1924    } else {
1925       frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1926    }
1927    if(frame_size<0)
1928    {
1929       return OPUS_BAD_ARG;
1930    }
1931
1932    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 24, &analysis_info);
1933
1934 }
1935 #endif
1936
1937
1938 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
1939 {
1940     int ret;
1941     CELTEncoder *celt_enc;
1942     va_list ap;
1943
1944     ret = OPUS_OK;
1945     va_start(ap, request);
1946
1947     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1948
1949     switch (request)
1950     {
1951         case OPUS_SET_APPLICATION_REQUEST:
1952         {
1953             opus_int32 value = va_arg(ap, opus_int32);
1954             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
1955                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1956                || (!st->first && st->application != value))
1957             {
1958                ret = OPUS_BAD_ARG;
1959                break;
1960             }
1961             st->application = value;
1962         }
1963         break;
1964         case OPUS_GET_APPLICATION_REQUEST:
1965         {
1966             opus_int32 *value = va_arg(ap, opus_int32*);
1967             *value = st->application;
1968         }
1969         break;
1970         case OPUS_SET_BITRATE_REQUEST:
1971         {
1972             opus_int32 value = va_arg(ap, opus_int32);
1973             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1974             {
1975                 if (value <= 0)
1976                     goto bad_arg;
1977                 else if (value <= 500)
1978                     value = 500;
1979                 else if (value > (opus_int32)300000*st->channels)
1980                     value = (opus_int32)300000*st->channels;
1981             }
1982             st->user_bitrate_bps = value;
1983         }
1984         break;
1985         case OPUS_GET_BITRATE_REQUEST:
1986         {
1987             opus_int32 *value = va_arg(ap, opus_int32*);
1988             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
1989         }
1990         break;
1991         case OPUS_SET_FORCE_CHANNELS_REQUEST:
1992         {
1993             opus_int32 value = va_arg(ap, opus_int32);
1994             if((value<1 || value>st->channels) && value != OPUS_AUTO)
1995                 return OPUS_BAD_ARG;
1996             st->force_channels = value;
1997         }
1998         break;
1999         case OPUS_GET_FORCE_CHANNELS_REQUEST:
2000         {
2001             opus_int32 *value = va_arg(ap, opus_int32*);
2002             *value = st->force_channels;
2003         }
2004         break;
2005         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
2006         {
2007             opus_int32 value = va_arg(ap, opus_int32);
2008             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND)
2009                 return OPUS_BAD_ARG;
2010             st->max_bandwidth = value;
2011             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2012                 st->silk_mode.maxInternalSampleRate = 8000;
2013             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2014                 st->silk_mode.maxInternalSampleRate = 12000;
2015             } else {
2016                 st->silk_mode.maxInternalSampleRate = 16000;
2017             }
2018         }
2019         break;
2020         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
2021         {
2022             opus_int32 *value = va_arg(ap, opus_int32*);
2023             *value = st->max_bandwidth;
2024         }
2025         break;
2026         case OPUS_SET_BANDWIDTH_REQUEST:
2027         {
2028             opus_int32 value = va_arg(ap, opus_int32);
2029             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
2030                 return OPUS_BAD_ARG;
2031             st->user_bandwidth = value;
2032             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2033                 st->silk_mode.maxInternalSampleRate = 8000;
2034             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2035                 st->silk_mode.maxInternalSampleRate = 12000;
2036             } else {
2037                 st->silk_mode.maxInternalSampleRate = 16000;
2038             }
2039         }
2040         break;
2041         case OPUS_GET_BANDWIDTH_REQUEST:
2042         {
2043             opus_int32 *value = va_arg(ap, opus_int32*);
2044             *value = st->bandwidth;
2045         }
2046         break;
2047         case OPUS_SET_DTX_REQUEST:
2048         {
2049             opus_int32 value = va_arg(ap, opus_int32);
2050             if(value<0 || value>1)
2051                 return OPUS_BAD_ARG;
2052             st->silk_mode.useDTX = value;
2053         }
2054         break;
2055         case OPUS_GET_DTX_REQUEST:
2056         {
2057             opus_int32 *value = va_arg(ap, opus_int32*);
2058             *value = st->silk_mode.useDTX;
2059         }
2060         break;
2061         case OPUS_SET_COMPLEXITY_REQUEST:
2062         {
2063             opus_int32 value = va_arg(ap, opus_int32);
2064             if(value<0 || value>10)
2065                 return OPUS_BAD_ARG;
2066             st->silk_mode.complexity = value;
2067             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
2068         }
2069         break;
2070         case OPUS_GET_COMPLEXITY_REQUEST:
2071         {
2072             opus_int32 *value = va_arg(ap, opus_int32*);
2073             *value = st->silk_mode.complexity;
2074         }
2075         break;
2076         case OPUS_SET_INBAND_FEC_REQUEST:
2077         {
2078             opus_int32 value = va_arg(ap, opus_int32);
2079             if(value<0 || value>1)
2080                 return OPUS_BAD_ARG;
2081             st->silk_mode.useInBandFEC = value;
2082         }
2083         break;
2084         case OPUS_GET_INBAND_FEC_REQUEST:
2085         {
2086             opus_int32 *value = va_arg(ap, opus_int32*);
2087             *value = st->silk_mode.useInBandFEC;
2088         }
2089         break;
2090         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
2091         {
2092             opus_int32 value = va_arg(ap, opus_int32);
2093             if (value < 0 || value > 100)
2094                 return OPUS_BAD_ARG;
2095             st->silk_mode.packetLossPercentage = value;
2096             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
2097         }
2098         break;
2099         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
2100         {
2101             opus_int32 *value = va_arg(ap, opus_int32*);
2102             *value = st->silk_mode.packetLossPercentage;
2103         }
2104         break;
2105         case OPUS_SET_VBR_REQUEST:
2106         {
2107             opus_int32 value = va_arg(ap, opus_int32);
2108             if(value<0 || value>1)
2109                 return OPUS_BAD_ARG;
2110             st->use_vbr = value;
2111             st->silk_mode.useCBR = 1-value;
2112         }
2113         break;
2114         case OPUS_GET_VBR_REQUEST:
2115         {
2116             opus_int32 *value = va_arg(ap, opus_int32*);
2117             *value = st->use_vbr;
2118         }
2119         break;
2120         case OPUS_SET_VOICE_RATIO_REQUEST:
2121         {
2122             opus_int32 value = va_arg(ap, opus_int32);
2123             if (value>100 || value<-1)
2124                 goto bad_arg;
2125             st->voice_ratio = value;
2126         }
2127         break;
2128         case OPUS_GET_VOICE_RATIO_REQUEST:
2129         {
2130             opus_int32 *value = va_arg(ap, opus_int32*);
2131             *value = st->voice_ratio;
2132         }
2133         break;
2134         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
2135         {
2136             opus_int32 value = va_arg(ap, opus_int32);
2137             if(value<0 || value>1)
2138                 return OPUS_BAD_ARG;
2139             st->vbr_constraint = value;
2140         }
2141         break;
2142         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
2143         {
2144             opus_int32 *value = va_arg(ap, opus_int32*);
2145             *value = st->vbr_constraint;
2146         }
2147         break;
2148         case OPUS_SET_SIGNAL_REQUEST:
2149         {
2150             opus_int32 value = va_arg(ap, opus_int32);
2151             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
2152                 return OPUS_BAD_ARG;
2153             st->signal_type = value;
2154         }
2155         break;
2156         case OPUS_GET_SIGNAL_REQUEST:
2157         {
2158             opus_int32 *value = va_arg(ap, opus_int32*);
2159             *value = st->signal_type;
2160         }
2161         break;
2162         case OPUS_GET_LOOKAHEAD_REQUEST:
2163         {
2164             opus_int32 *value = va_arg(ap, opus_int32*);
2165             *value = st->Fs/400;
2166             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2167                 *value += st->delay_compensation;
2168         }
2169         break;
2170         case OPUS_GET_SAMPLE_RATE_REQUEST:
2171         {
2172             opus_int32 *value = va_arg(ap, opus_int32*);
2173             if (value==NULL)
2174             {
2175                 ret = OPUS_BAD_ARG;
2176                 break;
2177             }
2178             *value = st->Fs;
2179         }
2180         break;
2181         case OPUS_GET_FINAL_RANGE_REQUEST:
2182         {
2183             opus_uint32 *value = va_arg(ap, opus_uint32*);
2184             *value = st->rangeFinal;
2185         }
2186         break;
2187         case OPUS_SET_LSB_DEPTH_REQUEST:
2188         {
2189             opus_int32 value = va_arg(ap, opus_int32);
2190             if (value<8 || value>24)
2191                goto bad_arg;
2192             st->lsb_depth=value;
2193         }
2194         break;
2195         case OPUS_GET_LSB_DEPTH_REQUEST:
2196         {
2197             opus_int32 *value = va_arg(ap, opus_int32*);
2198             *value = st->lsb_depth;
2199         }
2200         break;
2201         case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
2202         {
2203             opus_int32 value = va_arg(ap, opus_int32);
2204             st->variable_duration = value;
2205             celt_encoder_ctl(celt_enc, OPUS_SET_EXPERT_FRAME_DURATION(value));
2206         }
2207         break;
2208         case OPUS_GET_EXPERT_FRAME_DURATION_REQUEST:
2209         {
2210             opus_int32 *value = va_arg(ap, opus_int32*);
2211             *value = st->variable_duration;
2212         }
2213         break;
2214         case OPUS_RESET_STATE:
2215         {
2216            void *silk_enc;
2217            silk_EncControlStruct dummy;
2218            silk_enc = (char*)st+st->silk_enc_offset;
2219
2220            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
2221                  sizeof(OpusEncoder)-
2222                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
2223
2224            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2225            silk_InitEncoder( silk_enc, &dummy );
2226            st->stream_channels = st->channels;
2227            st->hybrid_stereo_width_Q14 = 1 << 14;
2228            st->prev_HB_gain = Q15ONE;
2229            st->first = 1;
2230            st->mode = MODE_HYBRID;
2231            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
2232            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
2233         }
2234         break;
2235         case OPUS_SET_FORCE_MODE_REQUEST:
2236         {
2237             opus_int32 value = va_arg(ap, opus_int32);
2238             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
2239                goto bad_arg;
2240             st->user_forced_mode = value;
2241         }
2242         break;
2243         case OPUS_SET_LFE_REQUEST:
2244         {
2245             opus_int32 value = va_arg(ap, opus_int32);
2246             st->lfe = value;
2247             celt_encoder_ctl(celt_enc, OPUS_SET_LFE(value));
2248         }
2249         break;
2250         case OPUS_SET_ENERGY_SAVE_REQUEST:
2251         {
2252             opus_val16 *value = va_arg(ap, opus_val16*);
2253             celt_encoder_ctl(celt_enc, OPUS_SET_ENERGY_SAVE(value));
2254         }
2255         break;
2256         case OPUS_SET_ENERGY_MASK_REQUEST:
2257         {
2258             opus_val16 *value = va_arg(ap, opus_val16*);
2259             st->energy_masking = (value!=NULL);
2260             celt_encoder_ctl(celt_enc, OPUS_SET_ENERGY_MASK(value));
2261         }
2262         break;
2263
2264         case CELT_GET_MODE_REQUEST:
2265         {
2266            const CELTMode ** value = va_arg(ap, const CELTMode**);
2267            if (value==0)
2268               goto bad_arg;
2269            celt_encoder_ctl(celt_enc, CELT_GET_MODE(value));
2270         }
2271         break;
2272         default:
2273             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
2274             ret = OPUS_UNIMPLEMENTED;
2275             break;
2276     }
2277     va_end(ap);
2278     return ret;
2279 bad_arg:
2280     va_end(ap);
2281     return OPUS_BAD_ARG;
2282 }
2283
2284 void opus_encoder_destroy(OpusEncoder *st)
2285 {
2286     opus_free(st);
2287 }