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