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