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