4b6995d194e5fea6c26e62ba23bccdb09fec392b
[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         21000, 2000, /* WB<->SWB */
101         29000, 2000, /* 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 #ifdef FIXED_POINT
950        const opus_int16 *pcm_silk;
951 #else
952        VARDECL(opus_int16, pcm_silk);
953        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
954 #endif
955         st->silk_mode.bitRate = 8*bytes_target*frame_rate;
956         if( st->mode == MODE_HYBRID ) {
957             st->silk_mode.bitRate /= st->stream_channels;
958             if( curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
959                 if( st->Fs == 100 * frame_size ) {
960                     /* 24 kHz, 10 ms */
961                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 2000 + st->use_vbr * 1000 ) * 2 ) / 3;
962                 } else {
963                     /* 24 kHz, 20 ms */
964                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 1000 + st->use_vbr * 1000 ) * 2 ) / 3;
965                 }
966             } else {
967                 if( st->Fs == 100 * frame_size ) {
968                     /* 48 kHz, 10 ms */
969                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 8000 + st->use_vbr * 3000 ) / 2;
970                 } else {
971                     /* 48 kHz, 20 ms */
972                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 9000 + st->use_vbr * 1000 ) / 2;
973                 }
974             }
975             st->silk_mode.bitRate *= st->stream_channels;
976             /* don't let SILK use more than 80% */
977             if( st->silk_mode.bitRate > ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5 ) {
978                 st->silk_mode.bitRate = ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5;
979             }
980         }
981
982         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
983         st->silk_mode.nChannelsAPI = st->channels;
984         st->silk_mode.nChannelsInternal = st->stream_channels;
985         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
986             st->silk_mode.desiredInternalSampleRate = 8000;
987         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
988             st->silk_mode.desiredInternalSampleRate = 12000;
989         } else {
990             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
991             st->silk_mode.desiredInternalSampleRate = 16000;
992         }
993         if( st->mode == MODE_HYBRID ) {
994             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
995             st->silk_mode.minInternalSampleRate = 16000;
996         } else {
997             st->silk_mode.minInternalSampleRate = 8000;
998         }
999
1000         if (st->mode == MODE_SILK_ONLY)
1001         {
1002            opus_int32 effective_max_rate = max_rate;
1003            st->silk_mode.maxInternalSampleRate = 16000;
1004            if (frame_rate > 50)
1005               effective_max_rate = effective_max_rate*2/3;
1006            if (effective_max_rate < 13000)
1007            {
1008               st->silk_mode.maxInternalSampleRate = 12000;
1009               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
1010            }
1011            if (effective_max_rate < 9600)
1012            {
1013               st->silk_mode.maxInternalSampleRate = 8000;
1014               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
1015            }
1016         } else {
1017            st->silk_mode.maxInternalSampleRate = 16000;
1018         }
1019
1020         st->silk_mode.useCBR = !st->use_vbr;
1021
1022         /* Call SILK encoder for the low band */
1023         nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes);
1024
1025         st->silk_mode.maxBits = nBytes*8;
1026         /* Only allow up to 90% of the bits for hybrid mode*/
1027         if (st->mode == MODE_HYBRID)
1028            st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
1029         if (st->silk_mode.useCBR)
1030         {
1031            st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
1032            /* Reduce the initial target to make it easier to reach the CBR rate */
1033            st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000);
1034         }
1035
1036         if (prefill)
1037         {
1038             opus_int32 zero=0;
1039 #ifdef FIXED_POINT
1040             pcm_silk = st->delay_buffer;
1041 #else
1042             for (i=0;i<st->encoder_buffer*st->channels;i++)
1043                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
1044 #endif
1045             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
1046         }
1047
1048 #ifdef FIXED_POINT
1049         pcm_silk = pcm_buf+total_buffer*st->channels;
1050 #else
1051         for (i=0;i<frame_size*st->channels;i++)
1052             pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
1053 #endif
1054         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
1055         if( ret ) {
1056             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
1057             /* Handle error */
1058            RESTORE_STACK;
1059            return OPUS_INTERNAL_ERROR;
1060         }
1061         if (nBytes==0)
1062         {
1063            st->rangeFinal = 0;
1064            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1065            RESTORE_STACK;
1066            return 1;
1067         }
1068         /* Extract SILK internal bandwidth for signaling in first byte */
1069         if( st->mode == MODE_SILK_ONLY ) {
1070             if( st->silk_mode.internalSampleRate == 8000 ) {
1071                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1072             } else if( st->silk_mode.internalSampleRate == 12000 ) {
1073                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1074             } else if( st->silk_mode.internalSampleRate == 16000 ) {
1075                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1076             }
1077         } else {
1078             silk_assert( st->silk_mode.internalSampleRate == 16000 );
1079         }
1080
1081         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
1082         /* FIXME: How do we allocate the redundancy for CBR? */
1083         if (st->silk_mode.opusCanSwitch)
1084         {
1085            redundancy = 1;
1086            celt_to_silk = 0;
1087            st->silk_bw_switch = 1;
1088         }
1089     }
1090
1091     /* CELT processing */
1092     {
1093         int endband=21;
1094
1095         switch(curr_bandwidth)
1096         {
1097             case OPUS_BANDWIDTH_NARROWBAND:
1098                 endband = 13;
1099                 break;
1100             case OPUS_BANDWIDTH_MEDIUMBAND:
1101             case OPUS_BANDWIDTH_WIDEBAND:
1102                 endband = 17;
1103                 break;
1104             case OPUS_BANDWIDTH_SUPERWIDEBAND:
1105                 endband = 19;
1106                 break;
1107             case OPUS_BANDWIDTH_FULLBAND:
1108                 endband = 21;
1109                 break;
1110         }
1111         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
1112         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
1113     }
1114     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1115     if (st->mode != MODE_SILK_ONLY)
1116     {
1117         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1118         /* Allow prediction unless we decide to disable it later */
1119         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
1120
1121         if (st->mode == MODE_HYBRID)
1122         {
1123             int len;
1124
1125             len = (ec_tell(&enc)+7)>>3;
1126             if (redundancy)
1127                len += st->mode == MODE_HYBRID ? 3 : 1;
1128             if( st->use_vbr ) {
1129                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
1130             } else {
1131                 /* check if SILK used up too much */
1132                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
1133             }
1134         } else {
1135             if (st->use_vbr)
1136             {
1137                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
1138                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
1139                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps));
1140                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
1141             } else {
1142                 nb_compr_bytes = bytes_target;
1143             }
1144         }
1145
1146     } else {
1147         nb_compr_bytes = 0;
1148     }
1149
1150     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
1151     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
1152     {
1153        for (i=0;i<st->channels*st->Fs/400;i++)
1154           tmp_prefill[i] = st->delay_buffer[(extra_buffer+st->encoder_buffer-total_buffer-st->Fs/400)*st->channels + i];
1155     }
1156
1157     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+total_buffer));i++)
1158         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
1159     for (;i<st->encoder_buffer*st->channels;i++)
1160         st->delay_buffer[i] = pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels+i];
1161
1162
1163     if (st->mode != MODE_HYBRID || st->stream_channels==1)
1164        st->silk_mode.stereoWidth_Q14 = 1<<14;
1165     if( st->channels == 2 ) {
1166         /* Apply stereo width reduction (at low bitrates) */
1167         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1168             opus_val16 g1, g2;
1169             const CELTMode *celt_mode;
1170
1171             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1172             g1 = st->hybrid_stereo_width_Q14;
1173             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1174 #ifdef FIXED_POINT
1175             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
1176             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
1177 #else
1178             g1 *= (1.f/16384);
1179             g2 *= (1.f/16384);
1180 #endif
1181             stereo_fade(pcm_buf+extra_buffer*st->channels, pcm_buf+extra_buffer*st->channels, g1, g2, celt_mode->overlap,
1182                   frame_size, st->channels, celt_mode->window, st->Fs);
1183             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1184         }
1185     }
1186
1187     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
1188     {
1189         /* For SILK mode, the redundancy is inferred from the length */
1190         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
1191            ec_enc_bit_logp(&enc, redundancy, 12);
1192         if (redundancy)
1193         {
1194             int max_redundancy;
1195             ec_enc_bit_logp(&enc, celt_to_silk, 1);
1196             if (st->mode == MODE_HYBRID)
1197                max_redundancy = (max_data_bytes-1)-nb_compr_bytes-1;
1198             else
1199                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1200             /* Target the same bit-rate for redundancy as for the rest,
1201                up to a max of 257 bytes */
1202             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
1203             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
1204             if (st->mode == MODE_HYBRID)
1205                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
1206         }
1207     } else {
1208         redundancy = 0;
1209     }
1210
1211     if (!redundancy)
1212     {
1213        st->silk_bw_switch = 0;
1214        redundancy_bytes = 0;
1215     }
1216     if (st->mode != MODE_CELT_ONLY)start_band=17;
1217
1218     if (st->mode == MODE_SILK_ONLY)
1219     {
1220         ret = (ec_tell(&enc)+7)>>3;
1221         ec_enc_done(&enc);
1222         nb_compr_bytes = ret;
1223     } else {
1224        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
1225        ec_enc_shrink(&enc, nb_compr_bytes);
1226     }
1227
1228
1229     /* 5 ms redundant frame for CELT->SILK */
1230     if (redundancy && celt_to_silk)
1231     {
1232         int err;
1233         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1234         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1235         err = celt_encode_with_ec(celt_enc, pcm_buf+extra_buffer*st->channels, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
1236         if (err < 0)
1237         {
1238            RESTORE_STACK;
1239            return OPUS_INTERNAL_ERROR;
1240         }
1241         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1242         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1243     }
1244
1245     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
1246
1247     if (st->mode != MODE_SILK_ONLY)
1248     {
1249         if (st->mode != st->prev_mode && st->prev_mode > 0)
1250         {
1251            unsigned char dummy[2];
1252            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1253
1254            /* Prefilling */
1255            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
1256            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1257         }
1258         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
1259         if (ec_tell(&enc) <= 8*nb_compr_bytes)
1260         {
1261 #ifndef FIXED_POINT
1262            if (perform_analysis)
1263               celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(&analysis_info));
1264 #endif
1265            ret = celt_encode_with_ec(celt_enc, pcm_buf+extra_buffer*st->channels, frame_size, NULL, nb_compr_bytes, &enc);
1266            if (ret < 0)
1267            {
1268               RESTORE_STACK;
1269               return OPUS_INTERNAL_ERROR;
1270            }
1271         }
1272     }
1273
1274     /* 5 ms redundant frame for SILK->CELT */
1275     if (redundancy && !celt_to_silk)
1276     {
1277         int err;
1278         unsigned char dummy[2];
1279         int N2, N4;
1280         N2 = st->Fs/200;
1281         N4 = st->Fs/400;
1282
1283         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1284         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1285         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1286
1287         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1288         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(extra_buffer+frame_size-N2-N4), N4, dummy, 2, NULL);
1289
1290         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(extra_buffer+frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1291         if (err < 0)
1292         {
1293            RESTORE_STACK;
1294            return OPUS_INTERNAL_ERROR;
1295         }
1296         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1297     }
1298
1299
1300
1301     /* Signalling the mode in the first byte */
1302     data--;
1303     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1304
1305     st->rangeFinal = enc.rng ^ redundant_rng;
1306
1307     if (to_celt)
1308         st->prev_mode = MODE_CELT_ONLY;
1309     else
1310         st->prev_mode = st->mode;
1311     st->prev_channels = st->stream_channels;
1312     st->prev_framesize = frame_size;
1313
1314     st->first = 0;
1315
1316     /* In the unlikely case that the SILK encoder busted its target, tell
1317        the decoder to call the PLC */
1318     if (ec_tell(&enc) > (max_data_bytes-1)*8)
1319     {
1320        if (max_data_bytes < 2)
1321        {
1322           RESTORE_STACK;
1323           return OPUS_BUFFER_TOO_SMALL;
1324        }
1325        data[1] = 0;
1326        ret = 1;
1327        st->rangeFinal = 0;
1328     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
1329     {
1330        /*When in LPC only mode it's perfectly
1331          reasonable to strip off trailing zero bytes as
1332          the required range decoder behavior is to
1333          fill these in. This can't be done when the MDCT
1334          modes are used because the decoder needs to know
1335          the actual length for allocation purposes.*/
1336        while(ret>2&&data[ret]==0)ret--;
1337     }
1338     /* Count ToC and redundancy */
1339     ret += 1+redundancy_bytes;
1340     if (!st->use_vbr && ret >= 3)
1341     {
1342        if (pad_frame(data, ret, max_data_bytes))
1343        {
1344           RESTORE_STACK;
1345           return OPUS_INTERNAL_ERROR;
1346        }
1347        ret = max_data_bytes;
1348     }
1349     RESTORE_STACK;
1350     return ret;
1351 }
1352
1353 #ifdef FIXED_POINT
1354
1355 #ifndef DISABLE_FLOAT_API
1356 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1357       unsigned char *data, opus_int32 max_data_bytes)
1358 {
1359    int i, ret;
1360    VARDECL(opus_int16, in);
1361    ALLOC_STACK;
1362
1363    if(frame_size<0)
1364    {
1365       RESTORE_STACK;
1366       return OPUS_BAD_ARG;
1367    }
1368
1369    ALLOC(in, frame_size*st->channels, opus_int16);
1370
1371    for (i=0;i<frame_size*st->channels;i++)
1372       in[i] = FLOAT2INT16(pcm[i]);
1373    ret = opus_encode(st, in, frame_size, data, max_data_bytes);
1374    RESTORE_STACK;
1375    return ret;
1376 }
1377 #endif
1378
1379 #else
1380 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1381       unsigned char *data, opus_int32 max_data_bytes)
1382 {
1383    int i, ret;
1384    VARDECL(float, in);
1385    ALLOC_STACK;
1386
1387    ALLOC(in, frame_size*st->channels, float);
1388
1389    for (i=0;i<frame_size*st->channels;i++)
1390       in[i] = (1.0f/32768)*pcm[i];
1391    ret = opus_encode_float(st, in, frame_size, data, max_data_bytes);
1392    RESTORE_STACK;
1393    return ret;
1394 }
1395 #endif
1396
1397
1398 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
1399 {
1400     int ret;
1401     CELTEncoder *celt_enc;
1402     va_list ap;
1403
1404     ret = OPUS_OK;
1405     va_start(ap, request);
1406
1407     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1408
1409     switch (request)
1410     {
1411         case OPUS_SET_APPLICATION_REQUEST:
1412         {
1413             opus_int32 value = va_arg(ap, opus_int32);
1414             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
1415                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1416                || (!st->first && st->application != value))
1417             {
1418                ret = OPUS_BAD_ARG;
1419                break;
1420             }
1421             st->application = value;
1422         }
1423         break;
1424         case OPUS_GET_APPLICATION_REQUEST:
1425         {
1426             opus_int32 *value = va_arg(ap, opus_int32*);
1427             *value = st->application;
1428         }
1429         break;
1430         case OPUS_SET_BITRATE_REQUEST:
1431         {
1432             opus_int32 value = va_arg(ap, opus_int32);
1433             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1434             {
1435                 if (value <= 0)
1436                     goto bad_arg;
1437                 else if (value <= 500)
1438                     value = 500;
1439                 else if (value > (opus_int32)300000*st->channels)
1440                     value = (opus_int32)300000*st->channels;
1441             }
1442             st->user_bitrate_bps = value;
1443         }
1444         break;
1445         case OPUS_GET_BITRATE_REQUEST:
1446         {
1447             opus_int32 *value = va_arg(ap, opus_int32*);
1448             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
1449         }
1450         break;
1451         case OPUS_SET_FORCE_CHANNELS_REQUEST:
1452         {
1453             opus_int32 value = va_arg(ap, opus_int32);
1454             if((value<1 || value>st->channels) && value != OPUS_AUTO)
1455                 return OPUS_BAD_ARG;
1456             st->force_channels = value;
1457         }
1458         break;
1459         case OPUS_GET_FORCE_CHANNELS_REQUEST:
1460         {
1461             opus_int32 *value = va_arg(ap, opus_int32*);
1462             *value = st->force_channels;
1463         }
1464         break;
1465         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
1466         {
1467             opus_int32 value = va_arg(ap, opus_int32);
1468             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND)
1469                 return OPUS_BAD_ARG;
1470             st->max_bandwidth = value;
1471             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1472                 st->silk_mode.maxInternalSampleRate = 8000;
1473             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1474                 st->silk_mode.maxInternalSampleRate = 12000;
1475             } else {
1476                 st->silk_mode.maxInternalSampleRate = 16000;
1477             }
1478         }
1479         break;
1480         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
1481         {
1482             opus_int32 *value = va_arg(ap, opus_int32*);
1483             *value = st->max_bandwidth;
1484         }
1485         break;
1486         case OPUS_SET_BANDWIDTH_REQUEST:
1487         {
1488             opus_int32 value = va_arg(ap, opus_int32);
1489             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
1490                 return OPUS_BAD_ARG;
1491             st->user_bandwidth = value;
1492             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1493                 st->silk_mode.maxInternalSampleRate = 8000;
1494             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1495                 st->silk_mode.maxInternalSampleRate = 12000;
1496             } else {
1497                 st->silk_mode.maxInternalSampleRate = 16000;
1498             }
1499         }
1500         break;
1501         case OPUS_GET_BANDWIDTH_REQUEST:
1502         {
1503             opus_int32 *value = va_arg(ap, opus_int32*);
1504             *value = st->bandwidth;
1505         }
1506         break;
1507         case OPUS_SET_DTX_REQUEST:
1508         {
1509             opus_int32 value = va_arg(ap, opus_int32);
1510             if(value<0 || value>1)
1511                 return OPUS_BAD_ARG;
1512             st->silk_mode.useDTX = value;
1513         }
1514         break;
1515         case OPUS_GET_DTX_REQUEST:
1516         {
1517             opus_int32 *value = va_arg(ap, opus_int32*);
1518             *value = st->silk_mode.useDTX;
1519         }
1520         break;
1521         case OPUS_SET_COMPLEXITY_REQUEST:
1522         {
1523             opus_int32 value = va_arg(ap, opus_int32);
1524             if(value<0 || value>10)
1525                 return OPUS_BAD_ARG;
1526             st->silk_mode.complexity = value;
1527             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
1528         }
1529         break;
1530         case OPUS_GET_COMPLEXITY_REQUEST:
1531         {
1532             opus_int32 *value = va_arg(ap, opus_int32*);
1533             *value = st->silk_mode.complexity;
1534         }
1535         break;
1536         case OPUS_SET_INBAND_FEC_REQUEST:
1537         {
1538             opus_int32 value = va_arg(ap, opus_int32);
1539             if(value<0 || value>1)
1540                 return OPUS_BAD_ARG;
1541             st->silk_mode.useInBandFEC = value;
1542         }
1543         break;
1544         case OPUS_GET_INBAND_FEC_REQUEST:
1545         {
1546             opus_int32 *value = va_arg(ap, opus_int32*);
1547             *value = st->silk_mode.useInBandFEC;
1548         }
1549         break;
1550         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1551         {
1552             opus_int32 value = va_arg(ap, opus_int32);
1553             if (value < 0 || value > 100)
1554                 return OPUS_BAD_ARG;
1555             st->silk_mode.packetLossPercentage = value;
1556             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
1557         }
1558         break;
1559         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1560         {
1561             opus_int32 *value = va_arg(ap, opus_int32*);
1562             *value = st->silk_mode.packetLossPercentage;
1563         }
1564         break;
1565         case OPUS_SET_VBR_REQUEST:
1566         {
1567             opus_int32 value = va_arg(ap, opus_int32);
1568             if(value<0 || value>1)
1569                 return OPUS_BAD_ARG;
1570             st->use_vbr = value;
1571             st->silk_mode.useCBR = 1-value;
1572         }
1573         break;
1574         case OPUS_GET_VBR_REQUEST:
1575         {
1576             opus_int32 *value = va_arg(ap, opus_int32*);
1577             *value = st->use_vbr;
1578         }
1579         break;
1580         case OPUS_SET_VOICE_RATIO_REQUEST:
1581         {
1582             opus_int32 value = va_arg(ap, opus_int32);
1583             if (value>100 || value<-1)
1584                 goto bad_arg;
1585             st->voice_ratio = value;
1586         }
1587         break;
1588         case OPUS_GET_VOICE_RATIO_REQUEST:
1589         {
1590             opus_int32 *value = va_arg(ap, opus_int32*);
1591             *value = st->voice_ratio;
1592         }
1593         break;
1594         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1595         {
1596             opus_int32 value = va_arg(ap, opus_int32);
1597             if(value<0 || value>1)
1598                 return OPUS_BAD_ARG;
1599             st->vbr_constraint = value;
1600         }
1601         break;
1602         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1603         {
1604             opus_int32 *value = va_arg(ap, opus_int32*);
1605             *value = st->vbr_constraint;
1606         }
1607         break;
1608         case OPUS_SET_SIGNAL_REQUEST:
1609         {
1610             opus_int32 value = va_arg(ap, opus_int32);
1611             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
1612                 return OPUS_BAD_ARG;
1613             st->signal_type = value;
1614         }
1615         break;
1616         case OPUS_GET_SIGNAL_REQUEST:
1617         {
1618             opus_int32 *value = va_arg(ap, opus_int32*);
1619             *value = st->signal_type;
1620         }
1621         break;
1622         case OPUS_GET_LOOKAHEAD_REQUEST:
1623         {
1624             opus_int32 *value = va_arg(ap, opus_int32*);
1625             *value = st->Fs/400;
1626             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1627                 *value += st->delay_compensation;
1628         }
1629         break;
1630         case OPUS_GET_SAMPLE_RATE_REQUEST:
1631         {
1632             opus_int32 *value = va_arg(ap, opus_int32*);
1633             if (value==NULL)
1634             {
1635                 ret = OPUS_BAD_ARG;
1636                 break;
1637             }
1638             *value = st->Fs;
1639         }
1640         break;
1641         case OPUS_GET_FINAL_RANGE_REQUEST:
1642         {
1643             opus_uint32 *value = va_arg(ap, opus_uint32*);
1644             *value = st->rangeFinal;
1645         }
1646         break;
1647         case OPUS_SET_LSB_DEPTH_REQUEST:
1648         {
1649             opus_int32 value = va_arg(ap, opus_int32);
1650             ret = celt_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(value));
1651         }
1652         break;
1653         case OPUS_GET_LSB_DEPTH_REQUEST:
1654         {
1655             opus_int32 *value = va_arg(ap, opus_int32*);
1656             celt_encoder_ctl(celt_enc, OPUS_GET_LSB_DEPTH(value));
1657         }
1658         break;
1659         case OPUS_RESET_STATE:
1660         {
1661            void *silk_enc;
1662            silk_EncControlStruct dummy;
1663            silk_enc = (char*)st+st->silk_enc_offset;
1664
1665            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
1666                  sizeof(OpusEncoder)-
1667                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
1668
1669            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1670            silk_InitEncoder( silk_enc, &dummy );
1671            st->stream_channels = st->channels;
1672            st->hybrid_stereo_width_Q14 = 1 << 14;
1673            st->first = 1;
1674            st->mode = MODE_HYBRID;
1675            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
1676            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1677         }
1678         break;
1679         case OPUS_SET_FORCE_MODE_REQUEST:
1680         {
1681             opus_int32 value = va_arg(ap, opus_int32);
1682             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
1683                goto bad_arg;
1684             st->user_forced_mode = value;
1685         }
1686         break;
1687         default:
1688             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
1689             ret = OPUS_UNIMPLEMENTED;
1690             break;
1691     }
1692     va_end(ap);
1693     return ret;
1694 bad_arg:
1695     va_end(ap);
1696     return OPUS_BAD_ARG;
1697 }
1698
1699 void opus_encoder_destroy(OpusEncoder *st)
1700 {
1701     opus_free(st);
1702 }