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