Moves analysis to the beginning of opus_encode()
[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     /* Only perform analysis for 10- and 20-ms frames. We don't have enough buffering for shorter
596        ones and longer ones will be split if they're in CELT-only mode. */
597     perform_analysis = st->silk_mode.complexity >= 7
598                        && (frame_size >= st->Fs/100 || frame_size >= st->Fs/50)
599                        && st->Fs==48000;
600     if (perform_analysis)
601     {
602        int nb_analysis_frames;
603        nb_analysis_frames = frame_size/(st->Fs/100);
604        for (i=0;i<nb_analysis_frames;i++)
605           tonality_analysis(&st->analysis, &analysis_info, celt_enc, pcm+i*(st->Fs/100)*st->channels, st->channels, lsb_depth);
606        if (st->signal_type == OPUS_AUTO)
607           st->voice_ratio = (int)floor(.5+100*(1-analysis_info.music_prob));
608        st->detected_bandwidth = analysis_info.opus_bandwidth;
609     } else {
610        analysis_info.valid = 0;
611        st->voice_ratio = -1;
612        st->detected_bandwidth = 0;
613     }
614 #endif
615
616     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
617        delay_compensation = 0;
618     else
619        delay_compensation = st->delay_compensation;
620     total_buffer = delay_compensation;
621     extra_buffer = total_buffer-delay_compensation;
622     st->bitrate_bps = user_bitrate_to_bitrate(st, frame_size, max_data_bytes);
623
624     frame_rate = st->Fs/frame_size;
625     if (max_data_bytes<3 || st->bitrate_bps < 3*frame_rate*8
626        || (frame_rate<50 && (max_data_bytes*frame_rate<300 || st->bitrate_bps < 2400)))
627     {
628        /*If the space is too low to do something useful, emit 'PLC' frames.*/
629        int tocmode = st->mode;
630        int bw = st->bandwidth == 0 ? OPUS_BANDWIDTH_NARROWBAND : st->bandwidth;
631        if (tocmode==0)
632           tocmode = MODE_SILK_ONLY;
633        if (frame_rate>100)
634           tocmode = MODE_CELT_ONLY;
635        if (frame_rate < 50)
636           tocmode = MODE_SILK_ONLY;
637        if(tocmode==MODE_SILK_ONLY&&bw>OPUS_BANDWIDTH_WIDEBAND)
638           bw=OPUS_BANDWIDTH_WIDEBAND;
639        else if (tocmode==MODE_CELT_ONLY&&bw==OPUS_BANDWIDTH_MEDIUMBAND)
640           bw=OPUS_BANDWIDTH_NARROWBAND;
641        else if (bw<=OPUS_BANDWIDTH_SUPERWIDEBAND)
642           bw=OPUS_BANDWIDTH_SUPERWIDEBAND;
643        data[0] = gen_toc(tocmode, frame_rate, bw, st->stream_channels);
644        RESTORE_STACK;
645        return 1;
646     }
647     if (!st->use_vbr)
648     {
649        int cbrBytes;
650        cbrBytes = IMIN( (st->bitrate_bps + 4*frame_rate)/(8*frame_rate) , max_data_bytes);
651        st->bitrate_bps = cbrBytes * (8*frame_rate);
652        max_data_bytes = cbrBytes;
653     }
654     max_rate = frame_rate*max_data_bytes*8;
655
656     /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */
657     equiv_rate = st->bitrate_bps - 60*(st->Fs/frame_size - 50);
658
659     if (st->signal_type == OPUS_SIGNAL_VOICE)
660        voice_est = 127;
661     else if (st->signal_type == OPUS_SIGNAL_MUSIC)
662        voice_est = 0;
663     else if (st->voice_ratio >= 0)
664        voice_est = st->voice_ratio*327>>8;
665     else if (st->application == OPUS_APPLICATION_VOIP)
666        voice_est = 115;
667     else
668        voice_est = 48;
669
670     if (st->force_channels!=OPUS_AUTO && st->channels == 2)
671     {
672         st->stream_channels = st->force_channels;
673     } else {
674 #ifdef FUZZING
675        /* Random mono/stereo decision */
676        if (st->channels == 2 && (rand()&0x1F)==0)
677           st->stream_channels = 3-st->stream_channels;
678 #else
679        /* Rate-dependent mono-stereo decision */
680        if (st->channels == 2)
681        {
682           opus_int32 stereo_threshold;
683           stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14);
684           if (st->stream_channels == 2)
685              stereo_threshold -= 4000;
686           else
687              stereo_threshold += 4000;
688           st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1;
689        } else {
690           st->stream_channels = st->channels;
691        }
692 #endif
693     }
694
695     /* Mode selection depending on application and signal type */
696     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
697     {
698        st->mode = MODE_CELT_ONLY;
699     } else if (st->user_forced_mode == OPUS_AUTO)
700     {
701 #ifdef FUZZING
702        /* Random mode switching */
703        if ((rand()&0xF)==0)
704        {
705           if ((rand()&0x1)==0)
706              st->mode = MODE_CELT_ONLY;
707           else
708              st->mode = MODE_SILK_ONLY;
709        } else {
710           if (st->prev_mode==MODE_CELT_ONLY)
711              st->mode = MODE_CELT_ONLY;
712           else
713              st->mode = MODE_SILK_ONLY;
714        }
715 #else
716        int chan;
717        opus_int32 mode_voice, mode_music;
718        opus_int32 threshold;
719
720        chan = (st->channels==2) && st->force_channels!=1;
721        mode_voice = mode_thresholds[chan][0];
722        mode_music = mode_thresholds[chan][1];
723        threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14);
724
725        /* Hysteresis */
726        if (st->prev_mode == MODE_CELT_ONLY)
727            threshold -= 4000;
728        else if (st->prev_mode>0)
729            threshold += 4000;
730
731        st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY;
732
733        /* When FEC is enabled and there's enough packet loss, use SILK */
734        if (st->silk_mode.useInBandFEC && st->silk_mode.packetLossPercentage > (128-voice_est)>>4)
735           st->mode = MODE_SILK_ONLY;
736        /* When encoding voice and DTX is enabled, set the encoder to SILK mode (at least for now) */
737        if (st->silk_mode.useDTX && voice_est > 100)
738           st->mode = MODE_SILK_ONLY;
739 #endif
740     } else {
741        st->mode = st->user_forced_mode;
742     }
743
744     /* Override the chosen mode to make sure we meet the requested frame size */
745     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
746        st->mode = MODE_CELT_ONLY;
747
748     if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0
749           && st->mode != MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)
750     {
751        /* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */
752        st->silk_mode.toMono = 1;
753        st->stream_channels = 2;
754     } else {
755        st->silk_mode.toMono = 0;
756     }
757
758     if (st->prev_mode > 0 &&
759         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
760     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
761     {
762         redundancy = 1;
763         celt_to_silk = (st->mode != MODE_CELT_ONLY);
764         if (!celt_to_silk)
765         {
766             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
767             if (frame_size >= st->Fs/100)
768             {
769                 st->mode = st->prev_mode;
770                 to_celt = 1;
771             } else {
772                 redundancy=0;
773             }
774         }
775     }
776     /* For the first frame at a new SILK bandwidth */
777     if (st->silk_bw_switch)
778     {
779        redundancy = 1;
780        celt_to_silk = 1;
781        st->silk_bw_switch = 0;
782     }
783
784     if (redundancy)
785     {
786        /* Fair share of the max size allowed */
787        redundancy_bytes = IMIN(257, max_data_bytes*(opus_int32)(st->Fs/200)/(frame_size+st->Fs/200));
788        /* For VBR, target the actual bitrate (subject to the limit above) */
789        if (st->use_vbr)
790           redundancy_bytes = IMIN(redundancy_bytes, st->bitrate_bps/1600);
791     }
792
793     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
794     {
795         silk_EncControlStruct dummy;
796         silk_InitEncoder( silk_enc, &dummy);
797         prefill=1;
798     }
799
800     /* Automatic (rate-dependent) bandwidth selection */
801     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
802     {
803         const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds;
804         opus_int32 bandwidth_thresholds[8];
805         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
806         opus_int32 equiv_rate2;
807
808         equiv_rate2 = equiv_rate;
809         if (st->mode != MODE_CELT_ONLY)
810         {
811            /* Adjust the threshold +/- 10% depending on complexity */
812            equiv_rate2 = equiv_rate2 * (45+st->silk_mode.complexity)/50;
813            /* CBR is less efficient by ~1 kb/s */
814            if (!st->use_vbr)
815               equiv_rate2 -= 1000;
816         }
817         if (st->channels==2 && st->force_channels!=1)
818         {
819            voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds;
820            music_bandwidth_thresholds = stereo_music_bandwidth_thresholds;
821         } else {
822            voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds;
823            music_bandwidth_thresholds = mono_music_bandwidth_thresholds;
824         }
825         /* Interpolate bandwidth thresholds depending on voice estimation */
826         for (i=0;i<8;i++)
827         {
828            bandwidth_thresholds[i] = music_bandwidth_thresholds[i]
829                     + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14);
830         }
831         do {
832             int threshold, hysteresis;
833             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
834             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
835             if (!st->first)
836             {
837                 if (st->bandwidth >= bandwidth)
838                     threshold -= hysteresis;
839                 else
840                     threshold += hysteresis;
841             }
842             if (equiv_rate2 >= threshold)
843                 break;
844         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
845         st->bandwidth = bandwidth;
846         /* Prevents any transition to SWB/FB until the SILK layer has fully
847            switched to WB mode and turned the variable LP filter off */
848         if (!st->first && st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
849             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
850     }
851
852     if (st->bandwidth>st->max_bandwidth)
853        st->bandwidth = st->max_bandwidth;
854
855     if (st->user_bandwidth != OPUS_AUTO)
856         st->bandwidth = st->user_bandwidth;
857
858     /* This prevents us from using hybrid at unsafe CBR/max rates */
859     if (st->mode != MODE_CELT_ONLY && max_rate < 15000)
860     {
861        st->bandwidth = IMIN(st->bandwidth, OPUS_BANDWIDTH_WIDEBAND);
862     }
863
864     /* Prevents Opus from wasting bits on frequencies that are above
865        the Nyquist rate of the input signal */
866     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
867         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
868     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
869         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
870     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
871         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
872     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
873         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
874 #ifndef FIXED_POINT
875     if (st->detected_bandwidth && st->user_bandwidth == OPUS_AUTO)
876     {
877        st->bandwidth = IMIN(st->bandwidth, st->detected_bandwidth);
878     }
879 #endif
880     celt_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(lsb_depth));
881
882     /* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */
883     if (max_data_bytes < (frame_rate > 50 ? 12000 : 8000)*frame_size / (st->Fs * 8))
884        st->mode = MODE_CELT_ONLY;
885
886     /* CELT mode doesn't support mediumband, use wideband instead */
887     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
888         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
889
890     /* Can't support higher than wideband for >20 ms frames */
891     if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND))
892     {
893        VARDECL(unsigned char, tmp_data);
894        int nb_frames;
895        int bak_mode, bak_bandwidth, bak_channels, bak_to_mono;
896        OpusRepacketizer rp;
897        opus_int32 bytes_per_frame;
898
899
900        nb_frames = frame_size > st->Fs/25 ? 3 : 2;
901        bytes_per_frame = IMIN(1276,(out_data_bytes-3)/nb_frames);
902
903        ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char);
904
905        opus_repacketizer_init(&rp);
906
907        bak_mode = st->user_forced_mode;
908        bak_bandwidth = st->user_bandwidth;
909        bak_channels = st->force_channels;
910
911        st->user_forced_mode = st->mode;
912        st->user_bandwidth = st->bandwidth;
913        st->force_channels = st->stream_channels;
914        bak_to_mono = st->silk_mode.toMono;
915
916        if (bak_to_mono)
917           st->force_channels = 1;
918        else
919           st->prev_channels = st->stream_channels;
920        for (i=0;i<nb_frames;i++)
921        {
922           int tmp_len;
923           st->silk_mode.toMono = 0;
924           /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
925           if (to_celt && i==nb_frames-1)
926              st->user_forced_mode = MODE_CELT_ONLY;
927           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);
928           if (tmp_len<0)
929           {
930              RESTORE_STACK;
931              return OPUS_INTERNAL_ERROR;
932           }
933           ret = opus_repacketizer_cat(&rp, tmp_data+i*bytes_per_frame, tmp_len);
934           if (ret<0)
935           {
936              RESTORE_STACK;
937              return OPUS_INTERNAL_ERROR;
938           }
939        }
940        ret = opus_repacketizer_out(&rp, data, out_data_bytes);
941        if (ret<0)
942        {
943           RESTORE_STACK;
944           return OPUS_INTERNAL_ERROR;
945        }
946        st->user_forced_mode = bak_mode;
947        st->user_bandwidth = bak_bandwidth;
948        st->force_channels = bak_channels;
949        st->silk_mode.toMono = bak_to_mono;
950        RESTORE_STACK;
951        return ret;
952     }
953
954     curr_bandwidth = st->bandwidth;
955
956     /* Chooses the appropriate mode for speech
957        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
958     if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND)
959         st->mode = MODE_HYBRID;
960     if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
961         st->mode = MODE_SILK_ONLY;
962
963     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
964     bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
965
966     data += 1;
967
968     ec_enc_init(&enc, data, max_data_bytes-1);
969
970     ALLOC(pcm_buf, (total_buffer+frame_size)*st->channels, opus_val16);
971     for (i=0;i<total_buffer*st->channels;i++)
972        pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-total_buffer)*st->channels+i];
973
974     if (st->mode == MODE_CELT_ONLY)
975        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
976     else
977        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
978
979     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
980           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
981
982     /* convert from log scale to Hertz */
983     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
984
985     if (st->application == OPUS_APPLICATION_VOIP)
986     {
987        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
988     } else {
989        dc_reject(pcm, 3, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
990     }
991
992
993
994     /* SILK processing */
995     HB_gain = Q15ONE;
996     if (st->mode != MODE_CELT_ONLY)
997     {
998         opus_int32 total_bitRate, celt_rate;
999 #ifdef FIXED_POINT
1000        const opus_int16 *pcm_silk;
1001 #else
1002        VARDECL(opus_int16, pcm_silk);
1003        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
1004 #endif
1005
1006         /* Distribute bits between SILK and CELT */
1007         total_bitRate = 8 * bytes_target * frame_rate;
1008         if( st->mode == MODE_HYBRID ) {
1009             int HB_gain_ref;
1010             /* Base rate for SILK */
1011             st->silk_mode.bitRate = st->stream_channels * ( 5000 + 1000 * ( st->Fs == 100 * frame_size ) );
1012             if( curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
1013                 /* SILK gets 2/3 of the remaining bits */
1014                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 2 / 3;
1015             } else { /* FULLBAND */
1016                 /* SILK gets 3/5 of the remaining bits */
1017                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 3 / 5;
1018             }
1019             /* Don't let SILK use more than 80% */
1020             if( st->silk_mode.bitRate > total_bitRate * 4/5 ) {
1021                 st->silk_mode.bitRate = total_bitRate * 4/5;
1022             }
1023             /* Increasingly attenuate high band when it gets allocated fewer bits */
1024             celt_rate = total_bitRate - st->silk_mode.bitRate;
1025             HB_gain_ref = (curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND) ? 2000 : 2400;
1026             HB_gain = SHL32((opus_val32)celt_rate, 9) / SHR32((opus_val32)celt_rate + st->stream_channels*HB_gain_ref, 6);
1027         } else {
1028             /* SILK gets all bits */
1029             st->silk_mode.bitRate = total_bitRate;
1030         }
1031
1032         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
1033         st->silk_mode.nChannelsAPI = st->channels;
1034         st->silk_mode.nChannelsInternal = st->stream_channels;
1035         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1036             st->silk_mode.desiredInternalSampleRate = 8000;
1037         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1038             st->silk_mode.desiredInternalSampleRate = 12000;
1039         } else {
1040             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
1041             st->silk_mode.desiredInternalSampleRate = 16000;
1042         }
1043         if( st->mode == MODE_HYBRID ) {
1044             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
1045             st->silk_mode.minInternalSampleRate = 16000;
1046         } else {
1047             st->silk_mode.minInternalSampleRate = 8000;
1048         }
1049
1050         if (st->mode == MODE_SILK_ONLY)
1051         {
1052            opus_int32 effective_max_rate = max_rate;
1053            st->silk_mode.maxInternalSampleRate = 16000;
1054            if (frame_rate > 50)
1055               effective_max_rate = effective_max_rate*2/3;
1056            if (effective_max_rate < 13000)
1057            {
1058               st->silk_mode.maxInternalSampleRate = 12000;
1059               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
1060            }
1061            if (effective_max_rate < 9600)
1062            {
1063               st->silk_mode.maxInternalSampleRate = 8000;
1064               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
1065            }
1066         } else {
1067            st->silk_mode.maxInternalSampleRate = 16000;
1068         }
1069
1070         st->silk_mode.useCBR = !st->use_vbr;
1071
1072         /* Call SILK encoder for the low band */
1073         nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes);
1074
1075         st->silk_mode.maxBits = nBytes*8;
1076         /* Only allow up to 90% of the bits for hybrid mode*/
1077         if (st->mode == MODE_HYBRID)
1078            st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
1079         if (st->silk_mode.useCBR)
1080         {
1081            st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
1082            /* Reduce the initial target to make it easier to reach the CBR rate */
1083            st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000);
1084         }
1085
1086         if (prefill)
1087         {
1088             opus_int32 zero=0;
1089             const CELTMode *celt_mode;
1090             int prefill_offset;
1091             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1092             /* Use a smooth onset for the SILK prefill to avoid the encoder trying to encode
1093                a discontinuity. The exact location is what we need to avoid leaving any "gap"
1094                in the audio when mixing with the redundant CELT frame. Here we can afford to
1095                overwrite st->delay_buffer because the only thing that uses it before it gets
1096                rewritten is tmp_prefill[] and even then only the part after the ramp really
1097                gets used (rather than sent to the encoder and discarded) */
1098             prefill_offset = st->channels*(st->encoder_buffer-st->delay_compensation-st->Fs/400);
1099             gain_fade(st->delay_buffer+prefill_offset, st->delay_buffer+prefill_offset,
1100                   0, Q15ONE, celt_mode->overlap, st->Fs/400, st->channels, celt_mode->window, st->Fs);
1101             for(i=0;i<prefill_offset;i++)
1102                st->delay_buffer[i]=0;
1103 #ifdef FIXED_POINT
1104             pcm_silk = st->delay_buffer;
1105 #else
1106             for (i=0;i<st->encoder_buffer*st->channels;i++)
1107                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
1108 #endif
1109             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
1110         }
1111
1112 #ifdef FIXED_POINT
1113         pcm_silk = pcm_buf+total_buffer*st->channels;
1114 #else
1115         for (i=0;i<frame_size*st->channels;i++)
1116             pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
1117 #endif
1118         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
1119         if( ret ) {
1120             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
1121             /* Handle error */
1122            RESTORE_STACK;
1123            return OPUS_INTERNAL_ERROR;
1124         }
1125         if (nBytes==0)
1126         {
1127            st->rangeFinal = 0;
1128            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1129            RESTORE_STACK;
1130            return 1;
1131         }
1132         /* Extract SILK internal bandwidth for signaling in first byte */
1133         if( st->mode == MODE_SILK_ONLY ) {
1134             if( st->silk_mode.internalSampleRate == 8000 ) {
1135                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1136             } else if( st->silk_mode.internalSampleRate == 12000 ) {
1137                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1138             } else if( st->silk_mode.internalSampleRate == 16000 ) {
1139                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1140             }
1141         } else {
1142             silk_assert( st->silk_mode.internalSampleRate == 16000 );
1143         }
1144
1145         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
1146         /* FIXME: How do we allocate the redundancy for CBR? */
1147         if (st->silk_mode.opusCanSwitch)
1148         {
1149            redundancy = 1;
1150            celt_to_silk = 0;
1151            st->silk_bw_switch = 1;
1152         }
1153     }
1154
1155     /* CELT processing */
1156     {
1157         int endband=21;
1158
1159         switch(curr_bandwidth)
1160         {
1161             case OPUS_BANDWIDTH_NARROWBAND:
1162                 endband = 13;
1163                 break;
1164             case OPUS_BANDWIDTH_MEDIUMBAND:
1165             case OPUS_BANDWIDTH_WIDEBAND:
1166                 endband = 17;
1167                 break;
1168             case OPUS_BANDWIDTH_SUPERWIDEBAND:
1169                 endband = 19;
1170                 break;
1171             case OPUS_BANDWIDTH_FULLBAND:
1172                 endband = 21;
1173                 break;
1174         }
1175         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
1176         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
1177     }
1178     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1179     if (st->mode != MODE_SILK_ONLY)
1180     {
1181         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1182         /* Allow prediction unless we decide to disable it later */
1183         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
1184
1185         if (st->mode == MODE_HYBRID)
1186         {
1187             int len;
1188
1189             len = (ec_tell(&enc)+7)>>3;
1190             if (redundancy)
1191                len += st->mode == MODE_HYBRID ? 3 : 1;
1192             if( st->use_vbr ) {
1193                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
1194             } else {
1195                 /* check if SILK used up too much */
1196                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
1197             }
1198         } else {
1199             if (st->use_vbr)
1200             {
1201                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
1202                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
1203                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps));
1204                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
1205             } else {
1206                 nb_compr_bytes = bytes_target;
1207             }
1208         }
1209
1210     } else {
1211         nb_compr_bytes = 0;
1212     }
1213
1214     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
1215     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
1216     {
1217        for (i=0;i<st->channels*st->Fs/400;i++)
1218           tmp_prefill[i] = st->delay_buffer[(extra_buffer+st->encoder_buffer-total_buffer-st->Fs/400)*st->channels + i];
1219     }
1220
1221     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+total_buffer));i++)
1222         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
1223     for (;i<st->encoder_buffer*st->channels;i++)
1224         st->delay_buffer[i] = pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels+i];
1225
1226     /* gain_fade() and stereo_fade() need to be after the buffer copying
1227        because we don't want any of this to affect the SILK part */
1228     if( st->prev_HB_gain < Q15ONE || HB_gain < Q15ONE ) {
1229        const CELTMode *celt_mode;
1230
1231        celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1232        gain_fade(pcm_buf+extra_buffer*st->channels, pcm_buf+extra_buffer*st->channels,
1233              st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs);
1234     }
1235     st->prev_HB_gain = HB_gain;
1236     if (st->mode != MODE_HYBRID || st->stream_channels==1)
1237        st->silk_mode.stereoWidth_Q14 = 1<<14;
1238     if( st->channels == 2 ) {
1239         /* Apply stereo width reduction (at low bitrates) */
1240         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1241             opus_val16 g1, g2;
1242             const CELTMode *celt_mode;
1243
1244             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1245             g1 = st->hybrid_stereo_width_Q14;
1246             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1247 #ifdef FIXED_POINT
1248             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
1249             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
1250 #else
1251             g1 *= (1.f/16384);
1252             g2 *= (1.f/16384);
1253 #endif
1254             stereo_fade(pcm_buf+extra_buffer*st->channels, pcm_buf+extra_buffer*st->channels, g1, g2, celt_mode->overlap,
1255                   frame_size, st->channels, celt_mode->window, st->Fs);
1256             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1257         }
1258     }
1259
1260     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
1261     {
1262         /* For SILK mode, the redundancy is inferred from the length */
1263         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
1264            ec_enc_bit_logp(&enc, redundancy, 12);
1265         if (redundancy)
1266         {
1267             int max_redundancy;
1268             ec_enc_bit_logp(&enc, celt_to_silk, 1);
1269             if (st->mode == MODE_HYBRID)
1270                max_redundancy = (max_data_bytes-1)-nb_compr_bytes-1;
1271             else
1272                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1273             /* Target the same bit-rate for redundancy as for the rest,
1274                up to a max of 257 bytes */
1275             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
1276             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
1277             if (st->mode == MODE_HYBRID)
1278                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
1279         }
1280     } else {
1281         redundancy = 0;
1282     }
1283
1284     if (!redundancy)
1285     {
1286        st->silk_bw_switch = 0;
1287        redundancy_bytes = 0;
1288     }
1289     if (st->mode != MODE_CELT_ONLY)start_band=17;
1290
1291     if (st->mode == MODE_SILK_ONLY)
1292     {
1293         ret = (ec_tell(&enc)+7)>>3;
1294         ec_enc_done(&enc);
1295         nb_compr_bytes = ret;
1296     } else {
1297        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
1298        ec_enc_shrink(&enc, nb_compr_bytes);
1299     }
1300
1301
1302     /* 5 ms redundant frame for CELT->SILK */
1303     if (redundancy && celt_to_silk)
1304     {
1305         int err;
1306         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1307         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1308         err = celt_encode_with_ec(celt_enc, pcm_buf+extra_buffer*st->channels, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
1309         if (err < 0)
1310         {
1311            RESTORE_STACK;
1312            return OPUS_INTERNAL_ERROR;
1313         }
1314         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1315         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1316     }
1317
1318     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
1319
1320     if (st->mode != MODE_SILK_ONLY)
1321     {
1322         if (st->mode != st->prev_mode && st->prev_mode > 0)
1323         {
1324            unsigned char dummy[2];
1325            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1326
1327            /* Prefilling */
1328            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
1329            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1330         }
1331         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
1332         if (ec_tell(&enc) <= 8*nb_compr_bytes)
1333         {
1334 #ifndef FIXED_POINT
1335            if (perform_analysis)
1336               celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(&analysis_info));
1337 #endif
1338            ret = celt_encode_with_ec(celt_enc, pcm_buf+extra_buffer*st->channels, frame_size, NULL, nb_compr_bytes, &enc);
1339            if (ret < 0)
1340            {
1341               RESTORE_STACK;
1342               return OPUS_INTERNAL_ERROR;
1343            }
1344         }
1345     }
1346
1347     /* 5 ms redundant frame for SILK->CELT */
1348     if (redundancy && !celt_to_silk)
1349     {
1350         int err;
1351         unsigned char dummy[2];
1352         int N2, N4;
1353         N2 = st->Fs/200;
1354         N4 = st->Fs/400;
1355
1356         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1357         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1358         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1359
1360         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1361         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(extra_buffer+frame_size-N2-N4), N4, dummy, 2, NULL);
1362
1363         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(extra_buffer+frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1364         if (err < 0)
1365         {
1366            RESTORE_STACK;
1367            return OPUS_INTERNAL_ERROR;
1368         }
1369         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1370     }
1371
1372
1373
1374     /* Signalling the mode in the first byte */
1375     data--;
1376     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1377
1378     st->rangeFinal = enc.rng ^ redundant_rng;
1379
1380     if (to_celt)
1381         st->prev_mode = MODE_CELT_ONLY;
1382     else
1383         st->prev_mode = st->mode;
1384     st->prev_channels = st->stream_channels;
1385     st->prev_framesize = frame_size;
1386
1387     st->first = 0;
1388
1389     /* In the unlikely case that the SILK encoder busted its target, tell
1390        the decoder to call the PLC */
1391     if (ec_tell(&enc) > (max_data_bytes-1)*8)
1392     {
1393        if (max_data_bytes < 2)
1394        {
1395           RESTORE_STACK;
1396           return OPUS_BUFFER_TOO_SMALL;
1397        }
1398        data[1] = 0;
1399        ret = 1;
1400        st->rangeFinal = 0;
1401     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
1402     {
1403        /*When in LPC only mode it's perfectly
1404          reasonable to strip off trailing zero bytes as
1405          the required range decoder behavior is to
1406          fill these in. This can't be done when the MDCT
1407          modes are used because the decoder needs to know
1408          the actual length for allocation purposes.*/
1409        while(ret>2&&data[ret]==0)ret--;
1410     }
1411     /* Count ToC and redundancy */
1412     ret += 1+redundancy_bytes;
1413     if (!st->use_vbr && ret >= 3)
1414     {
1415        if (pad_frame(data, ret, max_data_bytes))
1416        {
1417           RESTORE_STACK;
1418           return OPUS_INTERNAL_ERROR;
1419        }
1420        ret = max_data_bytes;
1421     }
1422     RESTORE_STACK;
1423     return ret;
1424 }
1425
1426 #ifdef FIXED_POINT
1427
1428 #ifndef DISABLE_FLOAT_API
1429 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1430       unsigned char *data, opus_int32 max_data_bytes)
1431 {
1432    int i, ret;
1433    VARDECL(opus_int16, in);
1434    ALLOC_STACK;
1435
1436    if(frame_size<0)
1437    {
1438       RESTORE_STACK;
1439       return OPUS_BAD_ARG;
1440    }
1441
1442    ALLOC(in, frame_size*st->channels, opus_int16);
1443
1444    for (i=0;i<frame_size*st->channels;i++)
1445       in[i] = FLOAT2INT16(pcm[i]);
1446    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16);
1447    RESTORE_STACK;
1448    return ret;
1449 }
1450 #endif
1451
1452 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1453                 unsigned char *data, opus_int32 out_data_bytes)
1454 {
1455    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 16);
1456 }
1457
1458 #else
1459 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1460       unsigned char *data, opus_int32 max_data_bytes)
1461 {
1462    int i, ret;
1463    VARDECL(float, in);
1464    ALLOC_STACK;
1465
1466    ALLOC(in, frame_size*st->channels, float);
1467
1468    for (i=0;i<frame_size*st->channels;i++)
1469       in[i] = (1.0f/32768)*pcm[i];
1470    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16);
1471    RESTORE_STACK;
1472    return ret;
1473 }
1474 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1475                       unsigned char *data, opus_int32 out_data_bytes)
1476 {
1477    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 24);
1478
1479 }
1480 #endif
1481
1482
1483 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
1484 {
1485     int ret;
1486     CELTEncoder *celt_enc;
1487     va_list ap;
1488
1489     ret = OPUS_OK;
1490     va_start(ap, request);
1491
1492     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1493
1494     switch (request)
1495     {
1496         case OPUS_SET_APPLICATION_REQUEST:
1497         {
1498             opus_int32 value = va_arg(ap, opus_int32);
1499             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
1500                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1501                || (!st->first && st->application != value))
1502             {
1503                ret = OPUS_BAD_ARG;
1504                break;
1505             }
1506             st->application = value;
1507         }
1508         break;
1509         case OPUS_GET_APPLICATION_REQUEST:
1510         {
1511             opus_int32 *value = va_arg(ap, opus_int32*);
1512             *value = st->application;
1513         }
1514         break;
1515         case OPUS_SET_BITRATE_REQUEST:
1516         {
1517             opus_int32 value = va_arg(ap, opus_int32);
1518             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1519             {
1520                 if (value <= 0)
1521                     goto bad_arg;
1522                 else if (value <= 500)
1523                     value = 500;
1524                 else if (value > (opus_int32)300000*st->channels)
1525                     value = (opus_int32)300000*st->channels;
1526             }
1527             st->user_bitrate_bps = value;
1528         }
1529         break;
1530         case OPUS_GET_BITRATE_REQUEST:
1531         {
1532             opus_int32 *value = va_arg(ap, opus_int32*);
1533             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
1534         }
1535         break;
1536         case OPUS_SET_FORCE_CHANNELS_REQUEST:
1537         {
1538             opus_int32 value = va_arg(ap, opus_int32);
1539             if((value<1 || value>st->channels) && value != OPUS_AUTO)
1540                 return OPUS_BAD_ARG;
1541             st->force_channels = value;
1542         }
1543         break;
1544         case OPUS_GET_FORCE_CHANNELS_REQUEST:
1545         {
1546             opus_int32 *value = va_arg(ap, opus_int32*);
1547             *value = st->force_channels;
1548         }
1549         break;
1550         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
1551         {
1552             opus_int32 value = va_arg(ap, opus_int32);
1553             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND)
1554                 return OPUS_BAD_ARG;
1555             st->max_bandwidth = value;
1556             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1557                 st->silk_mode.maxInternalSampleRate = 8000;
1558             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1559                 st->silk_mode.maxInternalSampleRate = 12000;
1560             } else {
1561                 st->silk_mode.maxInternalSampleRate = 16000;
1562             }
1563         }
1564         break;
1565         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
1566         {
1567             opus_int32 *value = va_arg(ap, opus_int32*);
1568             *value = st->max_bandwidth;
1569         }
1570         break;
1571         case OPUS_SET_BANDWIDTH_REQUEST:
1572         {
1573             opus_int32 value = va_arg(ap, opus_int32);
1574             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
1575                 return OPUS_BAD_ARG;
1576             st->user_bandwidth = value;
1577             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1578                 st->silk_mode.maxInternalSampleRate = 8000;
1579             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1580                 st->silk_mode.maxInternalSampleRate = 12000;
1581             } else {
1582                 st->silk_mode.maxInternalSampleRate = 16000;
1583             }
1584         }
1585         break;
1586         case OPUS_GET_BANDWIDTH_REQUEST:
1587         {
1588             opus_int32 *value = va_arg(ap, opus_int32*);
1589             *value = st->bandwidth;
1590         }
1591         break;
1592         case OPUS_SET_DTX_REQUEST:
1593         {
1594             opus_int32 value = va_arg(ap, opus_int32);
1595             if(value<0 || value>1)
1596                 return OPUS_BAD_ARG;
1597             st->silk_mode.useDTX = value;
1598         }
1599         break;
1600         case OPUS_GET_DTX_REQUEST:
1601         {
1602             opus_int32 *value = va_arg(ap, opus_int32*);
1603             *value = st->silk_mode.useDTX;
1604         }
1605         break;
1606         case OPUS_SET_COMPLEXITY_REQUEST:
1607         {
1608             opus_int32 value = va_arg(ap, opus_int32);
1609             if(value<0 || value>10)
1610                 return OPUS_BAD_ARG;
1611             st->silk_mode.complexity = value;
1612             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
1613         }
1614         break;
1615         case OPUS_GET_COMPLEXITY_REQUEST:
1616         {
1617             opus_int32 *value = va_arg(ap, opus_int32*);
1618             *value = st->silk_mode.complexity;
1619         }
1620         break;
1621         case OPUS_SET_INBAND_FEC_REQUEST:
1622         {
1623             opus_int32 value = va_arg(ap, opus_int32);
1624             if(value<0 || value>1)
1625                 return OPUS_BAD_ARG;
1626             st->silk_mode.useInBandFEC = value;
1627         }
1628         break;
1629         case OPUS_GET_INBAND_FEC_REQUEST:
1630         {
1631             opus_int32 *value = va_arg(ap, opus_int32*);
1632             *value = st->silk_mode.useInBandFEC;
1633         }
1634         break;
1635         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1636         {
1637             opus_int32 value = va_arg(ap, opus_int32);
1638             if (value < 0 || value > 100)
1639                 return OPUS_BAD_ARG;
1640             st->silk_mode.packetLossPercentage = value;
1641             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
1642         }
1643         break;
1644         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1645         {
1646             opus_int32 *value = va_arg(ap, opus_int32*);
1647             *value = st->silk_mode.packetLossPercentage;
1648         }
1649         break;
1650         case OPUS_SET_VBR_REQUEST:
1651         {
1652             opus_int32 value = va_arg(ap, opus_int32);
1653             if(value<0 || value>1)
1654                 return OPUS_BAD_ARG;
1655             st->use_vbr = value;
1656             st->silk_mode.useCBR = 1-value;
1657         }
1658         break;
1659         case OPUS_GET_VBR_REQUEST:
1660         {
1661             opus_int32 *value = va_arg(ap, opus_int32*);
1662             *value = st->use_vbr;
1663         }
1664         break;
1665         case OPUS_SET_VOICE_RATIO_REQUEST:
1666         {
1667             opus_int32 value = va_arg(ap, opus_int32);
1668             if (value>100 || value<-1)
1669                 goto bad_arg;
1670             st->voice_ratio = value;
1671         }
1672         break;
1673         case OPUS_GET_VOICE_RATIO_REQUEST:
1674         {
1675             opus_int32 *value = va_arg(ap, opus_int32*);
1676             *value = st->voice_ratio;
1677         }
1678         break;
1679         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1680         {
1681             opus_int32 value = va_arg(ap, opus_int32);
1682             if(value<0 || value>1)
1683                 return OPUS_BAD_ARG;
1684             st->vbr_constraint = value;
1685         }
1686         break;
1687         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1688         {
1689             opus_int32 *value = va_arg(ap, opus_int32*);
1690             *value = st->vbr_constraint;
1691         }
1692         break;
1693         case OPUS_SET_SIGNAL_REQUEST:
1694         {
1695             opus_int32 value = va_arg(ap, opus_int32);
1696             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
1697                 return OPUS_BAD_ARG;
1698             st->signal_type = value;
1699         }
1700         break;
1701         case OPUS_GET_SIGNAL_REQUEST:
1702         {
1703             opus_int32 *value = va_arg(ap, opus_int32*);
1704             *value = st->signal_type;
1705         }
1706         break;
1707         case OPUS_GET_LOOKAHEAD_REQUEST:
1708         {
1709             opus_int32 *value = va_arg(ap, opus_int32*);
1710             *value = st->Fs/400;
1711             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1712                 *value += st->delay_compensation;
1713         }
1714         break;
1715         case OPUS_GET_SAMPLE_RATE_REQUEST:
1716         {
1717             opus_int32 *value = va_arg(ap, opus_int32*);
1718             if (value==NULL)
1719             {
1720                 ret = OPUS_BAD_ARG;
1721                 break;
1722             }
1723             *value = st->Fs;
1724         }
1725         break;
1726         case OPUS_GET_FINAL_RANGE_REQUEST:
1727         {
1728             opus_uint32 *value = va_arg(ap, opus_uint32*);
1729             *value = st->rangeFinal;
1730         }
1731         break;
1732         case OPUS_SET_LSB_DEPTH_REQUEST:
1733         {
1734             opus_int32 value = va_arg(ap, opus_int32);
1735             if (value<8 || value>24)
1736                goto bad_arg;
1737             st->lsb_depth=value;
1738         }
1739         break;
1740         case OPUS_GET_LSB_DEPTH_REQUEST:
1741         {
1742             opus_int32 *value = va_arg(ap, opus_int32*);
1743             *value = st->lsb_depth;
1744         }
1745         break;
1746         case OPUS_RESET_STATE:
1747         {
1748            void *silk_enc;
1749            silk_EncControlStruct dummy;
1750            silk_enc = (char*)st+st->silk_enc_offset;
1751
1752            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
1753                  sizeof(OpusEncoder)-
1754                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
1755
1756            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1757            silk_InitEncoder( silk_enc, &dummy );
1758            st->stream_channels = st->channels;
1759            st->hybrid_stereo_width_Q14 = 1 << 14;
1760            st->prev_HB_gain = Q15ONE;
1761            st->first = 1;
1762            st->mode = MODE_HYBRID;
1763            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
1764            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1765         }
1766         break;
1767         case OPUS_SET_FORCE_MODE_REQUEST:
1768         {
1769             opus_int32 value = va_arg(ap, opus_int32);
1770             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
1771                goto bad_arg;
1772             st->user_forced_mode = value;
1773         }
1774         break;
1775         default:
1776             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
1777             ret = OPUS_UNIMPLEMENTED;
1778             break;
1779     }
1780     va_end(ap);
1781     return ret;
1782 bad_arg:
1783     va_end(ap);
1784     return OPUS_BAD_ARG;
1785 }
1786
1787 void opus_encoder_destroy(OpusEncoder *st)
1788 {
1789     opus_free(st);
1790 }