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