Prevents OPUS_RESET_STATE from causing segfault.
[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->encoder_buffer*st->channels;i++)
762         st->delay_buffer[i] = pcm_buf[(frame_size+st->delay_compensation-st->encoder_buffer)*st->channels+i];
763
764
765     if( st->mode == MODE_HYBRID && st->stream_channels == 2 ) {
766         /* Apply stereo width reduction (at low bitrates) */
767         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
768             int width_Q14, delta_Q14, nSamples_8ms, diff;
769             nSamples_8ms = ( st->Fs * 8 ) / 1000;
770             width_Q14 = (1 << 14 ) - st->hybrid_stereo_width_Q14;
771             delta_Q14 = ( st->hybrid_stereo_width_Q14 - st->silk_mode.stereoWidth_Q14 ) / nSamples_8ms;
772             for( i = 0; i < nSamples_8ms; i++ ) {
773                 width_Q14 += delta_Q14;
774                 diff = pcm_buf[ 2*i+1 ] - (opus_int32)pcm_buf[ 2*i ];
775                 diff = ( diff * width_Q14 ) >> 15;
776                 pcm_buf[ 2*i ]   = (opus_int16)( pcm_buf[ 2*i ]   + diff );
777                 pcm_buf[ 2*i+1 ] = (opus_int16)( pcm_buf[ 2*i+1 ] - diff );
778             }
779             for( ; i < frame_size; i++ ) {
780                 diff = pcm_buf[ 2*i+1 ] - (opus_int32)pcm_buf[ 2*i ];
781                 diff = ( diff * width_Q14 ) >> 15;
782                 pcm_buf[ 2*i ]   = (opus_int16)( pcm_buf[ 2*i ]   + diff );
783                 pcm_buf[ 2*i+1 ] = (opus_int16)( pcm_buf[ 2*i+1 ] - diff );
784             }
785             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
786         }
787     }
788
789     if (st->mode != MODE_CELT_ONLY)
790     {
791         /* Check if we have a redundant 0-8 kHz band */
792         ec_enc_bit_logp(&enc, redundancy, 12);
793         if (redundancy)
794         {
795             /* Target the same bit-rate for redundancy as for the rest,
796                up to a max of 257 bytes */
797             redundancy_bytes = IMIN(257, st->bitrate_bps/1600);
798             ec_enc_bit_logp(&enc, celt_to_silk, 1);
799             if (st->mode == MODE_HYBRID)
800                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
801         }
802         start_band = 17;
803     }
804
805     if (st->mode == MODE_SILK_ONLY)
806     {
807         ret = (ec_tell(&enc)+7)>>3;
808         ec_enc_done(&enc);
809         /*When in LPC only mode it's perfectly
810           reasonable to strip off trailing zero bytes as
811           the required range decoder behavior is to
812           fill these in. This can't be done when the MDCT
813           modes are used because the decoder needs to know
814           the actual length for allocation purposes.*/
815         if(!redundancy)
816             while(ret>2&&data[ret-1]==0)ret--;
817         nb_compr_bytes = ret;
818     } else {
819        nb_compr_bytes = IMIN(1275-redundancy_bytes, nb_compr_bytes);
820        ec_enc_shrink(&enc, nb_compr_bytes);
821     }
822
823
824     /* 5 ms redundant frame for CELT->SILK */
825     if (redundancy && celt_to_silk)
826     {
827         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
828         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
829         celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
830         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
831         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
832     }
833
834     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
835
836     if (st->mode != MODE_SILK_ONLY)
837     {
838         ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
839     }
840
841     /* 5 ms redundant frame for SILK->CELT */
842     if (redundancy && !celt_to_silk)
843     {
844         int N2, N4;
845         N2 = st->Fs/200;
846         N4 = st->Fs/400;
847
848         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
849         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
850         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
851
852         /* TODO: We could speed up prefilling here */
853         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, data+nb_compr_bytes, redundancy_bytes, NULL);
854
855         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
856         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
857     }
858
859
860
861     /* Signalling the mode in the first byte */
862     data--;
863     data[0] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, silk_internal_bandwidth, st->stream_channels);
864
865     st->rangeFinal = enc.rng ^ redundant_rng;
866
867     if (to_celt)
868         st->prev_mode = MODE_CELT_ONLY;
869     else
870         st->prev_mode = st->mode;
871     st->first = 0;
872     RESTORE_STACK;
873     return ret+1+redundancy_bytes;
874 }
875
876 #ifdef FIXED_POINT
877
878 #ifndef DISABLE_FLOAT_API
879 int opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
880       unsigned char *data, int max_data_bytes)
881 {
882    int i, ret;
883    VARDECL(opus_int16, in);
884    ALLOC_STACK;
885
886    ALLOC(in, frame_size*st->channels, opus_int16);
887
888    for (i=0;i<frame_size*st->channels;i++)
889       in[i] = FLOAT2INT16(pcm[i]);
890    ret = opus_encode(st, in, frame_size, data, max_data_bytes);
891    RESTORE_STACK;
892    return ret;
893 }
894 #endif
895
896 #else
897 int opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
898       unsigned char *data, int max_data_bytes)
899 {
900    int i, ret;
901    VARDECL(float, in);
902    ALLOC_STACK;
903
904    ALLOC(in, frame_size*st->channels, float);
905
906    for (i=0;i<frame_size*st->channels;i++)
907       in[i] = (1./32768)*pcm[i];
908    ret = opus_encode_float(st, in, frame_size, data, max_data_bytes);
909    RESTORE_STACK;
910    return ret;
911 }
912 #endif
913
914
915 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
916 {
917     int ret;
918     CELTEncoder *celt_enc;
919     va_list ap;
920
921     ret = OPUS_OK;
922     va_start(ap, request);
923
924     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
925
926     switch (request)
927     {
928         case OPUS_SET_APPLICATION_REQUEST:
929         {
930             opus_int32 value = va_arg(ap, opus_int32);
931             st->application = value;
932         }
933         break;
934         case OPUS_GET_APPLICATION_REQUEST:
935         {
936             opus_int32 *value = va_arg(ap, opus_int32*);
937             *value = st->mode;
938         }
939         break;
940         case OPUS_SET_BITRATE_REQUEST:
941         {
942             opus_int32 value = va_arg(ap, opus_int32);
943             if (value != OPUS_BITRATE_AUTO)
944             {
945                 if (value <= 0)
946                     goto bad_arg;
947                 else if (value <= 500)
948                     value = 500;
949             }
950             st->user_bitrate_bps = value;
951         }
952         break;
953         case OPUS_GET_BITRATE_REQUEST:
954         {
955             opus_int32 *value = va_arg(ap, opus_int32*);
956             *value = st->bitrate_bps;
957         }
958         break;
959         case OPUS_SET_FORCE_MONO_REQUEST:
960         {
961             opus_int32 value = va_arg(ap, opus_int32);
962             st->force_mono = value;
963         }
964         break;
965         case OPUS_GET_FORCE_MONO_REQUEST:
966         {
967             opus_int32 *value = va_arg(ap, opus_int32*);
968             *value = !!st->force_mono;
969         }
970         break;
971         case OPUS_SET_BANDWIDTH_REQUEST:
972         {
973             opus_int32 value = va_arg(ap, opus_int32);
974             if (value < OPUS_BANDWIDTH_AUTO || value > OPUS_BANDWIDTH_FULLBAND)
975                 return OPUS_BAD_ARG;
976             st->user_bandwidth = value;
977             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
978                 st->silk_mode.maxInternalSampleRate = 8000;
979             } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
980                 st->silk_mode.maxInternalSampleRate = 12000;
981             } else {
982                 st->silk_mode.maxInternalSampleRate = 16000;
983             }
984         }
985         break;
986         case OPUS_GET_BANDWIDTH_REQUEST:
987         {
988             opus_int32 *value = va_arg(ap, opus_int32*);
989             *value = st->bandwidth;
990         }
991         break;
992         case OPUS_SET_DTX_REQUEST:
993         {
994             opus_int32 value = va_arg(ap, opus_int32);
995             st->silk_mode.useDTX = value;
996         }
997         break;
998         case OPUS_GET_DTX_REQUEST:
999         {
1000             opus_int32 *value = va_arg(ap, opus_int32*);
1001             *value = st->silk_mode.useDTX;
1002         }
1003         break;
1004         case OPUS_SET_COMPLEXITY_REQUEST:
1005         {
1006             opus_int32 value = va_arg(ap, opus_int32);
1007             st->silk_mode.complexity = value;
1008             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
1009         }
1010         break;
1011         case OPUS_GET_COMPLEXITY_REQUEST:
1012         {
1013             opus_int32 *value = va_arg(ap, opus_int32*);
1014             *value = st->silk_mode.complexity;
1015         }
1016         break;
1017         case OPUS_SET_INBAND_FEC_REQUEST:
1018         {
1019             opus_int32 value = va_arg(ap, opus_int32);
1020             st->silk_mode.useInBandFEC = value;
1021         }
1022         break;
1023         case OPUS_GET_INBAND_FEC_REQUEST:
1024         {
1025             opus_int32 *value = va_arg(ap, opus_int32*);
1026             *value = st->silk_mode.useInBandFEC;
1027         }
1028         break;
1029         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1030         {
1031             opus_int32 value = va_arg(ap, opus_int32);
1032             if (value < 0 || value > 100)
1033                 return OPUS_BAD_ARG;
1034             st->silk_mode.packetLossPercentage = value;
1035             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
1036         }
1037         break;
1038         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1039         {
1040             opus_int32 *value = va_arg(ap, opus_int32*);
1041             *value = st->silk_mode.packetLossPercentage;
1042         }
1043         break;
1044         case OPUS_SET_VBR_REQUEST:
1045         {
1046             opus_int32 value = va_arg(ap, opus_int32);
1047             st->use_vbr = value;
1048             st->silk_mode.useCBR = 1-value;
1049         }
1050         break;
1051         case OPUS_GET_VBR_REQUEST:
1052         {
1053             opus_int32 *value = va_arg(ap, opus_int32*);
1054             *value = st->use_vbr;
1055         }
1056         break;
1057         case OPUS_SET_VOICE_RATIO_REQUEST:
1058         {
1059             opus_int32 value = va_arg(ap, opus_int32);
1060             if (value>100 || value<-1)
1061                 goto bad_arg;
1062             st->voice_ratio = value;
1063         }
1064         break;
1065         case OPUS_GET_VOICE_RATIO_REQUEST:
1066         {
1067             opus_int32 *value = va_arg(ap, opus_int32*);
1068             *value = st->voice_ratio;
1069         }
1070         break;
1071         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1072         {
1073             opus_int32 value = va_arg(ap, opus_int32);
1074             st->vbr_constraint = value;
1075         }
1076         break;
1077         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1078         {
1079             opus_int32 *value = va_arg(ap, opus_int32*);
1080             *value = st->vbr_constraint;
1081         }
1082         break;
1083         case OPUS_SET_SIGNAL_REQUEST:
1084         {
1085             opus_int32 value = va_arg(ap, opus_int32);
1086             st->signal_type = value;
1087         }
1088         break;
1089         case OPUS_GET_SIGNAL_REQUEST:
1090         {
1091             opus_int32 *value = va_arg(ap, opus_int32*);
1092             *value = st->signal_type;
1093         }
1094         break;
1095         case OPUS_GET_LOOKAHEAD_REQUEST:
1096         {
1097             opus_int32 *value = va_arg(ap, opus_int32*);
1098             *value = st->delay_compensation+st->Fs/400;
1099         }
1100         break;
1101         case OPUS_GET_FINAL_RANGE_REQUEST:
1102         {
1103             opus_uint32 *value = va_arg(ap, opus_uint32*);
1104             *value = st->rangeFinal;
1105         }
1106         break;
1107         case OPUS_RESET_STATE:
1108         {
1109            void *silk_enc;
1110            silk_EncControlStruct dummy;
1111            silk_enc = (char*)st+st->silk_enc_offset;
1112
1113            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
1114                  sizeof(OpusEncoder)-
1115                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
1116
1117            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1118            silk_InitEncoder( silk_enc, &dummy );
1119            st->stream_channels = st->channels;
1120            st->hybrid_stereo_width_Q14             = 1 << 14;
1121            st->first = 1;
1122            st->mode = MODE_HYBRID;
1123            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
1124            st->variable_HP_smth2_Q15 = SKP_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1125         }
1126         break;
1127         default:
1128             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
1129             ret = OPUS_UNIMPLEMENTED;
1130             break;
1131     }
1132     va_end(ap);
1133     return ret;
1134 bad_arg:
1135     va_end(ap);
1136     return OPUS_BAD_ARG;
1137 }
1138
1139 void opus_encoder_destroy(OpusEncoder *st)
1140 {
1141     opus_free(st);
1142 }