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