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