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