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