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