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