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