Fixes the high-band hybrid gain from the previous commit
[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 COPYRIGHT OWNER
19    OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
23    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
24    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #ifdef HAVE_CONFIG_H
29 #include "config.h"
30 #endif
31
32 #include <stdarg.h>
33 #include "celt.h"
34 #include "entenc.h"
35 #include "modes.h"
36 #include "API.h"
37 #include "stack_alloc.h"
38 #include "float_cast.h"
39 #include "opus.h"
40 #include "arch.h"
41 #include "opus_private.h"
42 #include "os_support.h"
43 #include "analysis.h"
44 #include "mathops.h"
45 #include "tuning_parameters.h"
46 #ifdef FIXED_POINT
47 #include "fixed/structs_FIX.h"
48 #else
49 #include "float/structs_FLP.h"
50 #endif
51
52 #define MAX_ENCODER_BUFFER 480
53
54 struct OpusEncoder {
55     int          celt_enc_offset;
56     int          silk_enc_offset;
57     silk_EncControlStruct silk_mode;
58     int          application;
59     int          channels;
60     int          delay_compensation;
61     int          force_channels;
62     int          signal_type;
63     int          user_bandwidth;
64     int          max_bandwidth;
65     int          user_forced_mode;
66     int          voice_ratio;
67     opus_int32   Fs;
68     int          use_vbr;
69     int          vbr_constraint;
70     opus_int32   bitrate_bps;
71     opus_int32   user_bitrate_bps;
72     int          encoder_buffer;
73
74 #define OPUS_ENCODER_RESET_START stream_channels
75     int          stream_channels;
76     opus_int16   hybrid_stereo_width_Q14;
77     opus_int32   variable_HP_smth2_Q15;
78     opus_val16   prev_HB_gain;
79     opus_val32   hp_mem[4];
80     int          mode;
81     int          prev_mode;
82     int          prev_channels;
83     int          prev_framesize;
84     int          bandwidth;
85     int          silk_bw_switch;
86     /* Sampling rate (at the API level) */
87     int          first;
88     opus_val16   delay_buffer[MAX_ENCODER_BUFFER*2];
89 #ifndef FIXED_POINT
90     TonalityAnalysisState analysis;
91 #endif
92     opus_uint32  rangeFinal;
93 };
94
95 /* Transition tables for the voice and music. First column is the
96    middle (memoriless) threshold. The second column is the hysteresis
97    (difference with the middle) */
98 static const opus_int32 mono_voice_bandwidth_thresholds[8] = {
99         11000, 1000, /* NB<->MB */
100         14000, 1000, /* MB<->WB */
101         17000, 1000, /* WB<->SWB */
102         20000, 1000, /* SWB<->FB */
103 };
104 static const opus_int32 mono_music_bandwidth_thresholds[8] = {
105         14000, 1000, /* MB not allowed */
106         18000, 2000, /* MB<->WB */
107         24000, 2000, /* WB<->SWB */
108         33000, 2000, /* SWB<->FB */
109 };
110 static const opus_int32 stereo_voice_bandwidth_thresholds[8] = {
111         11000, 1000, /* NB<->MB */
112         14000, 1000, /* MB<->WB */
113         21000, 2000, /* WB<->SWB */
114         32000, 2000, /* SWB<->FB */
115 };
116 static const opus_int32 stereo_music_bandwidth_thresholds[8] = {
117         14000, 1000, /* MB not allowed */
118         18000, 2000, /* MB<->WB */
119         24000, 2000, /* WB<->SWB */
120         48000, 2000, /* SWB<->FB */
121 };
122 /* Threshold bit-rates for switching between mono and stereo */
123 static const opus_int32 stereo_voice_threshold = 26000;
124 static const opus_int32 stereo_music_threshold = 36000;
125
126 /* Threshold bit-rate for switching between SILK/hybrid and CELT-only */
127 static const opus_int32 mode_thresholds[2][2] = {
128       /* voice */ /* music */
129       {  48000,      24000}, /* mono */
130       {  48000,      24000}, /* stereo */
131 };
132
133 int opus_encoder_get_size(int channels)
134 {
135     int silkEncSizeBytes, celtEncSizeBytes;
136     int ret;
137     if (channels<1 || channels > 2)
138         return 0;
139     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
140     if (ret)
141         return 0;
142     silkEncSizeBytes = align(silkEncSizeBytes);
143     celtEncSizeBytes = celt_encoder_get_size(channels);
144     return align(sizeof(OpusEncoder))+silkEncSizeBytes+celtEncSizeBytes;
145 }
146
147 int opus_encoder_init(OpusEncoder* st, opus_int32 Fs, int channels, int application)
148 {
149     void *silk_enc;
150     CELTEncoder *celt_enc;
151     int err;
152     int ret, silkEncSizeBytes;
153
154    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
155         (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
156         && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
157         return OPUS_BAD_ARG;
158
159     OPUS_CLEAR((char*)st, opus_encoder_get_size(channels));
160     /* Create SILK encoder */
161     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
162     if (ret)
163         return OPUS_BAD_ARG;
164     silkEncSizeBytes = align(silkEncSizeBytes);
165     st->silk_enc_offset = align(sizeof(OpusEncoder));
166     st->celt_enc_offset = st->silk_enc_offset+silkEncSizeBytes;
167     silk_enc = (char*)st+st->silk_enc_offset;
168     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
169
170     st->stream_channels = st->channels = channels;
171
172     st->Fs = Fs;
173
174     ret = silk_InitEncoder( silk_enc, &st->silk_mode );
175     if(ret)return OPUS_INTERNAL_ERROR;
176
177     /* default SILK parameters */
178     st->silk_mode.nChannelsAPI              = channels;
179     st->silk_mode.nChannelsInternal         = channels;
180     st->silk_mode.API_sampleRate            = st->Fs;
181     st->silk_mode.maxInternalSampleRate     = 16000;
182     st->silk_mode.minInternalSampleRate     = 8000;
183     st->silk_mode.desiredInternalSampleRate = 16000;
184     st->silk_mode.payloadSize_ms            = 20;
185     st->silk_mode.bitRate                   = 25000;
186     st->silk_mode.packetLossPercentage      = 0;
187     st->silk_mode.complexity                = 10;
188     st->silk_mode.useInBandFEC              = 0;
189     st->silk_mode.useDTX                    = 0;
190     st->silk_mode.useCBR                    = 0;
191
192     /* Create CELT encoder */
193     /* Initialize CELT encoder */
194     err = celt_encoder_init(celt_enc, Fs, channels);
195     if(err!=OPUS_OK)return OPUS_INTERNAL_ERROR;
196
197     celt_encoder_ctl(celt_enc, CELT_SET_SIGNALLING(0));
198     celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(10));
199
200     st->use_vbr = 1;
201     /* Makes constrained VBR the default (safer for real-time use) */
202     st->vbr_constraint = 1;
203     st->user_bitrate_bps = OPUS_AUTO;
204     st->bitrate_bps = 3000+Fs*channels;
205     st->application = application;
206     st->signal_type = OPUS_AUTO;
207     st->user_bandwidth = OPUS_AUTO;
208     st->max_bandwidth = OPUS_BANDWIDTH_FULLBAND;
209     st->force_channels = OPUS_AUTO;
210     st->user_forced_mode = OPUS_AUTO;
211     st->voice_ratio = -1;
212     st->encoder_buffer = st->Fs/100;
213
214     /* Delay compensation of 4 ms (2.5 ms for SILK's extra look-ahead 
215        + 1.5 ms for SILK resamplers and stereo prediction) */
216     st->delay_compensation = st->Fs/250;
217
218     st->hybrid_stereo_width_Q14 = 1 << 14;
219     st->prev_HB_gain = Q15ONE;
220     st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
221     st->first = 1;
222     st->mode = MODE_HYBRID;
223     st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
224
225     return OPUS_OK;
226 }
227
228 static int pad_frame(unsigned char *data, opus_int32 len, opus_int32 new_len)
229 {
230    if (len == new_len)
231       return 0;
232    if (len > new_len)
233       return 1;
234
235    if ((data[0]&0x3)==0)
236    {
237       int i;
238       int padding, nb_255s;
239
240       padding = new_len - len;
241       if (padding >= 2)
242       {
243          nb_255s = (padding-2)/255;
244
245          for (i=len-1;i>=1;i--)
246             data[i+nb_255s+2] = data[i];
247          data[0] |= 0x3;
248          data[1] = 0x41;
249          for (i=0;i<nb_255s;i++)
250             data[i+2] = 255;
251          data[nb_255s+2] = padding-255*nb_255s-2;
252          for (i=len+3+nb_255s;i<new_len;i++)
253             data[i] = 0;
254       } else {
255          for (i=len-1;i>=1;i--)
256             data[i+1] = data[i];
257          data[0] |= 0x3;
258          data[1] = 1;
259       }
260       return 0;
261    } else {
262       return 1;
263    }
264 }
265
266 static unsigned char gen_toc(int mode, int framerate, int bandwidth, int channels)
267 {
268    int period;
269    unsigned char toc;
270    period = 0;
271    while (framerate < 400)
272    {
273        framerate <<= 1;
274        period++;
275    }
276    if (mode == MODE_SILK_ONLY)
277    {
278        toc = (bandwidth-OPUS_BANDWIDTH_NARROWBAND)<<5;
279        toc |= (period-2)<<3;
280    } else if (mode == MODE_CELT_ONLY)
281    {
282        int tmp = bandwidth-OPUS_BANDWIDTH_MEDIUMBAND;
283        if (tmp < 0)
284            tmp = 0;
285        toc = 0x80;
286        toc |= tmp << 5;
287        toc |= period<<3;
288    } else /* Hybrid */
289    {
290        toc = 0x60;
291        toc |= (bandwidth-OPUS_BANDWIDTH_SUPERWIDEBAND)<<4;
292        toc |= (period-2)<<3;
293    }
294    toc |= (channels==2)<<2;
295    return toc;
296 }
297
298 #ifndef FIXED_POINT
299 static void silk_biquad_float(
300     const opus_val16      *in,            /* I:    Input signal                   */
301     const opus_int32      *B_Q28,         /* I:    MA coefficients [3]            */
302     const opus_int32      *A_Q28,         /* I:    AR coefficients [2]            */
303     opus_val32            *S,             /* I/O:  State vector [2]               */
304     opus_val16            *out,           /* O:    Output signal                  */
305     const opus_int32      len,            /* I:    Signal length (must be even)   */
306     int stride
307 )
308 {
309     /* DIRECT FORM II TRANSPOSED (uses 2 element state vector) */
310     opus_int   k;
311     opus_val32 vout;
312     opus_val32 inval;
313     opus_val32 A[2], B[3];
314
315     A[0] = (opus_val32)(A_Q28[0] * (1.f/((opus_int32)1<<28)));
316     A[1] = (opus_val32)(A_Q28[1] * (1.f/((opus_int32)1<<28)));
317     B[0] = (opus_val32)(B_Q28[0] * (1.f/((opus_int32)1<<28)));
318     B[1] = (opus_val32)(B_Q28[1] * (1.f/((opus_int32)1<<28)));
319     B[2] = (opus_val32)(B_Q28[2] * (1.f/((opus_int32)1<<28)));
320
321     /* Negate A_Q28 values and split in two parts */
322
323     for( k = 0; k < len; k++ ) {
324         /* S[ 0 ], S[ 1 ]: Q12 */
325         inval = in[ k*stride ];
326         vout = S[ 0 ] + B[0]*inval;
327
328         S[ 0 ] = S[1] - vout*A[0] + B[1]*inval;
329
330         S[ 1 ] = - vout*A[1] + B[2]*inval;
331
332         /* Scale back to Q0 and saturate */
333         out[ k*stride ] = vout;
334     }
335 }
336 #endif
337
338 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)
339 {
340    opus_int32 B_Q28[ 3 ], A_Q28[ 2 ];
341    opus_int32 Fc_Q19, r_Q28, r_Q22;
342
343    silk_assert( cutoff_Hz <= silk_int32_MAX / SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ) );
344    Fc_Q19 = silk_DIV32_16( silk_SMULBB( SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ), cutoff_Hz ), Fs/1000 );
345    silk_assert( Fc_Q19 > 0 && Fc_Q19 < 32768 );
346
347    r_Q28 = SILK_FIX_CONST( 1.0, 28 ) - silk_MUL( SILK_FIX_CONST( 0.92, 9 ), Fc_Q19 );
348
349    /* b = r * [ 1; -2; 1 ]; */
350    /* a = [ 1; -2 * r * ( 1 - 0.5 * Fc^2 ); r^2 ]; */
351    B_Q28[ 0 ] = r_Q28;
352    B_Q28[ 1 ] = silk_LSHIFT( -r_Q28, 1 );
353    B_Q28[ 2 ] = r_Q28;
354
355    /* -r * ( 2 - Fc * Fc ); */
356    r_Q22  = silk_RSHIFT( r_Q28, 6 );
357    A_Q28[ 0 ] = silk_SMULWW( r_Q22, silk_SMULWW( Fc_Q19, Fc_Q19 ) - SILK_FIX_CONST( 2.0,  22 ) );
358    A_Q28[ 1 ] = silk_SMULWW( r_Q22, r_Q22 );
359
360 #ifdef FIXED_POINT
361    silk_biquad_alt( in, B_Q28, A_Q28, hp_mem, out, len, channels );
362    if( channels == 2 ) {
363        silk_biquad_alt( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
364    }
365 #else
366    silk_biquad_float( in, B_Q28, A_Q28, hp_mem, out, len, channels );
367    if( channels == 2 ) {
368        silk_biquad_float( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
369    }
370 #endif
371 }
372
373 #ifdef FIXED_POINT
374 static void dc_reject(const opus_val16 *in, opus_int32 cutoff_Hz, opus_val16 *out, opus_val32 *hp_mem, int len, int channels, opus_int32 Fs)
375 {
376    int c, i;
377    int shift;
378
379    /* Approximates -round(log2(4.*cutoff_Hz/Fs)) */
380    shift=celt_ilog2(Fs/(cutoff_Hz*3));
381    for (c=0;c<channels;c++)
382    {
383       for (i=0;i<len;i++)
384       {
385          opus_val32 x, tmp, y;
386          x = SHL32(EXTEND32(in[channels*i+c]), 15);
387          /* First stage */
388          tmp = x-hp_mem[2*c];
389          hp_mem[2*c] = hp_mem[2*c] + PSHR32(x - hp_mem[2*c], shift);
390          /* Second stage */
391          y = tmp - hp_mem[2*c+1];
392          hp_mem[2*c+1] = hp_mem[2*c+1] + PSHR32(tmp - hp_mem[2*c+1], shift);
393          out[channels*i+c] = EXTRACT16(SATURATE(PSHR32(y, 15), 32767));
394       }
395    }
396 }
397
398 #else
399 static void dc_reject(const opus_val16 *in, opus_int32 cutoff_Hz, opus_val16 *out, opus_val32 *hp_mem, int len, int channels, opus_int32 Fs)
400 {
401    int c, i;
402    float coef;
403
404    coef = 4.*cutoff_Hz/Fs;
405    for (c=0;c<channels;c++)
406    {
407       for (i=0;i<len;i++)
408       {
409          opus_val32 x, tmp, y;
410          x = in[channels*i+c];
411          /* First stage */
412          tmp = x-hp_mem[2*c];
413          hp_mem[2*c] = hp_mem[2*c] + coef*(x - hp_mem[2*c]);
414          /* Second stage */
415          y = tmp - hp_mem[2*c+1];
416          hp_mem[2*c+1] = hp_mem[2*c+1] + coef*(tmp - hp_mem[2*c+1]);
417          out[channels*i+c] = y;
418       }
419    }
420 }
421 #endif
422
423 static void stereo_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2,
424         int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
425 {
426     int i;
427     int overlap;
428     int inc;
429     inc = 48000/Fs;
430     overlap=overlap48/inc;
431     g1 = Q15ONE-g1;
432     g2 = Q15ONE-g2;
433     for (i=0;i<overlap;i++)
434     {
435        opus_val32 diff;
436        opus_val16 g, w;
437        w = MULT16_16_Q15(window[i*inc], window[i*inc]);
438        g = SHR32(MAC16_16(MULT16_16(w,g2),
439              Q15ONE-w, g1), 15);
440        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
441        diff = MULT16_16_Q15(g, diff);
442        out[i*channels] = out[i*channels] - diff;
443        out[i*channels+1] = out[i*channels+1] + diff;
444     }
445     for (;i<frame_size;i++)
446     {
447        opus_val32 diff;
448        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
449        diff = MULT16_16_Q15(g2, diff);
450        out[i*channels] = out[i*channels] - diff;
451        out[i*channels+1] = out[i*channels+1] + diff;
452     }
453 }
454
455 static void gain_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2,
456         int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
457 {
458     int i;
459     int inc;
460     int overlap;
461     inc = 48000/Fs;
462     overlap=overlap48/inc;
463     for (i=0;i<overlap;i++)
464     {
465        opus_val16 g, w;
466        w = MULT16_16_Q15(window[i*inc], window[i*inc]);
467        g = SHR32(MAC16_16(MULT16_16(w,g2),
468              Q15ONE-w, g1), 15);
469        out[i*channels] = MULT16_16_Q15(g, in[i*channels]);
470        out[i*channels+1] = MULT16_16_Q15(g, in[i*channels+1]);
471     }
472     for (;i<frame_size;i++)
473     {
474        out[i*channels] = MULT16_16_Q15(g2, in[i*channels]);
475        out[i*channels+1] = MULT16_16_Q15(g2, in[i*channels+1]);
476     }
477 }
478
479 OpusEncoder *opus_encoder_create(opus_int32 Fs, int channels, int application, int *error)
480 {
481    int ret;
482    OpusEncoder *st;
483    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
484        (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
485        && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
486    {
487       if (error)
488          *error = OPUS_BAD_ARG;
489       return NULL;
490    }
491    st = (OpusEncoder *)opus_alloc(opus_encoder_get_size(channels));
492    if (st == NULL)
493    {
494       if (error)
495          *error = OPUS_ALLOC_FAIL;
496       return NULL;
497    }
498    ret = opus_encoder_init(st, Fs, channels, application);
499    if (error)
500       *error = ret;
501    if (ret != OPUS_OK)
502    {
503       opus_free(st);
504       st = NULL;
505    }
506    return st;
507 }
508
509 static opus_int32 user_bitrate_to_bitrate(OpusEncoder *st, int frame_size, int max_data_bytes)
510 {
511   if(!frame_size)frame_size=st->Fs/400;
512   if (st->user_bitrate_bps==OPUS_AUTO)
513     return 60*st->Fs/frame_size + st->Fs*st->channels;
514   else if (st->user_bitrate_bps==OPUS_BITRATE_MAX)
515     return max_data_bytes*8*st->Fs/frame_size;
516   else
517     return st->user_bitrate_bps;
518 }
519
520 #ifdef FIXED_POINT
521 #define opus_encode_native opus_encode
522 opus_int32 opus_encode(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
523                 unsigned char *data, opus_int32 out_data_bytes)
524 #else
525 #define opus_encode_native opus_encode_float
526 opus_int32 opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
527                       unsigned char *data, opus_int32 out_data_bytes)
528 #endif
529 {
530     void *silk_enc;
531     CELTEncoder *celt_enc;
532     int i;
533     int ret=0;
534     opus_int32 nBytes;
535     ec_enc enc;
536     int bytes_target;
537     int prefill=0;
538     int start_band = 0;
539     int redundancy = 0;
540     int redundancy_bytes = 0; /* Number of bytes to use for redundancy frame */
541     int celt_to_silk = 0;
542     VARDECL(opus_val16, pcm_buf);
543     int nb_compr_bytes;
544     int to_celt = 0;
545     opus_uint32 redundant_rng = 0;
546     int cutoff_Hz, hp_freq_smth1;
547     int voice_est; /* Probability of voice in Q7 */
548     opus_int32 equiv_rate;
549     int delay_compensation;
550     int frame_rate;
551     opus_int32 max_rate; /* Max bitrate we're allowed to use */
552     int curr_bandwidth;
553     opus_val16 HB_gain;
554     opus_int32 max_data_bytes; /* Max number of bytes we're allowed to use */
555     int extra_buffer, total_buffer;
556     int perform_analysis=0;
557 #ifndef FIXED_POINT
558     AnalysisInfo analysis_info;
559 #endif
560     VARDECL(opus_val16, tmp_prefill);
561
562     ALLOC_STACK;
563
564     max_data_bytes = IMIN(1276, out_data_bytes);
565
566     st->rangeFinal = 0;
567     if (400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
568          50*frame_size != st->Fs &&  25*frame_size != st->Fs &&  50*frame_size != 3*st->Fs)
569     {
570        RESTORE_STACK;
571        return OPUS_BAD_ARG;
572     }
573     if (max_data_bytes<=0)
574     {
575        RESTORE_STACK;
576        return OPUS_BAD_ARG;
577     }
578     silk_enc = (char*)st+st->silk_enc_offset;
579     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
580
581 #ifndef FIXED_POINT
582     perform_analysis = st->silk_mode.complexity >= 7 && frame_size >= st->Fs/100 && st->Fs==48000;
583 #endif
584     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
585        delay_compensation = 0;
586     else
587        delay_compensation = st->delay_compensation;
588     if (perform_analysis)
589     {
590        total_buffer = IMAX(st->Fs/200, delay_compensation);
591     } else {
592        total_buffer = delay_compensation;
593     }
594     extra_buffer = total_buffer-delay_compensation;
595     st->bitrate_bps = user_bitrate_to_bitrate(st, frame_size, max_data_bytes);
596
597     frame_rate = st->Fs/frame_size;
598     if (max_data_bytes<3 || st->bitrate_bps < 3*frame_rate*8
599        || (frame_rate<50 && (max_data_bytes*frame_rate<300 || st->bitrate_bps < 2400)))
600     {
601        /*If the space is too low to do something useful, emit 'PLC' frames.*/
602        int tocmode = st->mode;
603        int bw = st->bandwidth == 0 ? OPUS_BANDWIDTH_NARROWBAND : st->bandwidth;
604        if (tocmode==0)
605           tocmode = MODE_SILK_ONLY;
606        if (frame_rate>100)
607           tocmode = MODE_CELT_ONLY;
608        if (frame_rate < 50)
609           tocmode = MODE_SILK_ONLY;
610        if(tocmode==MODE_SILK_ONLY&&bw>OPUS_BANDWIDTH_WIDEBAND)
611           bw=OPUS_BANDWIDTH_WIDEBAND;
612        else if (tocmode==MODE_CELT_ONLY&&bw==OPUS_BANDWIDTH_MEDIUMBAND)
613           bw=OPUS_BANDWIDTH_NARROWBAND;
614        else if (bw<=OPUS_BANDWIDTH_SUPERWIDEBAND)
615           bw=OPUS_BANDWIDTH_SUPERWIDEBAND;
616        data[0] = gen_toc(tocmode, frame_rate, bw, st->stream_channels);
617        RESTORE_STACK;
618        return 1;
619     }
620     if (!st->use_vbr)
621     {
622        int cbrBytes;
623        cbrBytes = IMIN( (st->bitrate_bps + 4*frame_rate)/(8*frame_rate) , max_data_bytes);
624        st->bitrate_bps = cbrBytes * (8*frame_rate);
625        max_data_bytes = cbrBytes;
626     }
627     max_rate = frame_rate*max_data_bytes*8;
628
629     /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */
630     equiv_rate = st->bitrate_bps - 60*(st->Fs/frame_size - 50);
631
632     if (st->signal_type == OPUS_SIGNAL_VOICE)
633        voice_est = 127;
634     else if (st->signal_type == OPUS_SIGNAL_MUSIC)
635        voice_est = 0;
636     else if (st->voice_ratio >= 0)
637        voice_est = st->voice_ratio*327>>8;
638     else if (st->application == OPUS_APPLICATION_VOIP)
639        voice_est = 115;
640     else
641        voice_est = 48;
642
643     if (st->force_channels!=OPUS_AUTO && st->channels == 2)
644     {
645         st->stream_channels = st->force_channels;
646     } else {
647 #ifdef FUZZING
648        /* Random mono/stereo decision */
649        if (st->channels == 2 && (rand()&0x1F)==0)
650           st->stream_channels = 3-st->stream_channels;
651 #else
652        /* Rate-dependent mono-stereo decision */
653        if (st->channels == 2)
654        {
655           opus_int32 stereo_threshold;
656           stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14);
657           if (st->stream_channels == 2)
658              stereo_threshold -= 4000;
659           else
660              stereo_threshold += 4000;
661           st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1;
662        } else {
663           st->stream_channels = st->channels;
664        }
665 #endif
666     }
667
668     /* Mode selection depending on application and signal type */
669     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
670     {
671        st->mode = MODE_CELT_ONLY;
672     } else if (st->user_forced_mode == OPUS_AUTO)
673     {
674 #ifdef FUZZING
675        /* Random mode switching */
676        if ((rand()&0xF)==0)
677        {
678           if ((rand()&0x1)==0)
679              st->mode = MODE_CELT_ONLY;
680           else
681              st->mode = MODE_SILK_ONLY;
682        } else {
683           if (st->prev_mode==MODE_CELT_ONLY)
684              st->mode = MODE_CELT_ONLY;
685           else
686              st->mode = MODE_SILK_ONLY;
687        }
688 #else
689        int chan;
690        opus_int32 mode_voice, mode_music;
691        opus_int32 threshold;
692
693        chan = (st->channels==2) && st->force_channels!=1;
694        mode_voice = mode_thresholds[chan][0];
695        mode_music = mode_thresholds[chan][1];
696        threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14);
697
698        /* Hysteresis */
699        if (st->prev_mode == MODE_CELT_ONLY)
700            threshold -= 4000;
701        else if (st->prev_mode>0)
702            threshold += 4000;
703
704        st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY;
705
706        /* When FEC is enabled and there's enough packet loss, use SILK */
707        if (st->silk_mode.useInBandFEC && st->silk_mode.packetLossPercentage > (128-voice_est)>>4)
708           st->mode = MODE_SILK_ONLY;
709        /* When encoding voice and DTX is enabled, set the encoder to SILK mode (at least for now) */
710        if (st->silk_mode.useDTX && voice_est > 100)
711           st->mode = MODE_SILK_ONLY;
712 #endif
713     } else {
714        st->mode = st->user_forced_mode;
715     }
716
717     /* Override the chosen mode to make sure we meet the requested frame size */
718     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
719        st->mode = MODE_CELT_ONLY;
720
721     if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0
722           && st->mode != MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)
723     {
724        /* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */
725        st->silk_mode.toMono = 1;
726        st->stream_channels = 2;
727     } else {
728        st->silk_mode.toMono = 0;
729     }
730
731     if (st->prev_mode > 0 &&
732         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
733     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
734     {
735         redundancy = 1;
736         celt_to_silk = (st->mode != MODE_CELT_ONLY);
737         if (!celt_to_silk)
738         {
739             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
740             if (frame_size >= st->Fs/100)
741             {
742                 st->mode = st->prev_mode;
743                 to_celt = 1;
744             } else {
745                 redundancy=0;
746             }
747         }
748     }
749     /* For the first frame at a new SILK bandwidth */
750     if (st->silk_bw_switch)
751     {
752        redundancy = 1;
753        celt_to_silk = 1;
754        st->silk_bw_switch = 0;
755     }
756
757     if (redundancy)
758     {
759        /* Fair share of the max size allowed */
760        redundancy_bytes = IMIN(257, max_data_bytes*(opus_int32)(st->Fs/200)/(frame_size+st->Fs/200));
761        /* For VBR, target the actual bitrate (subject to the limit above) */
762        if (st->use_vbr)
763           redundancy_bytes = IMIN(redundancy_bytes, st->bitrate_bps/1600);
764     }
765
766     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
767     {
768         silk_EncControlStruct dummy;
769         silk_InitEncoder( silk_enc, &dummy);
770         prefill=1;
771     }
772
773     /* Automatic (rate-dependent) bandwidth selection */
774     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
775     {
776         const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds;
777         opus_int32 bandwidth_thresholds[8];
778         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
779         opus_int32 equiv_rate2;
780
781         equiv_rate2 = equiv_rate;
782         if (st->mode != MODE_CELT_ONLY)
783         {
784            /* Adjust the threshold +/- 10% depending on complexity */
785            equiv_rate2 = equiv_rate2 * (45+st->silk_mode.complexity)/50;
786            /* CBR is less efficient by ~1 kb/s */
787            if (!st->use_vbr)
788               equiv_rate2 -= 1000;
789         }
790         if (st->channels==2 && st->force_channels!=1)
791         {
792            voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds;
793            music_bandwidth_thresholds = stereo_music_bandwidth_thresholds;
794         } else {
795            voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds;
796            music_bandwidth_thresholds = mono_music_bandwidth_thresholds;
797         }
798         /* Interpolate bandwidth thresholds depending on voice estimation */
799         for (i=0;i<8;i++)
800         {
801            bandwidth_thresholds[i] = music_bandwidth_thresholds[i]
802                     + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14);
803         }
804         do {
805             int threshold, hysteresis;
806             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
807             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
808             if (!st->first)
809             {
810                 if (st->bandwidth >= bandwidth)
811                     threshold -= hysteresis;
812                 else
813                     threshold += hysteresis;
814             }
815             if (equiv_rate2 >= threshold)
816                 break;
817         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
818         st->bandwidth = bandwidth;
819         /* Prevents any transition to SWB/FB until the SILK layer has fully
820            switched to WB mode and turned the variable LP filter off */
821         if (!st->first && st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
822             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
823     }
824
825     if (st->bandwidth>st->max_bandwidth)
826        st->bandwidth = st->max_bandwidth;
827
828     if (st->user_bandwidth != OPUS_AUTO)
829         st->bandwidth = st->user_bandwidth;
830
831     /* This prevents us from using hybrid at unsafe CBR/max rates */
832     if (st->mode != MODE_CELT_ONLY && max_rate < 15000)
833     {
834        st->bandwidth = IMIN(st->bandwidth, OPUS_BANDWIDTH_WIDEBAND);
835     }
836
837     /* Prevents Opus from wasting bits on frequencies that are above
838        the Nyquist rate of the input signal */
839     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
840         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
841     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
842         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
843     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
844         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
845     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
846         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
847
848     /* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */
849     if (max_data_bytes < (frame_rate > 50 ? 12000 : 8000)*frame_size / (st->Fs * 8))
850        st->mode = MODE_CELT_ONLY;
851
852     /* CELT mode doesn't support mediumband, use wideband instead */
853     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
854         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
855
856     /* Can't support higher than wideband for >20 ms frames */
857     if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND))
858     {
859        VARDECL(unsigned char, tmp_data);
860        int nb_frames;
861        int bak_mode, bak_bandwidth, bak_channels, bak_to_mono;
862        OpusRepacketizer rp;
863        opus_int32 bytes_per_frame;
864
865
866        nb_frames = frame_size > st->Fs/25 ? 3 : 2;
867        bytes_per_frame = IMIN(1276,(out_data_bytes-3)/nb_frames);
868
869        ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char);
870
871        opus_repacketizer_init(&rp);
872
873        bak_mode = st->user_forced_mode;
874        bak_bandwidth = st->user_bandwidth;
875        bak_channels = st->force_channels;
876
877        st->user_forced_mode = st->mode;
878        st->user_bandwidth = st->bandwidth;
879        st->force_channels = st->stream_channels;
880        bak_to_mono = st->silk_mode.toMono;
881
882        if (bak_to_mono)
883           st->force_channels = 1;
884        else
885           st->prev_channels = st->stream_channels;
886        for (i=0;i<nb_frames;i++)
887        {
888           int tmp_len;
889           st->silk_mode.toMono = 0;
890           /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
891           if (to_celt && i==nb_frames-1)
892              st->user_forced_mode = MODE_CELT_ONLY;
893           tmp_len = opus_encode_native(st, pcm+i*(st->channels*st->Fs/50), st->Fs/50, tmp_data+i*bytes_per_frame, bytes_per_frame);
894           if (tmp_len<0)
895           {
896              RESTORE_STACK;
897              return OPUS_INTERNAL_ERROR;
898           }
899           ret = opus_repacketizer_cat(&rp, tmp_data+i*bytes_per_frame, tmp_len);
900           if (ret<0)
901           {
902              RESTORE_STACK;
903              return OPUS_INTERNAL_ERROR;
904           }
905        }
906        ret = opus_repacketizer_out(&rp, data, out_data_bytes);
907        if (ret<0)
908        {
909           RESTORE_STACK;
910           return OPUS_INTERNAL_ERROR;
911        }
912        st->user_forced_mode = bak_mode;
913        st->user_bandwidth = bak_bandwidth;
914        st->force_channels = bak_channels;
915        st->silk_mode.toMono = bak_to_mono;
916        RESTORE_STACK;
917        return ret;
918     }
919
920     curr_bandwidth = st->bandwidth;
921
922     /* Chooses the appropriate mode for speech
923        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
924     if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND)
925         st->mode = MODE_HYBRID;
926     if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
927         st->mode = MODE_SILK_ONLY;
928
929     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
930     bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
931
932     data += 1;
933
934     ec_enc_init(&enc, data, max_data_bytes-1);
935
936     ALLOC(pcm_buf, (total_buffer+frame_size)*st->channels, opus_val16);
937     for (i=0;i<total_buffer*st->channels;i++)
938        pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-total_buffer)*st->channels+i];
939
940     if (st->mode == MODE_CELT_ONLY)
941        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
942     else
943        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
944
945     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
946           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
947
948     /* convert from log scale to Hertz */
949     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
950
951     if (st->application == OPUS_APPLICATION_VOIP)
952     {
953        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
954     } else {
955        dc_reject(pcm, 3, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
956     }
957
958 #ifndef FIXED_POINT
959     if (perform_analysis)
960     {
961        int nb_analysis_frames;
962        nb_analysis_frames = frame_size/(st->Fs/100);
963        for (i=0;i<nb_analysis_frames;i++)
964           tonality_analysis(&st->analysis, &analysis_info, celt_enc, pcm_buf+i*(st->Fs/100)*st->channels, st->channels);
965        if (st->signal_type == OPUS_AUTO)
966           st->voice_ratio = floor(.5+100*(1-analysis_info.music_prob));
967     } else {
968        analysis_info.valid = 0;
969        st->voice_ratio = -1;
970     }
971 #endif
972
973     /* SILK processing */
974     HB_gain = Q15ONE;
975     if (st->mode != MODE_CELT_ONLY)
976     {
977         opus_int32 total_bitRate, celt_rate;
978 #ifdef FIXED_POINT
979        const opus_int16 *pcm_silk;
980 #else
981        VARDECL(opus_int16, pcm_silk);
982        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
983 #endif
984
985         /* Distribute bits between SILK and CELT */
986         total_bitRate = 8 * bytes_target * frame_rate;
987         if( st->mode == MODE_HYBRID ) {
988             int HB_gain_ref;
989             /* Base rate for SILK */
990             st->silk_mode.bitRate = st->stream_channels * ( 5000 + 1000 * ( st->Fs == 100 * frame_size ) );
991             if( curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
992                 /* SILK gets 2/3 of the remaining bits */
993                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 2 / 3;
994             } else { /* FULLBAND */
995                 /* SILK gets 3/5 of the remaining bits */
996                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 3 / 5;
997             }
998             /* Don't let SILK use more than 80% */
999             if( st->silk_mode.bitRate > total_bitRate * 4/5 ) {
1000                 st->silk_mode.bitRate = total_bitRate * 4/5;
1001             }
1002             /* Increasingly attenuate high band when it gets allocated fewer bits */
1003             celt_rate = total_bitRate - st->silk_mode.bitRate;
1004             HB_gain_ref = (curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND) ? 2000 : 2400;
1005             HB_gain = SHL32((opus_val32)celt_rate, 9) / SHR32((opus_val32)celt_rate + st->stream_channels*HB_gain_ref, 6);
1006         } else {
1007             /* SILK gets all bits */
1008             st->silk_mode.bitRate = total_bitRate;
1009         }
1010
1011         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
1012         st->silk_mode.nChannelsAPI = st->channels;
1013         st->silk_mode.nChannelsInternal = st->stream_channels;
1014         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1015             st->silk_mode.desiredInternalSampleRate = 8000;
1016         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1017             st->silk_mode.desiredInternalSampleRate = 12000;
1018         } else {
1019             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
1020             st->silk_mode.desiredInternalSampleRate = 16000;
1021         }
1022         if( st->mode == MODE_HYBRID ) {
1023             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
1024             st->silk_mode.minInternalSampleRate = 16000;
1025         } else {
1026             st->silk_mode.minInternalSampleRate = 8000;
1027         }
1028
1029         if (st->mode == MODE_SILK_ONLY)
1030         {
1031            opus_int32 effective_max_rate = max_rate;
1032            st->silk_mode.maxInternalSampleRate = 16000;
1033            if (frame_rate > 50)
1034               effective_max_rate = effective_max_rate*2/3;
1035            if (effective_max_rate < 13000)
1036            {
1037               st->silk_mode.maxInternalSampleRate = 12000;
1038               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
1039            }
1040            if (effective_max_rate < 9600)
1041            {
1042               st->silk_mode.maxInternalSampleRate = 8000;
1043               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
1044            }
1045         } else {
1046            st->silk_mode.maxInternalSampleRate = 16000;
1047         }
1048
1049         st->silk_mode.useCBR = !st->use_vbr;
1050
1051         /* Call SILK encoder for the low band */
1052         nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes);
1053
1054         st->silk_mode.maxBits = nBytes*8;
1055         /* Only allow up to 90% of the bits for hybrid mode*/
1056         if (st->mode == MODE_HYBRID)
1057            st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
1058         if (st->silk_mode.useCBR)
1059         {
1060            st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
1061            /* Reduce the initial target to make it easier to reach the CBR rate */
1062            st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000);
1063         }
1064
1065         if (prefill)
1066         {
1067             opus_int32 zero=0;
1068 #ifdef FIXED_POINT
1069             pcm_silk = st->delay_buffer;
1070 #else
1071             for (i=0;i<st->encoder_buffer*st->channels;i++)
1072                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
1073 #endif
1074             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
1075         }
1076
1077 #ifdef FIXED_POINT
1078         pcm_silk = pcm_buf+total_buffer*st->channels;
1079 #else
1080         for (i=0;i<frame_size*st->channels;i++)
1081             pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
1082 #endif
1083         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
1084         if( ret ) {
1085             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
1086             /* Handle error */
1087            RESTORE_STACK;
1088            return OPUS_INTERNAL_ERROR;
1089         }
1090         if (nBytes==0)
1091         {
1092            st->rangeFinal = 0;
1093            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1094            RESTORE_STACK;
1095            return 1;
1096         }
1097         /* Extract SILK internal bandwidth for signaling in first byte */
1098         if( st->mode == MODE_SILK_ONLY ) {
1099             if( st->silk_mode.internalSampleRate == 8000 ) {
1100                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1101             } else if( st->silk_mode.internalSampleRate == 12000 ) {
1102                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1103             } else if( st->silk_mode.internalSampleRate == 16000 ) {
1104                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1105             }
1106         } else {
1107             silk_assert( st->silk_mode.internalSampleRate == 16000 );
1108         }
1109
1110         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
1111         /* FIXME: How do we allocate the redundancy for CBR? */
1112         if (st->silk_mode.opusCanSwitch)
1113         {
1114            redundancy = 1;
1115            celt_to_silk = 0;
1116            st->silk_bw_switch = 1;
1117         }
1118     }
1119
1120     /* CELT processing */
1121     {
1122         int endband=21;
1123
1124         switch(curr_bandwidth)
1125         {
1126             case OPUS_BANDWIDTH_NARROWBAND:
1127                 endband = 13;
1128                 break;
1129             case OPUS_BANDWIDTH_MEDIUMBAND:
1130             case OPUS_BANDWIDTH_WIDEBAND:
1131                 endband = 17;
1132                 break;
1133             case OPUS_BANDWIDTH_SUPERWIDEBAND:
1134                 endband = 19;
1135                 break;
1136             case OPUS_BANDWIDTH_FULLBAND:
1137                 endband = 21;
1138                 break;
1139         }
1140         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
1141         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
1142     }
1143     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1144     if (st->mode != MODE_SILK_ONLY)
1145     {
1146         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1147         /* Allow prediction unless we decide to disable it later */
1148         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
1149
1150         if (st->mode == MODE_HYBRID)
1151         {
1152             int len;
1153
1154             len = (ec_tell(&enc)+7)>>3;
1155             if (redundancy)
1156                len += st->mode == MODE_HYBRID ? 3 : 1;
1157             if( st->use_vbr ) {
1158                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
1159             } else {
1160                 /* check if SILK used up too much */
1161                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
1162             }
1163         } else {
1164             if (st->use_vbr)
1165             {
1166                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
1167                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
1168                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps));
1169                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
1170             } else {
1171                 nb_compr_bytes = bytes_target;
1172             }
1173         }
1174
1175     } else {
1176         nb_compr_bytes = 0;
1177     }
1178
1179     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
1180     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
1181     {
1182        for (i=0;i<st->channels*st->Fs/400;i++)
1183           tmp_prefill[i] = st->delay_buffer[(extra_buffer+st->encoder_buffer-total_buffer-st->Fs/400)*st->channels + i];
1184     }
1185
1186     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+total_buffer));i++)
1187         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
1188     for (;i<st->encoder_buffer*st->channels;i++)
1189         st->delay_buffer[i] = pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels+i];
1190
1191     /* gain_fade() and stereo_fade() need to be after the buffer copying
1192        because we don't want any of this to affect the SILK part */
1193     if( st->prev_HB_gain < Q15ONE || HB_gain < Q15ONE ) {
1194        const CELTMode *celt_mode;
1195
1196        celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1197        gain_fade(pcm_buf, pcm_buf,
1198              st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs);
1199     }
1200     st->prev_HB_gain = HB_gain;
1201     if (st->mode != MODE_HYBRID || st->stream_channels==1)
1202        st->silk_mode.stereoWidth_Q14 = 1<<14;
1203     if( st->channels == 2 ) {
1204         /* Apply stereo width reduction (at low bitrates) */
1205         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1206             opus_val16 g1, g2;
1207             const CELTMode *celt_mode;
1208
1209             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1210             g1 = st->hybrid_stereo_width_Q14;
1211             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1212 #ifdef FIXED_POINT
1213             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
1214             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
1215 #else
1216             g1 *= (1.f/16384);
1217             g2 *= (1.f/16384);
1218 #endif
1219             stereo_fade(pcm_buf+extra_buffer*st->channels, pcm_buf+extra_buffer*st->channels, g1, g2, celt_mode->overlap,
1220                   frame_size, st->channels, celt_mode->window, st->Fs);
1221             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1222         }
1223     }
1224
1225     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
1226     {
1227         /* For SILK mode, the redundancy is inferred from the length */
1228         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
1229            ec_enc_bit_logp(&enc, redundancy, 12);
1230         if (redundancy)
1231         {
1232             int max_redundancy;
1233             ec_enc_bit_logp(&enc, celt_to_silk, 1);
1234             if (st->mode == MODE_HYBRID)
1235                max_redundancy = (max_data_bytes-1)-nb_compr_bytes-1;
1236             else
1237                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1238             /* Target the same bit-rate for redundancy as for the rest,
1239                up to a max of 257 bytes */
1240             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
1241             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
1242             if (st->mode == MODE_HYBRID)
1243                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
1244         }
1245     } else {
1246         redundancy = 0;
1247     }
1248
1249     if (!redundancy)
1250     {
1251        st->silk_bw_switch = 0;
1252        redundancy_bytes = 0;
1253     }
1254     if (st->mode != MODE_CELT_ONLY)start_band=17;
1255
1256     if (st->mode == MODE_SILK_ONLY)
1257     {
1258         ret = (ec_tell(&enc)+7)>>3;
1259         ec_enc_done(&enc);
1260         nb_compr_bytes = ret;
1261     } else {
1262        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
1263        ec_enc_shrink(&enc, nb_compr_bytes);
1264     }
1265
1266
1267     /* 5 ms redundant frame for CELT->SILK */
1268     if (redundancy && celt_to_silk)
1269     {
1270         int err;
1271         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1272         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1273         err = celt_encode_with_ec(celt_enc, pcm_buf+extra_buffer*st->channels, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
1274         if (err < 0)
1275         {
1276            RESTORE_STACK;
1277            return OPUS_INTERNAL_ERROR;
1278         }
1279         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1280         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1281     }
1282
1283     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
1284
1285     if (st->mode != MODE_SILK_ONLY)
1286     {
1287         if (st->mode != st->prev_mode && st->prev_mode > 0)
1288         {
1289            unsigned char dummy[2];
1290            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1291
1292            /* Prefilling */
1293            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
1294            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1295         }
1296         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
1297         if (ec_tell(&enc) <= 8*nb_compr_bytes)
1298         {
1299 #ifndef FIXED_POINT
1300            if (perform_analysis)
1301               celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(&analysis_info));
1302 #endif
1303            ret = celt_encode_with_ec(celt_enc, pcm_buf+extra_buffer*st->channels, frame_size, NULL, nb_compr_bytes, &enc);
1304            if (ret < 0)
1305            {
1306               RESTORE_STACK;
1307               return OPUS_INTERNAL_ERROR;
1308            }
1309         }
1310     }
1311
1312     /* 5 ms redundant frame for SILK->CELT */
1313     if (redundancy && !celt_to_silk)
1314     {
1315         int err;
1316         unsigned char dummy[2];
1317         int N2, N4;
1318         N2 = st->Fs/200;
1319         N4 = st->Fs/400;
1320
1321         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1322         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1323         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1324
1325         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1326         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(extra_buffer+frame_size-N2-N4), N4, dummy, 2, NULL);
1327
1328         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(extra_buffer+frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1329         if (err < 0)
1330         {
1331            RESTORE_STACK;
1332            return OPUS_INTERNAL_ERROR;
1333         }
1334         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1335     }
1336
1337
1338
1339     /* Signalling the mode in the first byte */
1340     data--;
1341     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1342
1343     st->rangeFinal = enc.rng ^ redundant_rng;
1344
1345     if (to_celt)
1346         st->prev_mode = MODE_CELT_ONLY;
1347     else
1348         st->prev_mode = st->mode;
1349     st->prev_channels = st->stream_channels;
1350     st->prev_framesize = frame_size;
1351
1352     st->first = 0;
1353
1354     /* In the unlikely case that the SILK encoder busted its target, tell
1355        the decoder to call the PLC */
1356     if (ec_tell(&enc) > (max_data_bytes-1)*8)
1357     {
1358        if (max_data_bytes < 2)
1359        {
1360           RESTORE_STACK;
1361           return OPUS_BUFFER_TOO_SMALL;
1362        }
1363        data[1] = 0;
1364        ret = 1;
1365        st->rangeFinal = 0;
1366     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
1367     {
1368        /*When in LPC only mode it's perfectly
1369          reasonable to strip off trailing zero bytes as
1370          the required range decoder behavior is to
1371          fill these in. This can't be done when the MDCT
1372          modes are used because the decoder needs to know
1373          the actual length for allocation purposes.*/
1374        while(ret>2&&data[ret]==0)ret--;
1375     }
1376     /* Count ToC and redundancy */
1377     ret += 1+redundancy_bytes;
1378     if (!st->use_vbr && ret >= 3)
1379     {
1380        if (pad_frame(data, ret, max_data_bytes))
1381        {
1382           RESTORE_STACK;
1383           return OPUS_INTERNAL_ERROR;
1384        }
1385        ret = max_data_bytes;
1386     }
1387     RESTORE_STACK;
1388     return ret;
1389 }
1390
1391 #ifdef FIXED_POINT
1392
1393 #ifndef DISABLE_FLOAT_API
1394 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1395       unsigned char *data, opus_int32 max_data_bytes)
1396 {
1397    int i, ret;
1398    VARDECL(opus_int16, in);
1399    ALLOC_STACK;
1400
1401    if(frame_size<0)
1402    {
1403       RESTORE_STACK;
1404       return OPUS_BAD_ARG;
1405    }
1406
1407    ALLOC(in, frame_size*st->channels, opus_int16);
1408
1409    for (i=0;i<frame_size*st->channels;i++)
1410       in[i] = FLOAT2INT16(pcm[i]);
1411    ret = opus_encode(st, in, frame_size, data, max_data_bytes);
1412    RESTORE_STACK;
1413    return ret;
1414 }
1415 #endif
1416
1417 #else
1418 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1419       unsigned char *data, opus_int32 max_data_bytes)
1420 {
1421    int i, ret;
1422    VARDECL(float, in);
1423    ALLOC_STACK;
1424
1425    ALLOC(in, frame_size*st->channels, float);
1426
1427    for (i=0;i<frame_size*st->channels;i++)
1428       in[i] = (1.0f/32768)*pcm[i];
1429    ret = opus_encode_float(st, in, frame_size, data, max_data_bytes);
1430    RESTORE_STACK;
1431    return ret;
1432 }
1433 #endif
1434
1435
1436 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
1437 {
1438     int ret;
1439     CELTEncoder *celt_enc;
1440     va_list ap;
1441
1442     ret = OPUS_OK;
1443     va_start(ap, request);
1444
1445     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1446
1447     switch (request)
1448     {
1449         case OPUS_SET_APPLICATION_REQUEST:
1450         {
1451             opus_int32 value = va_arg(ap, opus_int32);
1452             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
1453                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1454                || (!st->first && st->application != value))
1455             {
1456                ret = OPUS_BAD_ARG;
1457                break;
1458             }
1459             st->application = value;
1460         }
1461         break;
1462         case OPUS_GET_APPLICATION_REQUEST:
1463         {
1464             opus_int32 *value = va_arg(ap, opus_int32*);
1465             *value = st->application;
1466         }
1467         break;
1468         case OPUS_SET_BITRATE_REQUEST:
1469         {
1470             opus_int32 value = va_arg(ap, opus_int32);
1471             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1472             {
1473                 if (value <= 0)
1474                     goto bad_arg;
1475                 else if (value <= 500)
1476                     value = 500;
1477                 else if (value > (opus_int32)300000*st->channels)
1478                     value = (opus_int32)300000*st->channels;
1479             }
1480             st->user_bitrate_bps = value;
1481         }
1482         break;
1483         case OPUS_GET_BITRATE_REQUEST:
1484         {
1485             opus_int32 *value = va_arg(ap, opus_int32*);
1486             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
1487         }
1488         break;
1489         case OPUS_SET_FORCE_CHANNELS_REQUEST:
1490         {
1491             opus_int32 value = va_arg(ap, opus_int32);
1492             if((value<1 || value>st->channels) && value != OPUS_AUTO)
1493                 return OPUS_BAD_ARG;
1494             st->force_channels = value;
1495         }
1496         break;
1497         case OPUS_GET_FORCE_CHANNELS_REQUEST:
1498         {
1499             opus_int32 *value = va_arg(ap, opus_int32*);
1500             *value = st->force_channels;
1501         }
1502         break;
1503         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
1504         {
1505             opus_int32 value = va_arg(ap, opus_int32);
1506             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND)
1507                 return OPUS_BAD_ARG;
1508             st->max_bandwidth = value;
1509             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1510                 st->silk_mode.maxInternalSampleRate = 8000;
1511             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1512                 st->silk_mode.maxInternalSampleRate = 12000;
1513             } else {
1514                 st->silk_mode.maxInternalSampleRate = 16000;
1515             }
1516         }
1517         break;
1518         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
1519         {
1520             opus_int32 *value = va_arg(ap, opus_int32*);
1521             *value = st->max_bandwidth;
1522         }
1523         break;
1524         case OPUS_SET_BANDWIDTH_REQUEST:
1525         {
1526             opus_int32 value = va_arg(ap, opus_int32);
1527             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
1528                 return OPUS_BAD_ARG;
1529             st->user_bandwidth = value;
1530             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1531                 st->silk_mode.maxInternalSampleRate = 8000;
1532             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1533                 st->silk_mode.maxInternalSampleRate = 12000;
1534             } else {
1535                 st->silk_mode.maxInternalSampleRate = 16000;
1536             }
1537         }
1538         break;
1539         case OPUS_GET_BANDWIDTH_REQUEST:
1540         {
1541             opus_int32 *value = va_arg(ap, opus_int32*);
1542             *value = st->bandwidth;
1543         }
1544         break;
1545         case OPUS_SET_DTX_REQUEST:
1546         {
1547             opus_int32 value = va_arg(ap, opus_int32);
1548             if(value<0 || value>1)
1549                 return OPUS_BAD_ARG;
1550             st->silk_mode.useDTX = value;
1551         }
1552         break;
1553         case OPUS_GET_DTX_REQUEST:
1554         {
1555             opus_int32 *value = va_arg(ap, opus_int32*);
1556             *value = st->silk_mode.useDTX;
1557         }
1558         break;
1559         case OPUS_SET_COMPLEXITY_REQUEST:
1560         {
1561             opus_int32 value = va_arg(ap, opus_int32);
1562             if(value<0 || value>10)
1563                 return OPUS_BAD_ARG;
1564             st->silk_mode.complexity = value;
1565             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
1566         }
1567         break;
1568         case OPUS_GET_COMPLEXITY_REQUEST:
1569         {
1570             opus_int32 *value = va_arg(ap, opus_int32*);
1571             *value = st->silk_mode.complexity;
1572         }
1573         break;
1574         case OPUS_SET_INBAND_FEC_REQUEST:
1575         {
1576             opus_int32 value = va_arg(ap, opus_int32);
1577             if(value<0 || value>1)
1578                 return OPUS_BAD_ARG;
1579             st->silk_mode.useInBandFEC = value;
1580         }
1581         break;
1582         case OPUS_GET_INBAND_FEC_REQUEST:
1583         {
1584             opus_int32 *value = va_arg(ap, opus_int32*);
1585             *value = st->silk_mode.useInBandFEC;
1586         }
1587         break;
1588         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1589         {
1590             opus_int32 value = va_arg(ap, opus_int32);
1591             if (value < 0 || value > 100)
1592                 return OPUS_BAD_ARG;
1593             st->silk_mode.packetLossPercentage = value;
1594             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
1595         }
1596         break;
1597         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1598         {
1599             opus_int32 *value = va_arg(ap, opus_int32*);
1600             *value = st->silk_mode.packetLossPercentage;
1601         }
1602         break;
1603         case OPUS_SET_VBR_REQUEST:
1604         {
1605             opus_int32 value = va_arg(ap, opus_int32);
1606             if(value<0 || value>1)
1607                 return OPUS_BAD_ARG;
1608             st->use_vbr = value;
1609             st->silk_mode.useCBR = 1-value;
1610         }
1611         break;
1612         case OPUS_GET_VBR_REQUEST:
1613         {
1614             opus_int32 *value = va_arg(ap, opus_int32*);
1615             *value = st->use_vbr;
1616         }
1617         break;
1618         case OPUS_SET_VOICE_RATIO_REQUEST:
1619         {
1620             opus_int32 value = va_arg(ap, opus_int32);
1621             if (value>100 || value<-1)
1622                 goto bad_arg;
1623             st->voice_ratio = value;
1624         }
1625         break;
1626         case OPUS_GET_VOICE_RATIO_REQUEST:
1627         {
1628             opus_int32 *value = va_arg(ap, opus_int32*);
1629             *value = st->voice_ratio;
1630         }
1631         break;
1632         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1633         {
1634             opus_int32 value = va_arg(ap, opus_int32);
1635             if(value<0 || value>1)
1636                 return OPUS_BAD_ARG;
1637             st->vbr_constraint = value;
1638         }
1639         break;
1640         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1641         {
1642             opus_int32 *value = va_arg(ap, opus_int32*);
1643             *value = st->vbr_constraint;
1644         }
1645         break;
1646         case OPUS_SET_SIGNAL_REQUEST:
1647         {
1648             opus_int32 value = va_arg(ap, opus_int32);
1649             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
1650                 return OPUS_BAD_ARG;
1651             st->signal_type = value;
1652         }
1653         break;
1654         case OPUS_GET_SIGNAL_REQUEST:
1655         {
1656             opus_int32 *value = va_arg(ap, opus_int32*);
1657             *value = st->signal_type;
1658         }
1659         break;
1660         case OPUS_GET_LOOKAHEAD_REQUEST:
1661         {
1662             opus_int32 *value = va_arg(ap, opus_int32*);
1663             *value = st->Fs/400;
1664             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1665                 *value += st->delay_compensation;
1666         }
1667         break;
1668         case OPUS_GET_SAMPLE_RATE_REQUEST:
1669         {
1670             opus_int32 *value = va_arg(ap, opus_int32*);
1671             if (value==NULL)
1672             {
1673                 ret = OPUS_BAD_ARG;
1674                 break;
1675             }
1676             *value = st->Fs;
1677         }
1678         break;
1679         case OPUS_GET_FINAL_RANGE_REQUEST:
1680         {
1681             opus_uint32 *value = va_arg(ap, opus_uint32*);
1682             *value = st->rangeFinal;
1683         }
1684         break;
1685         case OPUS_SET_LSB_DEPTH_REQUEST:
1686         {
1687             opus_int32 value = va_arg(ap, opus_int32);
1688             ret = celt_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(value));
1689         }
1690         break;
1691         case OPUS_GET_LSB_DEPTH_REQUEST:
1692         {
1693             opus_int32 *value = va_arg(ap, opus_int32*);
1694             celt_encoder_ctl(celt_enc, OPUS_GET_LSB_DEPTH(value));
1695         }
1696         break;
1697         case OPUS_RESET_STATE:
1698         {
1699            void *silk_enc;
1700            silk_EncControlStruct dummy;
1701            silk_enc = (char*)st+st->silk_enc_offset;
1702
1703            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
1704                  sizeof(OpusEncoder)-
1705                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
1706
1707            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1708            silk_InitEncoder( silk_enc, &dummy );
1709            st->stream_channels = st->channels;
1710            st->hybrid_stereo_width_Q14 = 1 << 14;
1711            st->prev_HB_gain = Q15ONE;
1712            st->first = 1;
1713            st->mode = MODE_HYBRID;
1714            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
1715            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1716         }
1717         break;
1718         case OPUS_SET_FORCE_MODE_REQUEST:
1719         {
1720             opus_int32 value = va_arg(ap, opus_int32);
1721             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
1722                goto bad_arg;
1723             st->user_forced_mode = value;
1724         }
1725         break;
1726         default:
1727             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
1728             ret = OPUS_UNIMPLEMENTED;
1729             break;
1730     }
1731     va_end(ap);
1732     return ret;
1733 bad_arg:
1734     va_end(ap);
1735     return OPUS_BAD_ARG;
1736 }
1737
1738 void opus_encoder_destroy(OpusEncoder *st)
1739 {
1740     opus_free(st);
1741 }