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