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