Making CELT stereo<->mono transitions gradual
[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 = 31000;
126 static const opus_int32 stereo_music_threshold = 31000;
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=overlap;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 -= 1000;
714        else if (st->prev_mode>0)
715            threshold += 1000;
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     /* Use detected bandwidth to reduce the encoded bandwidth. */
862     if (st->detected_bandwidth && st->user_bandwidth == OPUS_AUTO)
863     {
864        /* When operating in SILK/hybrid mode, we don't go below wideband to avoid
865           more complicated switches that require redundancy */
866        if (st->mode == MODE_CELT_ONLY)
867           st->bandwidth = IMIN(st->bandwidth, st->detected_bandwidth);
868        else
869           st->bandwidth = IMIN(st->bandwidth, IMAX(OPUS_BANDWIDTH_WIDEBAND, st->detected_bandwidth));
870     }
871 #endif
872     celt_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(lsb_depth));
873
874     /* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */
875     if (max_data_bytes < (frame_rate > 50 ? 12000 : 8000)*frame_size / (st->Fs * 8))
876        st->mode = MODE_CELT_ONLY;
877
878     /* CELT mode doesn't support mediumband, use wideband instead */
879     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
880         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
881
882     /* Can't support higher than wideband for >20 ms frames */
883     if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND))
884     {
885        VARDECL(unsigned char, tmp_data);
886        int nb_frames;
887        int bak_mode, bak_bandwidth, bak_channels, bak_to_mono;
888        OpusRepacketizer rp;
889        opus_int32 bytes_per_frame;
890
891
892        nb_frames = frame_size > st->Fs/25 ? 3 : 2;
893        bytes_per_frame = IMIN(1276,(out_data_bytes-3)/nb_frames);
894
895        ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char);
896
897        opus_repacketizer_init(&rp);
898
899        bak_mode = st->user_forced_mode;
900        bak_bandwidth = st->user_bandwidth;
901        bak_channels = st->force_channels;
902
903        st->user_forced_mode = st->mode;
904        st->user_bandwidth = st->bandwidth;
905        st->force_channels = st->stream_channels;
906        bak_to_mono = st->silk_mode.toMono;
907
908        if (bak_to_mono)
909           st->force_channels = 1;
910        else
911           st->prev_channels = st->stream_channels;
912        for (i=0;i<nb_frames;i++)
913        {
914           int tmp_len;
915           st->silk_mode.toMono = 0;
916           /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
917           if (to_celt && i==nb_frames-1)
918              st->user_forced_mode = MODE_CELT_ONLY;
919           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);
920           if (tmp_len<0)
921           {
922              RESTORE_STACK;
923              return OPUS_INTERNAL_ERROR;
924           }
925           ret = opus_repacketizer_cat(&rp, tmp_data+i*bytes_per_frame, tmp_len);
926           if (ret<0)
927           {
928              RESTORE_STACK;
929              return OPUS_INTERNAL_ERROR;
930           }
931        }
932        ret = opus_repacketizer_out(&rp, data, out_data_bytes);
933        if (ret<0)
934        {
935           RESTORE_STACK;
936           return OPUS_INTERNAL_ERROR;
937        }
938        st->user_forced_mode = bak_mode;
939        st->user_bandwidth = bak_bandwidth;
940        st->force_channels = bak_channels;
941        st->silk_mode.toMono = bak_to_mono;
942        RESTORE_STACK;
943        return ret;
944     }
945
946     curr_bandwidth = st->bandwidth;
947
948     /* Chooses the appropriate mode for speech
949        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
950     if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND)
951         st->mode = MODE_HYBRID;
952     if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
953         st->mode = MODE_SILK_ONLY;
954
955     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
956     bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
957
958     data += 1;
959
960     ec_enc_init(&enc, data, max_data_bytes-1);
961
962     ALLOC(pcm_buf, (total_buffer+frame_size)*st->channels, opus_val16);
963     for (i=0;i<total_buffer*st->channels;i++)
964        pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-total_buffer)*st->channels+i];
965
966     if (st->mode == MODE_CELT_ONLY)
967        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
968     else
969        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
970
971     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
972           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
973
974     /* convert from log scale to Hertz */
975     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
976
977     if (st->application == OPUS_APPLICATION_VOIP)
978     {
979        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
980     } else {
981        dc_reject(pcm, 3, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
982     }
983
984 #ifndef FIXED_POINT
985     if (perform_analysis)
986     {
987        int nb_analysis_frames;
988        nb_analysis_frames = frame_size/(st->Fs/100);
989        for (i=0;i<nb_analysis_frames;i++)
990           tonality_analysis(&st->analysis, &analysis_info, celt_enc, pcm_buf+i*(st->Fs/100)*st->channels, st->channels, lsb_depth);
991        if (st->signal_type == OPUS_AUTO)
992           st->voice_ratio = (int)floor(.5+100*(1-analysis_info.music_prob));
993        st->detected_bandwidth = analysis_info.opus_bandwidth;
994     } else {
995        analysis_info.valid = 0;
996        st->voice_ratio = -1;
997        st->detected_bandwidth = 0;
998     }
999 #endif
1000
1001     /* SILK processing */
1002     HB_gain = Q15ONE;
1003     if (st->mode != MODE_CELT_ONLY)
1004     {
1005         opus_int32 total_bitRate, celt_rate;
1006 #ifdef FIXED_POINT
1007        const opus_int16 *pcm_silk;
1008 #else
1009        VARDECL(opus_int16, pcm_silk);
1010        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
1011 #endif
1012
1013         /* Distribute bits between SILK and CELT */
1014         total_bitRate = 8 * bytes_target * frame_rate;
1015         if( st->mode == MODE_HYBRID ) {
1016             int HB_gain_ref;
1017             /* Base rate for SILK */
1018             st->silk_mode.bitRate = st->stream_channels * ( 5000 + 1000 * ( st->Fs == 100 * frame_size ) );
1019             if( curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
1020                 /* SILK gets 2/3 of the remaining bits */
1021                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 2 / 3;
1022             } else { /* FULLBAND */
1023                 /* SILK gets 3/5 of the remaining bits */
1024                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 3 / 5;
1025             }
1026             /* Don't let SILK use more than 80% */
1027             if( st->silk_mode.bitRate > total_bitRate * 4/5 ) {
1028                 st->silk_mode.bitRate = total_bitRate * 4/5;
1029             }
1030             /* Increasingly attenuate high band when it gets allocated fewer bits */
1031             celt_rate = total_bitRate - st->silk_mode.bitRate;
1032             HB_gain_ref = (curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND) ? 2000 : 2400;
1033             HB_gain = SHL32((opus_val32)celt_rate, 9) / SHR32((opus_val32)celt_rate + st->stream_channels*HB_gain_ref, 6);
1034         } else {
1035             /* SILK gets all bits */
1036             st->silk_mode.bitRate = total_bitRate;
1037         }
1038
1039         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
1040         st->silk_mode.nChannelsAPI = st->channels;
1041         st->silk_mode.nChannelsInternal = st->stream_channels;
1042         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1043             st->silk_mode.desiredInternalSampleRate = 8000;
1044         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1045             st->silk_mode.desiredInternalSampleRate = 12000;
1046         } else {
1047             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
1048             st->silk_mode.desiredInternalSampleRate = 16000;
1049         }
1050         if( st->mode == MODE_HYBRID ) {
1051             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
1052             st->silk_mode.minInternalSampleRate = 16000;
1053         } else {
1054             st->silk_mode.minInternalSampleRate = 8000;
1055         }
1056
1057         if (st->mode == MODE_SILK_ONLY)
1058         {
1059            opus_int32 effective_max_rate = max_rate;
1060            st->silk_mode.maxInternalSampleRate = 16000;
1061            if (frame_rate > 50)
1062               effective_max_rate = effective_max_rate*2/3;
1063            if (effective_max_rate < 13000)
1064            {
1065               st->silk_mode.maxInternalSampleRate = 12000;
1066               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
1067            }
1068            if (effective_max_rate < 9600)
1069            {
1070               st->silk_mode.maxInternalSampleRate = 8000;
1071               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
1072            }
1073         } else {
1074            st->silk_mode.maxInternalSampleRate = 16000;
1075         }
1076
1077         st->silk_mode.useCBR = !st->use_vbr;
1078
1079         /* Call SILK encoder for the low band */
1080         nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes);
1081
1082         st->silk_mode.maxBits = nBytes*8;
1083         /* Only allow up to 90% of the bits for hybrid mode*/
1084         if (st->mode == MODE_HYBRID)
1085            st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
1086         if (st->silk_mode.useCBR)
1087         {
1088            st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
1089            /* Reduce the initial target to make it easier to reach the CBR rate */
1090            st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000);
1091         }
1092
1093         if (prefill)
1094         {
1095             opus_int32 zero=0;
1096             const CELTMode *celt_mode;
1097             int prefill_offset;
1098             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1099             /* Use a smooth onset for the SILK prefill to avoid the encoder trying to encode
1100                a discontinuity. The exact location is what we need to avoid leaving any "gap"
1101                in the audio when mixing with the redundant CELT frame. Here we can afford to
1102                overwrite st->delay_buffer because the only thing that uses it before it gets
1103                rewritten is tmp_prefill[] and even then only the part after the ramp really
1104                gets used (rather than sent to the encoder and discarded) */
1105             prefill_offset = st->channels*(st->encoder_buffer-st->delay_compensation-st->Fs/400);
1106             gain_fade(st->delay_buffer+prefill_offset, st->delay_buffer+prefill_offset,
1107                   0, Q15ONE, celt_mode->overlap, st->Fs/400, st->channels, celt_mode->window, st->Fs);
1108             for(i=0;i<prefill_offset;i++)
1109                st->delay_buffer[i]=0;
1110 #ifdef FIXED_POINT
1111             pcm_silk = st->delay_buffer;
1112 #else
1113             for (i=0;i<st->encoder_buffer*st->channels;i++)
1114                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
1115 #endif
1116             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
1117         }
1118
1119 #ifdef FIXED_POINT
1120         pcm_silk = pcm_buf+total_buffer*st->channels;
1121 #else
1122         for (i=0;i<frame_size*st->channels;i++)
1123             pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
1124 #endif
1125         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
1126         if( ret ) {
1127             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
1128             /* Handle error */
1129            RESTORE_STACK;
1130            return OPUS_INTERNAL_ERROR;
1131         }
1132         if (nBytes==0)
1133         {
1134            st->rangeFinal = 0;
1135            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1136            RESTORE_STACK;
1137            return 1;
1138         }
1139         /* Extract SILK internal bandwidth for signaling in first byte */
1140         if( st->mode == MODE_SILK_ONLY ) {
1141             if( st->silk_mode.internalSampleRate == 8000 ) {
1142                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1143             } else if( st->silk_mode.internalSampleRate == 12000 ) {
1144                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1145             } else if( st->silk_mode.internalSampleRate == 16000 ) {
1146                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1147             }
1148         } else {
1149             silk_assert( st->silk_mode.internalSampleRate == 16000 );
1150         }
1151
1152         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
1153         /* FIXME: How do we allocate the redundancy for CBR? */
1154         if (st->silk_mode.opusCanSwitch)
1155         {
1156            redundancy = 1;
1157            celt_to_silk = 0;
1158            st->silk_bw_switch = 1;
1159         }
1160     }
1161
1162     /* CELT processing */
1163     {
1164         int endband=21;
1165
1166         switch(curr_bandwidth)
1167         {
1168             case OPUS_BANDWIDTH_NARROWBAND:
1169                 endband = 13;
1170                 break;
1171             case OPUS_BANDWIDTH_MEDIUMBAND:
1172             case OPUS_BANDWIDTH_WIDEBAND:
1173                 endband = 17;
1174                 break;
1175             case OPUS_BANDWIDTH_SUPERWIDEBAND:
1176                 endband = 19;
1177                 break;
1178             case OPUS_BANDWIDTH_FULLBAND:
1179                 endband = 21;
1180                 break;
1181         }
1182         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
1183         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
1184     }
1185     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1186     if (st->mode != MODE_SILK_ONLY)
1187     {
1188         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1189         /* Allow prediction unless we decide to disable it later */
1190         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
1191
1192         if (st->mode == MODE_HYBRID)
1193         {
1194             int len;
1195
1196             len = (ec_tell(&enc)+7)>>3;
1197             if (redundancy)
1198                len += st->mode == MODE_HYBRID ? 3 : 1;
1199             if( st->use_vbr ) {
1200                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
1201             } else {
1202                 /* check if SILK used up too much */
1203                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
1204             }
1205         } else {
1206             if (st->use_vbr)
1207             {
1208                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
1209                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
1210                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps));
1211                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
1212             } else {
1213                 nb_compr_bytes = bytes_target;
1214             }
1215         }
1216
1217     } else {
1218         nb_compr_bytes = 0;
1219     }
1220
1221     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
1222     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
1223     {
1224        for (i=0;i<st->channels*st->Fs/400;i++)
1225           tmp_prefill[i] = st->delay_buffer[(extra_buffer+st->encoder_buffer-total_buffer-st->Fs/400)*st->channels + i];
1226     }
1227
1228     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+total_buffer));i++)
1229         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
1230     for (;i<st->encoder_buffer*st->channels;i++)
1231         st->delay_buffer[i] = pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels+i];
1232
1233     /* gain_fade() and stereo_fade() need to be after the buffer copying
1234        because we don't want any of this to affect the SILK part */
1235     if( st->prev_HB_gain < Q15ONE || HB_gain < Q15ONE ) {
1236        const CELTMode *celt_mode;
1237
1238        celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1239        gain_fade(pcm_buf+extra_buffer*st->channels, pcm_buf+extra_buffer*st->channels,
1240              st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs);
1241     }
1242     st->prev_HB_gain = HB_gain;
1243     if (st->mode != MODE_HYBRID || st->stream_channels==1)
1244        st->silk_mode.stereoWidth_Q14 = IMIN((1<<14),IMAX(0,st->bitrate_bps-32000));
1245     if( st->channels == 2 ) {
1246         /* Apply stereo width reduction (at low bitrates) */
1247         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1248             opus_val16 g1, g2;
1249             const CELTMode *celt_mode;
1250
1251             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1252             g1 = st->hybrid_stereo_width_Q14;
1253             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1254 #ifdef FIXED_POINT
1255             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
1256             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
1257 #else
1258             g1 *= (1.f/16384);
1259             g2 *= (1.f/16384);
1260 #endif
1261             stereo_fade(pcm_buf+extra_buffer*st->channels, pcm_buf+extra_buffer*st->channels, g1, g2, celt_mode->overlap,
1262                   frame_size, st->channels, celt_mode->window, st->Fs);
1263             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1264         }
1265     }
1266
1267     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
1268     {
1269         /* For SILK mode, the redundancy is inferred from the length */
1270         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
1271            ec_enc_bit_logp(&enc, redundancy, 12);
1272         if (redundancy)
1273         {
1274             int max_redundancy;
1275             ec_enc_bit_logp(&enc, celt_to_silk, 1);
1276             if (st->mode == MODE_HYBRID)
1277                max_redundancy = (max_data_bytes-1)-nb_compr_bytes-1;
1278             else
1279                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1280             /* Target the same bit-rate for redundancy as for the rest,
1281                up to a max of 257 bytes */
1282             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
1283             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
1284             if (st->mode == MODE_HYBRID)
1285                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
1286         }
1287     } else {
1288         redundancy = 0;
1289     }
1290
1291     if (!redundancy)
1292     {
1293        st->silk_bw_switch = 0;
1294        redundancy_bytes = 0;
1295     }
1296     if (st->mode != MODE_CELT_ONLY)start_band=17;
1297
1298     if (st->mode == MODE_SILK_ONLY)
1299     {
1300         ret = (ec_tell(&enc)+7)>>3;
1301         ec_enc_done(&enc);
1302         nb_compr_bytes = ret;
1303     } else {
1304        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
1305        ec_enc_shrink(&enc, nb_compr_bytes);
1306     }
1307
1308
1309     /* 5 ms redundant frame for CELT->SILK */
1310     if (redundancy && celt_to_silk)
1311     {
1312         int err;
1313         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1314         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1315         err = celt_encode_with_ec(celt_enc, pcm_buf+extra_buffer*st->channels, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
1316         if (err < 0)
1317         {
1318            RESTORE_STACK;
1319            return OPUS_INTERNAL_ERROR;
1320         }
1321         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1322         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1323     }
1324
1325     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
1326
1327     if (st->mode != MODE_SILK_ONLY)
1328     {
1329         if (st->mode != st->prev_mode && st->prev_mode > 0)
1330         {
1331            unsigned char dummy[2];
1332            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1333
1334            /* Prefilling */
1335            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
1336            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1337         }
1338         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
1339         if (ec_tell(&enc) <= 8*nb_compr_bytes)
1340         {
1341 #ifndef FIXED_POINT
1342            if (perform_analysis)
1343               celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(&analysis_info));
1344 #endif
1345            ret = celt_encode_with_ec(celt_enc, pcm_buf+extra_buffer*st->channels, frame_size, NULL, nb_compr_bytes, &enc);
1346            if (ret < 0)
1347            {
1348               RESTORE_STACK;
1349               return OPUS_INTERNAL_ERROR;
1350            }
1351         }
1352     }
1353
1354     /* 5 ms redundant frame for SILK->CELT */
1355     if (redundancy && !celt_to_silk)
1356     {
1357         int err;
1358         unsigned char dummy[2];
1359         int N2, N4;
1360         N2 = st->Fs/200;
1361         N4 = st->Fs/400;
1362
1363         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1364         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1365         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1366
1367         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1368         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(extra_buffer+frame_size-N2-N4), N4, dummy, 2, NULL);
1369
1370         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(extra_buffer+frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1371         if (err < 0)
1372         {
1373            RESTORE_STACK;
1374            return OPUS_INTERNAL_ERROR;
1375         }
1376         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1377     }
1378
1379
1380
1381     /* Signalling the mode in the first byte */
1382     data--;
1383     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1384
1385     st->rangeFinal = enc.rng ^ redundant_rng;
1386
1387     if (to_celt)
1388         st->prev_mode = MODE_CELT_ONLY;
1389     else
1390         st->prev_mode = st->mode;
1391     st->prev_channels = st->stream_channels;
1392     st->prev_framesize = frame_size;
1393
1394     st->first = 0;
1395
1396     /* In the unlikely case that the SILK encoder busted its target, tell
1397        the decoder to call the PLC */
1398     if (ec_tell(&enc) > (max_data_bytes-1)*8)
1399     {
1400        if (max_data_bytes < 2)
1401        {
1402           RESTORE_STACK;
1403           return OPUS_BUFFER_TOO_SMALL;
1404        }
1405        data[1] = 0;
1406        ret = 1;
1407        st->rangeFinal = 0;
1408     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
1409     {
1410        /*When in LPC only mode it's perfectly
1411          reasonable to strip off trailing zero bytes as
1412          the required range decoder behavior is to
1413          fill these in. This can't be done when the MDCT
1414          modes are used because the decoder needs to know
1415          the actual length for allocation purposes.*/
1416        while(ret>2&&data[ret]==0)ret--;
1417     }
1418     /* Count ToC and redundancy */
1419     ret += 1+redundancy_bytes;
1420     if (!st->use_vbr && ret >= 3)
1421     {
1422        if (pad_frame(data, ret, max_data_bytes))
1423        {
1424           RESTORE_STACK;
1425           return OPUS_INTERNAL_ERROR;
1426        }
1427        ret = max_data_bytes;
1428     }
1429     RESTORE_STACK;
1430     return ret;
1431 }
1432
1433 #ifdef FIXED_POINT
1434
1435 #ifndef DISABLE_FLOAT_API
1436 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1437       unsigned char *data, opus_int32 max_data_bytes)
1438 {
1439    int i, ret;
1440    VARDECL(opus_int16, in);
1441    ALLOC_STACK;
1442
1443    if(frame_size<0)
1444    {
1445       RESTORE_STACK;
1446       return OPUS_BAD_ARG;
1447    }
1448
1449    ALLOC(in, frame_size*st->channels, opus_int16);
1450
1451    for (i=0;i<frame_size*st->channels;i++)
1452       in[i] = FLOAT2INT16(pcm[i]);
1453    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16);
1454    RESTORE_STACK;
1455    return ret;
1456 }
1457 #endif
1458
1459 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1460                 unsigned char *data, opus_int32 out_data_bytes)
1461 {
1462    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 16);
1463 }
1464
1465 #else
1466 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1467       unsigned char *data, opus_int32 max_data_bytes)
1468 {
1469    int i, ret;
1470    VARDECL(float, in);
1471    ALLOC_STACK;
1472
1473    ALLOC(in, frame_size*st->channels, float);
1474
1475    for (i=0;i<frame_size*st->channels;i++)
1476       in[i] = (1.0f/32768)*pcm[i];
1477    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16);
1478    RESTORE_STACK;
1479    return ret;
1480 }
1481 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1482                       unsigned char *data, opus_int32 out_data_bytes)
1483 {
1484    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 24);
1485
1486 }
1487 #endif
1488
1489
1490 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
1491 {
1492     int ret;
1493     CELTEncoder *celt_enc;
1494     va_list ap;
1495
1496     ret = OPUS_OK;
1497     va_start(ap, request);
1498
1499     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1500
1501     switch (request)
1502     {
1503         case OPUS_SET_APPLICATION_REQUEST:
1504         {
1505             opus_int32 value = va_arg(ap, opus_int32);
1506             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
1507                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1508                || (!st->first && st->application != value))
1509             {
1510                ret = OPUS_BAD_ARG;
1511                break;
1512             }
1513             st->application = value;
1514         }
1515         break;
1516         case OPUS_GET_APPLICATION_REQUEST:
1517         {
1518             opus_int32 *value = va_arg(ap, opus_int32*);
1519             *value = st->application;
1520         }
1521         break;
1522         case OPUS_SET_BITRATE_REQUEST:
1523         {
1524             opus_int32 value = va_arg(ap, opus_int32);
1525             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1526             {
1527                 if (value <= 0)
1528                     goto bad_arg;
1529                 else if (value <= 500)
1530                     value = 500;
1531                 else if (value > (opus_int32)300000*st->channels)
1532                     value = (opus_int32)300000*st->channels;
1533             }
1534             st->user_bitrate_bps = value;
1535         }
1536         break;
1537         case OPUS_GET_BITRATE_REQUEST:
1538         {
1539             opus_int32 *value = va_arg(ap, opus_int32*);
1540             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
1541         }
1542         break;
1543         case OPUS_SET_FORCE_CHANNELS_REQUEST:
1544         {
1545             opus_int32 value = va_arg(ap, opus_int32);
1546             if((value<1 || value>st->channels) && value != OPUS_AUTO)
1547                 return OPUS_BAD_ARG;
1548             st->force_channels = value;
1549         }
1550         break;
1551         case OPUS_GET_FORCE_CHANNELS_REQUEST:
1552         {
1553             opus_int32 *value = va_arg(ap, opus_int32*);
1554             *value = st->force_channels;
1555         }
1556         break;
1557         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
1558         {
1559             opus_int32 value = va_arg(ap, opus_int32);
1560             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND)
1561                 return OPUS_BAD_ARG;
1562             st->max_bandwidth = value;
1563             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1564                 st->silk_mode.maxInternalSampleRate = 8000;
1565             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1566                 st->silk_mode.maxInternalSampleRate = 12000;
1567             } else {
1568                 st->silk_mode.maxInternalSampleRate = 16000;
1569             }
1570         }
1571         break;
1572         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
1573         {
1574             opus_int32 *value = va_arg(ap, opus_int32*);
1575             *value = st->max_bandwidth;
1576         }
1577         break;
1578         case OPUS_SET_BANDWIDTH_REQUEST:
1579         {
1580             opus_int32 value = va_arg(ap, opus_int32);
1581             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
1582                 return OPUS_BAD_ARG;
1583             st->user_bandwidth = value;
1584             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1585                 st->silk_mode.maxInternalSampleRate = 8000;
1586             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1587                 st->silk_mode.maxInternalSampleRate = 12000;
1588             } else {
1589                 st->silk_mode.maxInternalSampleRate = 16000;
1590             }
1591         }
1592         break;
1593         case OPUS_GET_BANDWIDTH_REQUEST:
1594         {
1595             opus_int32 *value = va_arg(ap, opus_int32*);
1596             *value = st->bandwidth;
1597         }
1598         break;
1599         case OPUS_SET_DTX_REQUEST:
1600         {
1601             opus_int32 value = va_arg(ap, opus_int32);
1602             if(value<0 || value>1)
1603                 return OPUS_BAD_ARG;
1604             st->silk_mode.useDTX = value;
1605         }
1606         break;
1607         case OPUS_GET_DTX_REQUEST:
1608         {
1609             opus_int32 *value = va_arg(ap, opus_int32*);
1610             *value = st->silk_mode.useDTX;
1611         }
1612         break;
1613         case OPUS_SET_COMPLEXITY_REQUEST:
1614         {
1615             opus_int32 value = va_arg(ap, opus_int32);
1616             if(value<0 || value>10)
1617                 return OPUS_BAD_ARG;
1618             st->silk_mode.complexity = value;
1619             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
1620         }
1621         break;
1622         case OPUS_GET_COMPLEXITY_REQUEST:
1623         {
1624             opus_int32 *value = va_arg(ap, opus_int32*);
1625             *value = st->silk_mode.complexity;
1626         }
1627         break;
1628         case OPUS_SET_INBAND_FEC_REQUEST:
1629         {
1630             opus_int32 value = va_arg(ap, opus_int32);
1631             if(value<0 || value>1)
1632                 return OPUS_BAD_ARG;
1633             st->silk_mode.useInBandFEC = value;
1634         }
1635         break;
1636         case OPUS_GET_INBAND_FEC_REQUEST:
1637         {
1638             opus_int32 *value = va_arg(ap, opus_int32*);
1639             *value = st->silk_mode.useInBandFEC;
1640         }
1641         break;
1642         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1643         {
1644             opus_int32 value = va_arg(ap, opus_int32);
1645             if (value < 0 || value > 100)
1646                 return OPUS_BAD_ARG;
1647             st->silk_mode.packetLossPercentage = value;
1648             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
1649         }
1650         break;
1651         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1652         {
1653             opus_int32 *value = va_arg(ap, opus_int32*);
1654             *value = st->silk_mode.packetLossPercentage;
1655         }
1656         break;
1657         case OPUS_SET_VBR_REQUEST:
1658         {
1659             opus_int32 value = va_arg(ap, opus_int32);
1660             if(value<0 || value>1)
1661                 return OPUS_BAD_ARG;
1662             st->use_vbr = value;
1663             st->silk_mode.useCBR = 1-value;
1664         }
1665         break;
1666         case OPUS_GET_VBR_REQUEST:
1667         {
1668             opus_int32 *value = va_arg(ap, opus_int32*);
1669             *value = st->use_vbr;
1670         }
1671         break;
1672         case OPUS_SET_VOICE_RATIO_REQUEST:
1673         {
1674             opus_int32 value = va_arg(ap, opus_int32);
1675             if (value>100 || value<-1)
1676                 goto bad_arg;
1677             st->voice_ratio = value;
1678         }
1679         break;
1680         case OPUS_GET_VOICE_RATIO_REQUEST:
1681         {
1682             opus_int32 *value = va_arg(ap, opus_int32*);
1683             *value = st->voice_ratio;
1684         }
1685         break;
1686         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1687         {
1688             opus_int32 value = va_arg(ap, opus_int32);
1689             if(value<0 || value>1)
1690                 return OPUS_BAD_ARG;
1691             st->vbr_constraint = value;
1692         }
1693         break;
1694         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1695         {
1696             opus_int32 *value = va_arg(ap, opus_int32*);
1697             *value = st->vbr_constraint;
1698         }
1699         break;
1700         case OPUS_SET_SIGNAL_REQUEST:
1701         {
1702             opus_int32 value = va_arg(ap, opus_int32);
1703             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
1704                 return OPUS_BAD_ARG;
1705             st->signal_type = value;
1706         }
1707         break;
1708         case OPUS_GET_SIGNAL_REQUEST:
1709         {
1710             opus_int32 *value = va_arg(ap, opus_int32*);
1711             *value = st->signal_type;
1712         }
1713         break;
1714         case OPUS_GET_LOOKAHEAD_REQUEST:
1715         {
1716             opus_int32 *value = va_arg(ap, opus_int32*);
1717             *value = st->Fs/400;
1718             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1719                 *value += st->delay_compensation;
1720         }
1721         break;
1722         case OPUS_GET_SAMPLE_RATE_REQUEST:
1723         {
1724             opus_int32 *value = va_arg(ap, opus_int32*);
1725             if (value==NULL)
1726             {
1727                 ret = OPUS_BAD_ARG;
1728                 break;
1729             }
1730             *value = st->Fs;
1731         }
1732         break;
1733         case OPUS_GET_FINAL_RANGE_REQUEST:
1734         {
1735             opus_uint32 *value = va_arg(ap, opus_uint32*);
1736             *value = st->rangeFinal;
1737         }
1738         break;
1739         case OPUS_SET_LSB_DEPTH_REQUEST:
1740         {
1741             opus_int32 value = va_arg(ap, opus_int32);
1742             if (value<8 || value>24)
1743                goto bad_arg;
1744             st->lsb_depth=value;
1745         }
1746         break;
1747         case OPUS_GET_LSB_DEPTH_REQUEST:
1748         {
1749             opus_int32 *value = va_arg(ap, opus_int32*);
1750             *value = st->lsb_depth;
1751         }
1752         break;
1753         case OPUS_RESET_STATE:
1754         {
1755            void *silk_enc;
1756            silk_EncControlStruct dummy;
1757            silk_enc = (char*)st+st->silk_enc_offset;
1758
1759            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
1760                  sizeof(OpusEncoder)-
1761                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
1762
1763            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1764            silk_InitEncoder( silk_enc, &dummy );
1765            st->stream_channels = st->channels;
1766            st->hybrid_stereo_width_Q14 = 1 << 14;
1767            st->prev_HB_gain = Q15ONE;
1768            st->first = 1;
1769            st->mode = MODE_HYBRID;
1770            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
1771            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1772         }
1773         break;
1774         case OPUS_SET_FORCE_MODE_REQUEST:
1775         {
1776             opus_int32 value = va_arg(ap, opus_int32);
1777             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
1778                goto bad_arg;
1779             st->user_forced_mode = value;
1780         }
1781         break;
1782         default:
1783             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
1784             ret = OPUS_UNIMPLEMENTED;
1785             break;
1786     }
1787     va_end(ap);
1788     return ret;
1789 bad_arg:
1790     va_end(ap);
1791     return OPUS_BAD_ARG;
1792 }
1793
1794 void opus_encoder_destroy(OpusEncoder *st)
1795 {
1796     opus_free(st);
1797 }