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