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