5051f43e709169271652615b17a2c53e0296fd5e
[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 FOUNDATION OR
19    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 "silk_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
44 #include "silk_tuning_parameters.h"
45 #ifdef FIXED_POINT
46 #include "fixed/silk_structs_FIX.h"
47 #else
48 #include "float/silk_structs_FLP.h"
49 #endif
50
51 #define MAX_ENCODER_BUFFER 480
52
53 struct OpusEncoder {
54     int          celt_enc_offset;
55     int          silk_enc_offset;
56     silk_EncControlStruct silk_mode;
57     int          application;
58     int          channels;
59     int          delay_compensation;
60     int          force_channels;
61     int          signal_type;
62     int          user_bandwidth;
63     int          user_forced_mode;
64     int          voice_ratio;
65     opus_int32   Fs;
66     int          use_vbr;
67     int          vbr_constraint;
68     int          bitrate_bps;
69     int          user_bitrate_bps;
70     int          lowdelay;
71     int          encoder_buffer;
72
73 #define OPUS_ENCODER_RESET_START stream_channels
74     int          stream_channels;
75     int          hybrid_stereo_width_Q14;
76     opus_int32   variable_HP_smth2_Q15;
77     opus_val32   hp_mem[4];
78     int          mode;
79     int          prev_mode;
80     int          bandwidth;
81     /* Sampling rate (at the API level) */
82     int          first;
83     opus_val16   delay_buffer[MAX_ENCODER_BUFFER*2];
84
85     opus_uint32  rangeFinal;
86 };
87
88 /* Transition tables for the voice and music. First column is the
89    middle (memoriless) threshold. The second column is the hysteresis
90    (difference with the middle) */
91 static const opus_int32 mono_voice_bandwidth_thresholds[8] = {
92         11000, 1000, /* NB<->MB */
93         14000, 1000, /* MB<->WB */
94         21000, 2000, /* WB<->SWB */
95         29000, 2000, /* SWB<->FB */
96 };
97 static const opus_int32 mono_music_bandwidth_thresholds[8] = {
98         14000, 1000, /* MB not allowed */
99         18000, 2000, /* MB<->WB */
100         24000, 2000, /* WB<->SWB */
101         33000, 2000, /* SWB<->FB */
102 };
103 static const opus_int32 stereo_voice_bandwidth_thresholds[8] = {
104         11000, 1000, /* NB<->MB */
105         14000, 1000, /* MB<->WB */
106         21000, 2000, /* WB<->SWB */
107         32000, 2000, /* SWB<->FB */
108 };
109 static const opus_int32 stereo_music_bandwidth_thresholds[8] = {
110         14000, 1000, /* MB not allowed */
111         18000, 2000, /* MB<->WB */
112         24000, 2000, /* WB<->SWB */
113         48000, 2000, /* SWB<->FB */
114 };
115 /* Threshold bit-rates for switching between mono and stereo */
116 static const opus_int32 stereo_voice_threshold = 26000;
117 static const opus_int32 stereo_music_threshold = 36000;
118
119 /* Threshold bit-rate for switching between SILK/hybrid and CELT-only */
120 static const opus_int32 mode_thresholds[2][2] = {
121       /* voice */ /* music */
122       {  48000,      24000}, /* mono */
123       {  48000,      24000}, /* stereo */
124 };
125 int opus_encoder_get_size(int channels)
126 {
127     int silkEncSizeBytes, celtEncSizeBytes;
128     int ret;
129     if (channels<1 || channels > 2)
130         return 0;
131     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
132     if (ret)
133         return 0;
134     silkEncSizeBytes = align(silkEncSizeBytes);
135     celtEncSizeBytes = celt_encoder_get_size(channels);
136     return align(sizeof(OpusEncoder))+silkEncSizeBytes+celtEncSizeBytes;
137 }
138
139 int opus_encoder_init(OpusEncoder* st, opus_int32 Fs, int channels, int application)
140 {
141     void *silk_enc;
142     CELTEncoder *celt_enc;
143     int err;
144     int ret, silkEncSizeBytes;
145
146     if (channels > 2 || channels < 1)
147         return OPUS_BAD_ARG;
148     if (application < OPUS_APPLICATION_VOIP || application > OPUS_APPLICATION_AUDIO)
149         return OPUS_BAD_ARG;
150     if (Fs != 8000 && Fs != 12000 && Fs != 16000 && Fs != 24000 && Fs != 48000)
151         return OPUS_BAD_ARG;
152
153     OPUS_CLEAR((char*)st, opus_encoder_get_size(channels));
154     /* Create SILK encoder */
155     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
156     if (ret)
157         return OPUS_BAD_ARG;
158     silkEncSizeBytes = align(silkEncSizeBytes);
159     st->silk_enc_offset = align(sizeof(OpusEncoder));
160     st->celt_enc_offset = st->silk_enc_offset+silkEncSizeBytes;
161     silk_enc = (char*)st+st->silk_enc_offset;
162     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
163
164     st->stream_channels = st->channels = channels;
165
166     st->Fs = Fs;
167
168     ret = silk_InitEncoder( silk_enc, &st->silk_mode );
169     if(ret)return OPUS_INTERNAL_ERROR;
170
171     /* default SILK parameters */
172     st->silk_mode.nChannelsAPI              = channels;
173     st->silk_mode.nChannelsInternal         = channels;
174     st->silk_mode.API_sampleRate            = st->Fs;
175     st->silk_mode.maxInternalSampleRate     = 16000;
176     st->silk_mode.minInternalSampleRate     = 8000;
177     st->silk_mode.desiredInternalSampleRate = 16000;
178     st->silk_mode.payloadSize_ms            = 20;
179     st->silk_mode.bitRate                   = 25000;
180     st->silk_mode.packetLossPercentage      = 0;
181     st->silk_mode.complexity                = 10;
182     st->silk_mode.useInBandFEC              = 0;
183     st->silk_mode.useDTX                    = 0;
184     st->silk_mode.useCBR                    = 0;
185
186     /* Create CELT encoder */
187     /* Initialize CELT encoder */
188     err = celt_encoder_init(celt_enc, Fs, channels);
189     if(err!=OPUS_OK)return OPUS_INTERNAL_ERROR;
190
191     celt_encoder_ctl(celt_enc, CELT_SET_SIGNALLING(0));
192
193     st->use_vbr = 0;
194     st->user_bitrate_bps = OPUS_AUTO;
195     st->bitrate_bps = 3000+Fs*channels;
196     st->application = application;
197     st->signal_type = OPUS_AUTO;
198     st->user_bandwidth = OPUS_AUTO;
199     st->force_channels = OPUS_AUTO;
200     st->user_forced_mode = OPUS_AUTO;
201     st->voice_ratio = -1;
202     st->encoder_buffer = st->Fs/100;
203
204     st->delay_compensation = st->Fs/400;
205     /* This part is meant to compensate for the resampler delay as a function
206        of the API sampling rate */
207     if (st->Fs == 48000)
208         st->delay_compensation += 23;
209     else if (st->Fs == 24000)
210        st->delay_compensation += 15;
211     else
212        st->delay_compensation += 2;
213
214     st->hybrid_stereo_width_Q14             = 1 << 14;
215     st->variable_HP_smth2_Q15 = SKP_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
216     st->first = 1;
217     st->mode = MODE_HYBRID;
218     st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
219
220     return OPUS_OK;
221 }
222
223 static unsigned char gen_toc(int mode, int framerate, int bandwidth, int silk_bandwidth, int channels)
224 {
225    int period;
226    unsigned char toc;
227    period = 0;
228    while (framerate < 400)
229    {
230        framerate <<= 1;
231        period++;
232    }
233    if (mode == MODE_SILK_ONLY)
234    {
235        toc = (silk_bandwidth-OPUS_BANDWIDTH_NARROWBAND)<<5;
236        toc |= (period-2)<<3;
237    } else if (mode == MODE_CELT_ONLY)
238    {
239        int tmp = bandwidth-OPUS_BANDWIDTH_MEDIUMBAND;
240        if (tmp < 0)
241            tmp = 0;
242        toc = 0x80;
243        toc |= tmp << 5;
244        toc |= period<<3;
245    } else /* Hybrid */
246    {
247        toc = 0x60;
248        toc |= (bandwidth-OPUS_BANDWIDTH_SUPERWIDEBAND)<<4;
249        toc |= (period-2)<<3;
250    }
251    toc |= (channels==2)<<2;
252    return toc;
253 }
254
255 #ifndef FIXED_POINT
256 void silk_biquad_float(
257     const opus_val16      *in,            /* I:    Input signal                   */
258     const opus_int32      *B_Q28,         /* I:    MA coefficients [3]            */
259     const opus_int32      *A_Q28,         /* I:    AR coefficients [2]            */
260     opus_val32            *S,             /* I/O:  State vector [2]               */
261     opus_val16            *out,           /* O:    Output signal                  */
262     const opus_int32      len,            /* I:    Signal length (must be even)   */
263     int stride
264 )
265 {
266     /* DIRECT FORM II TRANSPOSED (uses 2 element state vector) */
267     opus_int   k;
268     opus_val32 vout;
269     opus_val32 inval;
270     opus_val32 A[2], B[3];
271
272     A[0] = A_Q28[0] * (1./((opus_int32)1<<28));
273     A[1] = A_Q28[1] * (1./((opus_int32)1<<28));
274     B[0] = B_Q28[0] * (1./((opus_int32)1<<28));
275     B[1] = B_Q28[1] * (1./((opus_int32)1<<28));
276     B[2] = B_Q28[2] * (1./((opus_int32)1<<28));
277
278     /* Negate A_Q28 values and split in two parts */
279
280     for( k = 0; k < len; k++ ) {
281         /* S[ 0 ], S[ 1 ]: Q12 */
282         inval = in[ k*stride ];
283         vout = S[ 0 ] + B[0]*inval;
284
285         S[ 0 ] = S[1] - vout*A[0] + B[1]*inval;
286
287         S[ 1 ] = - vout*A[1] + B[2]*inval;
288
289         /* Scale back to Q0 and saturate */
290         out[ k*stride ] = vout;
291     }
292 }
293 #endif
294
295 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)
296 {
297    opus_int32 B_Q28[ 3 ], A_Q28[ 2 ];
298    opus_int32 Fc_Q19, r_Q28, r_Q22;
299
300    SKP_assert( cutoff_Hz <= SKP_int32_MAX / SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ) );
301    Fc_Q19 = SKP_DIV32_16( SKP_SMULBB( SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ), cutoff_Hz ), Fs/1000 );
302    SKP_assert( Fc_Q19 > 0 && Fc_Q19 < 32768 );
303
304    r_Q28 = SILK_FIX_CONST( 1.0, 28 ) - SKP_MUL( SILK_FIX_CONST( 0.92, 9 ), Fc_Q19 );
305
306    /* b = r * [ 1; -2; 1 ]; */
307    /* a = [ 1; -2 * r * ( 1 - 0.5 * Fc^2 ); r^2 ]; */
308    B_Q28[ 0 ] = r_Q28;
309    B_Q28[ 1 ] = SKP_LSHIFT( -r_Q28, 1 );
310    B_Q28[ 2 ] = r_Q28;
311
312    /* -r * ( 2 - Fc * Fc ); */
313    r_Q22  = SKP_RSHIFT( r_Q28, 6 );
314    A_Q28[ 0 ] = SKP_SMULWW( r_Q22, SKP_SMULWW( Fc_Q19, Fc_Q19 ) - SILK_FIX_CONST( 2.0,  22 ) );
315    A_Q28[ 1 ] = SKP_SMULWW( r_Q22, r_Q22 );
316
317 #ifdef FIXED_POINT
318    silk_biquad_alt( in, B_Q28, A_Q28, hp_mem, out, len, channels );
319    if( channels == 2 ) {
320        silk_biquad_alt( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
321    }
322 #else
323    silk_biquad_float( in, B_Q28, A_Q28, hp_mem, out, len, channels );
324    if( channels == 2 ) {
325        silk_biquad_float( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
326    }
327 #endif
328 }
329
330 OpusEncoder *opus_encoder_create(opus_int32 Fs, int channels, int mode, int *error)
331 {
332    int ret;
333    OpusEncoder *st = (OpusEncoder *)opus_alloc(opus_encoder_get_size(channels));
334    if (st == NULL)
335    {
336       if (error)
337          *error = OPUS_ALLOC_FAIL;
338       return NULL;
339    }
340    ret = opus_encoder_init(st, Fs, channels, mode);
341    if (error)
342       *error = ret;
343    if (ret != OPUS_OK)
344    {
345       opus_free(st);
346       st = NULL;
347    }
348    return st;
349 }
350 #ifdef FIXED_POINT
351 #define opus_encode_native opus_encode
352 int opus_encode(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
353                 unsigned char *data, int max_data_bytes)
354 #else
355 #define opus_encode_native opus_encode_float
356 int opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
357                       unsigned char *data, int max_data_bytes)
358 #endif
359 {
360     void *silk_enc;
361     CELTEncoder *celt_enc;
362     int i;
363     int ret=0;
364     int nBytes;
365     ec_enc enc;
366     int silk_internal_bandwidth=-1;
367     int bytes_target;
368     int prefill=0;
369     int start_band = 0;
370     int redundancy = 0;
371     int redundancy_bytes = 0;
372     int celt_to_silk = 0;
373     VARDECL(opus_val16, pcm_buf);
374     int nb_compr_bytes;
375     int to_celt = 0;
376     opus_uint32 redundant_rng = 0;
377     int cutoff_Hz, hp_freq_smth1;
378     int voice_est;
379     opus_int32 equiv_rate;
380     int delay_compensation;
381     ALLOC_STACK;
382
383     st->rangeFinal = 0;
384     if (400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
385          50*frame_size != st->Fs &&  25*frame_size != st->Fs &&  50*frame_size != 3*st->Fs)
386     {
387        RESTORE_STACK;
388        return OPUS_BAD_ARG;
389     }
390     silk_enc = (char*)st+st->silk_enc_offset;
391     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
392
393     if (st->lowdelay)
394        delay_compensation = 0;
395     else
396        delay_compensation = st->delay_compensation;
397
398     if (st->user_bitrate_bps==OPUS_AUTO)
399         st->bitrate_bps = 60*st->Fs/frame_size + st->Fs*st->channels;
400     else if (st->user_bitrate_bps==OPUS_BITRATE_MAX)
401        st->bitrate_bps = max_data_bytes*8*st->Fs/frame_size;
402     else
403         st->bitrate_bps = st->user_bitrate_bps;
404
405     /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */
406     equiv_rate = st->bitrate_bps - 60*(st->Fs/frame_size - 50);
407
408     if (st->signal_type == OPUS_SIGNAL_VOICE)
409        voice_est = 127;
410     else if (st->signal_type == OPUS_SIGNAL_MUSIC)
411        voice_est = 0;
412     else if (st->voice_ratio >= 0)
413        voice_est = st->voice_ratio*327>>8;
414     else if (st->application == OPUS_APPLICATION_VOIP)
415        voice_est = 115;
416     else
417        voice_est = 64;
418
419 #ifdef FUZZING
420     /* Random mono/stereo decision */
421     if (st->channels == 2 && (rand()&0x1F)==0)
422        st->stream_channels = 3-st->stream_channels;
423 #else
424     /* Rate-dependent mono-stereo decision */
425     if (st->force_channels!=OPUS_AUTO && st->channels == 2)
426     {
427         st->stream_channels = st->force_channels;
428     } else if (st->channels == 2)
429     {
430        opus_int32 stereo_threshold;
431        stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14);
432        if (st->stream_channels == 2)
433           stereo_threshold -= 4000;
434        else
435           stereo_threshold += 4000;
436        st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1;
437     } else {
438             st->stream_channels = st->channels;
439     }
440 #endif
441
442 #ifdef FUZZING
443     /* Random mode switching */
444     if ((rand()&0xF)==0)
445     {
446        if ((rand()&0x1)==0)
447           st->mode = MODE_CELT_ONLY;
448        else
449           st->mode = MODE_SILK_ONLY;
450     } else {
451        if (st->prev_mode==MODE_CELT_ONLY)
452           st->mode = MODE_CELT_ONLY;
453        else
454           st->mode = MODE_SILK_ONLY;
455     }
456 #else
457     /* Mode selection depending on application and signal type */
458     if (st->lowdelay)
459     {
460        st->mode = MODE_CELT_ONLY;
461     } else if (st->user_forced_mode == OPUS_AUTO)
462     {
463        int chan;
464        opus_int32 mode_voice, mode_music;
465        opus_int32 threshold;
466
467        chan = (st->channels==2) && st->force_channels!=1;
468        mode_voice = mode_thresholds[chan][0];
469        mode_music = mode_thresholds[chan][1];
470        threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14);
471
472        /* Hysteresis */
473        if (st->prev_mode == MODE_CELT_ONLY)
474            threshold -= 4000;
475        else if (st->prev_mode>0)
476            threshold += 4000;
477
478        st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY;
479     } else {
480        st->mode = st->user_forced_mode;
481     }
482 #endif
483
484     /* Override the chosen mode to make sure we meet the requested frame size */
485     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
486        st->mode = MODE_CELT_ONLY;
487
488     if (st->prev_mode > 0 &&
489         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
490     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
491     {
492         redundancy = 1;
493         celt_to_silk = (st->mode != MODE_CELT_ONLY);
494         if (!celt_to_silk)
495         {
496             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
497             if (frame_size >= st->Fs/100)
498             {
499                 st->mode = st->prev_mode;
500                 to_celt = 1;
501             } else {
502                 redundancy=0;
503             }
504         }
505     }
506     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
507     {
508         silk_EncControlStruct dummy;
509         silk_InitEncoder( silk_enc, &dummy);
510         prefill=1;
511     }
512
513     /* Automatic (rate-dependent) bandwidth selection */
514     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
515     {
516         const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds;
517         opus_int32 bandwidth_thresholds[8];
518         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
519
520         if (st->channels==2 && st->force_channels!=1)
521         {
522            voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds;
523            music_bandwidth_thresholds = stereo_music_bandwidth_thresholds;
524         } else {
525            voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds;
526            music_bandwidth_thresholds = mono_music_bandwidth_thresholds;
527         }
528         /* Interpolate bandwidth thresholds depending on voice estimation */
529         for (i=0;i<8;i++)
530         {
531            bandwidth_thresholds[i] = music_bandwidth_thresholds[i]
532                     + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14);
533         }
534         do {
535             int threshold, hysteresis;
536             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
537             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
538             if (!st->first)
539             {
540                 if (st->bandwidth >= bandwidth)
541                     threshold -= hysteresis;
542                 else
543                     threshold += hysteresis;
544             }
545             if (equiv_rate >= threshold)
546                 break;
547         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
548         st->bandwidth = bandwidth;
549         /* Prevents any transition to SWB/FB until the SILK layer has fully
550            switched to WB mode and turned the variable LP filter off */
551         if (st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
552             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
553     }
554
555     /* Prevents Opus from wasting bits on frequencies that are above
556        the Nyquist rate of the input signal */
557     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
558         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
559     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
560         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
561     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
562         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
563     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
564         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
565
566     if (st->user_bandwidth != OPUS_AUTO)
567         st->bandwidth = st->user_bandwidth;
568
569     /* Can't support higher than wideband for >20 ms frames */
570     if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND))
571     {
572        unsigned char tmp_data[3][1276];
573        int nb_frames;
574        int bak_mode, bak_bandwidth, bak_channels;
575        OpusRepacketizer *rp = opus_repacketizer_create();
576
577        bak_mode = st->user_forced_mode;
578        bak_bandwidth = st->user_bandwidth;
579        bak_channels = st->force_channels;
580
581        st->user_forced_mode = st->mode;
582        st->user_bandwidth = st->bandwidth;
583        st->force_channels = st->stream_channels;
584
585        nb_frames = frame_size > st->Fs/25 ? 3 : 2;
586        for (i=0;i<nb_frames;i++)
587        {
588           int tmp_len;
589           tmp_len = opus_encode_native(st, pcm+i*(st->channels*st->Fs/50), st->Fs/50, tmp_data[i], max_data_bytes/nb_frames-3);
590           ret = opus_repacketizer_cat(rp, tmp_data[i], tmp_len);
591        }
592        ret = opus_repacketizer_out(rp, data, max_data_bytes);
593
594        opus_repacketizer_destroy(rp);
595
596        st->user_forced_mode = bak_mode;
597        st->user_bandwidth = bak_bandwidth;
598        st->force_channels = bak_channels;
599        RESTORE_STACK;
600        return ret;
601     }
602     /* CELT mode doesn't support mediumband, use wideband instead */
603     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
604         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
605
606     /* Chooses the appropriate mode for speech
607        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
608     if (st->mode == MODE_SILK_ONLY && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
609         st->mode = MODE_HYBRID;
610     if (st->mode == MODE_HYBRID && st->bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
611         st->mode = MODE_SILK_ONLY;
612
613     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, st->bandwidth); */
614     bytes_target = st->bitrate_bps * frame_size / (st->Fs * 8) - 1;
615
616     data += 1;
617
618     ec_enc_init(&enc, data, max_data_bytes-1);
619
620     ALLOC(pcm_buf, (delay_compensation+frame_size)*st->channels, opus_val16);
621     for (i=0;i<delay_compensation*st->channels;i++)
622        pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-delay_compensation)*st->channels+i];
623
624     if (st->mode == MODE_CELT_ONLY)
625        hp_freq_smth1 = SKP_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
626     else
627        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
628
629     st->variable_HP_smth2_Q15 = SKP_SMLAWB( st->variable_HP_smth2_Q15,
630           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
631
632     /* convert from log scale to Hertz */
633     cutoff_Hz = silk_log2lin( SKP_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
634
635     if (st->application == OPUS_APPLICATION_VOIP)
636     {
637        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[delay_compensation*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
638     } else {
639        for (i=0;i<frame_size*st->channels;i++)
640           pcm_buf[delay_compensation*st->channels + i] = pcm[i];
641     }
642
643     /* SILK processing */
644     if (st->mode != MODE_CELT_ONLY)
645     {
646 #ifdef FIXED_POINT
647        const opus_int16 *pcm_silk;
648 #else
649        VARDECL(opus_int16, pcm_silk);
650        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
651 #endif
652         st->silk_mode.bitRate = st->bitrate_bps - 8*st->Fs/frame_size;
653         if( st->mode == MODE_HYBRID ) {
654             st->silk_mode.bitRate /= st->stream_channels;
655             if( st->bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
656                 if( st->Fs == 100 * frame_size ) {
657                     /* 24 kHz, 10 ms */
658                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 2000 + st->use_vbr * 1000 ) * 2 ) / 3;
659                 } else {
660                     /* 24 kHz, 20 ms */
661                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 1000 + st->use_vbr * 1000 ) * 2 ) / 3;
662                 }
663             } else {
664                 if( st->Fs == 100 * frame_size ) {
665                     /* 48 kHz, 10 ms */
666                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 8000 + st->use_vbr * 3000 ) / 2;
667                 } else {
668                     /* 48 kHz, 20 ms */
669                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 9000 + st->use_vbr * 1000 ) / 2;
670                 }
671             }
672             st->silk_mode.bitRate *= st->stream_channels;
673             /* don't let SILK use more than 80% */
674             if( st->silk_mode.bitRate > ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5 ) {
675                 st->silk_mode.bitRate = ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5;
676             }
677         }
678
679         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
680         st->silk_mode.nChannelsAPI = st->channels;
681         st->silk_mode.nChannelsInternal = st->stream_channels;
682         if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
683             st->silk_mode.desiredInternalSampleRate = 8000;
684         } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
685             st->silk_mode.desiredInternalSampleRate = 12000;
686         } else {
687             SKP_assert( st->mode == MODE_HYBRID || st->bandwidth == OPUS_BANDWIDTH_WIDEBAND );
688             st->silk_mode.desiredInternalSampleRate = 16000;
689         }
690         if( st->mode == MODE_HYBRID ) {
691             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
692             st->silk_mode.minInternalSampleRate = 16000;
693         } else {
694             st->silk_mode.minInternalSampleRate = 8000;
695         }
696         st->silk_mode.maxInternalSampleRate = 16000;
697
698         /* Call SILK encoder for the low band */
699         nBytes = IMIN(1275, max_data_bytes-1);
700         if (prefill)
701         {
702             int zero=0;
703 #ifdef FIXED_POINT
704             pcm_silk = st->delay_buffer;
705 #else
706             for (i=0;i<st->encoder_buffer*st->channels;i++)
707                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
708 #endif
709             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
710         }
711
712 #ifdef FIXED_POINT
713         pcm_silk = pcm_buf+delay_compensation*st->channels;
714 #else
715         for (i=0;i<frame_size*st->channels;i++)
716             pcm_silk[i] = FLOAT2INT16(pcm_buf[delay_compensation*st->channels + i]);
717 #endif
718         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
719         if( ret ) {
720             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
721             /* Handle error */
722            return OPUS_INTERNAL_ERROR;
723         }
724         if (nBytes==0)
725         {
726            data[-1] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, silk_internal_bandwidth, st->stream_channels);
727            RESTORE_STACK;
728            return 1;
729         }
730         /* Extract SILK internal bandwidth for signaling in first byte */
731         if( st->mode == MODE_SILK_ONLY ) {
732             if( st->silk_mode.internalSampleRate == 8000 ) {
733                 silk_internal_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
734             } else if( st->silk_mode.internalSampleRate == 12000 ) {
735                 silk_internal_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
736             } else if( st->silk_mode.internalSampleRate == 16000 ) {
737                 silk_internal_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
738             }
739         } else {
740             SKP_assert( st->silk_mode.internalSampleRate == 16000 );
741         }
742     }
743
744     /* CELT processing */
745     {
746         int endband=21;
747
748         switch(st->bandwidth)
749         {
750             case OPUS_BANDWIDTH_NARROWBAND:
751                 endband = 13;
752                 break;
753             case OPUS_BANDWIDTH_MEDIUMBAND:
754             case OPUS_BANDWIDTH_WIDEBAND:
755                 endband = 17;
756                 break;
757             case OPUS_BANDWIDTH_SUPERWIDEBAND:
758                 endband = 19;
759                 break;
760             case OPUS_BANDWIDTH_FULLBAND:
761                 endband = 21;
762                 break;
763         }
764         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
765         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
766     }
767     if (st->mode != MODE_SILK_ONLY)
768     {
769         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
770         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
771         if (st->prev_mode == MODE_SILK_ONLY)
772         {
773             unsigned char dummy[10];
774             celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
775             celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
776             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
777             /* TODO: This wastes CPU a bit compared to just prefilling the buffer */
778             celt_encode_with_ec(celt_enc, &st->delay_buffer[(st->encoder_buffer-delay_compensation-st->Fs/400)*st->channels], st->Fs/400, dummy, 10, NULL);
779         } else {
780             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
781         }
782
783         if (st->mode == MODE_HYBRID)
784         {
785             int len;
786
787             len = (ec_tell(&enc)+7)>>3;
788             if( st->use_vbr ) {
789                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
790             } else {
791                 /* check if SILK used up too much */
792                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
793             }
794         } else {
795             if (st->use_vbr)
796             {
797                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
798                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
799                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps));
800                 nb_compr_bytes = max_data_bytes-1;
801             } else {
802                 nb_compr_bytes = bytes_target;
803             }
804         }
805
806     } else {
807         nb_compr_bytes = 0;
808     }
809
810     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+delay_compensation));i++)
811         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
812     for (;i<st->encoder_buffer*st->channels;i++)
813         st->delay_buffer[i] = pcm_buf[(frame_size+delay_compensation-st->encoder_buffer)*st->channels+i];
814
815
816     if( st->mode == MODE_HYBRID && st->stream_channels == 2 ) {
817         /* Apply stereo width reduction (at low bitrates) */
818         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
819             int width_Q14, delta_Q14, nSamples_8ms, diff;
820             nSamples_8ms = ( st->Fs * 8 ) / 1000;
821             width_Q14 = (1 << 14 ) - st->hybrid_stereo_width_Q14;
822             delta_Q14 = ( st->hybrid_stereo_width_Q14 - st->silk_mode.stereoWidth_Q14 ) / nSamples_8ms;
823             for( i = 0; i < nSamples_8ms; i++ ) {
824                 width_Q14 += delta_Q14;
825                 diff = pcm_buf[ 2*i+1 ] - (opus_int32)pcm_buf[ 2*i ];
826                 diff = ( diff * width_Q14 ) >> 15;
827                 pcm_buf[ 2*i ]   = (opus_int16)( pcm_buf[ 2*i ]   + diff );
828                 pcm_buf[ 2*i+1 ] = (opus_int16)( pcm_buf[ 2*i+1 ] - diff );
829             }
830             for( ; i < frame_size; i++ ) {
831                 diff = pcm_buf[ 2*i+1 ] - (opus_int32)pcm_buf[ 2*i ];
832                 diff = ( diff * width_Q14 ) >> 15;
833                 pcm_buf[ 2*i ]   = (opus_int16)( pcm_buf[ 2*i ]   + diff );
834                 pcm_buf[ 2*i+1 ] = (opus_int16)( pcm_buf[ 2*i+1 ] - diff );
835             }
836             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
837         }
838     }
839
840     if (st->mode != MODE_CELT_ONLY && ec_tell(&enc)+29+8*(st->mode == MODE_HYBRID) < 8*nb_compr_bytes)
841     {
842         /* Check if we have a redundant 0-8 kHz band */
843         ec_enc_bit_logp(&enc, redundancy, 12);
844         if (redundancy)
845         {
846             int max_redundancy;
847             ec_enc_bit_logp(&enc, celt_to_silk, 1);
848             max_redundancy = nb_compr_bytes-((ec_tell(&enc)+7)>>3)-(st->mode == MODE_HYBRID);
849             /* Target the same bit-rate for redundancy as for the rest,
850                up to a max of 257 bytes */
851             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
852             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
853             if (st->mode == MODE_HYBRID)
854                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
855         }
856     } else {
857         redundancy = 0;
858     }
859
860     if (st->mode != MODE_CELT_ONLY)start_band=17;
861
862     if (st->mode == MODE_SILK_ONLY)
863     {
864         ret = (ec_tell(&enc)+7)>>3;
865         ec_enc_done(&enc);
866         /*When in LPC only mode it's perfectly
867           reasonable to strip off trailing zero bytes as
868           the required range decoder behavior is to
869           fill these in. This can't be done when the MDCT
870           modes are used because the decoder needs to know
871           the actual length for allocation purposes.*/
872         if(!redundancy)
873             while(ret>2&&data[ret-1]==0)ret--;
874         nb_compr_bytes = ret;
875     } else {
876        nb_compr_bytes = IMIN(1275-redundancy_bytes, nb_compr_bytes);
877        ec_enc_shrink(&enc, nb_compr_bytes);
878     }
879
880
881     /* 5 ms redundant frame for CELT->SILK */
882     if (redundancy && celt_to_silk)
883     {
884         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
885         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
886         celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
887         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
888         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
889     }
890
891     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
892
893     if (st->mode != MODE_SILK_ONLY)
894     {
895         ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
896         if (ret < 0)
897            return OPUS_INTERNAL_ERROR;
898     }
899
900     /* 5 ms redundant frame for SILK->CELT */
901     if (redundancy && !celt_to_silk)
902     {
903         int N2, N4;
904         N2 = st->Fs/200;
905         N4 = st->Fs/400;
906
907         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
908         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
909         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
910
911         /* TODO: We could speed up prefilling here */
912         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, data+nb_compr_bytes, redundancy_bytes, NULL);
913
914         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
915         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
916     }
917
918
919
920     /* Signalling the mode in the first byte */
921     data--;
922     data[0] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, silk_internal_bandwidth, st->stream_channels);
923
924     st->rangeFinal = enc.rng ^ redundant_rng;
925
926     if (to_celt)
927         st->prev_mode = MODE_CELT_ONLY;
928     else
929         st->prev_mode = st->mode;
930     st->first = 0;
931     RESTORE_STACK;
932     return ret+1+redundancy_bytes;
933 }
934
935 #ifdef FIXED_POINT
936
937 #ifndef DISABLE_FLOAT_API
938 int opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
939       unsigned char *data, int max_data_bytes)
940 {
941    int i, ret;
942    VARDECL(opus_int16, in);
943    ALLOC_STACK;
944
945    ALLOC(in, frame_size*st->channels, opus_int16);
946
947    for (i=0;i<frame_size*st->channels;i++)
948       in[i] = FLOAT2INT16(pcm[i]);
949    ret = opus_encode(st, in, frame_size, data, max_data_bytes);
950    RESTORE_STACK;
951    return ret;
952 }
953 #endif
954
955 #else
956 int opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
957       unsigned char *data, int max_data_bytes)
958 {
959    int i, ret;
960    VARDECL(float, in);
961    ALLOC_STACK;
962
963    ALLOC(in, frame_size*st->channels, float);
964
965    for (i=0;i<frame_size*st->channels;i++)
966       in[i] = (1./32768)*pcm[i];
967    ret = opus_encode_float(st, in, frame_size, data, max_data_bytes);
968    RESTORE_STACK;
969    return ret;
970 }
971 #endif
972
973
974 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
975 {
976     int ret;
977     CELTEncoder *celt_enc;
978     va_list ap;
979
980     ret = OPUS_OK;
981     va_start(ap, request);
982
983     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
984
985     switch (request)
986     {
987         case OPUS_SET_APPLICATION_REQUEST:
988         {
989             opus_int32 value = va_arg(ap, opus_int32);
990             st->application = value;
991         }
992         break;
993         case OPUS_GET_APPLICATION_REQUEST:
994         {
995             opus_int32 *value = va_arg(ap, opus_int32*);
996             *value = st->mode;
997         }
998         break;
999         case OPUS_SET_BITRATE_REQUEST:
1000         {
1001             opus_int32 value = va_arg(ap, opus_int32);
1002             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1003             {
1004                 if (value <= 0)
1005                     goto bad_arg;
1006                 else if (value <= 500)
1007                     value = 500;
1008                 else if (value > (opus_int32)300000*st->channels)
1009                     value = (opus_int32)300000*st->channels;
1010             }
1011             st->user_bitrate_bps = value;
1012         }
1013         break;
1014         case OPUS_GET_BITRATE_REQUEST:
1015         {
1016             opus_int32 *value = va_arg(ap, opus_int32*);
1017             *value = st->bitrate_bps;
1018         }
1019         break;
1020         case OPUS_SET_FORCE_CHANNELS_REQUEST:
1021         {
1022             opus_int32 value = va_arg(ap, opus_int32);
1023             st->force_channels = value;
1024         }
1025         break;
1026         case OPUS_GET_FORCE_CHANNELS_REQUEST:
1027         {
1028             opus_int32 *value = va_arg(ap, opus_int32*);
1029             *value = st->force_channels;
1030         }
1031         break;
1032         case OPUS_SET_BANDWIDTH_REQUEST:
1033         {
1034             opus_int32 value = va_arg(ap, opus_int32);
1035             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
1036                 return OPUS_BAD_ARG;
1037             st->user_bandwidth = value;
1038             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1039                 st->silk_mode.maxInternalSampleRate = 8000;
1040             } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1041                 st->silk_mode.maxInternalSampleRate = 12000;
1042             } else {
1043                 st->silk_mode.maxInternalSampleRate = 16000;
1044             }
1045         }
1046         break;
1047         case OPUS_GET_BANDWIDTH_REQUEST:
1048         {
1049             opus_int32 *value = va_arg(ap, opus_int32*);
1050             *value = st->bandwidth;
1051         }
1052         break;
1053         case OPUS_SET_DTX_REQUEST:
1054         {
1055             opus_int32 value = va_arg(ap, opus_int32);
1056             st->silk_mode.useDTX = value;
1057         }
1058         break;
1059         case OPUS_GET_DTX_REQUEST:
1060         {
1061             opus_int32 *value = va_arg(ap, opus_int32*);
1062             *value = st->silk_mode.useDTX;
1063         }
1064         break;
1065         case OPUS_SET_COMPLEXITY_REQUEST:
1066         {
1067             opus_int32 value = va_arg(ap, opus_int32);
1068             st->silk_mode.complexity = value;
1069             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
1070         }
1071         break;
1072         case OPUS_GET_COMPLEXITY_REQUEST:
1073         {
1074             opus_int32 *value = va_arg(ap, opus_int32*);
1075             *value = st->silk_mode.complexity;
1076         }
1077         break;
1078         case OPUS_SET_INBAND_FEC_REQUEST:
1079         {
1080             opus_int32 value = va_arg(ap, opus_int32);
1081             st->silk_mode.useInBandFEC = value;
1082         }
1083         break;
1084         case OPUS_GET_INBAND_FEC_REQUEST:
1085         {
1086             opus_int32 *value = va_arg(ap, opus_int32*);
1087             *value = st->silk_mode.useInBandFEC;
1088         }
1089         break;
1090         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1091         {
1092             opus_int32 value = va_arg(ap, opus_int32);
1093             if (value < 0 || value > 100)
1094                 return OPUS_BAD_ARG;
1095             st->silk_mode.packetLossPercentage = value;
1096             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
1097         }
1098         break;
1099         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1100         {
1101             opus_int32 *value = va_arg(ap, opus_int32*);
1102             *value = st->silk_mode.packetLossPercentage;
1103         }
1104         break;
1105         case OPUS_SET_VBR_REQUEST:
1106         {
1107             opus_int32 value = va_arg(ap, opus_int32);
1108             st->use_vbr = value;
1109             st->silk_mode.useCBR = 1-value;
1110         }
1111         break;
1112         case OPUS_GET_VBR_REQUEST:
1113         {
1114             opus_int32 *value = va_arg(ap, opus_int32*);
1115             *value = st->use_vbr;
1116         }
1117         break;
1118         case OPUS_SET_VOICE_RATIO_REQUEST:
1119         {
1120             opus_int32 value = va_arg(ap, opus_int32);
1121             if (value>100 || value<-1)
1122                 goto bad_arg;
1123             st->voice_ratio = value;
1124         }
1125         break;
1126         case OPUS_GET_VOICE_RATIO_REQUEST:
1127         {
1128             opus_int32 *value = va_arg(ap, opus_int32*);
1129             *value = st->voice_ratio;
1130         }
1131         break;
1132         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1133         {
1134             opus_int32 value = va_arg(ap, opus_int32);
1135             st->vbr_constraint = value;
1136         }
1137         break;
1138         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1139         {
1140             opus_int32 *value = va_arg(ap, opus_int32*);
1141             *value = st->vbr_constraint;
1142         }
1143         break;
1144         case OPUS_SET_SIGNAL_REQUEST:
1145         {
1146             opus_int32 value = va_arg(ap, opus_int32);
1147             st->signal_type = value;
1148         }
1149         break;
1150         case OPUS_GET_SIGNAL_REQUEST:
1151         {
1152             opus_int32 *value = va_arg(ap, opus_int32*);
1153             *value = st->signal_type;
1154         }
1155         break;
1156         case OPUS_GET_LOOKAHEAD_REQUEST:
1157         {
1158             opus_int32 *value = va_arg(ap, opus_int32*);
1159             *value = st->Fs/400;
1160             if (!st->lowdelay)
1161                *value += st->delay_compensation;
1162         }
1163         break;
1164         case OPUS_GET_FINAL_RANGE_REQUEST:
1165         {
1166             opus_uint32 *value = va_arg(ap, opus_uint32*);
1167             *value = st->rangeFinal;
1168         }
1169         break;
1170         case OPUS_RESET_STATE:
1171         {
1172            void *silk_enc;
1173            silk_EncControlStruct dummy;
1174            silk_enc = (char*)st+st->silk_enc_offset;
1175
1176            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
1177                  sizeof(OpusEncoder)-
1178                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
1179
1180            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1181            silk_InitEncoder( silk_enc, &dummy );
1182            st->stream_channels = st->channels;
1183            st->hybrid_stereo_width_Q14             = 1 << 14;
1184            st->first = 1;
1185            st->mode = MODE_HYBRID;
1186            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
1187            st->variable_HP_smth2_Q15 = SKP_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1188         }
1189         break;
1190         case OPUS_SET_FORCE_MODE_REQUEST:
1191         {
1192             opus_int32 value = va_arg(ap, opus_int32);
1193             if (value < MODE_SILK_ONLY || value > MODE_CELT_ONLY)
1194                goto bad_arg;
1195             st->user_forced_mode = value;
1196         }
1197         break;
1198         case OPUS_SET_RESTRICTED_LOWDELAY_REQUEST:
1199         {
1200             opus_int32 value = va_arg(ap, opus_int32);
1201             if (!st->first && st->lowdelay != !!value)
1202             {
1203                ret = OPUS_BAD_ARG;
1204                break;
1205             }
1206             st->lowdelay = !!value;
1207         }
1208         break;
1209         case OPUS_GET_RESTRICTED_LOWDELAY_REQUEST:
1210         {
1211             opus_int32 *value = va_arg(ap, opus_int32*);
1212             *value = st->lowdelay;
1213         }
1214         break;
1215         default:
1216             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
1217             ret = OPUS_UNIMPLEMENTED;
1218             break;
1219     }
1220     va_end(ap);
1221     return ret;
1222 bad_arg:
1223     va_end(ap);
1224     return OPUS_BAD_ARG;
1225 }
1226
1227 void opus_encoder_destroy(OpusEncoder *st)
1228 {
1229     opus_free(st);
1230 }