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