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