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