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