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