Adds a bound on the SILK rate to prevent it from busting the byte limit
[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     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 = SKP_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    SKP_assert( cutoff_Hz <= SKP_int32_MAX / SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ) );
302    Fc_Q19 = SKP_DIV32_16( SKP_SMULBB( SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ), cutoff_Hz ), Fs/1000 );
303    SKP_assert( Fc_Q19 > 0 && Fc_Q19 < 32768 );
304
305    r_Q28 = SILK_FIX_CONST( 1.0, 28 ) - SKP_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 ] = SKP_LSHIFT( -r_Q28, 1 );
311    B_Q28[ 2 ] = r_Q28;
312
313    /* -r * ( 2 - Fc * Fc ); */
314    r_Q22  = SKP_RSHIFT( r_Q28, 6 );
315    A_Q28[ 0 ] = SKP_SMULWW( r_Q22, SKP_SMULWW( Fc_Q19, Fc_Q19 ) - SILK_FIX_CONST( 2.0,  22 ) );
316    A_Q28[ 1 ] = SKP_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     /* Prevents Opus from wasting bits on frequencies that are above
559        the Nyquist rate of the input signal */
560     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
561         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
562     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
563         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
564     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
565         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
566     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
567         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
568
569     if (st->user_bandwidth != OPUS_AUTO)
570         st->bandwidth = st->user_bandwidth;
571
572     /* Can't support higher than wideband for >20 ms frames */
573     if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND))
574     {
575        VARDECL(unsigned char, tmp_data);
576        VARDECL(unsigned char, rp_);
577        int nb_frames;
578        int bak_mode, bak_bandwidth, bak_channels;
579        OpusRepacketizer *rp;
580        int bytes_per_frame;
581
582        nb_frames = frame_size > st->Fs/25 ? 3 : 2;
583        bytes_per_frame = max_data_bytes/nb_frames-3;
584
585        ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char);
586        ALLOC(rp_, opus_repacketizer_get_size(), unsigned char);
587
588        rp = opus_repacketizer_init((OpusRepacketizer*)rp_);
589
590        bak_mode = st->user_forced_mode;
591        bak_bandwidth = st->user_bandwidth;
592        bak_channels = st->force_channels;
593
594        st->user_forced_mode = st->mode;
595        st->user_bandwidth = st->bandwidth;
596        st->force_channels = st->stream_channels;
597
598        for (i=0;i<nb_frames;i++)
599        {
600           int tmp_len;
601           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);
602           ret = opus_repacketizer_cat(rp, tmp_data+i*bytes_per_frame, tmp_len);
603        }
604        ret = opus_repacketizer_out(rp, data, max_data_bytes);
605
606        st->user_forced_mode = bak_mode;
607        st->user_bandwidth = bak_bandwidth;
608        st->force_channels = bak_channels;
609        RESTORE_STACK;
610        return ret;
611     }
612     /* CELT mode doesn't support mediumband, use wideband instead */
613     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
614         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
615
616     /* Chooses the appropriate mode for speech
617        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
618     if (st->mode == MODE_SILK_ONLY && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
619         st->mode = MODE_HYBRID;
620     if (st->mode == MODE_HYBRID && st->bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
621         st->mode = MODE_SILK_ONLY;
622
623     /* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */
624     if (max_data_bytes < 8000*frame_size / (st->Fs * 8))
625        st->mode = MODE_CELT_ONLY;
626     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, st->bandwidth); */
627     bytes_target = IMIN(max_data_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
628
629     data += 1;
630
631     ec_enc_init(&enc, data, max_data_bytes-1);
632
633     ALLOC(pcm_buf, (delay_compensation+frame_size)*st->channels, opus_val16);
634     for (i=0;i<delay_compensation*st->channels;i++)
635        pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-delay_compensation)*st->channels+i];
636
637     if (st->mode == MODE_CELT_ONLY)
638        hp_freq_smth1 = SKP_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
639     else
640        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
641
642     st->variable_HP_smth2_Q15 = SKP_SMLAWB( st->variable_HP_smth2_Q15,
643           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
644
645     /* convert from log scale to Hertz */
646     cutoff_Hz = silk_log2lin( SKP_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
647
648     if (st->application == OPUS_APPLICATION_VOIP)
649     {
650        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[delay_compensation*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
651     } else {
652        for (i=0;i<frame_size*st->channels;i++)
653           pcm_buf[delay_compensation*st->channels + i] = pcm[i];
654     }
655
656     /* SILK processing */
657     if (st->mode != MODE_CELT_ONLY)
658     {
659 #ifdef FIXED_POINT
660        const opus_int16 *pcm_silk;
661 #else
662        VARDECL(opus_int16, pcm_silk);
663        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
664 #endif
665         st->silk_mode.bitRate = st->bitrate_bps - 8*st->Fs/frame_size;
666         if( st->mode == MODE_HYBRID ) {
667             st->silk_mode.bitRate /= st->stream_channels;
668             if( st->bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
669                 if( st->Fs == 100 * frame_size ) {
670                     /* 24 kHz, 10 ms */
671                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 2000 + st->use_vbr * 1000 ) * 2 ) / 3;
672                 } else {
673                     /* 24 kHz, 20 ms */
674                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 1000 + st->use_vbr * 1000 ) * 2 ) / 3;
675                 }
676             } else {
677                 if( st->Fs == 100 * frame_size ) {
678                     /* 48 kHz, 10 ms */
679                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 8000 + st->use_vbr * 3000 ) / 2;
680                 } else {
681                     /* 48 kHz, 20 ms */
682                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 9000 + st->use_vbr * 1000 ) / 2;
683                 }
684             }
685             st->silk_mode.bitRate *= st->stream_channels;
686             /* don't let SILK use more than 80% */
687             if( st->silk_mode.bitRate > ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5 ) {
688                 st->silk_mode.bitRate = ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5;
689             }
690         }
691         /* SILK is not allow to use more than 50% of max_data_bytes */
692         if (max_data_bytes < 2*st->silk_mode.bitRate*frame_size / (st->Fs * 8))
693            st->silk_mode.bitRate = max_data_bytes*st->Fs*4/frame_size;
694
695         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
696         st->silk_mode.nChannelsAPI = st->channels;
697         st->silk_mode.nChannelsInternal = st->stream_channels;
698         if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
699             st->silk_mode.desiredInternalSampleRate = 8000;
700         } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
701             st->silk_mode.desiredInternalSampleRate = 12000;
702         } else {
703             SKP_assert( st->mode == MODE_HYBRID || st->bandwidth == OPUS_BANDWIDTH_WIDEBAND );
704             st->silk_mode.desiredInternalSampleRate = 16000;
705         }
706         if( st->mode == MODE_HYBRID ) {
707             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
708             st->silk_mode.minInternalSampleRate = 16000;
709         } else {
710             st->silk_mode.minInternalSampleRate = 8000;
711         }
712         st->silk_mode.maxInternalSampleRate = 16000;
713
714         /* Call SILK encoder for the low band */
715         nBytes = IMIN(1275, max_data_bytes-1);
716         if (prefill)
717         {
718             int zero=0;
719 #ifdef FIXED_POINT
720             pcm_silk = st->delay_buffer;
721 #else
722             for (i=0;i<st->encoder_buffer*st->channels;i++)
723                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
724 #endif
725             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
726         }
727
728 #ifdef FIXED_POINT
729         pcm_silk = pcm_buf+delay_compensation*st->channels;
730 #else
731         for (i=0;i<frame_size*st->channels;i++)
732             pcm_silk[i] = FLOAT2INT16(pcm_buf[delay_compensation*st->channels + i]);
733 #endif
734         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
735         if( ret ) {
736             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
737             /* Handle error */
738            return OPUS_INTERNAL_ERROR;
739         }
740         if (nBytes==0)
741         {
742            data[-1] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, silk_internal_bandwidth, st->stream_channels);
743            RESTORE_STACK;
744            return 1;
745         }
746         /* Extract SILK internal bandwidth for signaling in first byte */
747         if( st->mode == MODE_SILK_ONLY ) {
748             if( st->silk_mode.internalSampleRate == 8000 ) {
749                 silk_internal_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
750             } else if( st->silk_mode.internalSampleRate == 12000 ) {
751                 silk_internal_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
752             } else if( st->silk_mode.internalSampleRate == 16000 ) {
753                 silk_internal_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
754             }
755         } else {
756             SKP_assert( st->silk_mode.internalSampleRate == 16000 );
757         }
758     }
759
760     /* CELT processing */
761     {
762         int endband=21;
763
764         switch(st->bandwidth)
765         {
766             case OPUS_BANDWIDTH_NARROWBAND:
767                 endband = 13;
768                 break;
769             case OPUS_BANDWIDTH_MEDIUMBAND:
770             case OPUS_BANDWIDTH_WIDEBAND:
771                 endband = 17;
772                 break;
773             case OPUS_BANDWIDTH_SUPERWIDEBAND:
774                 endband = 19;
775                 break;
776             case OPUS_BANDWIDTH_FULLBAND:
777                 endband = 21;
778                 break;
779         }
780         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
781         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
782     }
783     if (st->mode != MODE_SILK_ONLY)
784     {
785         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
786         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
787         if (st->prev_mode == MODE_SILK_ONLY)
788         {
789             unsigned char dummy[10];
790             celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
791             celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
792             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
793             /* TODO: This wastes CPU a bit compared to just prefilling the buffer */
794             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);
795         } else {
796             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
797         }
798
799         if (st->mode == MODE_HYBRID)
800         {
801             int len;
802
803             len = (ec_tell(&enc)+7)>>3;
804             if( st->use_vbr ) {
805                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
806             } else {
807                 /* check if SILK used up too much */
808                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
809             }
810         } else {
811             if (st->use_vbr)
812             {
813                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
814                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
815                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps));
816                 nb_compr_bytes = max_data_bytes-1;
817             } else {
818                 nb_compr_bytes = bytes_target;
819             }
820         }
821
822     } else {
823         nb_compr_bytes = 0;
824     }
825
826     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+delay_compensation));i++)
827         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
828     for (;i<st->encoder_buffer*st->channels;i++)
829         st->delay_buffer[i] = pcm_buf[(frame_size+delay_compensation-st->encoder_buffer)*st->channels+i];
830
831
832     if( st->mode == MODE_HYBRID && st->stream_channels == 2 ) {
833         /* Apply stereo width reduction (at low bitrates) */
834         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
835             int width_Q14, delta_Q14, nSamples_8ms, diff;
836             nSamples_8ms = ( st->Fs * 8 ) / 1000;
837             width_Q14 = (1 << 14 ) - st->hybrid_stereo_width_Q14;
838             delta_Q14 = ( st->hybrid_stereo_width_Q14 - st->silk_mode.stereoWidth_Q14 ) / nSamples_8ms;
839             for( i = 0; i < nSamples_8ms; i++ ) {
840                 width_Q14 += delta_Q14;
841                 diff = pcm_buf[ 2*i+1 ] - (opus_int32)pcm_buf[ 2*i ];
842                 diff = ( diff * width_Q14 ) >> 15;
843                 pcm_buf[ 2*i ]   = (opus_int16)( pcm_buf[ 2*i ]   + diff );
844                 pcm_buf[ 2*i+1 ] = (opus_int16)( pcm_buf[ 2*i+1 ] - diff );
845             }
846             for( ; i < frame_size; i++ ) {
847                 diff = pcm_buf[ 2*i+1 ] - (opus_int32)pcm_buf[ 2*i ];
848                 diff = ( diff * width_Q14 ) >> 15;
849                 pcm_buf[ 2*i ]   = (opus_int16)( pcm_buf[ 2*i ]   + diff );
850                 pcm_buf[ 2*i+1 ] = (opus_int16)( pcm_buf[ 2*i+1 ] - diff );
851             }
852             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
853         }
854     }
855
856     if (st->mode != MODE_CELT_ONLY && ec_tell(&enc)+29+8*(st->mode == MODE_HYBRID) < 8*nb_compr_bytes)
857     {
858         /* Check if we have a redundant 0-8 kHz band */
859         ec_enc_bit_logp(&enc, redundancy, 12);
860         if (redundancy)
861         {
862             int max_redundancy;
863             ec_enc_bit_logp(&enc, celt_to_silk, 1);
864             max_redundancy = nb_compr_bytes-((ec_tell(&enc)+7)>>3)-(st->mode == MODE_HYBRID);
865             /* Target the same bit-rate for redundancy as for the rest,
866                up to a max of 257 bytes */
867             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
868             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
869             if (st->mode == MODE_HYBRID)
870                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
871         }
872     } else {
873         redundancy = 0;
874     }
875
876     if (st->mode != MODE_CELT_ONLY)start_band=17;
877
878     if (st->mode == MODE_SILK_ONLY)
879     {
880         ret = (ec_tell(&enc)+7)>>3;
881         ec_enc_done(&enc);
882         /*When in LPC only mode it's perfectly
883           reasonable to strip off trailing zero bytes as
884           the required range decoder behavior is to
885           fill these in. This can't be done when the MDCT
886           modes are used because the decoder needs to know
887           the actual length for allocation purposes.*/
888         if(!redundancy)
889             while(ret>2&&data[ret-1]==0)ret--;
890         nb_compr_bytes = ret;
891     } else {
892        nb_compr_bytes = IMIN(1275-redundancy_bytes, nb_compr_bytes);
893        ec_enc_shrink(&enc, nb_compr_bytes);
894     }
895
896
897     /* 5 ms redundant frame for CELT->SILK */
898     if (redundancy && celt_to_silk)
899     {
900         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
901         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
902         celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
903         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
904         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
905     }
906
907     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
908
909     if (st->mode != MODE_SILK_ONLY)
910     {
911         ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
912         if (ret < 0)
913            return OPUS_INTERNAL_ERROR;
914     }
915
916     /* 5 ms redundant frame for SILK->CELT */
917     if (redundancy && !celt_to_silk)
918     {
919         int N2, N4;
920         N2 = st->Fs/200;
921         N4 = st->Fs/400;
922
923         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
924         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
925         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
926
927         /* TODO: We could speed up prefilling here */
928         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, data+nb_compr_bytes, redundancy_bytes, NULL);
929
930         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
931         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
932     }
933
934
935
936     /* Signalling the mode in the first byte */
937     data--;
938     data[0] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, silk_internal_bandwidth, st->stream_channels);
939
940     st->rangeFinal = enc.rng ^ redundant_rng;
941
942     if (to_celt)
943         st->prev_mode = MODE_CELT_ONLY;
944     else
945         st->prev_mode = st->mode;
946     st->first = 0;
947     RESTORE_STACK;
948     return ret+1+redundancy_bytes;
949 }
950
951 #ifdef FIXED_POINT
952
953 #ifndef DISABLE_FLOAT_API
954 int opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
955       unsigned char *data, int max_data_bytes)
956 {
957    int i, ret;
958    VARDECL(opus_int16, in);
959    ALLOC_STACK;
960
961    ALLOC(in, frame_size*st->channels, opus_int16);
962
963    for (i=0;i<frame_size*st->channels;i++)
964       in[i] = FLOAT2INT16(pcm[i]);
965    ret = opus_encode(st, in, frame_size, data, max_data_bytes);
966    RESTORE_STACK;
967    return ret;
968 }
969 #endif
970
971 #else
972 int opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
973       unsigned char *data, int max_data_bytes)
974 {
975    int i, ret;
976    VARDECL(float, in);
977    ALLOC_STACK;
978
979    ALLOC(in, frame_size*st->channels, float);
980
981    for (i=0;i<frame_size*st->channels;i++)
982       in[i] = (1./32768)*pcm[i];
983    ret = opus_encode_float(st, in, frame_size, data, max_data_bytes);
984    RESTORE_STACK;
985    return ret;
986 }
987 #endif
988
989
990 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
991 {
992     int ret;
993     CELTEncoder *celt_enc;
994     va_list ap;
995
996     ret = OPUS_OK;
997     va_start(ap, request);
998
999     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1000
1001     switch (request)
1002     {
1003         case OPUS_SET_APPLICATION_REQUEST:
1004         {
1005             opus_int32 value = va_arg(ap, opus_int32);
1006             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
1007                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1008                || (!st->first && st->application != value))
1009             {
1010                ret = OPUS_BAD_ARG;
1011                break;
1012             }
1013             st->application = value;
1014         }
1015         break;
1016         case OPUS_GET_APPLICATION_REQUEST:
1017         {
1018             opus_int32 *value = va_arg(ap, opus_int32*);
1019             *value = st->mode;
1020         }
1021         break;
1022         case OPUS_SET_BITRATE_REQUEST:
1023         {
1024             opus_int32 value = va_arg(ap, opus_int32);
1025             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1026             {
1027                 if (value <= 0)
1028                     goto bad_arg;
1029                 else if (value <= 500)
1030                     value = 500;
1031                 else if (value > (opus_int32)300000*st->channels)
1032                     value = (opus_int32)300000*st->channels;
1033             }
1034             st->user_bitrate_bps = value;
1035         }
1036         break;
1037         case OPUS_GET_BITRATE_REQUEST:
1038         {
1039             opus_int32 *value = va_arg(ap, opus_int32*);
1040             *value = st->bitrate_bps;
1041         }
1042         break;
1043         case OPUS_SET_FORCE_CHANNELS_REQUEST:
1044         {
1045             opus_int32 value = va_arg(ap, opus_int32);
1046             st->force_channels = value;
1047         }
1048         break;
1049         case OPUS_GET_FORCE_CHANNELS_REQUEST:
1050         {
1051             opus_int32 *value = va_arg(ap, opus_int32*);
1052             *value = st->force_channels;
1053         }
1054         break;
1055         case OPUS_SET_BANDWIDTH_REQUEST:
1056         {
1057             opus_int32 value = va_arg(ap, opus_int32);
1058             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
1059                 return OPUS_BAD_ARG;
1060             st->user_bandwidth = value;
1061             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1062                 st->silk_mode.maxInternalSampleRate = 8000;
1063             } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1064                 st->silk_mode.maxInternalSampleRate = 12000;
1065             } else {
1066                 st->silk_mode.maxInternalSampleRate = 16000;
1067             }
1068         }
1069         break;
1070         case OPUS_GET_BANDWIDTH_REQUEST:
1071         {
1072             opus_int32 *value = va_arg(ap, opus_int32*);
1073             *value = st->bandwidth;
1074         }
1075         break;
1076         case OPUS_SET_DTX_REQUEST:
1077         {
1078             opus_int32 value = va_arg(ap, opus_int32);
1079             st->silk_mode.useDTX = value;
1080         }
1081         break;
1082         case OPUS_GET_DTX_REQUEST:
1083         {
1084             opus_int32 *value = va_arg(ap, opus_int32*);
1085             *value = st->silk_mode.useDTX;
1086         }
1087         break;
1088         case OPUS_SET_COMPLEXITY_REQUEST:
1089         {
1090             opus_int32 value = va_arg(ap, opus_int32);
1091             st->silk_mode.complexity = value;
1092             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
1093         }
1094         break;
1095         case OPUS_GET_COMPLEXITY_REQUEST:
1096         {
1097             opus_int32 *value = va_arg(ap, opus_int32*);
1098             *value = st->silk_mode.complexity;
1099         }
1100         break;
1101         case OPUS_SET_INBAND_FEC_REQUEST:
1102         {
1103             opus_int32 value = va_arg(ap, opus_int32);
1104             st->silk_mode.useInBandFEC = value;
1105         }
1106         break;
1107         case OPUS_GET_INBAND_FEC_REQUEST:
1108         {
1109             opus_int32 *value = va_arg(ap, opus_int32*);
1110             *value = st->silk_mode.useInBandFEC;
1111         }
1112         break;
1113         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1114         {
1115             opus_int32 value = va_arg(ap, opus_int32);
1116             if (value < 0 || value > 100)
1117                 return OPUS_BAD_ARG;
1118             st->silk_mode.packetLossPercentage = value;
1119             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
1120         }
1121         break;
1122         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1123         {
1124             opus_int32 *value = va_arg(ap, opus_int32*);
1125             *value = st->silk_mode.packetLossPercentage;
1126         }
1127         break;
1128         case OPUS_SET_VBR_REQUEST:
1129         {
1130             opus_int32 value = va_arg(ap, opus_int32);
1131             st->use_vbr = value;
1132             st->silk_mode.useCBR = 1-value;
1133         }
1134         break;
1135         case OPUS_GET_VBR_REQUEST:
1136         {
1137             opus_int32 *value = va_arg(ap, opus_int32*);
1138             *value = st->use_vbr;
1139         }
1140         break;
1141         case OPUS_SET_VOICE_RATIO_REQUEST:
1142         {
1143             opus_int32 value = va_arg(ap, opus_int32);
1144             if (value>100 || value<-1)
1145                 goto bad_arg;
1146             st->voice_ratio = value;
1147         }
1148         break;
1149         case OPUS_GET_VOICE_RATIO_REQUEST:
1150         {
1151             opus_int32 *value = va_arg(ap, opus_int32*);
1152             *value = st->voice_ratio;
1153         }
1154         break;
1155         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1156         {
1157             opus_int32 value = va_arg(ap, opus_int32);
1158             st->vbr_constraint = value;
1159         }
1160         break;
1161         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1162         {
1163             opus_int32 *value = va_arg(ap, opus_int32*);
1164             *value = st->vbr_constraint;
1165         }
1166         break;
1167         case OPUS_SET_SIGNAL_REQUEST:
1168         {
1169             opus_int32 value = va_arg(ap, opus_int32);
1170             st->signal_type = value;
1171         }
1172         break;
1173         case OPUS_GET_SIGNAL_REQUEST:
1174         {
1175             opus_int32 *value = va_arg(ap, opus_int32*);
1176             *value = st->signal_type;
1177         }
1178         break;
1179         case OPUS_GET_LOOKAHEAD_REQUEST:
1180         {
1181             opus_int32 *value = va_arg(ap, opus_int32*);
1182             *value = st->Fs/400;
1183             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1184                *value += st->delay_compensation;
1185         }
1186         break;
1187         case OPUS_GET_FINAL_RANGE_REQUEST:
1188         {
1189             opus_uint32 *value = va_arg(ap, opus_uint32*);
1190             *value = st->rangeFinal;
1191         }
1192         break;
1193         case OPUS_RESET_STATE:
1194         {
1195            void *silk_enc;
1196            silk_EncControlStruct dummy;
1197            silk_enc = (char*)st+st->silk_enc_offset;
1198
1199            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
1200                  sizeof(OpusEncoder)-
1201                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
1202
1203            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1204            silk_InitEncoder( silk_enc, &dummy );
1205            st->stream_channels = st->channels;
1206            st->hybrid_stereo_width_Q14             = 1 << 14;
1207            st->first = 1;
1208            st->mode = MODE_HYBRID;
1209            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
1210            st->variable_HP_smth2_Q15 = SKP_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1211         }
1212         break;
1213         case OPUS_SET_FORCE_MODE_REQUEST:
1214         {
1215             opus_int32 value = va_arg(ap, opus_int32);
1216             if (value < MODE_SILK_ONLY || value > MODE_CELT_ONLY)
1217                goto bad_arg;
1218             st->user_forced_mode = value;
1219         }
1220         break;
1221         default:
1222             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
1223             ret = OPUS_UNIMPLEMENTED;
1224             break;
1225     }
1226     va_end(ap);
1227     return ret;
1228 bad_arg:
1229     va_end(ap);
1230     return OPUS_BAD_ARG;
1231 }
1232
1233 void opus_encoder_destroy(OpusEncoder *st)
1234 {
1235     opus_free(st);
1236 }