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