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