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