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