Adds OPUS_SET_RESTRICTED_LOWDELAY() encoder ctl
[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 int opus_encode(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
352                 unsigned char *data, int max_data_bytes)
353 #else
354 int opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
355                       unsigned char *data, int max_data_bytes)
356 #endif
357 {
358     void *silk_enc;
359     CELTEncoder *celt_enc;
360     int i;
361     int ret=0;
362     int nBytes;
363     ec_enc enc;
364     int silk_internal_bandwidth=-1;
365     int bytes_target;
366     int prefill=0;
367     int start_band = 0;
368     int redundancy = 0;
369     int redundancy_bytes = 0;
370     int celt_to_silk = 0;
371     VARDECL(opus_val16, pcm_buf);
372     int nb_compr_bytes;
373     int to_celt = 0;
374     opus_uint32 redundant_rng = 0;
375     int cutoff_Hz, hp_freq_smth1;
376     int voice_est;
377     opus_int32 equiv_rate;
378     int delay_compensation;
379     ALLOC_STACK;
380
381     st->rangeFinal = 0;
382     if (400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
383          50*frame_size != st->Fs &&  25*frame_size != st->Fs &&  50*frame_size != 3*st->Fs)
384     {
385        RESTORE_STACK;
386        return OPUS_BAD_ARG;
387     }
388     silk_enc = (char*)st+st->silk_enc_offset;
389     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
390
391     if (st->lowdelay)
392        delay_compensation = 0;
393     else
394        delay_compensation = st->delay_compensation;
395
396     if (st->user_bitrate_bps==OPUS_AUTO)
397         st->bitrate_bps = 60*st->Fs/frame_size + st->Fs*st->channels;
398     else if (st->user_bitrate_bps==OPUS_BITRATE_MAX)
399        st->bitrate_bps = max_data_bytes*8*st->Fs/frame_size;
400     else
401         st->bitrate_bps = st->user_bitrate_bps;
402
403     /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */
404     equiv_rate = st->bitrate_bps - 60*(st->Fs/frame_size - 50);
405
406     if (st->signal_type == OPUS_SIGNAL_VOICE)
407        voice_est = 127;
408     else if (st->signal_type == OPUS_SIGNAL_MUSIC)
409        voice_est = 0;
410     else if (st->voice_ratio >= 0)
411        voice_est = st->voice_ratio*327>>8;
412     else if (st->application == OPUS_APPLICATION_VOIP)
413        voice_est = 115;
414     else
415        voice_est = 64;
416
417 #ifdef FUZZING
418     /* Random mono/stereo decision */
419     if (st->channels == 2 && (rand()&0x1F)==0)
420        st->stream_channels = 3-st->stream_channels;
421 #else
422     /* Rate-dependent mono-stereo decision */
423     if (st->force_channels!=OPUS_AUTO && st->channels == 2)
424     {
425         st->stream_channels = st->force_channels;
426     } else if (st->channels == 2)
427     {
428        opus_int32 stereo_threshold;
429        stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14);
430        if (st->stream_channels == 2)
431           stereo_threshold -= 4000;
432        else
433           stereo_threshold += 4000;
434        st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1;
435     } else {
436             st->stream_channels = st->channels;
437     }
438 #endif
439
440 #ifdef FUZZING
441     /* Random mode switching */
442     if ((rand()&0xF)==0)
443     {
444        if ((rand()&0x1)==0)
445           st->mode = MODE_CELT_ONLY;
446        else
447           st->mode = MODE_SILK_ONLY;
448     } else {
449        if (st->prev_mode==MODE_CELT_ONLY)
450           st->mode = MODE_CELT_ONLY;
451        else
452           st->mode = MODE_SILK_ONLY;
453     }
454 #else
455     /* Mode selection depending on application and signal type */
456     if (st->lowdelay)
457     {
458        st->mode = MODE_CELT_ONLY;
459     } else if (st->user_forced_mode == OPUS_AUTO)
460     {
461        int chan;
462        opus_int32 mode_voice, mode_music;
463        opus_int32 threshold;
464
465        chan = (st->channels==2) && st->force_channels!=1;
466        mode_voice = mode_thresholds[chan][0];
467        mode_music = mode_thresholds[chan][1];
468        threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14);
469
470        /* Hysteresis */
471        if (st->prev_mode == MODE_CELT_ONLY)
472            threshold -= 4000;
473        else if (st->prev_mode>0)
474            threshold += 4000;
475
476        st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY;
477     } else {
478        st->mode = st->user_forced_mode;
479     }
480 #endif
481
482     /* Override the chosen mode to make sure we meet the requested frame size */
483     if (st->mode == MODE_CELT_ONLY && frame_size > st->Fs/50)
484        st->mode = MODE_SILK_ONLY;
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->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
571        st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
572
573     /* CELT mode doesn't support mediumband, use wideband instead */
574     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
575         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
576
577     /* Chooses the appropriate mode for speech
578        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
579     if (st->mode == MODE_SILK_ONLY && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
580         st->mode = MODE_HYBRID;
581     if (st->mode == MODE_HYBRID && st->bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
582         st->mode = MODE_SILK_ONLY;
583
584     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, st->bandwidth); */
585     bytes_target = st->bitrate_bps * frame_size / (st->Fs * 8) - 1;
586
587     data += 1;
588
589     ec_enc_init(&enc, data, max_data_bytes-1);
590
591     ALLOC(pcm_buf, (delay_compensation+frame_size)*st->channels, opus_val16);
592     for (i=0;i<delay_compensation*st->channels;i++)
593        pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-delay_compensation)*st->channels+i];
594
595     if (st->mode == MODE_CELT_ONLY)
596        hp_freq_smth1 = SKP_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
597     else
598        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
599
600     st->variable_HP_smth2_Q15 = SKP_SMLAWB( st->variable_HP_smth2_Q15,
601           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
602
603     /* convert from log scale to Hertz */
604     cutoff_Hz = silk_log2lin( SKP_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
605
606     if (st->application == OPUS_APPLICATION_VOIP)
607     {
608        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[delay_compensation*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
609     } else {
610        for (i=0;i<frame_size*st->channels;i++)
611           pcm_buf[delay_compensation*st->channels + i] = pcm[i];
612     }
613
614     /* SILK processing */
615     if (st->mode != MODE_CELT_ONLY)
616     {
617 #ifdef FIXED_POINT
618        const opus_int16 *pcm_silk;
619 #else
620        VARDECL(opus_int16, pcm_silk);
621        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
622 #endif
623         st->silk_mode.bitRate = st->bitrate_bps - 8*st->Fs/frame_size;
624         if( st->mode == MODE_HYBRID ) {
625             st->silk_mode.bitRate /= st->stream_channels;
626             if( st->bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
627                 if( st->Fs == 100 * frame_size ) {
628                     /* 24 kHz, 10 ms */
629                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 2000 + st->use_vbr * 1000 ) * 2 ) / 3;
630                 } else {
631                     /* 24 kHz, 20 ms */
632                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 1000 + st->use_vbr * 1000 ) * 2 ) / 3;
633                 }
634             } else {
635                 if( st->Fs == 100 * frame_size ) {
636                     /* 48 kHz, 10 ms */
637                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 8000 + st->use_vbr * 3000 ) / 2;
638                 } else {
639                     /* 48 kHz, 20 ms */
640                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 9000 + st->use_vbr * 1000 ) / 2;
641                 }
642             }
643             st->silk_mode.bitRate *= st->stream_channels;
644             /* don't let SILK use more than 80% */
645             if( st->silk_mode.bitRate > ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5 ) {
646                 st->silk_mode.bitRate = ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5;
647             }
648         }
649
650         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
651         st->silk_mode.nChannelsAPI = st->channels;
652         st->silk_mode.nChannelsInternal = st->stream_channels;
653         if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
654             st->silk_mode.desiredInternalSampleRate = 8000;
655         } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
656             st->silk_mode.desiredInternalSampleRate = 12000;
657         } else {
658             SKP_assert( st->mode == MODE_HYBRID || st->bandwidth == OPUS_BANDWIDTH_WIDEBAND );
659             st->silk_mode.desiredInternalSampleRate = 16000;
660         }
661         if( st->mode == MODE_HYBRID ) {
662             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
663             st->silk_mode.minInternalSampleRate = 16000;
664         } else {
665             st->silk_mode.minInternalSampleRate = 8000;
666         }
667         st->silk_mode.maxInternalSampleRate = 16000;
668
669         /* Call SILK encoder for the low band */
670         nBytes = IMIN(1275, max_data_bytes-1);
671         if (prefill)
672         {
673             int zero=0;
674 #ifdef FIXED_POINT
675             pcm_silk = st->delay_buffer;
676 #else
677             for (i=0;i<st->encoder_buffer*st->channels;i++)
678                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
679 #endif
680             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
681         }
682
683 #ifdef FIXED_POINT
684         pcm_silk = pcm_buf+delay_compensation*st->channels;
685 #else
686         for (i=0;i<frame_size*st->channels;i++)
687             pcm_silk[i] = FLOAT2INT16(pcm_buf[delay_compensation*st->channels + i]);
688 #endif
689         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
690         if( ret ) {
691             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
692             /* Handle error */
693            return OPUS_INTERNAL_ERROR;
694         }
695         if (nBytes==0)
696         {
697            data[-1] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, silk_internal_bandwidth, st->stream_channels);
698            RESTORE_STACK;
699            return 1;
700         }
701         /* Extract SILK internal bandwidth for signaling in first byte */
702         if( st->mode == MODE_SILK_ONLY ) {
703             if( st->silk_mode.internalSampleRate == 8000 ) {
704                 silk_internal_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
705             } else if( st->silk_mode.internalSampleRate == 12000 ) {
706                 silk_internal_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
707             } else if( st->silk_mode.internalSampleRate == 16000 ) {
708                 silk_internal_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
709             }
710         } else {
711             SKP_assert( st->silk_mode.internalSampleRate == 16000 );
712         }
713     }
714
715     /* CELT processing */
716     {
717         int endband=21;
718
719         switch(st->bandwidth)
720         {
721             case OPUS_BANDWIDTH_NARROWBAND:
722                 endband = 13;
723                 break;
724             case OPUS_BANDWIDTH_MEDIUMBAND:
725             case OPUS_BANDWIDTH_WIDEBAND:
726                 endband = 17;
727                 break;
728             case OPUS_BANDWIDTH_SUPERWIDEBAND:
729                 endband = 19;
730                 break;
731             case OPUS_BANDWIDTH_FULLBAND:
732                 endband = 21;
733                 break;
734         }
735         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
736         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
737     }
738     if (st->mode != MODE_SILK_ONLY)
739     {
740         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
741         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
742         if (st->prev_mode == MODE_SILK_ONLY)
743         {
744             unsigned char dummy[10];
745             celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
746             celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
747             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
748             /* TODO: This wastes CPU a bit compared to just prefilling the buffer */
749             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);
750         } else {
751             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
752         }
753
754         if (st->mode == MODE_HYBRID)
755         {
756             int len;
757
758             len = (ec_tell(&enc)+7)>>3;
759             if( st->use_vbr ) {
760                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
761             } else {
762                 /* check if SILK used up too much */
763                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
764             }
765         } else {
766             if (st->use_vbr)
767             {
768                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
769                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
770                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps));
771                 nb_compr_bytes = max_data_bytes-1;
772             } else {
773                 nb_compr_bytes = bytes_target;
774             }
775         }
776
777     } else {
778         nb_compr_bytes = 0;
779     }
780
781     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+delay_compensation));i++)
782         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
783     for (;i<st->encoder_buffer*st->channels;i++)
784         st->delay_buffer[i] = pcm_buf[(frame_size+delay_compensation-st->encoder_buffer)*st->channels+i];
785
786
787     if( st->mode == MODE_HYBRID && st->stream_channels == 2 ) {
788         /* Apply stereo width reduction (at low bitrates) */
789         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
790             int width_Q14, delta_Q14, nSamples_8ms, diff;
791             nSamples_8ms = ( st->Fs * 8 ) / 1000;
792             width_Q14 = (1 << 14 ) - st->hybrid_stereo_width_Q14;
793             delta_Q14 = ( st->hybrid_stereo_width_Q14 - st->silk_mode.stereoWidth_Q14 ) / nSamples_8ms;
794             for( i = 0; i < nSamples_8ms; i++ ) {
795                 width_Q14 += delta_Q14;
796                 diff = pcm_buf[ 2*i+1 ] - (opus_int32)pcm_buf[ 2*i ];
797                 diff = ( diff * width_Q14 ) >> 15;
798                 pcm_buf[ 2*i ]   = (opus_int16)( pcm_buf[ 2*i ]   + diff );
799                 pcm_buf[ 2*i+1 ] = (opus_int16)( pcm_buf[ 2*i+1 ] - diff );
800             }
801             for( ; i < frame_size; i++ ) {
802                 diff = pcm_buf[ 2*i+1 ] - (opus_int32)pcm_buf[ 2*i ];
803                 diff = ( diff * width_Q14 ) >> 15;
804                 pcm_buf[ 2*i ]   = (opus_int16)( pcm_buf[ 2*i ]   + diff );
805                 pcm_buf[ 2*i+1 ] = (opus_int16)( pcm_buf[ 2*i+1 ] - diff );
806             }
807             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
808         }
809     }
810
811     if (st->mode != MODE_CELT_ONLY && ec_tell(&enc)+29+8*(st->mode == MODE_HYBRID) < 8*nb_compr_bytes)
812     {
813         /* Check if we have a redundant 0-8 kHz band */
814         ec_enc_bit_logp(&enc, redundancy, 12);
815         if (redundancy)
816         {
817             int max_redundancy;
818             ec_enc_bit_logp(&enc, celt_to_silk, 1);
819             max_redundancy = nb_compr_bytes-((ec_tell(&enc)+7)>>3)-(st->mode == MODE_HYBRID);
820             /* Target the same bit-rate for redundancy as for the rest,
821                up to a max of 257 bytes */
822             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
823             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
824             if (st->mode == MODE_HYBRID)
825                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
826         }
827     } else {
828         redundancy = 0;
829     }
830
831     if (st->mode != MODE_CELT_ONLY)start_band=17;
832
833     if (st->mode == MODE_SILK_ONLY)
834     {
835         ret = (ec_tell(&enc)+7)>>3;
836         ec_enc_done(&enc);
837         /*When in LPC only mode it's perfectly
838           reasonable to strip off trailing zero bytes as
839           the required range decoder behavior is to
840           fill these in. This can't be done when the MDCT
841           modes are used because the decoder needs to know
842           the actual length for allocation purposes.*/
843         if(!redundancy)
844             while(ret>2&&data[ret-1]==0)ret--;
845         nb_compr_bytes = ret;
846     } else {
847        nb_compr_bytes = IMIN(1275-redundancy_bytes, nb_compr_bytes);
848        ec_enc_shrink(&enc, nb_compr_bytes);
849     }
850
851
852     /* 5 ms redundant frame for CELT->SILK */
853     if (redundancy && celt_to_silk)
854     {
855         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
856         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
857         celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
858         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
859         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
860     }
861
862     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
863
864     if (st->mode != MODE_SILK_ONLY)
865     {
866         ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
867         if (ret < 0)
868            return OPUS_INTERNAL_ERROR;
869     }
870
871     /* 5 ms redundant frame for SILK->CELT */
872     if (redundancy && !celt_to_silk)
873     {
874         int N2, N4;
875         N2 = st->Fs/200;
876         N4 = st->Fs/400;
877
878         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
879         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
880         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
881
882         /* TODO: We could speed up prefilling here */
883         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, data+nb_compr_bytes, redundancy_bytes, NULL);
884
885         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
886         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
887     }
888
889
890
891     /* Signalling the mode in the first byte */
892     data--;
893     data[0] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, silk_internal_bandwidth, st->stream_channels);
894
895     st->rangeFinal = enc.rng ^ redundant_rng;
896
897     if (to_celt)
898         st->prev_mode = MODE_CELT_ONLY;
899     else
900         st->prev_mode = st->mode;
901     st->first = 0;
902     RESTORE_STACK;
903     return ret+1+redundancy_bytes;
904 }
905
906 #ifdef FIXED_POINT
907
908 #ifndef DISABLE_FLOAT_API
909 int opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
910       unsigned char *data, int max_data_bytes)
911 {
912    int i, ret;
913    VARDECL(opus_int16, in);
914    ALLOC_STACK;
915
916    ALLOC(in, frame_size*st->channels, opus_int16);
917
918    for (i=0;i<frame_size*st->channels;i++)
919       in[i] = FLOAT2INT16(pcm[i]);
920    ret = opus_encode(st, in, frame_size, data, max_data_bytes);
921    RESTORE_STACK;
922    return ret;
923 }
924 #endif
925
926 #else
927 int opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
928       unsigned char *data, int max_data_bytes)
929 {
930    int i, ret;
931    VARDECL(float, in);
932    ALLOC_STACK;
933
934    ALLOC(in, frame_size*st->channels, float);
935
936    for (i=0;i<frame_size*st->channels;i++)
937       in[i] = (1./32768)*pcm[i];
938    ret = opus_encode_float(st, in, frame_size, data, max_data_bytes);
939    RESTORE_STACK;
940    return ret;
941 }
942 #endif
943
944
945 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
946 {
947     int ret;
948     CELTEncoder *celt_enc;
949     va_list ap;
950
951     ret = OPUS_OK;
952     va_start(ap, request);
953
954     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
955
956     switch (request)
957     {
958         case OPUS_SET_APPLICATION_REQUEST:
959         {
960             opus_int32 value = va_arg(ap, opus_int32);
961             st->application = value;
962         }
963         break;
964         case OPUS_GET_APPLICATION_REQUEST:
965         {
966             opus_int32 *value = va_arg(ap, opus_int32*);
967             *value = st->mode;
968         }
969         break;
970         case OPUS_SET_BITRATE_REQUEST:
971         {
972             opus_int32 value = va_arg(ap, opus_int32);
973             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
974             {
975                 if (value <= 0)
976                     goto bad_arg;
977                 else if (value <= 500)
978                     value = 500;
979                 else if (value > (opus_int32)300000*st->channels)
980                     value = (opus_int32)300000*st->channels;
981             }
982             st->user_bitrate_bps = value;
983         }
984         break;
985         case OPUS_GET_BITRATE_REQUEST:
986         {
987             opus_int32 *value = va_arg(ap, opus_int32*);
988             *value = st->bitrate_bps;
989         }
990         break;
991         case OPUS_SET_FORCE_CHANNELS_REQUEST:
992         {
993             opus_int32 value = va_arg(ap, opus_int32);
994             st->force_channels = value;
995         }
996         break;
997         case OPUS_GET_FORCE_CHANNELS_REQUEST:
998         {
999             opus_int32 *value = va_arg(ap, opus_int32*);
1000             *value = st->force_channels;
1001         }
1002         break;
1003         case OPUS_SET_BANDWIDTH_REQUEST:
1004         {
1005             opus_int32 value = va_arg(ap, opus_int32);
1006             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
1007                 return OPUS_BAD_ARG;
1008             st->user_bandwidth = value;
1009             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1010                 st->silk_mode.maxInternalSampleRate = 8000;
1011             } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1012                 st->silk_mode.maxInternalSampleRate = 12000;
1013             } else {
1014                 st->silk_mode.maxInternalSampleRate = 16000;
1015             }
1016         }
1017         break;
1018         case OPUS_GET_BANDWIDTH_REQUEST:
1019         {
1020             opus_int32 *value = va_arg(ap, opus_int32*);
1021             *value = st->bandwidth;
1022         }
1023         break;
1024         case OPUS_SET_DTX_REQUEST:
1025         {
1026             opus_int32 value = va_arg(ap, opus_int32);
1027             st->silk_mode.useDTX = value;
1028         }
1029         break;
1030         case OPUS_GET_DTX_REQUEST:
1031         {
1032             opus_int32 *value = va_arg(ap, opus_int32*);
1033             *value = st->silk_mode.useDTX;
1034         }
1035         break;
1036         case OPUS_SET_COMPLEXITY_REQUEST:
1037         {
1038             opus_int32 value = va_arg(ap, opus_int32);
1039             st->silk_mode.complexity = value;
1040             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
1041         }
1042         break;
1043         case OPUS_GET_COMPLEXITY_REQUEST:
1044         {
1045             opus_int32 *value = va_arg(ap, opus_int32*);
1046             *value = st->silk_mode.complexity;
1047         }
1048         break;
1049         case OPUS_SET_INBAND_FEC_REQUEST:
1050         {
1051             opus_int32 value = va_arg(ap, opus_int32);
1052             st->silk_mode.useInBandFEC = value;
1053         }
1054         break;
1055         case OPUS_GET_INBAND_FEC_REQUEST:
1056         {
1057             opus_int32 *value = va_arg(ap, opus_int32*);
1058             *value = st->silk_mode.useInBandFEC;
1059         }
1060         break;
1061         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1062         {
1063             opus_int32 value = va_arg(ap, opus_int32);
1064             if (value < 0 || value > 100)
1065                 return OPUS_BAD_ARG;
1066             st->silk_mode.packetLossPercentage = value;
1067             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
1068         }
1069         break;
1070         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1071         {
1072             opus_int32 *value = va_arg(ap, opus_int32*);
1073             *value = st->silk_mode.packetLossPercentage;
1074         }
1075         break;
1076         case OPUS_SET_VBR_REQUEST:
1077         {
1078             opus_int32 value = va_arg(ap, opus_int32);
1079             st->use_vbr = value;
1080             st->silk_mode.useCBR = 1-value;
1081         }
1082         break;
1083         case OPUS_GET_VBR_REQUEST:
1084         {
1085             opus_int32 *value = va_arg(ap, opus_int32*);
1086             *value = st->use_vbr;
1087         }
1088         break;
1089         case OPUS_SET_VOICE_RATIO_REQUEST:
1090         {
1091             opus_int32 value = va_arg(ap, opus_int32);
1092             if (value>100 || value<-1)
1093                 goto bad_arg;
1094             st->voice_ratio = value;
1095         }
1096         break;
1097         case OPUS_GET_VOICE_RATIO_REQUEST:
1098         {
1099             opus_int32 *value = va_arg(ap, opus_int32*);
1100             *value = st->voice_ratio;
1101         }
1102         break;
1103         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1104         {
1105             opus_int32 value = va_arg(ap, opus_int32);
1106             st->vbr_constraint = value;
1107         }
1108         break;
1109         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1110         {
1111             opus_int32 *value = va_arg(ap, opus_int32*);
1112             *value = st->vbr_constraint;
1113         }
1114         break;
1115         case OPUS_SET_SIGNAL_REQUEST:
1116         {
1117             opus_int32 value = va_arg(ap, opus_int32);
1118             st->signal_type = value;
1119         }
1120         break;
1121         case OPUS_GET_SIGNAL_REQUEST:
1122         {
1123             opus_int32 *value = va_arg(ap, opus_int32*);
1124             *value = st->signal_type;
1125         }
1126         break;
1127         case OPUS_GET_LOOKAHEAD_REQUEST:
1128         {
1129             opus_int32 *value = va_arg(ap, opus_int32*);
1130             *value = st->Fs/400;
1131             if (!st->lowdelay)
1132                *value += st->delay_compensation;
1133         }
1134         break;
1135         case OPUS_GET_FINAL_RANGE_REQUEST:
1136         {
1137             opus_uint32 *value = va_arg(ap, opus_uint32*);
1138             *value = st->rangeFinal;
1139         }
1140         break;
1141         case OPUS_RESET_STATE:
1142         {
1143            void *silk_enc;
1144            silk_EncControlStruct dummy;
1145            silk_enc = (char*)st+st->silk_enc_offset;
1146
1147            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
1148                  sizeof(OpusEncoder)-
1149                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
1150
1151            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1152            silk_InitEncoder( silk_enc, &dummy );
1153            st->stream_channels = st->channels;
1154            st->hybrid_stereo_width_Q14             = 1 << 14;
1155            st->first = 1;
1156            st->mode = MODE_HYBRID;
1157            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
1158            st->variable_HP_smth2_Q15 = SKP_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1159         }
1160         break;
1161         case OPUS_SET_FORCE_MODE_REQUEST:
1162         {
1163             opus_int32 value = va_arg(ap, opus_int32);
1164             if (value < MODE_SILK_ONLY || value > MODE_CELT_ONLY)
1165                goto bad_arg;
1166             st->user_forced_mode = value;
1167         }
1168         break;
1169         case OPUS_SET_RESTRICTED_LOWDELAY_REQUEST:
1170         {
1171             opus_int32 value = va_arg(ap, opus_int32);
1172             if (!st->first && st->lowdelay != !!value)
1173             {
1174                ret = OPUS_BAD_ARG;
1175                break;
1176             }
1177             st->lowdelay = !!value;
1178         }
1179         break;
1180         case OPUS_GET_RESTRICTED_LOWDELAY_REQUEST:
1181         {
1182             opus_int32 *value = va_arg(ap, opus_int32*);
1183             *value = st->lowdelay;
1184         }
1185         break;
1186         default:
1187             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
1188             ret = OPUS_UNIMPLEMENTED;
1189             break;
1190     }
1191     va_end(ap);
1192     return ret;
1193 bad_arg:
1194     va_end(ap);
1195     return OPUS_BAD_ARG;
1196 }
1197
1198 void opus_encoder_destroy(OpusEncoder *st)
1199 {
1200     opus_free(st);
1201 }