00f8a1cd8f85a7a84e63b0b78a7217054e049ca2
[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     } else {
808         redundancy = 0;
809     }
810
811     if (st->mode != MODE_CELT_ONLY)start_band=17;
812
813     if (st->mode == MODE_SILK_ONLY)
814     {
815         ret = (ec_tell(&enc)+7)>>3;
816         ec_enc_done(&enc);
817         /*When in LPC only mode it's perfectly
818           reasonable to strip off trailing zero bytes as
819           the required range decoder behavior is to
820           fill these in. This can't be done when the MDCT
821           modes are used because the decoder needs to know
822           the actual length for allocation purposes.*/
823         if(!redundancy)
824             while(ret>2&&data[ret-1]==0)ret--;
825         nb_compr_bytes = ret;
826     } else {
827        nb_compr_bytes = IMIN(1275-redundancy_bytes, nb_compr_bytes);
828        ec_enc_shrink(&enc, nb_compr_bytes);
829     }
830
831
832     /* 5 ms redundant frame for CELT->SILK */
833     if (redundancy && celt_to_silk)
834     {
835         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
836         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
837         celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
838         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
839         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
840     }
841
842     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
843
844     if (st->mode != MODE_SILK_ONLY)
845     {
846         ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
847     }
848
849     /* 5 ms redundant frame for SILK->CELT */
850     if (redundancy && !celt_to_silk)
851     {
852         int N2, N4;
853         N2 = st->Fs/200;
854         N4 = st->Fs/400;
855
856         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
857         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
858         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
859
860         /* TODO: We could speed up prefilling here */
861         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, data+nb_compr_bytes, redundancy_bytes, NULL);
862
863         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
864         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
865     }
866
867
868
869     /* Signalling the mode in the first byte */
870     data--;
871     data[0] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, silk_internal_bandwidth, st->stream_channels);
872
873     st->rangeFinal = enc.rng ^ redundant_rng;
874
875     if (to_celt)
876         st->prev_mode = MODE_CELT_ONLY;
877     else
878         st->prev_mode = st->mode;
879     st->first = 0;
880     RESTORE_STACK;
881     return ret+1+redundancy_bytes;
882 }
883
884 #ifdef FIXED_POINT
885
886 #ifndef DISABLE_FLOAT_API
887 int opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
888       unsigned char *data, int max_data_bytes)
889 {
890    int i, ret;
891    VARDECL(opus_int16, in);
892    ALLOC_STACK;
893
894    ALLOC(in, frame_size*st->channels, opus_int16);
895
896    for (i=0;i<frame_size*st->channels;i++)
897       in[i] = FLOAT2INT16(pcm[i]);
898    ret = opus_encode(st, in, frame_size, data, max_data_bytes);
899    RESTORE_STACK;
900    return ret;
901 }
902 #endif
903
904 #else
905 int opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
906       unsigned char *data, int max_data_bytes)
907 {
908    int i, ret;
909    VARDECL(float, in);
910    ALLOC_STACK;
911
912    ALLOC(in, frame_size*st->channels, float);
913
914    for (i=0;i<frame_size*st->channels;i++)
915       in[i] = (1./32768)*pcm[i];
916    ret = opus_encode_float(st, in, frame_size, data, max_data_bytes);
917    RESTORE_STACK;
918    return ret;
919 }
920 #endif
921
922
923 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
924 {
925     int ret;
926     CELTEncoder *celt_enc;
927     va_list ap;
928
929     ret = OPUS_OK;
930     va_start(ap, request);
931
932     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
933
934     switch (request)
935     {
936         case OPUS_SET_APPLICATION_REQUEST:
937         {
938             opus_int32 value = va_arg(ap, opus_int32);
939             st->application = value;
940         }
941         break;
942         case OPUS_GET_APPLICATION_REQUEST:
943         {
944             opus_int32 *value = va_arg(ap, opus_int32*);
945             *value = st->mode;
946         }
947         break;
948         case OPUS_SET_BITRATE_REQUEST:
949         {
950             opus_int32 value = va_arg(ap, opus_int32);
951             if (value != OPUS_BITRATE_AUTO)
952             {
953                 if (value <= 0)
954                     goto bad_arg;
955                 else if (value <= 500)
956                     value = 500;
957             }
958             st->user_bitrate_bps = value;
959         }
960         break;
961         case OPUS_GET_BITRATE_REQUEST:
962         {
963             opus_int32 *value = va_arg(ap, opus_int32*);
964             *value = st->bitrate_bps;
965         }
966         break;
967         case OPUS_SET_FORCE_MONO_REQUEST:
968         {
969             opus_int32 value = va_arg(ap, opus_int32);
970             st->force_mono = value;
971         }
972         break;
973         case OPUS_GET_FORCE_MONO_REQUEST:
974         {
975             opus_int32 *value = va_arg(ap, opus_int32*);
976             *value = !!st->force_mono;
977         }
978         break;
979         case OPUS_SET_BANDWIDTH_REQUEST:
980         {
981             opus_int32 value = va_arg(ap, opus_int32);
982             if (value < OPUS_BANDWIDTH_AUTO || value > OPUS_BANDWIDTH_FULLBAND)
983                 return OPUS_BAD_ARG;
984             st->user_bandwidth = value;
985             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
986                 st->silk_mode.maxInternalSampleRate = 8000;
987             } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
988                 st->silk_mode.maxInternalSampleRate = 12000;
989             } else {
990                 st->silk_mode.maxInternalSampleRate = 16000;
991             }
992         }
993         break;
994         case OPUS_GET_BANDWIDTH_REQUEST:
995         {
996             opus_int32 *value = va_arg(ap, opus_int32*);
997             *value = st->bandwidth;
998         }
999         break;
1000         case OPUS_SET_DTX_REQUEST:
1001         {
1002             opus_int32 value = va_arg(ap, opus_int32);
1003             st->silk_mode.useDTX = value;
1004         }
1005         break;
1006         case OPUS_GET_DTX_REQUEST:
1007         {
1008             opus_int32 *value = va_arg(ap, opus_int32*);
1009             *value = st->silk_mode.useDTX;
1010         }
1011         break;
1012         case OPUS_SET_COMPLEXITY_REQUEST:
1013         {
1014             opus_int32 value = va_arg(ap, opus_int32);
1015             st->silk_mode.complexity = value;
1016             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
1017         }
1018         break;
1019         case OPUS_GET_COMPLEXITY_REQUEST:
1020         {
1021             opus_int32 *value = va_arg(ap, opus_int32*);
1022             *value = st->silk_mode.complexity;
1023         }
1024         break;
1025         case OPUS_SET_INBAND_FEC_REQUEST:
1026         {
1027             opus_int32 value = va_arg(ap, opus_int32);
1028             st->silk_mode.useInBandFEC = value;
1029         }
1030         break;
1031         case OPUS_GET_INBAND_FEC_REQUEST:
1032         {
1033             opus_int32 *value = va_arg(ap, opus_int32*);
1034             *value = st->silk_mode.useInBandFEC;
1035         }
1036         break;
1037         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1038         {
1039             opus_int32 value = va_arg(ap, opus_int32);
1040             if (value < 0 || value > 100)
1041                 return OPUS_BAD_ARG;
1042             st->silk_mode.packetLossPercentage = value;
1043             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
1044         }
1045         break;
1046         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1047         {
1048             opus_int32 *value = va_arg(ap, opus_int32*);
1049             *value = st->silk_mode.packetLossPercentage;
1050         }
1051         break;
1052         case OPUS_SET_VBR_REQUEST:
1053         {
1054             opus_int32 value = va_arg(ap, opus_int32);
1055             st->use_vbr = value;
1056             st->silk_mode.useCBR = 1-value;
1057         }
1058         break;
1059         case OPUS_GET_VBR_REQUEST:
1060         {
1061             opus_int32 *value = va_arg(ap, opus_int32*);
1062             *value = st->use_vbr;
1063         }
1064         break;
1065         case OPUS_SET_VOICE_RATIO_REQUEST:
1066         {
1067             opus_int32 value = va_arg(ap, opus_int32);
1068             if (value>100 || value<-1)
1069                 goto bad_arg;
1070             st->voice_ratio = value;
1071         }
1072         break;
1073         case OPUS_GET_VOICE_RATIO_REQUEST:
1074         {
1075             opus_int32 *value = va_arg(ap, opus_int32*);
1076             *value = st->voice_ratio;
1077         }
1078         break;
1079         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1080         {
1081             opus_int32 value = va_arg(ap, opus_int32);
1082             st->vbr_constraint = value;
1083         }
1084         break;
1085         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1086         {
1087             opus_int32 *value = va_arg(ap, opus_int32*);
1088             *value = st->vbr_constraint;
1089         }
1090         break;
1091         case OPUS_SET_SIGNAL_REQUEST:
1092         {
1093             opus_int32 value = va_arg(ap, opus_int32);
1094             st->signal_type = value;
1095         }
1096         break;
1097         case OPUS_GET_SIGNAL_REQUEST:
1098         {
1099             opus_int32 *value = va_arg(ap, opus_int32*);
1100             *value = st->signal_type;
1101         }
1102         break;
1103         case OPUS_GET_LOOKAHEAD_REQUEST:
1104         {
1105             opus_int32 *value = va_arg(ap, opus_int32*);
1106             *value = st->delay_compensation+st->Fs/400;
1107         }
1108         break;
1109         case OPUS_GET_FINAL_RANGE_REQUEST:
1110         {
1111             opus_uint32 *value = va_arg(ap, opus_uint32*);
1112             *value = st->rangeFinal;
1113         }
1114         break;
1115         case OPUS_RESET_STATE:
1116         {
1117            void *silk_enc;
1118            silk_EncControlStruct dummy;
1119            silk_enc = (char*)st+st->silk_enc_offset;
1120
1121            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
1122                  sizeof(OpusEncoder)-
1123                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
1124
1125            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1126            silk_InitEncoder( silk_enc, &dummy );
1127            st->stream_channels = st->channels;
1128            st->hybrid_stereo_width_Q14             = 1 << 14;
1129            st->first = 1;
1130            st->mode = MODE_HYBRID;
1131            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
1132            st->variable_HP_smth2_Q15 = SKP_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1133         }
1134         break;
1135         default:
1136             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
1137             ret = OPUS_UNIMPLEMENTED;
1138             break;
1139     }
1140     va_end(ap);
1141     return ret;
1142 bad_arg:
1143     va_end(ap);
1144     return OPUS_BAD_ARG;
1145 }
1146
1147 void opus_encoder_destroy(OpusEncoder *st)
1148 {
1149     opus_free(st);
1150 }