61bddc2b579fcca19f66c6d841ac06859344b74d
[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 struct OpusEncoder {
55     int          celt_enc_offset;
56     int          silk_enc_offset;
57     silk_EncControlStruct silk_mode;
58     int          application;
59     int          channels;
60     int          delay_compensation;
61     int          force_channels;
62     int          signal_type;
63     int          user_bandwidth;
64     int          max_bandwidth;
65     int          user_forced_mode;
66     int          voice_ratio;
67     opus_int32   Fs;
68     int          use_vbr;
69     int          vbr_constraint;
70     opus_int32   bitrate_bps;
71     opus_int32   user_bitrate_bps;
72     int          encoder_buffer;
73
74 #define OPUS_ENCODER_RESET_START stream_channels
75     int          stream_channels;
76     opus_int16   hybrid_stereo_width_Q14;
77     opus_int32   variable_HP_smth2_Q15;
78     opus_val32   hp_mem[4];
79     int          mode;
80     int          prev_mode;
81     int          prev_channels;
82     int          prev_framesize;
83     int          bandwidth;
84     int          silk_bw_switch;
85     /* Sampling rate (at the API level) */
86     int          first;
87     opus_val16   delay_buffer[MAX_ENCODER_BUFFER*2];
88 #ifndef FIXED_POINT
89     TonalityAnalysisState analysis;
90 #endif
91     opus_uint32  rangeFinal;
92 };
93
94 /* Transition tables for the voice and music. First column is the
95    middle (memoriless) threshold. The second column is the hysteresis
96    (difference with the middle) */
97 static const opus_int32 mono_voice_bandwidth_thresholds[8] = {
98         11000, 1000, /* NB<->MB */
99         14000, 1000, /* MB<->WB */
100         17000, 1000, /* WB<->SWB */
101         20000, 1000, /* SWB<->FB */
102 };
103 static const opus_int32 mono_music_bandwidth_thresholds[8] = {
104         14000, 1000, /* MB not allowed */
105         18000, 2000, /* MB<->WB */
106         24000, 2000, /* WB<->SWB */
107         33000, 2000, /* SWB<->FB */
108 };
109 static const opus_int32 stereo_voice_bandwidth_thresholds[8] = {
110         11000, 1000, /* NB<->MB */
111         14000, 1000, /* MB<->WB */
112         21000, 2000, /* WB<->SWB */
113         32000, 2000, /* SWB<->FB */
114 };
115 static const opus_int32 stereo_music_bandwidth_thresholds[8] = {
116         14000, 1000, /* MB not allowed */
117         18000, 2000, /* MB<->WB */
118         24000, 2000, /* WB<->SWB */
119         48000, 2000, /* SWB<->FB */
120 };
121 /* Threshold bit-rates for switching between mono and stereo */
122 static const opus_int32 stereo_voice_threshold = 26000;
123 static const opus_int32 stereo_music_threshold = 36000;
124
125 /* Threshold bit-rate for switching between SILK/hybrid and CELT-only */
126 static const opus_int32 mode_thresholds[2][2] = {
127       /* voice */ /* music */
128       {  48000,      24000}, /* mono */
129       {  48000,      24000}, /* stereo */
130 };
131
132 int opus_encoder_get_size(int channels)
133 {
134     int silkEncSizeBytes, celtEncSizeBytes;
135     int ret;
136     if (channels<1 || channels > 2)
137         return 0;
138     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
139     if (ret)
140         return 0;
141     silkEncSizeBytes = align(silkEncSizeBytes);
142     celtEncSizeBytes = celt_encoder_get_size(channels);
143     return align(sizeof(OpusEncoder))+silkEncSizeBytes+celtEncSizeBytes;
144 }
145
146 int opus_encoder_init(OpusEncoder* st, opus_int32 Fs, int channels, int application)
147 {
148     void *silk_enc;
149     CELTEncoder *celt_enc;
150     int err;
151     int ret, silkEncSizeBytes;
152
153    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
154         (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
155         && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
156         return OPUS_BAD_ARG;
157
158     OPUS_CLEAR((char*)st, opus_encoder_get_size(channels));
159     /* Create SILK encoder */
160     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
161     if (ret)
162         return OPUS_BAD_ARG;
163     silkEncSizeBytes = align(silkEncSizeBytes);
164     st->silk_enc_offset = align(sizeof(OpusEncoder));
165     st->celt_enc_offset = st->silk_enc_offset+silkEncSizeBytes;
166     silk_enc = (char*)st+st->silk_enc_offset;
167     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
168
169     st->stream_channels = st->channels = channels;
170
171     st->Fs = Fs;
172
173     ret = silk_InitEncoder( silk_enc, &st->silk_mode );
174     if(ret)return OPUS_INTERNAL_ERROR;
175
176     /* default SILK parameters */
177     st->silk_mode.nChannelsAPI              = channels;
178     st->silk_mode.nChannelsInternal         = channels;
179     st->silk_mode.API_sampleRate            = st->Fs;
180     st->silk_mode.maxInternalSampleRate     = 16000;
181     st->silk_mode.minInternalSampleRate     = 8000;
182     st->silk_mode.desiredInternalSampleRate = 16000;
183     st->silk_mode.payloadSize_ms            = 20;
184     st->silk_mode.bitRate                   = 25000;
185     st->silk_mode.packetLossPercentage      = 0;
186     st->silk_mode.complexity                = 10;
187     st->silk_mode.useInBandFEC              = 0;
188     st->silk_mode.useDTX                    = 0;
189     st->silk_mode.useCBR                    = 0;
190
191     /* Create CELT encoder */
192     /* Initialize CELT encoder */
193     err = celt_encoder_init(celt_enc, Fs, channels);
194     if(err!=OPUS_OK)return OPUS_INTERNAL_ERROR;
195
196     celt_encoder_ctl(celt_enc, CELT_SET_SIGNALLING(0));
197     celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(10));
198
199     st->use_vbr = 1;
200     /* Makes constrained VBR the default (safer for real-time use) */
201     st->vbr_constraint = 1;
202     st->user_bitrate_bps = OPUS_AUTO;
203     st->bitrate_bps = 3000+Fs*channels;
204     st->application = application;
205     st->signal_type = OPUS_AUTO;
206     st->user_bandwidth = OPUS_AUTO;
207     st->max_bandwidth = OPUS_BANDWIDTH_FULLBAND;
208     st->force_channels = OPUS_AUTO;
209     st->user_forced_mode = OPUS_AUTO;
210     st->voice_ratio = -1;
211     st->encoder_buffer = st->Fs/100;
212
213     /* Delay compensation of 4 ms (2.5 ms for SILK's extra look-ahead 
214        + 1.5 ms for SILK resamplers and stereo prediction) */
215     st->delay_compensation = st->Fs/250;
216
217     st->hybrid_stereo_width_Q14 = 1 << 14;
218     st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
219     st->first = 1;
220     st->mode = MODE_HYBRID;
221     st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
222
223     return OPUS_OK;
224 }
225
226 static int pad_frame(unsigned char *data, opus_int32 len, opus_int32 new_len)
227 {
228    if (len == new_len)
229       return 0;
230    if (len > new_len)
231       return 1;
232
233    if ((data[0]&0x3)==0)
234    {
235       int i;
236       int padding, nb_255s;
237
238       padding = new_len - len;
239       if (padding >= 2)
240       {
241          nb_255s = (padding-2)/255;
242
243          for (i=len-1;i>=1;i--)
244             data[i+nb_255s+2] = data[i];
245          data[0] |= 0x3;
246          data[1] = 0x41;
247          for (i=0;i<nb_255s;i++)
248             data[i+2] = 255;
249          data[nb_255s+2] = padding-255*nb_255s-2;
250          for (i=len+3+nb_255s;i<new_len;i++)
251             data[i] = 0;
252       } else {
253          for (i=len-1;i>=1;i--)
254             data[i+1] = data[i];
255          data[0] |= 0x3;
256          data[1] = 1;
257       }
258       return 0;
259    } else {
260       return 1;
261    }
262 }
263
264 static unsigned char gen_toc(int mode, int framerate, int bandwidth, int channels)
265 {
266    int period;
267    unsigned char toc;
268    period = 0;
269    while (framerate < 400)
270    {
271        framerate <<= 1;
272        period++;
273    }
274    if (mode == MODE_SILK_ONLY)
275    {
276        toc = (bandwidth-OPUS_BANDWIDTH_NARROWBAND)<<5;
277        toc |= (period-2)<<3;
278    } else if (mode == MODE_CELT_ONLY)
279    {
280        int tmp = bandwidth-OPUS_BANDWIDTH_MEDIUMBAND;
281        if (tmp < 0)
282            tmp = 0;
283        toc = 0x80;
284        toc |= tmp << 5;
285        toc |= period<<3;
286    } else /* Hybrid */
287    {
288        toc = 0x60;
289        toc |= (bandwidth-OPUS_BANDWIDTH_SUPERWIDEBAND)<<4;
290        toc |= (period-2)<<3;
291    }
292    toc |= (channels==2)<<2;
293    return toc;
294 }
295
296 #ifndef FIXED_POINT
297 static void silk_biquad_float(
298     const opus_val16      *in,            /* I:    Input signal                   */
299     const opus_int32      *B_Q28,         /* I:    MA coefficients [3]            */
300     const opus_int32      *A_Q28,         /* I:    AR coefficients [2]            */
301     opus_val32            *S,             /* I/O:  State vector [2]               */
302     opus_val16            *out,           /* O:    Output signal                  */
303     const opus_int32      len,            /* I:    Signal length (must be even)   */
304     int stride
305 )
306 {
307     /* DIRECT FORM II TRANSPOSED (uses 2 element state vector) */
308     opus_int   k;
309     opus_val32 vout;
310     opus_val32 inval;
311     opus_val32 A[2], B[3];
312
313     A[0] = (opus_val32)(A_Q28[0] * (1.f/((opus_int32)1<<28)));
314     A[1] = (opus_val32)(A_Q28[1] * (1.f/((opus_int32)1<<28)));
315     B[0] = (opus_val32)(B_Q28[0] * (1.f/((opus_int32)1<<28)));
316     B[1] = (opus_val32)(B_Q28[1] * (1.f/((opus_int32)1<<28)));
317     B[2] = (opus_val32)(B_Q28[2] * (1.f/((opus_int32)1<<28)));
318
319     /* Negate A_Q28 values and split in two parts */
320
321     for( k = 0; k < len; k++ ) {
322         /* S[ 0 ], S[ 1 ]: Q12 */
323         inval = in[ k*stride ];
324         vout = S[ 0 ] + B[0]*inval;
325
326         S[ 0 ] = S[1] - vout*A[0] + B[1]*inval;
327
328         S[ 1 ] = - vout*A[1] + B[2]*inval;
329
330         /* Scale back to Q0 and saturate */
331         out[ k*stride ] = vout;
332     }
333 }
334 #endif
335
336 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)
337 {
338    opus_int32 B_Q28[ 3 ], A_Q28[ 2 ];
339    opus_int32 Fc_Q19, r_Q28, r_Q22;
340
341    silk_assert( cutoff_Hz <= silk_int32_MAX / SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ) );
342    Fc_Q19 = silk_DIV32_16( silk_SMULBB( SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ), cutoff_Hz ), Fs/1000 );
343    silk_assert( Fc_Q19 > 0 && Fc_Q19 < 32768 );
344
345    r_Q28 = SILK_FIX_CONST( 1.0, 28 ) - silk_MUL( SILK_FIX_CONST( 0.92, 9 ), Fc_Q19 );
346
347    /* b = r * [ 1; -2; 1 ]; */
348    /* a = [ 1; -2 * r * ( 1 - 0.5 * Fc^2 ); r^2 ]; */
349    B_Q28[ 0 ] = r_Q28;
350    B_Q28[ 1 ] = silk_LSHIFT( -r_Q28, 1 );
351    B_Q28[ 2 ] = r_Q28;
352
353    /* -r * ( 2 - Fc * Fc ); */
354    r_Q22  = silk_RSHIFT( r_Q28, 6 );
355    A_Q28[ 0 ] = silk_SMULWW( r_Q22, silk_SMULWW( Fc_Q19, Fc_Q19 ) - SILK_FIX_CONST( 2.0,  22 ) );
356    A_Q28[ 1 ] = silk_SMULWW( r_Q22, r_Q22 );
357
358 #ifdef FIXED_POINT
359    silk_biquad_alt( in, B_Q28, A_Q28, hp_mem, out, len, channels );
360    if( channels == 2 ) {
361        silk_biquad_alt( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
362    }
363 #else
364    silk_biquad_float( in, B_Q28, A_Q28, hp_mem, out, len, channels );
365    if( channels == 2 ) {
366        silk_biquad_float( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
367    }
368 #endif
369 }
370
371 #ifdef FIXED_POINT
372 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)
373 {
374    int c, i;
375    int shift;
376
377    /* Approximates -round(log2(4.*cutoff_Hz/Fs)) */
378    shift=celt_ilog2(Fs/(cutoff_Hz*3));
379    for (c=0;c<channels;c++)
380    {
381       for (i=0;i<len;i++)
382       {
383          opus_val32 x, tmp, y;
384          x = SHL32(EXTEND32(in[channels*i+c]), 15);
385          /* First stage */
386          tmp = x-hp_mem[2*c];
387          hp_mem[2*c] = hp_mem[2*c] + PSHR32(x - hp_mem[2*c], shift);
388          /* Second stage */
389          y = tmp - hp_mem[2*c+1];
390          hp_mem[2*c+1] = hp_mem[2*c+1] + PSHR32(tmp - hp_mem[2*c+1], shift);
391          out[channels*i+c] = EXTRACT16(SATURATE(PSHR32(y, 15), 32767));
392       }
393    }
394 }
395
396 #else
397 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)
398 {
399    int c, i;
400    float coef;
401
402    coef = 4.*cutoff_Hz/Fs;
403    for (c=0;c<channels;c++)
404    {
405       for (i=0;i<len;i++)
406       {
407          opus_val32 x, tmp, y;
408          x = in[channels*i+c];
409          /* First stage */
410          tmp = x-hp_mem[2*c];
411          hp_mem[2*c] = hp_mem[2*c] + coef*(x - hp_mem[2*c]);
412          /* Second stage */
413          y = tmp - hp_mem[2*c+1];
414          hp_mem[2*c+1] = hp_mem[2*c+1] + coef*(tmp - hp_mem[2*c+1]);
415          out[channels*i+c] = y;
416       }
417    }
418 }
419 #endif
420
421 static void stereo_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2,
422         int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
423 {
424     int i;
425     int overlap;
426     int inc;
427     inc = 48000/Fs;
428     overlap=overlap48/inc;
429     g1 = Q15ONE-g1;
430     g2 = Q15ONE-g2;
431     for (i=0;i<overlap;i++)
432     {
433        opus_val32 diff;
434        opus_val16 g, w;
435        w = MULT16_16_Q15(window[i*inc], window[i*inc]);
436        g = SHR32(MAC16_16(MULT16_16(w,g2),
437              Q15ONE-w, g1), 15);
438        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
439        diff = MULT16_16_Q15(g, diff);
440        out[i*channels] = out[i*channels] - diff;
441        out[i*channels+1] = out[i*channels+1] + diff;
442     }
443     for (;i<frame_size;i++)
444     {
445        opus_val32 diff;
446        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
447        diff = MULT16_16_Q15(g2, diff);
448        out[i*channels] = out[i*channels] - diff;
449        out[i*channels+1] = out[i*channels+1] + diff;
450     }
451 }
452
453 OpusEncoder *opus_encoder_create(opus_int32 Fs, int channels, int application, int *error)
454 {
455    int ret;
456    OpusEncoder *st;
457    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
458        (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
459        && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
460    {
461       if (error)
462          *error = OPUS_BAD_ARG;
463       return NULL;
464    }
465    st = (OpusEncoder *)opus_alloc(opus_encoder_get_size(channels));
466    if (st == NULL)
467    {
468       if (error)
469          *error = OPUS_ALLOC_FAIL;
470       return NULL;
471    }
472    ret = opus_encoder_init(st, Fs, channels, application);
473    if (error)
474       *error = ret;
475    if (ret != OPUS_OK)
476    {
477       opus_free(st);
478       st = NULL;
479    }
480    return st;
481 }
482
483 static opus_int32 user_bitrate_to_bitrate(OpusEncoder *st, int frame_size, int max_data_bytes)
484 {
485   if(!frame_size)frame_size=st->Fs/400;
486   if (st->user_bitrate_bps==OPUS_AUTO)
487     return 60*st->Fs/frame_size + st->Fs*st->channels;
488   else if (st->user_bitrate_bps==OPUS_BITRATE_MAX)
489     return max_data_bytes*8*st->Fs/frame_size;
490   else
491     return st->user_bitrate_bps;
492 }
493
494 #ifdef FIXED_POINT
495 #define opus_encode_native opus_encode
496 opus_int32 opus_encode(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
497                 unsigned char *data, opus_int32 out_data_bytes)
498 #else
499 #define opus_encode_native opus_encode_float
500 opus_int32 opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
501                       unsigned char *data, opus_int32 out_data_bytes)
502 #endif
503 {
504     void *silk_enc;
505     CELTEncoder *celt_enc;
506     int i;
507     int ret=0;
508     opus_int32 nBytes;
509     ec_enc enc;
510     int bytes_target;
511     int prefill=0;
512     int start_band = 0;
513     int redundancy = 0;
514     int redundancy_bytes = 0; /* Number of bytes to use for redundancy frame */
515     int celt_to_silk = 0;
516     VARDECL(opus_val16, pcm_buf);
517     int nb_compr_bytes;
518     int to_celt = 0;
519     opus_uint32 redundant_rng = 0;
520     int cutoff_Hz, hp_freq_smth1;
521     int voice_est; /* Probability of voice in Q7 */
522     opus_int32 equiv_rate;
523     int delay_compensation;
524     int frame_rate;
525     opus_int32 max_rate; /* Max bitrate we're allowed to use */
526     int curr_bandwidth;
527     opus_int32 max_data_bytes; /* Max number of bytes we're allowed to use */
528     int extra_buffer, total_buffer;
529     int perform_analysis=0;
530 #ifndef FIXED_POINT
531     AnalysisInfo analysis_info;
532 #endif
533     VARDECL(opus_val16, tmp_prefill);
534
535     ALLOC_STACK;
536
537     max_data_bytes = IMIN(1276, out_data_bytes);
538
539     st->rangeFinal = 0;
540     if (400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
541          50*frame_size != st->Fs &&  25*frame_size != st->Fs &&  50*frame_size != 3*st->Fs)
542     {
543        RESTORE_STACK;
544        return OPUS_BAD_ARG;
545     }
546     if (max_data_bytes<=0)
547     {
548        RESTORE_STACK;
549        return OPUS_BAD_ARG;
550     }
551     silk_enc = (char*)st+st->silk_enc_offset;
552     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
553
554 #ifndef FIXED_POINT
555     perform_analysis = st->silk_mode.complexity >= 7 && frame_size >= st->Fs/100 && st->Fs==48000;
556 #endif
557     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
558        delay_compensation = 0;
559     else
560        delay_compensation = st->delay_compensation;
561     if (perform_analysis)
562     {
563        total_buffer = IMAX(st->Fs/200, delay_compensation);
564     } else {
565        total_buffer = delay_compensation;
566     }
567     extra_buffer = total_buffer-delay_compensation;
568     st->bitrate_bps = user_bitrate_to_bitrate(st, frame_size, max_data_bytes);
569
570     frame_rate = st->Fs/frame_size;
571     if (max_data_bytes<3 || st->bitrate_bps < 3*frame_rate*8
572        || (frame_rate<50 && (max_data_bytes*frame_rate<300 || st->bitrate_bps < 2400)))
573     {
574        /*If the space is too low to do something useful, emit 'PLC' frames.*/
575        int tocmode = st->mode;
576        int bw = st->bandwidth == 0 ? OPUS_BANDWIDTH_NARROWBAND : st->bandwidth;
577        if (tocmode==0)
578           tocmode = MODE_SILK_ONLY;
579        if (frame_rate>100)
580           tocmode = MODE_CELT_ONLY;
581        if (frame_rate < 50)
582           tocmode = MODE_SILK_ONLY;
583        if(tocmode==MODE_SILK_ONLY&&bw>OPUS_BANDWIDTH_WIDEBAND)
584           bw=OPUS_BANDWIDTH_WIDEBAND;
585        else if (tocmode==MODE_CELT_ONLY&&bw==OPUS_BANDWIDTH_MEDIUMBAND)
586           bw=OPUS_BANDWIDTH_NARROWBAND;
587        else if (bw<=OPUS_BANDWIDTH_SUPERWIDEBAND)
588           bw=OPUS_BANDWIDTH_SUPERWIDEBAND;
589        data[0] = gen_toc(tocmode, frame_rate, bw, st->stream_channels);
590        RESTORE_STACK;
591        return 1;
592     }
593     if (!st->use_vbr)
594     {
595        int cbrBytes;
596        cbrBytes = IMIN( (st->bitrate_bps + 4*frame_rate)/(8*frame_rate) , max_data_bytes);
597        st->bitrate_bps = cbrBytes * (8*frame_rate);
598        max_data_bytes = cbrBytes;
599     }
600     max_rate = frame_rate*max_data_bytes*8;
601
602     /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */
603     equiv_rate = st->bitrate_bps - 60*(st->Fs/frame_size - 50);
604
605     if (st->signal_type == OPUS_SIGNAL_VOICE)
606        voice_est = 127;
607     else if (st->signal_type == OPUS_SIGNAL_MUSIC)
608        voice_est = 0;
609     else if (st->voice_ratio >= 0)
610        voice_est = st->voice_ratio*327>>8;
611     else if (st->application == OPUS_APPLICATION_VOIP)
612        voice_est = 115;
613     else
614        voice_est = 48;
615
616     if (st->force_channels!=OPUS_AUTO && st->channels == 2)
617     {
618         st->stream_channels = st->force_channels;
619     } else {
620 #ifdef FUZZING
621        /* Random mono/stereo decision */
622        if (st->channels == 2 && (rand()&0x1F)==0)
623           st->stream_channels = 3-st->stream_channels;
624 #else
625        /* Rate-dependent mono-stereo decision */
626        if (st->channels == 2)
627        {
628           opus_int32 stereo_threshold;
629           stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14);
630           if (st->stream_channels == 2)
631              stereo_threshold -= 4000;
632           else
633              stereo_threshold += 4000;
634           st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1;
635        } else {
636           st->stream_channels = st->channels;
637        }
638 #endif
639     }
640
641     /* Mode selection depending on application and signal type */
642     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
643     {
644        st->mode = MODE_CELT_ONLY;
645     } else if (st->user_forced_mode == OPUS_AUTO)
646     {
647 #ifdef FUZZING
648        /* Random mode switching */
649        if ((rand()&0xF)==0)
650        {
651           if ((rand()&0x1)==0)
652              st->mode = MODE_CELT_ONLY;
653           else
654              st->mode = MODE_SILK_ONLY;
655        } else {
656           if (st->prev_mode==MODE_CELT_ONLY)
657              st->mode = MODE_CELT_ONLY;
658           else
659              st->mode = MODE_SILK_ONLY;
660        }
661 #else
662        int chan;
663        opus_int32 mode_voice, mode_music;
664        opus_int32 threshold;
665
666        chan = (st->channels==2) && st->force_channels!=1;
667        mode_voice = mode_thresholds[chan][0];
668        mode_music = mode_thresholds[chan][1];
669        threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14);
670
671        /* Hysteresis */
672        if (st->prev_mode == MODE_CELT_ONLY)
673            threshold -= 4000;
674        else if (st->prev_mode>0)
675            threshold += 4000;
676
677        st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY;
678
679        /* When FEC is enabled and there's enough packet loss, use SILK */
680        if (st->silk_mode.useInBandFEC && st->silk_mode.packetLossPercentage > (128-voice_est)>>4)
681           st->mode = MODE_SILK_ONLY;
682        /* When encoding voice and DTX is enabled, set the encoder to SILK mode (at least for now) */
683        if (st->silk_mode.useDTX && voice_est > 100)
684           st->mode = MODE_SILK_ONLY;
685 #endif
686     } else {
687        st->mode = st->user_forced_mode;
688     }
689
690     /* Override the chosen mode to make sure we meet the requested frame size */
691     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
692        st->mode = MODE_CELT_ONLY;
693
694     if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0
695           && st->mode != MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)
696     {
697        /* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */
698        st->silk_mode.toMono = 1;
699        st->stream_channels = 2;
700     } else {
701        st->silk_mode.toMono = 0;
702     }
703
704     if (st->prev_mode > 0 &&
705         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
706     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
707     {
708         redundancy = 1;
709         celt_to_silk = (st->mode != MODE_CELT_ONLY);
710         if (!celt_to_silk)
711         {
712             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
713             if (frame_size >= st->Fs/100)
714             {
715                 st->mode = st->prev_mode;
716                 to_celt = 1;
717             } else {
718                 redundancy=0;
719             }
720         }
721     }
722     /* For the first frame at a new SILK bandwidth */
723     if (st->silk_bw_switch)
724     {
725        redundancy = 1;
726        celt_to_silk = 1;
727        st->silk_bw_switch = 0;
728     }
729
730     if (redundancy)
731     {
732        /* Fair share of the max size allowed */
733        redundancy_bytes = IMIN(257, max_data_bytes*(opus_int32)(st->Fs/200)/(frame_size+st->Fs/200));
734        /* For VBR, target the actual bitrate (subject to the limit above) */
735        if (st->use_vbr)
736           redundancy_bytes = IMIN(redundancy_bytes, st->bitrate_bps/1600);
737     }
738
739     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
740     {
741         silk_EncControlStruct dummy;
742         silk_InitEncoder( silk_enc, &dummy);
743         prefill=1;
744     }
745
746     /* Automatic (rate-dependent) bandwidth selection */
747     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
748     {
749         const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds;
750         opus_int32 bandwidth_thresholds[8];
751         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
752         opus_int32 equiv_rate2;
753
754         equiv_rate2 = equiv_rate;
755         if (st->mode != MODE_CELT_ONLY)
756         {
757            /* Adjust the threshold +/- 10% depending on complexity */
758            equiv_rate2 = equiv_rate2 * (45+st->silk_mode.complexity)/50;
759            /* CBR is less efficient by ~1 kb/s */
760            if (!st->use_vbr)
761               equiv_rate2 -= 1000;
762         }
763         if (st->channels==2 && st->force_channels!=1)
764         {
765            voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds;
766            music_bandwidth_thresholds = stereo_music_bandwidth_thresholds;
767         } else {
768            voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds;
769            music_bandwidth_thresholds = mono_music_bandwidth_thresholds;
770         }
771         /* Interpolate bandwidth thresholds depending on voice estimation */
772         for (i=0;i<8;i++)
773         {
774            bandwidth_thresholds[i] = music_bandwidth_thresholds[i]
775                     + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14);
776         }
777         do {
778             int threshold, hysteresis;
779             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
780             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
781             if (!st->first)
782             {
783                 if (st->bandwidth >= bandwidth)
784                     threshold -= hysteresis;
785                 else
786                     threshold += hysteresis;
787             }
788             if (equiv_rate2 >= threshold)
789                 break;
790         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
791         st->bandwidth = bandwidth;
792         /* Prevents any transition to SWB/FB until the SILK layer has fully
793            switched to WB mode and turned the variable LP filter off */
794         if (!st->first && st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
795             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
796     }
797
798     if (st->bandwidth>st->max_bandwidth)
799        st->bandwidth = st->max_bandwidth;
800
801     if (st->user_bandwidth != OPUS_AUTO)
802         st->bandwidth = st->user_bandwidth;
803
804     /* This prevents us from using hybrid at unsafe CBR/max rates */
805     if (st->mode != MODE_CELT_ONLY && max_rate < 15000)
806     {
807        st->bandwidth = IMIN(st->bandwidth, OPUS_BANDWIDTH_WIDEBAND);
808     }
809
810     /* Prevents Opus from wasting bits on frequencies that are above
811        the Nyquist rate of the input signal */
812     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
813         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
814     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
815         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
816     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
817         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
818     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
819         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
820
821     /* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */
822     if (max_data_bytes < (frame_rate > 50 ? 12000 : 8000)*frame_size / (st->Fs * 8))
823        st->mode = MODE_CELT_ONLY;
824
825     /* CELT mode doesn't support mediumband, use wideband instead */
826     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
827         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
828
829     /* Can't support higher than wideband for >20 ms frames */
830     if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND))
831     {
832        VARDECL(unsigned char, tmp_data);
833        int nb_frames;
834        int bak_mode, bak_bandwidth, bak_channels, bak_to_mono;
835        OpusRepacketizer rp;
836        opus_int32 bytes_per_frame;
837
838
839        nb_frames = frame_size > st->Fs/25 ? 3 : 2;
840        bytes_per_frame = IMIN(1276,(out_data_bytes-3)/nb_frames);
841
842        ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char);
843
844        opus_repacketizer_init(&rp);
845
846        bak_mode = st->user_forced_mode;
847        bak_bandwidth = st->user_bandwidth;
848        bak_channels = st->force_channels;
849
850        st->user_forced_mode = st->mode;
851        st->user_bandwidth = st->bandwidth;
852        st->force_channels = st->stream_channels;
853        bak_to_mono = st->silk_mode.toMono;
854
855        if (bak_to_mono)
856           st->force_channels = 1;
857        else
858           st->prev_channels = st->stream_channels;
859        for (i=0;i<nb_frames;i++)
860        {
861           int tmp_len;
862           st->silk_mode.toMono = 0;
863           /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
864           if (to_celt && i==nb_frames-1)
865              st->user_forced_mode = MODE_CELT_ONLY;
866           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);
867           if (tmp_len<0)
868           {
869              RESTORE_STACK;
870              return OPUS_INTERNAL_ERROR;
871           }
872           ret = opus_repacketizer_cat(&rp, tmp_data+i*bytes_per_frame, tmp_len);
873           if (ret<0)
874           {
875              RESTORE_STACK;
876              return OPUS_INTERNAL_ERROR;
877           }
878        }
879        ret = opus_repacketizer_out(&rp, data, out_data_bytes);
880        if (ret<0)
881        {
882           RESTORE_STACK;
883           return OPUS_INTERNAL_ERROR;
884        }
885        st->user_forced_mode = bak_mode;
886        st->user_bandwidth = bak_bandwidth;
887        st->force_channels = bak_channels;
888        st->silk_mode.toMono = bak_to_mono;
889        RESTORE_STACK;
890        return ret;
891     }
892
893     curr_bandwidth = st->bandwidth;
894
895     /* Chooses the appropriate mode for speech
896        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
897     if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND)
898         st->mode = MODE_HYBRID;
899     if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
900         st->mode = MODE_SILK_ONLY;
901
902     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
903     bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
904
905     data += 1;
906
907     ec_enc_init(&enc, data, max_data_bytes-1);
908
909     ALLOC(pcm_buf, (total_buffer+frame_size)*st->channels, opus_val16);
910     for (i=0;i<total_buffer*st->channels;i++)
911        pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-total_buffer)*st->channels+i];
912
913     if (st->mode == MODE_CELT_ONLY)
914        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
915     else
916        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
917
918     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
919           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
920
921     /* convert from log scale to Hertz */
922     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
923
924     if (st->application == OPUS_APPLICATION_VOIP)
925     {
926        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
927     } else {
928        dc_reject(pcm, 3, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
929     }
930
931 #ifndef FIXED_POINT
932     if (perform_analysis)
933     {
934        int nb_analysis_frames;
935        nb_analysis_frames = frame_size/(st->Fs/100);
936        for (i=0;i<nb_analysis_frames;i++)
937           tonality_analysis(&st->analysis, &analysis_info, celt_enc, pcm_buf+i*(st->Fs/100)*st->channels, st->channels);
938        if (st->signal_type == OPUS_AUTO)
939           st->voice_ratio = floor(.5+100*(1-analysis_info.music_prob));
940     } else {
941        analysis_info.valid = 0;
942        st->voice_ratio = -1;
943     }
944 #endif
945
946     /* SILK processing */
947     if (st->mode != MODE_CELT_ONLY)
948     {
949         opus_int32 total_bitRate, celt_rate, HB_gain_Q16;
950 #ifdef FIXED_POINT
951        const opus_int16 *pcm_silk;
952 #else
953        VARDECL(opus_int16, pcm_silk);
954        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
955 #endif
956
957         /* Distribute bits between SILK and CELT */
958         total_bitRate = 8 * bytes_target * frame_rate;
959         if( st->mode == MODE_HYBRID ) {
960             /* Base rate for SILK */
961             st->silk_mode.bitRate = st->stream_channels * ( 5000 + 1000 * ( st->Fs == 100 * frame_size ) );
962             if( curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
963                 /* SILK gets 2/3 of the remaining bits */
964                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 2 / 3;
965             } else { /* FULLBAND */
966                 /* SILK gets 3/5 of the remaining bits */
967                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 3 / 5;
968             }
969             /* Don't let SILK use more than 80% */
970             if( st->silk_mode.bitRate > total_bitRate * 4/5 ) {
971                 st->silk_mode.bitRate = total_bitRate * 4/5;
972             }
973             /* Increasingly attenuate high band when it gets allocated fewer bits */
974             celt_rate = total_bitRate - st->silk_mode.bitRate;
975             if( curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
976                 HB_gain_Q16 = ( celt_rate << 10 ) / ( ( celt_rate + st->stream_channels * 2000 ) >> 6 );
977             } else { /* FULLBAND */
978                 HB_gain_Q16 = ( celt_rate << 10 ) / ( ( celt_rate + st->stream_channels * 2400 ) >> 6 );
979             }
980         } else {
981             /* SILK gets all bits */
982             st->silk_mode.bitRate = total_bitRate;
983         }
984
985         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
986         st->silk_mode.nChannelsAPI = st->channels;
987         st->silk_mode.nChannelsInternal = st->stream_channels;
988         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
989             st->silk_mode.desiredInternalSampleRate = 8000;
990         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
991             st->silk_mode.desiredInternalSampleRate = 12000;
992         } else {
993             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
994             st->silk_mode.desiredInternalSampleRate = 16000;
995         }
996         if( st->mode == MODE_HYBRID ) {
997             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
998             st->silk_mode.minInternalSampleRate = 16000;
999         } else {
1000             st->silk_mode.minInternalSampleRate = 8000;
1001         }
1002
1003         if (st->mode == MODE_SILK_ONLY)
1004         {
1005            opus_int32 effective_max_rate = max_rate;
1006            st->silk_mode.maxInternalSampleRate = 16000;
1007            if (frame_rate > 50)
1008               effective_max_rate = effective_max_rate*2/3;
1009            if (effective_max_rate < 13000)
1010            {
1011               st->silk_mode.maxInternalSampleRate = 12000;
1012               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
1013            }
1014            if (effective_max_rate < 9600)
1015            {
1016               st->silk_mode.maxInternalSampleRate = 8000;
1017               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
1018            }
1019         } else {
1020            st->silk_mode.maxInternalSampleRate = 16000;
1021         }
1022
1023         st->silk_mode.useCBR = !st->use_vbr;
1024
1025         /* Call SILK encoder for the low band */
1026         nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes);
1027
1028         st->silk_mode.maxBits = nBytes*8;
1029         /* Only allow up to 90% of the bits for hybrid mode*/
1030         if (st->mode == MODE_HYBRID)
1031            st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
1032         if (st->silk_mode.useCBR)
1033         {
1034            st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
1035            /* Reduce the initial target to make it easier to reach the CBR rate */
1036            st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000);
1037         }
1038
1039         if (prefill)
1040         {
1041             opus_int32 zero=0;
1042 #ifdef FIXED_POINT
1043             pcm_silk = st->delay_buffer;
1044 #else
1045             for (i=0;i<st->encoder_buffer*st->channels;i++)
1046                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
1047 #endif
1048             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
1049         }
1050
1051 #ifdef FIXED_POINT
1052         pcm_silk = pcm_buf+total_buffer*st->channels;
1053 #else
1054         for (i=0;i<frame_size*st->channels;i++)
1055             pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
1056 #endif
1057         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
1058         if( ret ) {
1059             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
1060             /* Handle error */
1061            RESTORE_STACK;
1062            return OPUS_INTERNAL_ERROR;
1063         }
1064         if (nBytes==0)
1065         {
1066            st->rangeFinal = 0;
1067            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1068            RESTORE_STACK;
1069            return 1;
1070         }
1071         /* Extract SILK internal bandwidth for signaling in first byte */
1072         if( st->mode == MODE_SILK_ONLY ) {
1073             if( st->silk_mode.internalSampleRate == 8000 ) {
1074                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1075             } else if( st->silk_mode.internalSampleRate == 12000 ) {
1076                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1077             } else if( st->silk_mode.internalSampleRate == 16000 ) {
1078                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1079             }
1080         } else {
1081             silk_assert( st->silk_mode.internalSampleRate == 16000 );
1082         }
1083
1084         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
1085         /* FIXME: How do we allocate the redundancy for CBR? */
1086         if (st->silk_mode.opusCanSwitch)
1087         {
1088            redundancy = 1;
1089            celt_to_silk = 0;
1090            st->silk_bw_switch = 1;
1091         }
1092
1093         if( st->mode == MODE_HYBRID ) {
1094 #ifdef FIXED_POINT
1095             for (i=0;i<frame_size*st->channels;i++) {
1096                 pcm_buf[delay_compensation*st->channels + i] = (opus_val16)( ( HB_gain_Q16 * pcm_buf[delay_compensation*st->channels + i] ) >> 16 );
1097             }
1098 #else
1099             float HB_gain = HB_gain_Q16 / 65536.0f;
1100             for (i=0;i<frame_size*st->channels;i++) {
1101                 pcm_buf[delay_compensation*st->channels + i] *= HB_gain;
1102             }
1103 #endif
1104         }
1105     }
1106
1107     /* CELT processing */
1108     {
1109         int endband=21;
1110
1111         switch(curr_bandwidth)
1112         {
1113             case OPUS_BANDWIDTH_NARROWBAND:
1114                 endband = 13;
1115                 break;
1116             case OPUS_BANDWIDTH_MEDIUMBAND:
1117             case OPUS_BANDWIDTH_WIDEBAND:
1118                 endband = 17;
1119                 break;
1120             case OPUS_BANDWIDTH_SUPERWIDEBAND:
1121                 endband = 19;
1122                 break;
1123             case OPUS_BANDWIDTH_FULLBAND:
1124                 endband = 21;
1125                 break;
1126         }
1127         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
1128         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
1129     }
1130     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1131     if (st->mode != MODE_SILK_ONLY)
1132     {
1133         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1134         /* Allow prediction unless we decide to disable it later */
1135         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
1136
1137         if (st->mode == MODE_HYBRID)
1138         {
1139             int len;
1140
1141             len = (ec_tell(&enc)+7)>>3;
1142             if (redundancy)
1143                len += st->mode == MODE_HYBRID ? 3 : 1;
1144             if( st->use_vbr ) {
1145                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
1146             } else {
1147                 /* check if SILK used up too much */
1148                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
1149             }
1150         } else {
1151             if (st->use_vbr)
1152             {
1153                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
1154                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
1155                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps));
1156                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
1157             } else {
1158                 nb_compr_bytes = bytes_target;
1159             }
1160         }
1161
1162     } else {
1163         nb_compr_bytes = 0;
1164     }
1165
1166     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
1167     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
1168     {
1169        for (i=0;i<st->channels*st->Fs/400;i++)
1170           tmp_prefill[i] = st->delay_buffer[(extra_buffer+st->encoder_buffer-total_buffer-st->Fs/400)*st->channels + i];
1171     }
1172
1173     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+total_buffer));i++)
1174         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
1175     for (;i<st->encoder_buffer*st->channels;i++)
1176         st->delay_buffer[i] = pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels+i];
1177
1178
1179     if (st->mode != MODE_HYBRID || st->stream_channels==1)
1180        st->silk_mode.stereoWidth_Q14 = 1<<14;
1181     if( st->channels == 2 ) {
1182         /* Apply stereo width reduction (at low bitrates) */
1183         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1184             opus_val16 g1, g2;
1185             const CELTMode *celt_mode;
1186
1187             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1188             g1 = st->hybrid_stereo_width_Q14;
1189             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1190 #ifdef FIXED_POINT
1191             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
1192             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
1193 #else
1194             g1 *= (1.f/16384);
1195             g2 *= (1.f/16384);
1196 #endif
1197             stereo_fade(pcm_buf+extra_buffer*st->channels, pcm_buf+extra_buffer*st->channels, g1, g2, celt_mode->overlap,
1198                   frame_size, st->channels, celt_mode->window, st->Fs);
1199             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1200         }
1201     }
1202
1203     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
1204     {
1205         /* For SILK mode, the redundancy is inferred from the length */
1206         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
1207            ec_enc_bit_logp(&enc, redundancy, 12);
1208         if (redundancy)
1209         {
1210             int max_redundancy;
1211             ec_enc_bit_logp(&enc, celt_to_silk, 1);
1212             if (st->mode == MODE_HYBRID)
1213                max_redundancy = (max_data_bytes-1)-nb_compr_bytes-1;
1214             else
1215                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1216             /* Target the same bit-rate for redundancy as for the rest,
1217                up to a max of 257 bytes */
1218             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
1219             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
1220             if (st->mode == MODE_HYBRID)
1221                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
1222         }
1223     } else {
1224         redundancy = 0;
1225     }
1226
1227     if (!redundancy)
1228     {
1229        st->silk_bw_switch = 0;
1230        redundancy_bytes = 0;
1231     }
1232     if (st->mode != MODE_CELT_ONLY)start_band=17;
1233
1234     if (st->mode == MODE_SILK_ONLY)
1235     {
1236         ret = (ec_tell(&enc)+7)>>3;
1237         ec_enc_done(&enc);
1238         nb_compr_bytes = ret;
1239     } else {
1240        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
1241        ec_enc_shrink(&enc, nb_compr_bytes);
1242     }
1243
1244
1245     /* 5 ms redundant frame for CELT->SILK */
1246     if (redundancy && celt_to_silk)
1247     {
1248         int err;
1249         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1250         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1251         err = celt_encode_with_ec(celt_enc, pcm_buf+extra_buffer*st->channels, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
1252         if (err < 0)
1253         {
1254            RESTORE_STACK;
1255            return OPUS_INTERNAL_ERROR;
1256         }
1257         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1258         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1259     }
1260
1261     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
1262
1263     if (st->mode != MODE_SILK_ONLY)
1264     {
1265         if (st->mode != st->prev_mode && st->prev_mode > 0)
1266         {
1267            unsigned char dummy[2];
1268            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1269
1270            /* Prefilling */
1271            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
1272            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1273         }
1274         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
1275         if (ec_tell(&enc) <= 8*nb_compr_bytes)
1276         {
1277 #ifndef FIXED_POINT
1278            if (perform_analysis)
1279               celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(&analysis_info));
1280 #endif
1281            ret = celt_encode_with_ec(celt_enc, pcm_buf+extra_buffer*st->channels, frame_size, NULL, nb_compr_bytes, &enc);
1282            if (ret < 0)
1283            {
1284               RESTORE_STACK;
1285               return OPUS_INTERNAL_ERROR;
1286            }
1287         }
1288     }
1289
1290     /* 5 ms redundant frame for SILK->CELT */
1291     if (redundancy && !celt_to_silk)
1292     {
1293         int err;
1294         unsigned char dummy[2];
1295         int N2, N4;
1296         N2 = st->Fs/200;
1297         N4 = st->Fs/400;
1298
1299         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1300         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1301         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1302
1303         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1304         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(extra_buffer+frame_size-N2-N4), N4, dummy, 2, NULL);
1305
1306         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(extra_buffer+frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1307         if (err < 0)
1308         {
1309            RESTORE_STACK;
1310            return OPUS_INTERNAL_ERROR;
1311         }
1312         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1313     }
1314
1315
1316
1317     /* Signalling the mode in the first byte */
1318     data--;
1319     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1320
1321     st->rangeFinal = enc.rng ^ redundant_rng;
1322
1323     if (to_celt)
1324         st->prev_mode = MODE_CELT_ONLY;
1325     else
1326         st->prev_mode = st->mode;
1327     st->prev_channels = st->stream_channels;
1328     st->prev_framesize = frame_size;
1329
1330     st->first = 0;
1331
1332     /* In the unlikely case that the SILK encoder busted its target, tell
1333        the decoder to call the PLC */
1334     if (ec_tell(&enc) > (max_data_bytes-1)*8)
1335     {
1336        if (max_data_bytes < 2)
1337        {
1338           RESTORE_STACK;
1339           return OPUS_BUFFER_TOO_SMALL;
1340        }
1341        data[1] = 0;
1342        ret = 1;
1343        st->rangeFinal = 0;
1344     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
1345     {
1346        /*When in LPC only mode it's perfectly
1347          reasonable to strip off trailing zero bytes as
1348          the required range decoder behavior is to
1349          fill these in. This can't be done when the MDCT
1350          modes are used because the decoder needs to know
1351          the actual length for allocation purposes.*/
1352        while(ret>2&&data[ret]==0)ret--;
1353     }
1354     /* Count ToC and redundancy */
1355     ret += 1+redundancy_bytes;
1356     if (!st->use_vbr && ret >= 3)
1357     {
1358        if (pad_frame(data, ret, max_data_bytes))
1359        {
1360           RESTORE_STACK;
1361           return OPUS_INTERNAL_ERROR;
1362        }
1363        ret = max_data_bytes;
1364     }
1365     RESTORE_STACK;
1366     return ret;
1367 }
1368
1369 #ifdef FIXED_POINT
1370
1371 #ifndef DISABLE_FLOAT_API
1372 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1373       unsigned char *data, opus_int32 max_data_bytes)
1374 {
1375    int i, ret;
1376    VARDECL(opus_int16, in);
1377    ALLOC_STACK;
1378
1379    if(frame_size<0)
1380    {
1381       RESTORE_STACK;
1382       return OPUS_BAD_ARG;
1383    }
1384
1385    ALLOC(in, frame_size*st->channels, opus_int16);
1386
1387    for (i=0;i<frame_size*st->channels;i++)
1388       in[i] = FLOAT2INT16(pcm[i]);
1389    ret = opus_encode(st, in, frame_size, data, max_data_bytes);
1390    RESTORE_STACK;
1391    return ret;
1392 }
1393 #endif
1394
1395 #else
1396 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1397       unsigned char *data, opus_int32 max_data_bytes)
1398 {
1399    int i, ret;
1400    VARDECL(float, in);
1401    ALLOC_STACK;
1402
1403    ALLOC(in, frame_size*st->channels, float);
1404
1405    for (i=0;i<frame_size*st->channels;i++)
1406       in[i] = (1.0f/32768)*pcm[i];
1407    ret = opus_encode_float(st, in, frame_size, data, max_data_bytes);
1408    RESTORE_STACK;
1409    return ret;
1410 }
1411 #endif
1412
1413
1414 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
1415 {
1416     int ret;
1417     CELTEncoder *celt_enc;
1418     va_list ap;
1419
1420     ret = OPUS_OK;
1421     va_start(ap, request);
1422
1423     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1424
1425     switch (request)
1426     {
1427         case OPUS_SET_APPLICATION_REQUEST:
1428         {
1429             opus_int32 value = va_arg(ap, opus_int32);
1430             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
1431                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1432                || (!st->first && st->application != value))
1433             {
1434                ret = OPUS_BAD_ARG;
1435                break;
1436             }
1437             st->application = value;
1438         }
1439         break;
1440         case OPUS_GET_APPLICATION_REQUEST:
1441         {
1442             opus_int32 *value = va_arg(ap, opus_int32*);
1443             *value = st->application;
1444         }
1445         break;
1446         case OPUS_SET_BITRATE_REQUEST:
1447         {
1448             opus_int32 value = va_arg(ap, opus_int32);
1449             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1450             {
1451                 if (value <= 0)
1452                     goto bad_arg;
1453                 else if (value <= 500)
1454                     value = 500;
1455                 else if (value > (opus_int32)300000*st->channels)
1456                     value = (opus_int32)300000*st->channels;
1457             }
1458             st->user_bitrate_bps = value;
1459         }
1460         break;
1461         case OPUS_GET_BITRATE_REQUEST:
1462         {
1463             opus_int32 *value = va_arg(ap, opus_int32*);
1464             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
1465         }
1466         break;
1467         case OPUS_SET_FORCE_CHANNELS_REQUEST:
1468         {
1469             opus_int32 value = va_arg(ap, opus_int32);
1470             if((value<1 || value>st->channels) && value != OPUS_AUTO)
1471                 return OPUS_BAD_ARG;
1472             st->force_channels = value;
1473         }
1474         break;
1475         case OPUS_GET_FORCE_CHANNELS_REQUEST:
1476         {
1477             opus_int32 *value = va_arg(ap, opus_int32*);
1478             *value = st->force_channels;
1479         }
1480         break;
1481         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
1482         {
1483             opus_int32 value = va_arg(ap, opus_int32);
1484             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND)
1485                 return OPUS_BAD_ARG;
1486             st->max_bandwidth = value;
1487             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1488                 st->silk_mode.maxInternalSampleRate = 8000;
1489             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1490                 st->silk_mode.maxInternalSampleRate = 12000;
1491             } else {
1492                 st->silk_mode.maxInternalSampleRate = 16000;
1493             }
1494         }
1495         break;
1496         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
1497         {
1498             opus_int32 *value = va_arg(ap, opus_int32*);
1499             *value = st->max_bandwidth;
1500         }
1501         break;
1502         case OPUS_SET_BANDWIDTH_REQUEST:
1503         {
1504             opus_int32 value = va_arg(ap, opus_int32);
1505             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
1506                 return OPUS_BAD_ARG;
1507             st->user_bandwidth = value;
1508             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1509                 st->silk_mode.maxInternalSampleRate = 8000;
1510             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1511                 st->silk_mode.maxInternalSampleRate = 12000;
1512             } else {
1513                 st->silk_mode.maxInternalSampleRate = 16000;
1514             }
1515         }
1516         break;
1517         case OPUS_GET_BANDWIDTH_REQUEST:
1518         {
1519             opus_int32 *value = va_arg(ap, opus_int32*);
1520             *value = st->bandwidth;
1521         }
1522         break;
1523         case OPUS_SET_DTX_REQUEST:
1524         {
1525             opus_int32 value = va_arg(ap, opus_int32);
1526             if(value<0 || value>1)
1527                 return OPUS_BAD_ARG;
1528             st->silk_mode.useDTX = value;
1529         }
1530         break;
1531         case OPUS_GET_DTX_REQUEST:
1532         {
1533             opus_int32 *value = va_arg(ap, opus_int32*);
1534             *value = st->silk_mode.useDTX;
1535         }
1536         break;
1537         case OPUS_SET_COMPLEXITY_REQUEST:
1538         {
1539             opus_int32 value = va_arg(ap, opus_int32);
1540             if(value<0 || value>10)
1541                 return OPUS_BAD_ARG;
1542             st->silk_mode.complexity = value;
1543             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
1544         }
1545         break;
1546         case OPUS_GET_COMPLEXITY_REQUEST:
1547         {
1548             opus_int32 *value = va_arg(ap, opus_int32*);
1549             *value = st->silk_mode.complexity;
1550         }
1551         break;
1552         case OPUS_SET_INBAND_FEC_REQUEST:
1553         {
1554             opus_int32 value = va_arg(ap, opus_int32);
1555             if(value<0 || value>1)
1556                 return OPUS_BAD_ARG;
1557             st->silk_mode.useInBandFEC = value;
1558         }
1559         break;
1560         case OPUS_GET_INBAND_FEC_REQUEST:
1561         {
1562             opus_int32 *value = va_arg(ap, opus_int32*);
1563             *value = st->silk_mode.useInBandFEC;
1564         }
1565         break;
1566         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1567         {
1568             opus_int32 value = va_arg(ap, opus_int32);
1569             if (value < 0 || value > 100)
1570                 return OPUS_BAD_ARG;
1571             st->silk_mode.packetLossPercentage = value;
1572             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
1573         }
1574         break;
1575         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1576         {
1577             opus_int32 *value = va_arg(ap, opus_int32*);
1578             *value = st->silk_mode.packetLossPercentage;
1579         }
1580         break;
1581         case OPUS_SET_VBR_REQUEST:
1582         {
1583             opus_int32 value = va_arg(ap, opus_int32);
1584             if(value<0 || value>1)
1585                 return OPUS_BAD_ARG;
1586             st->use_vbr = value;
1587             st->silk_mode.useCBR = 1-value;
1588         }
1589         break;
1590         case OPUS_GET_VBR_REQUEST:
1591         {
1592             opus_int32 *value = va_arg(ap, opus_int32*);
1593             *value = st->use_vbr;
1594         }
1595         break;
1596         case OPUS_SET_VOICE_RATIO_REQUEST:
1597         {
1598             opus_int32 value = va_arg(ap, opus_int32);
1599             if (value>100 || value<-1)
1600                 goto bad_arg;
1601             st->voice_ratio = value;
1602         }
1603         break;
1604         case OPUS_GET_VOICE_RATIO_REQUEST:
1605         {
1606             opus_int32 *value = va_arg(ap, opus_int32*);
1607             *value = st->voice_ratio;
1608         }
1609         break;
1610         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1611         {
1612             opus_int32 value = va_arg(ap, opus_int32);
1613             if(value<0 || value>1)
1614                 return OPUS_BAD_ARG;
1615             st->vbr_constraint = value;
1616         }
1617         break;
1618         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1619         {
1620             opus_int32 *value = va_arg(ap, opus_int32*);
1621             *value = st->vbr_constraint;
1622         }
1623         break;
1624         case OPUS_SET_SIGNAL_REQUEST:
1625         {
1626             opus_int32 value = va_arg(ap, opus_int32);
1627             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
1628                 return OPUS_BAD_ARG;
1629             st->signal_type = value;
1630         }
1631         break;
1632         case OPUS_GET_SIGNAL_REQUEST:
1633         {
1634             opus_int32 *value = va_arg(ap, opus_int32*);
1635             *value = st->signal_type;
1636         }
1637         break;
1638         case OPUS_GET_LOOKAHEAD_REQUEST:
1639         {
1640             opus_int32 *value = va_arg(ap, opus_int32*);
1641             *value = st->Fs/400;
1642             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1643                 *value += st->delay_compensation;
1644         }
1645         break;
1646         case OPUS_GET_SAMPLE_RATE_REQUEST:
1647         {
1648             opus_int32 *value = va_arg(ap, opus_int32*);
1649             if (value==NULL)
1650             {
1651                 ret = OPUS_BAD_ARG;
1652                 break;
1653             }
1654             *value = st->Fs;
1655         }
1656         break;
1657         case OPUS_GET_FINAL_RANGE_REQUEST:
1658         {
1659             opus_uint32 *value = va_arg(ap, opus_uint32*);
1660             *value = st->rangeFinal;
1661         }
1662         break;
1663         case OPUS_SET_LSB_DEPTH_REQUEST:
1664         {
1665             opus_int32 value = va_arg(ap, opus_int32);
1666             ret = celt_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(value));
1667         }
1668         break;
1669         case OPUS_GET_LSB_DEPTH_REQUEST:
1670         {
1671             opus_int32 *value = va_arg(ap, opus_int32*);
1672             celt_encoder_ctl(celt_enc, OPUS_GET_LSB_DEPTH(value));
1673         }
1674         break;
1675         case OPUS_RESET_STATE:
1676         {
1677            void *silk_enc;
1678            silk_EncControlStruct dummy;
1679            silk_enc = (char*)st+st->silk_enc_offset;
1680
1681            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
1682                  sizeof(OpusEncoder)-
1683                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
1684
1685            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1686            silk_InitEncoder( silk_enc, &dummy );
1687            st->stream_channels = st->channels;
1688            st->hybrid_stereo_width_Q14 = 1 << 14;
1689            st->first = 1;
1690            st->mode = MODE_HYBRID;
1691            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
1692            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1693         }
1694         break;
1695         case OPUS_SET_FORCE_MODE_REQUEST:
1696         {
1697             opus_int32 value = va_arg(ap, opus_int32);
1698             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
1699                goto bad_arg;
1700             st->user_forced_mode = value;
1701         }
1702         break;
1703         default:
1704             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
1705             ret = OPUS_UNIMPLEMENTED;
1706             break;
1707     }
1708     va_end(ap);
1709     return ret;
1710 bad_arg:
1711     va_end(ap);
1712     return OPUS_BAD_ARG;
1713 }
1714
1715 void opus_encoder_destroy(OpusEncoder *st)
1716 {
1717     opus_free(st);
1718 }