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