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