Minor fixes
[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] = (opus_val32)(A_Q28[0] * (1./((opus_int32)1<<28)));
272     A[1] = (opus_val32)(A_Q28[1] * (1./((opus_int32)1<<28)));
273     B[0] = (opus_val32)(B_Q28[0] * (1./((opus_int32)1<<28)));
274     B[1] = (opus_val32)(B_Q28[1] * (1./((opus_int32)1<<28)));
275     B[2] = (opus_val32)(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 (redundancy)
868                len += st->mode == MODE_HYBRID ? 3 : 1;
869             if( st->use_vbr ) {
870                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
871             } else {
872                 /* check if SILK used up too much */
873                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
874             }
875         } else {
876             if (st->use_vbr)
877             {
878                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
879                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
880                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps));
881                 nb_compr_bytes = max_data_bytes-1;
882             } else {
883                 nb_compr_bytes = bytes_target;
884             }
885         }
886
887     } else {
888         nb_compr_bytes = 0;
889     }
890
891     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+delay_compensation));i++)
892         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
893     for (;i<st->encoder_buffer*st->channels;i++)
894         st->delay_buffer[i] = pcm_buf[(frame_size+delay_compensation-st->encoder_buffer)*st->channels+i];
895
896
897     if (st->mode != MODE_HYBRID || st->stream_channels==1)
898        st->silk_mode.stereoWidth_Q14 = 1<<14;
899     if( st->channels == 2 ) {
900         /* Apply stereo width reduction (at low bitrates) */
901         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
902             opus_val16 g1, g2;
903             const CELTMode *celt_mode;
904
905             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
906             g1 = st->hybrid_stereo_width_Q14;
907             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
908 #ifdef FIXED_POINT
909             g1 *= (1./16384);
910             g2 *= (1./16384);
911 #else
912             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
913             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
914 #endif
915             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
916                   frame_size, st->channels, celt_mode->window, st->Fs);
917             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
918         }
919     }
920
921     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) < 8*(max_data_bytes-1))
922     {
923         /* For SILK mode, the redundancy is inferred from the length */
924         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 < 8*nb_compr_bytes))
925            ec_enc_bit_logp(&enc, redundancy, 12);
926         if (redundancy)
927         {
928             int max_redundancy;
929             ec_enc_bit_logp(&enc, celt_to_silk, 1);
930             if (st->mode == MODE_HYBRID)
931                max_redundancy = (max_data_bytes-1)-nb_compr_bytes-1;
932             else
933                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
934             /* Target the same bit-rate for redundancy as for the rest,
935                up to a max of 257 bytes */
936             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
937             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
938             if (st->mode == MODE_HYBRID)
939                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
940         }
941     } else {
942         redundancy = 0;
943     }
944
945     if (st->mode != MODE_CELT_ONLY)start_band=17;
946
947     if (st->mode == MODE_SILK_ONLY)
948     {
949         ret = (ec_tell(&enc)+7)>>3;
950         ec_enc_done(&enc);
951         /*When in LPC only mode it's perfectly
952           reasonable to strip off trailing zero bytes as
953           the required range decoder behavior is to
954           fill these in. This can't be done when the MDCT
955           modes are used because the decoder needs to know
956           the actual length for allocation purposes.*/
957         if(!redundancy)
958             while(ret>2&&data[ret-1]==0)ret--;
959         nb_compr_bytes = ret;
960     } else {
961        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
962        ec_enc_shrink(&enc, nb_compr_bytes);
963     }
964
965
966     /* 5 ms redundant frame for CELT->SILK */
967     if (redundancy && celt_to_silk)
968     {
969         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
970         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
971         celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
972         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
973         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
974     }
975
976     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
977
978     if (st->mode != MODE_SILK_ONLY)
979     {
980         ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
981         if (ret < 0)
982            return OPUS_INTERNAL_ERROR;
983     }
984
985     /* 5 ms redundant frame for SILK->CELT */
986     if (redundancy && !celt_to_silk)
987     {
988         int N2, N4;
989         N2 = st->Fs/200;
990         N4 = st->Fs/400;
991
992         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
993         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
994         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
995
996         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
997         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, data+nb_compr_bytes, redundancy_bytes, NULL);
998
999         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1000         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1001     }
1002
1003
1004
1005     /* Signalling the mode in the first byte */
1006     data--;
1007     data[0] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, st->stream_channels);
1008
1009     st->rangeFinal = enc.rng ^ redundant_rng;
1010
1011     if (to_celt)
1012         st->prev_mode = MODE_CELT_ONLY;
1013     else
1014         st->prev_mode = st->mode;
1015     st->prev_channels = st->stream_channels;
1016     st->prev_framesize = frame_size;
1017
1018     st->first = 0;
1019     RESTORE_STACK;
1020     return ret+1+redundancy_bytes;
1021 }
1022
1023 #ifdef FIXED_POINT
1024
1025 #ifndef DISABLE_FLOAT_API
1026 int opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1027       unsigned char *data, int max_data_bytes)
1028 {
1029    int i, ret;
1030    VARDECL(opus_int16, in);
1031    ALLOC_STACK;
1032
1033    ALLOC(in, frame_size*st->channels, opus_int16);
1034
1035    for (i=0;i<frame_size*st->channels;i++)
1036       in[i] = FLOAT2INT16(pcm[i]);
1037    ret = opus_encode(st, in, frame_size, data, max_data_bytes);
1038    RESTORE_STACK;
1039    return ret;
1040 }
1041 #endif
1042
1043 #else
1044 int opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1045       unsigned char *data, int max_data_bytes)
1046 {
1047    int i, ret;
1048    VARDECL(float, in);
1049    ALLOC_STACK;
1050
1051    ALLOC(in, frame_size*st->channels, float);
1052
1053    for (i=0;i<frame_size*st->channels;i++)
1054       in[i] = (1.0f/32768)*pcm[i];
1055    ret = opus_encode_float(st, in, frame_size, data, max_data_bytes);
1056    RESTORE_STACK;
1057    return ret;
1058 }
1059 #endif
1060
1061
1062 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
1063 {
1064     int ret;
1065     CELTEncoder *celt_enc;
1066     va_list ap;
1067
1068     ret = OPUS_OK;
1069     va_start(ap, request);
1070
1071     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1072
1073     switch (request)
1074     {
1075         case OPUS_SET_APPLICATION_REQUEST:
1076         {
1077             opus_int32 value = va_arg(ap, opus_int32);
1078             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
1079                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1080                || (!st->first && st->application != value))
1081             {
1082                ret = OPUS_BAD_ARG;
1083                break;
1084             }
1085             st->application = value;
1086         }
1087         break;
1088         case OPUS_GET_APPLICATION_REQUEST:
1089         {
1090             opus_int32 *value = va_arg(ap, opus_int32*);
1091             *value = st->application;
1092         }
1093         break;
1094         case OPUS_SET_BITRATE_REQUEST:
1095         {
1096             opus_int32 value = va_arg(ap, opus_int32);
1097             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1098             {
1099                 if (value <= 0)
1100                     goto bad_arg;
1101                 else if (value <= 500)
1102                     value = 500;
1103                 else if (value > (opus_int32)300000*st->channels)
1104                     value = (opus_int32)300000*st->channels;
1105             }
1106             st->user_bitrate_bps = value;
1107         }
1108         break;
1109         case OPUS_GET_BITRATE_REQUEST:
1110         {
1111             opus_int32 *value = va_arg(ap, opus_int32*);
1112             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
1113         }
1114         break;
1115         case OPUS_SET_FORCE_CHANNELS_REQUEST:
1116         {
1117             opus_int32 value = va_arg(ap, opus_int32);
1118             if((value<1 || value>st->channels) && value != OPUS_AUTO)
1119                 return OPUS_BAD_ARG;
1120             st->force_channels = value;
1121         }
1122         break;
1123         case OPUS_GET_FORCE_CHANNELS_REQUEST:
1124         {
1125             opus_int32 *value = va_arg(ap, opus_int32*);
1126             *value = st->force_channels;
1127         }
1128         break;
1129         case OPUS_SET_BANDWIDTH_REQUEST:
1130         {
1131             opus_int32 value = va_arg(ap, opus_int32);
1132             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
1133                 return OPUS_BAD_ARG;
1134             st->user_bandwidth = value;
1135             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1136                 st->silk_mode.maxInternalSampleRate = 8000;
1137             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1138                 st->silk_mode.maxInternalSampleRate = 12000;
1139             } else {
1140                 st->silk_mode.maxInternalSampleRate = 16000;
1141             }
1142         }
1143         break;
1144         case OPUS_GET_BANDWIDTH_REQUEST:
1145         {
1146             opus_int32 *value = va_arg(ap, opus_int32*);
1147             *value = st->bandwidth;
1148         }
1149         break;
1150         case OPUS_SET_DTX_REQUEST:
1151         {
1152             opus_int32 value = va_arg(ap, opus_int32);
1153             if(value<0 || value>1)
1154                 return OPUS_BAD_ARG;
1155             st->silk_mode.useDTX = value;
1156         }
1157         break;
1158         case OPUS_GET_DTX_REQUEST:
1159         {
1160             opus_int32 *value = va_arg(ap, opus_int32*);
1161             *value = st->silk_mode.useDTX;
1162         }
1163         break;
1164         case OPUS_SET_COMPLEXITY_REQUEST:
1165         {
1166             opus_int32 value = va_arg(ap, opus_int32);
1167             if(value<0 || value>10)
1168                 return OPUS_BAD_ARG;
1169             st->silk_mode.complexity = value;
1170             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
1171         }
1172         break;
1173         case OPUS_GET_COMPLEXITY_REQUEST:
1174         {
1175             opus_int32 *value = va_arg(ap, opus_int32*);
1176             *value = st->silk_mode.complexity;
1177         }
1178         break;
1179         case OPUS_SET_INBAND_FEC_REQUEST:
1180         {
1181             opus_int32 value = va_arg(ap, opus_int32);
1182             if(value<0 || value>1)
1183                 return OPUS_BAD_ARG;
1184             st->silk_mode.useInBandFEC = value;
1185         }
1186         break;
1187         case OPUS_GET_INBAND_FEC_REQUEST:
1188         {
1189             opus_int32 *value = va_arg(ap, opus_int32*);
1190             *value = st->silk_mode.useInBandFEC;
1191         }
1192         break;
1193         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1194         {
1195             opus_int32 value = va_arg(ap, opus_int32);
1196             if (value < 0 || value > 100)
1197                 return OPUS_BAD_ARG;
1198             st->silk_mode.packetLossPercentage = value;
1199             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
1200         }
1201         break;
1202         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1203         {
1204             opus_int32 *value = va_arg(ap, opus_int32*);
1205             *value = st->silk_mode.packetLossPercentage;
1206         }
1207         break;
1208         case OPUS_SET_VBR_REQUEST:
1209         {
1210             opus_int32 value = va_arg(ap, opus_int32);
1211             if(value<0 || value>1)
1212                 return OPUS_BAD_ARG;
1213             st->use_vbr = value;
1214             st->silk_mode.useCBR = 1-value;
1215         }
1216         break;
1217         case OPUS_GET_VBR_REQUEST:
1218         {
1219             opus_int32 *value = va_arg(ap, opus_int32*);
1220             *value = st->use_vbr;
1221         }
1222         break;
1223         case OPUS_SET_VOICE_RATIO_REQUEST:
1224         {
1225             opus_int32 value = va_arg(ap, opus_int32);
1226             if (value>100 || value<-1)
1227                 goto bad_arg;
1228             st->voice_ratio = value;
1229         }
1230         break;
1231         case OPUS_GET_VOICE_RATIO_REQUEST:
1232         {
1233             opus_int32 *value = va_arg(ap, opus_int32*);
1234             *value = st->voice_ratio;
1235         }
1236         break;
1237         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1238         {
1239             opus_int32 value = va_arg(ap, opus_int32);
1240             if(value<0 || value>1)
1241                 return OPUS_BAD_ARG;
1242             st->vbr_constraint = value;
1243         }
1244         break;
1245         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1246         {
1247             opus_int32 *value = va_arg(ap, opus_int32*);
1248             *value = st->vbr_constraint;
1249         }
1250         break;
1251         case OPUS_SET_SIGNAL_REQUEST:
1252         {
1253             opus_int32 value = va_arg(ap, opus_int32);
1254             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
1255                 return OPUS_BAD_ARG;
1256             st->signal_type = value;
1257         }
1258         break;
1259         case OPUS_GET_SIGNAL_REQUEST:
1260         {
1261             opus_int32 *value = va_arg(ap, opus_int32*);
1262             *value = st->signal_type;
1263         }
1264         break;
1265         case OPUS_GET_LOOKAHEAD_REQUEST:
1266         {
1267             opus_int32 *value = va_arg(ap, opus_int32*);
1268             *value = st->Fs/400;
1269             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1270                 *value += st->delay_compensation;
1271         }
1272         break;
1273         case OPUS_GET_FINAL_RANGE_REQUEST:
1274         {
1275             opus_uint32 *value = va_arg(ap, opus_uint32*);
1276             *value = st->rangeFinal;
1277         }
1278         break;
1279         case OPUS_RESET_STATE:
1280         {
1281            void *silk_enc;
1282            silk_EncControlStruct dummy;
1283            silk_enc = (char*)st+st->silk_enc_offset;
1284
1285            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
1286                  sizeof(OpusEncoder)-
1287                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
1288
1289            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1290            silk_InitEncoder( silk_enc, &dummy );
1291            st->stream_channels = st->channels;
1292            st->hybrid_stereo_width_Q14 = 1 << 14;
1293            st->first = 1;
1294            st->mode = MODE_HYBRID;
1295            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
1296            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1297         }
1298         break;
1299         case OPUS_SET_FORCE_MODE_REQUEST:
1300         {
1301             opus_int32 value = va_arg(ap, opus_int32);
1302             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
1303                goto bad_arg;
1304             st->user_forced_mode = value;
1305         }
1306         break;
1307         default:
1308             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
1309             ret = OPUS_UNIMPLEMENTED;
1310             break;
1311     }
1312     va_end(ap);
1313     return ret;
1314 bad_arg:
1315     va_end(ap);
1316     return OPUS_BAD_ARG;
1317 }
1318
1319 void opus_encoder_destroy(OpusEncoder *st)
1320 {
1321     opus_free(st);
1322 }