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