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