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