Tweaks the CELT fractional resampling delay to get perfect alignment
[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, int len, int 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, int max_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, int max_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     VARDECL(opus_val16, tmp_prefill);
472
473     ALLOC_STACK;
474
475     max_data_bytes = IMIN(1276, max_data_bytes);
476
477     st->rangeFinal = 0;
478     if (400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
479          50*frame_size != st->Fs &&  25*frame_size != st->Fs &&  50*frame_size != 3*st->Fs)
480     {
481        RESTORE_STACK;
482        return OPUS_BAD_ARG;
483     }
484     if (max_data_bytes<=0)
485     {
486        RESTORE_STACK;
487        return OPUS_BAD_ARG;
488     }
489     silk_enc = (char*)st+st->silk_enc_offset;
490     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
491
492     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
493        delay_compensation = 0;
494     else
495        delay_compensation = st->delay_compensation;
496
497     st->bitrate_bps = user_bitrate_to_bitrate(st, frame_size, max_data_bytes);
498
499     frame_rate = st->Fs/frame_size;
500     if (max_data_bytes<3 || st->bitrate_bps < 3*frame_rate*8
501        || (frame_rate<50 && (max_data_bytes*frame_rate<300 || st->bitrate_bps < 2400)))
502     {
503        int tocmode = st->mode;
504        if (tocmode==0)
505           tocmode = MODE_SILK_ONLY;
506        if (frame_rate>100)
507           tocmode = MODE_CELT_ONLY;
508        if (frame_rate < 50)
509           tocmode = MODE_SILK_ONLY;
510        data[0] = gen_toc(tocmode, frame_rate,
511                          st->bandwidth == 0 ? OPUS_BANDWIDTH_NARROWBAND : st->bandwidth,
512                          st->stream_channels);
513        RESTORE_STACK;
514        return 1;
515     }
516     if (!st->use_vbr)
517     {
518        int cbrBytes;
519        cbrBytes = IMIN( (st->bitrate_bps + 4*frame_rate)/(8*frame_rate) , max_data_bytes);
520        st->bitrate_bps = cbrBytes * (8*frame_rate);
521        max_data_bytes = cbrBytes;
522     }
523     max_rate = frame_rate*max_data_bytes*8;
524
525     /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */
526     equiv_rate = st->bitrate_bps - 60*(st->Fs/frame_size - 50);
527
528     if (st->signal_type == OPUS_SIGNAL_VOICE)
529        voice_est = 127;
530     else if (st->signal_type == OPUS_SIGNAL_MUSIC)
531        voice_est = 0;
532     else if (st->voice_ratio >= 0)
533        voice_est = st->voice_ratio*327>>8;
534     else if (st->application == OPUS_APPLICATION_VOIP)
535        voice_est = 115;
536     else
537        voice_est = 48;
538
539     if (st->force_channels!=OPUS_AUTO && st->channels == 2)
540     {
541         st->stream_channels = st->force_channels;
542     } else {
543 #ifdef FUZZING
544        /* Random mono/stereo decision */
545        if (st->channels == 2 && (rand()&0x1F)==0)
546           st->stream_channels = 3-st->stream_channels;
547 #else
548        /* Rate-dependent mono-stereo decision */
549        if (st->channels == 2)
550        {
551           opus_int32 stereo_threshold;
552           stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14);
553           if (st->stream_channels == 2)
554              stereo_threshold -= 4000;
555           else
556              stereo_threshold += 4000;
557           st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1;
558        } else {
559           st->stream_channels = st->channels;
560        }
561 #endif
562     }
563
564     /* Mode selection depending on application and signal type */
565     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
566     {
567        st->mode = MODE_CELT_ONLY;
568     } else if (st->user_forced_mode == OPUS_AUTO)
569     {
570 #ifdef FUZZING
571        /* Random mode switching */
572        if ((rand()&0xF)==0)
573        {
574           if ((rand()&0x1)==0)
575              st->mode = MODE_CELT_ONLY;
576           else
577              st->mode = MODE_SILK_ONLY;
578        } else {
579           if (st->prev_mode==MODE_CELT_ONLY)
580              st->mode = MODE_CELT_ONLY;
581           else
582              st->mode = MODE_SILK_ONLY;
583        }
584 #else
585        int chan;
586        opus_int32 mode_voice, mode_music;
587        opus_int32 threshold;
588
589        chan = (st->channels==2) && st->force_channels!=1;
590        mode_voice = mode_thresholds[chan][0];
591        mode_music = mode_thresholds[chan][1];
592        threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14);
593
594        /* Hysteresis */
595        if (st->prev_mode == MODE_CELT_ONLY)
596            threshold -= 4000;
597        else if (st->prev_mode>0)
598            threshold += 4000;
599
600        st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY;
601
602        /* When FEC is enabled and there's enough packet loss, use SILK */
603        if (st->silk_mode.useInBandFEC && st->silk_mode.packetLossPercentage > (128-voice_est)>>4)
604           st->mode = MODE_SILK_ONLY;
605        /* When encoding voice and DTX is enabled, set the encoder to SILK mode (at least for now) */
606        if (st->silk_mode.useDTX && voice_est > 100)
607           st->mode = MODE_SILK_ONLY;
608 #endif
609     } else {
610        st->mode = st->user_forced_mode;
611     }
612
613     /* Override the chosen mode to make sure we meet the requested frame size */
614     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
615        st->mode = MODE_CELT_ONLY;
616
617     if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0
618           && st->mode != MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)
619     {
620        /* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */
621        st->silk_mode.toMono = 1;
622        st->stream_channels = 2;
623     } else {
624        st->silk_mode.toMono = 0;
625     }
626
627     if (st->prev_mode > 0 &&
628         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
629     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
630     {
631         redundancy = 1;
632         celt_to_silk = (st->mode != MODE_CELT_ONLY);
633         if (!celt_to_silk)
634         {
635             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
636             if (frame_size >= st->Fs/100)
637             {
638                 st->mode = st->prev_mode;
639                 to_celt = 1;
640             } else {
641                 redundancy=0;
642             }
643         }
644     }
645     if (st->silk_bw_switch)
646     {
647        redundancy = 1;
648        celt_to_silk = 1;
649        st->silk_bw_switch = 0;
650     }
651
652     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
653     {
654         silk_EncControlStruct dummy;
655         silk_InitEncoder( silk_enc, &dummy);
656         prefill=1;
657     }
658
659     /* Automatic (rate-dependent) bandwidth selection */
660     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
661     {
662         const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds;
663         opus_int32 bandwidth_thresholds[8];
664         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
665         opus_int32 equiv_rate2;
666
667         equiv_rate2 = equiv_rate;
668         if (st->mode != MODE_CELT_ONLY)
669         {
670            /* Adjust the threshold +/- 10% depending on complexity */
671            equiv_rate2 = equiv_rate2 * (45+st->silk_mode.complexity)/50;
672            /* CBR is less efficient by ~1 kb/s */
673            if (!st->use_vbr)
674               equiv_rate2 -= 1000;
675         }
676         if (st->channels==2 && st->force_channels!=1)
677         {
678            voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds;
679            music_bandwidth_thresholds = stereo_music_bandwidth_thresholds;
680         } else {
681            voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds;
682            music_bandwidth_thresholds = mono_music_bandwidth_thresholds;
683         }
684         /* Interpolate bandwidth thresholds depending on voice estimation */
685         for (i=0;i<8;i++)
686         {
687            bandwidth_thresholds[i] = music_bandwidth_thresholds[i]
688                     + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14);
689         }
690         do {
691             int threshold, hysteresis;
692             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
693             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
694             if (!st->first)
695             {
696                 if (st->bandwidth >= bandwidth)
697                     threshold -= hysteresis;
698                 else
699                     threshold += hysteresis;
700             }
701             if (equiv_rate2 >= threshold)
702                 break;
703         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
704         st->bandwidth = bandwidth;
705         /* Prevents any transition to SWB/FB until the SILK layer has fully
706            switched to WB mode and turned the variable LP filter off */
707         if (!st->first && st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
708             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
709     }
710
711     if (st->bandwidth>st->max_bandwidth)
712        st->bandwidth = st->max_bandwidth;
713
714     if (st->user_bandwidth != OPUS_AUTO)
715         st->bandwidth = st->user_bandwidth;
716
717     /* This prevents us from using hybrid at unsafe CBR/max rates */
718     if (st->mode != MODE_CELT_ONLY && max_rate < 15000)
719     {
720        st->bandwidth = IMIN(st->bandwidth, OPUS_BANDWIDTH_WIDEBAND);
721     }
722
723     /* Prevents Opus from wasting bits on frequencies that are above
724        the Nyquist rate of the input signal */
725     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
726         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
727     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
728         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
729     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
730         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
731     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
732         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
733
734     /* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */
735     if (max_data_bytes < (frame_rate > 50 ? 12000 : 8000)*frame_size / (st->Fs * 8))
736        st->mode = MODE_CELT_ONLY;
737
738     /* CELT mode doesn't support mediumband, use wideband instead */
739     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
740         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
741
742     /* Can't support higher than wideband for >20 ms frames */
743     if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND))
744     {
745        VARDECL(unsigned char, tmp_data);
746        int nb_frames;
747        int bak_mode, bak_bandwidth, bak_channels, bak_to_mono;
748        OpusRepacketizer rp;
749        int bytes_per_frame;
750
751
752        nb_frames = frame_size > st->Fs/25 ? 3 : 2;
753        bytes_per_frame = max_data_bytes/nb_frames-3;
754
755        ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char);
756
757        opus_repacketizer_init(&rp);
758
759        bak_mode = st->user_forced_mode;
760        bak_bandwidth = st->user_bandwidth;
761        bak_channels = st->force_channels;
762
763        st->user_forced_mode = st->mode;
764        st->user_bandwidth = st->bandwidth;
765        st->force_channels = st->stream_channels;
766        bak_to_mono = st->silk_mode.toMono;
767
768        if (bak_to_mono)
769           st->force_channels = 1;
770        else
771           st->prev_channels = st->stream_channels;
772        for (i=0;i<nb_frames;i++)
773        {
774           int tmp_len;
775           st->silk_mode.toMono = 0;
776           /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
777           if (to_celt && i==nb_frames-1)
778              st->user_forced_mode = MODE_CELT_ONLY;
779           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);
780           if (tmp_len<0)
781              return OPUS_INTERNAL_ERROR;
782           ret = opus_repacketizer_cat(&rp, tmp_data+i*bytes_per_frame, tmp_len);
783           if (ret<0)
784              return OPUS_INTERNAL_ERROR;
785        }
786        ret = opus_repacketizer_out(&rp, data, max_data_bytes);
787        if (ret<0)
788           return OPUS_INTERNAL_ERROR;
789
790        st->user_forced_mode = bak_mode;
791        st->user_bandwidth = bak_bandwidth;
792        st->force_channels = bak_channels;
793        st->silk_mode.toMono = bak_to_mono;
794        RESTORE_STACK;
795        return ret;
796     }
797
798     curr_bandwidth = st->bandwidth;
799
800     /* Chooses the appropriate mode for speech
801        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
802     if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND)
803         st->mode = MODE_HYBRID;
804     if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
805         st->mode = MODE_SILK_ONLY;
806
807     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
808     bytes_target = IMIN(max_data_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
809
810     data += 1;
811
812     ec_enc_init(&enc, data, max_data_bytes-1);
813
814     ALLOC(pcm_buf, (delay_compensation+frame_size)*st->channels, opus_val16);
815     for (i=0;i<delay_compensation*st->channels;i++)
816        pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-delay_compensation)*st->channels+i];
817
818     if (st->mode == MODE_CELT_ONLY)
819        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
820     else
821        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
822
823     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
824           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
825
826     /* convert from log scale to Hertz */
827     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
828
829     if (st->application == OPUS_APPLICATION_VOIP)
830     {
831        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[delay_compensation*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
832     } else {
833        for (i=0;i<frame_size*st->channels;i++)
834           pcm_buf[delay_compensation*st->channels + i] = pcm[i];
835     }
836
837     /* SILK processing */
838     if (st->mode != MODE_CELT_ONLY)
839     {
840 #ifdef FIXED_POINT
841        const opus_int16 *pcm_silk;
842 #else
843        VARDECL(opus_int16, pcm_silk);
844        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
845 #endif
846         st->silk_mode.bitRate = 8*bytes_target*frame_rate;
847         if( st->mode == MODE_HYBRID ) {
848             st->silk_mode.bitRate /= st->stream_channels;
849             if( curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
850                 if( st->Fs == 100 * frame_size ) {
851                     /* 24 kHz, 10 ms */
852                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 2000 + st->use_vbr * 1000 ) * 2 ) / 3;
853                 } else {
854                     /* 24 kHz, 20 ms */
855                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 1000 + st->use_vbr * 1000 ) * 2 ) / 3;
856                 }
857             } else {
858                 if( st->Fs == 100 * frame_size ) {
859                     /* 48 kHz, 10 ms */
860                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 8000 + st->use_vbr * 3000 ) / 2;
861                 } else {
862                     /* 48 kHz, 20 ms */
863                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 9000 + st->use_vbr * 1000 ) / 2;
864                 }
865             }
866             st->silk_mode.bitRate *= st->stream_channels;
867             /* don't let SILK use more than 80% */
868             if( st->silk_mode.bitRate > ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5 ) {
869                 st->silk_mode.bitRate = ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5;
870             }
871         }
872
873         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
874         st->silk_mode.nChannelsAPI = st->channels;
875         st->silk_mode.nChannelsInternal = st->stream_channels;
876         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
877             st->silk_mode.desiredInternalSampleRate = 8000;
878         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
879             st->silk_mode.desiredInternalSampleRate = 12000;
880         } else {
881             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
882             st->silk_mode.desiredInternalSampleRate = 16000;
883         }
884         if( st->mode == MODE_HYBRID ) {
885             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
886             st->silk_mode.minInternalSampleRate = 16000;
887         } else {
888             st->silk_mode.minInternalSampleRate = 8000;
889         }
890
891         if (st->mode == MODE_SILK_ONLY)
892         {
893            opus_int32 effective_max_rate = max_rate;
894            st->silk_mode.maxInternalSampleRate = 16000;
895            if (frame_rate > 50)
896               effective_max_rate = effective_max_rate*2/3;
897            if (effective_max_rate < 13000)
898            {
899               st->silk_mode.maxInternalSampleRate = 12000;
900               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
901            }
902            if (effective_max_rate < 9600)
903            {
904               st->silk_mode.maxInternalSampleRate = 8000;
905               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
906            }
907         } else {
908            st->silk_mode.maxInternalSampleRate = 16000;
909         }
910
911         st->silk_mode.useCBR = !st->use_vbr;
912
913         /* Call SILK encoder for the low band */
914         nBytes = IMIN(1275, max_data_bytes-1);
915
916         st->silk_mode.maxBits = nBytes*8;
917         /* Only allow up to 90% of the bits for hybrid mode*/
918         if (st->mode == MODE_HYBRID)
919            st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
920         if (st->silk_mode.useCBR)
921         {
922            st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
923            /* Reduce the initial target to make it easier to reach the CBR rate */
924            st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000);
925         }
926         if (redundancy)
927            st->silk_mode.maxBits -= st->silk_mode.maxBits/(1 + frame_size/(st->Fs/200));
928
929         if (prefill)
930         {
931             int zero=0;
932 #ifdef FIXED_POINT
933             pcm_silk = st->delay_buffer;
934 #else
935             for (i=0;i<st->encoder_buffer*st->channels;i++)
936                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
937 #endif
938             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
939         }
940
941 #ifdef FIXED_POINT
942         pcm_silk = pcm_buf+delay_compensation*st->channels;
943 #else
944         for (i=0;i<frame_size*st->channels;i++)
945             pcm_silk[i] = FLOAT2INT16(pcm_buf[delay_compensation*st->channels + i]);
946 #endif
947         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
948         if( ret ) {
949             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
950             /* Handle error */
951            return OPUS_INTERNAL_ERROR;
952         }
953         if (nBytes==0)
954         {
955            st->rangeFinal = 0;
956            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
957            RESTORE_STACK;
958            return 1;
959         }
960         /* Extract SILK internal bandwidth for signaling in first byte */
961         if( st->mode == MODE_SILK_ONLY ) {
962             if( st->silk_mode.internalSampleRate == 8000 ) {
963                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
964             } else if( st->silk_mode.internalSampleRate == 12000 ) {
965                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
966             } else if( st->silk_mode.internalSampleRate == 16000 ) {
967                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
968             }
969         } else {
970             silk_assert( st->silk_mode.internalSampleRate == 16000 );
971         }
972
973         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
974         if (st->silk_mode.opusCanSwitch)
975         {
976            redundancy = 1;
977            celt_to_silk = 0;
978            st->silk_bw_switch = 1;
979         }
980     }
981
982     /* CELT processing */
983     {
984         int endband=21;
985
986         switch(curr_bandwidth)
987         {
988             case OPUS_BANDWIDTH_NARROWBAND:
989                 endband = 13;
990                 break;
991             case OPUS_BANDWIDTH_MEDIUMBAND:
992             case OPUS_BANDWIDTH_WIDEBAND:
993                 endband = 17;
994                 break;
995             case OPUS_BANDWIDTH_SUPERWIDEBAND:
996                 endband = 19;
997                 break;
998             case OPUS_BANDWIDTH_FULLBAND:
999                 endband = 21;
1000                 break;
1001         }
1002         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
1003         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
1004     }
1005     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1006     if (st->mode != MODE_SILK_ONLY)
1007     {
1008         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1009         /* Allow prediction unless we decide to disable it later */
1010         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
1011
1012         if (st->mode == MODE_HYBRID)
1013         {
1014             int len;
1015
1016             len = (ec_tell(&enc)+7)>>3;
1017             if (redundancy)
1018                len += st->mode == MODE_HYBRID ? 3 : 1;
1019             if( st->use_vbr ) {
1020                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
1021             } else {
1022                 /* check if SILK used up too much */
1023                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
1024             }
1025         } else {
1026             if (st->use_vbr)
1027             {
1028                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
1029                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
1030                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps));
1031                 nb_compr_bytes = max_data_bytes-1;
1032             } else {
1033                 nb_compr_bytes = bytes_target;
1034             }
1035         }
1036
1037     } else {
1038         nb_compr_bytes = 0;
1039     }
1040
1041     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
1042     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
1043     {
1044        for (i=0;i<st->channels*st->Fs/400;i++)
1045           tmp_prefill[i] = st->delay_buffer[(st->encoder_buffer-st->delay_compensation-st->Fs/400)*st->channels + i];
1046     }
1047
1048     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+delay_compensation));i++)
1049         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
1050     for (;i<st->encoder_buffer*st->channels;i++)
1051         st->delay_buffer[i] = pcm_buf[(frame_size+delay_compensation-st->encoder_buffer)*st->channels+i];
1052
1053
1054     if (st->mode != MODE_HYBRID || st->stream_channels==1)
1055        st->silk_mode.stereoWidth_Q14 = 1<<14;
1056     if( st->channels == 2 ) {
1057         /* Apply stereo width reduction (at low bitrates) */
1058         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1059             opus_val16 g1, g2;
1060             const CELTMode *celt_mode;
1061
1062             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1063             g1 = st->hybrid_stereo_width_Q14;
1064             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1065 #ifdef FIXED_POINT
1066             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
1067             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
1068 #else
1069             g1 *= (1./16384);
1070             g2 *= (1./16384);
1071 #endif
1072             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
1073                   frame_size, st->channels, celt_mode->window, st->Fs);
1074             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1075         }
1076     }
1077
1078     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
1079     {
1080         /* For SILK mode, the redundancy is inferred from the length */
1081         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
1082            ec_enc_bit_logp(&enc, redundancy, 12);
1083         if (redundancy)
1084         {
1085             int max_redundancy;
1086             ec_enc_bit_logp(&enc, celt_to_silk, 1);
1087             if (st->mode == MODE_HYBRID)
1088                max_redundancy = (max_data_bytes-1)-nb_compr_bytes-1;
1089             else
1090                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1091             /* Target the same bit-rate for redundancy as for the rest,
1092                up to a max of 257 bytes */
1093             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
1094             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
1095             if (st->mode == MODE_HYBRID)
1096                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
1097         }
1098     } else {
1099         redundancy = 0;
1100     }
1101
1102     if (!redundancy)
1103        st->silk_bw_switch = 0;
1104
1105     if (st->mode != MODE_CELT_ONLY)start_band=17;
1106
1107     if (st->mode == MODE_SILK_ONLY)
1108     {
1109         ret = (ec_tell(&enc)+7)>>3;
1110         ec_enc_done(&enc);
1111         nb_compr_bytes = ret;
1112     } else {
1113        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
1114        ec_enc_shrink(&enc, nb_compr_bytes);
1115     }
1116
1117
1118     /* 5 ms redundant frame for CELT->SILK */
1119     if (redundancy && celt_to_silk)
1120     {
1121         int err;
1122         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1123         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1124         err = celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
1125         if (err < 0)
1126             return OPUS_INTERNAL_ERROR;
1127         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1128         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1129     }
1130
1131     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
1132
1133     if (st->mode != MODE_SILK_ONLY)
1134     {
1135         if (st->mode != st->prev_mode && st->prev_mode > 0)
1136         {
1137            unsigned char dummy[2];
1138            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1139
1140            /* Prefilling */
1141            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
1142            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1143         }
1144         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
1145         if (ec_tell(&enc) <= 8*nb_compr_bytes)
1146         {
1147            ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
1148            if (ret < 0)
1149               return OPUS_INTERNAL_ERROR;
1150         }
1151     }
1152
1153     /* 5 ms redundant frame for SILK->CELT */
1154     if (redundancy && !celt_to_silk)
1155     {
1156         int err;
1157         unsigned char dummy[2];
1158         int N2, N4;
1159         N2 = st->Fs/200;
1160         N4 = st->Fs/400;
1161
1162         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1163         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1164         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1165
1166         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1167         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL);
1168
1169         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1170         if (err < 0)
1171             return OPUS_INTERNAL_ERROR;
1172         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1173     }
1174
1175
1176
1177     /* Signalling the mode in the first byte */
1178     data--;
1179     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1180
1181     st->rangeFinal = enc.rng ^ redundant_rng;
1182
1183     if (to_celt)
1184         st->prev_mode = MODE_CELT_ONLY;
1185     else
1186         st->prev_mode = st->mode;
1187     st->prev_channels = st->stream_channels;
1188     st->prev_framesize = frame_size;
1189
1190     st->first = 0;
1191
1192     /* In the unlikely case that the SILK encoder busted its target, tell
1193        the decoder to call the PLC */
1194     if (ec_tell(&enc) > (max_data_bytes-1)*8)
1195     {
1196        data[1] = 0;
1197        ret = 1;
1198        st->rangeFinal = 0;
1199     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
1200     {
1201        /*When in LPC only mode it's perfectly
1202          reasonable to strip off trailing zero bytes as
1203          the required range decoder behavior is to
1204          fill these in. This can't be done when the MDCT
1205          modes are used because the decoder needs to know
1206          the actual length for allocation purposes.*/
1207        while(ret>2&&data[ret]==0)ret--;
1208     }
1209     /* Count ToC and redundancy */
1210     ret += 1+redundancy_bytes;
1211     if (!st->use_vbr && ret >= 3)
1212     {
1213        if (pad_frame(data, ret, max_data_bytes))
1214           return OPUS_INTERNAL_ERROR;
1215        ret = max_data_bytes;
1216     }
1217     RESTORE_STACK;
1218     return ret;
1219 }
1220
1221 #ifdef FIXED_POINT
1222
1223 #ifndef DISABLE_FLOAT_API
1224 int opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1225       unsigned char *data, int max_data_bytes)
1226 {
1227    int i, ret;
1228    VARDECL(opus_int16, in);
1229    ALLOC_STACK;
1230
1231    if(frame_size<0)return OPUS_BAD_ARG;
1232
1233    ALLOC(in, frame_size*st->channels, opus_int16);
1234
1235    for (i=0;i<frame_size*st->channels;i++)
1236       in[i] = FLOAT2INT16(pcm[i]);
1237    ret = opus_encode(st, in, frame_size, data, max_data_bytes);
1238    RESTORE_STACK;
1239    return ret;
1240 }
1241 #endif
1242
1243 #else
1244 int opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1245       unsigned char *data, int max_data_bytes)
1246 {
1247    int i, ret;
1248    VARDECL(float, in);
1249    ALLOC_STACK;
1250
1251    ALLOC(in, frame_size*st->channels, float);
1252
1253    for (i=0;i<frame_size*st->channels;i++)
1254       in[i] = (1.0f/32768)*pcm[i];
1255    ret = opus_encode_float(st, in, frame_size, data, max_data_bytes);
1256    RESTORE_STACK;
1257    return ret;
1258 }
1259 #endif
1260
1261
1262 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
1263 {
1264     int ret;
1265     CELTEncoder *celt_enc;
1266     va_list ap;
1267
1268     ret = OPUS_OK;
1269     va_start(ap, request);
1270
1271     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1272
1273     switch (request)
1274     {
1275         case OPUS_SET_APPLICATION_REQUEST:
1276         {
1277             opus_int32 value = va_arg(ap, opus_int32);
1278             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
1279                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1280                || (!st->first && st->application != value))
1281             {
1282                ret = OPUS_BAD_ARG;
1283                break;
1284             }
1285             st->application = value;
1286         }
1287         break;
1288         case OPUS_GET_APPLICATION_REQUEST:
1289         {
1290             opus_int32 *value = va_arg(ap, opus_int32*);
1291             *value = st->application;
1292         }
1293         break;
1294         case OPUS_SET_BITRATE_REQUEST:
1295         {
1296             opus_int32 value = va_arg(ap, opus_int32);
1297             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1298             {
1299                 if (value <= 0)
1300                     goto bad_arg;
1301                 else if (value <= 500)
1302                     value = 500;
1303                 else if (value > (opus_int32)300000*st->channels)
1304                     value = (opus_int32)300000*st->channels;
1305             }
1306             st->user_bitrate_bps = value;
1307         }
1308         break;
1309         case OPUS_GET_BITRATE_REQUEST:
1310         {
1311             opus_int32 *value = va_arg(ap, opus_int32*);
1312             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
1313         }
1314         break;
1315         case OPUS_SET_FORCE_CHANNELS_REQUEST:
1316         {
1317             opus_int32 value = va_arg(ap, opus_int32);
1318             if((value<1 || value>st->channels) && value != OPUS_AUTO)
1319                 return OPUS_BAD_ARG;
1320             st->force_channels = value;
1321         }
1322         break;
1323         case OPUS_GET_FORCE_CHANNELS_REQUEST:
1324         {
1325             opus_int32 *value = va_arg(ap, opus_int32*);
1326             *value = st->force_channels;
1327         }
1328         break;
1329         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
1330         {
1331             opus_int32 value = va_arg(ap, opus_int32);
1332             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND)
1333                 return OPUS_BAD_ARG;
1334             st->max_bandwidth = value;
1335             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1336                 st->silk_mode.maxInternalSampleRate = 8000;
1337             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1338                 st->silk_mode.maxInternalSampleRate = 12000;
1339             } else {
1340                 st->silk_mode.maxInternalSampleRate = 16000;
1341             }
1342         }
1343         break;
1344         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
1345         {
1346             opus_int32 *value = va_arg(ap, opus_int32*);
1347             *value = st->max_bandwidth;
1348         }
1349         break;
1350         case OPUS_SET_BANDWIDTH_REQUEST:
1351         {
1352             opus_int32 value = va_arg(ap, opus_int32);
1353             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
1354                 return OPUS_BAD_ARG;
1355             st->user_bandwidth = value;
1356             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1357                 st->silk_mode.maxInternalSampleRate = 8000;
1358             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1359                 st->silk_mode.maxInternalSampleRate = 12000;
1360             } else {
1361                 st->silk_mode.maxInternalSampleRate = 16000;
1362             }
1363         }
1364         break;
1365         case OPUS_GET_BANDWIDTH_REQUEST:
1366         {
1367             opus_int32 *value = va_arg(ap, opus_int32*);
1368             *value = st->bandwidth;
1369         }
1370         break;
1371         case OPUS_SET_DTX_REQUEST:
1372         {
1373             opus_int32 value = va_arg(ap, opus_int32);
1374             if(value<0 || value>1)
1375                 return OPUS_BAD_ARG;
1376             st->silk_mode.useDTX = value;
1377         }
1378         break;
1379         case OPUS_GET_DTX_REQUEST:
1380         {
1381             opus_int32 *value = va_arg(ap, opus_int32*);
1382             *value = st->silk_mode.useDTX;
1383         }
1384         break;
1385         case OPUS_SET_COMPLEXITY_REQUEST:
1386         {
1387             opus_int32 value = va_arg(ap, opus_int32);
1388             if(value<0 || value>10)
1389                 return OPUS_BAD_ARG;
1390             st->silk_mode.complexity = value;
1391             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
1392         }
1393         break;
1394         case OPUS_GET_COMPLEXITY_REQUEST:
1395         {
1396             opus_int32 *value = va_arg(ap, opus_int32*);
1397             *value = st->silk_mode.complexity;
1398         }
1399         break;
1400         case OPUS_SET_INBAND_FEC_REQUEST:
1401         {
1402             opus_int32 value = va_arg(ap, opus_int32);
1403             if(value<0 || value>1)
1404                 return OPUS_BAD_ARG;
1405             st->silk_mode.useInBandFEC = value;
1406         }
1407         break;
1408         case OPUS_GET_INBAND_FEC_REQUEST:
1409         {
1410             opus_int32 *value = va_arg(ap, opus_int32*);
1411             *value = st->silk_mode.useInBandFEC;
1412         }
1413         break;
1414         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1415         {
1416             opus_int32 value = va_arg(ap, opus_int32);
1417             if (value < 0 || value > 100)
1418                 return OPUS_BAD_ARG;
1419             st->silk_mode.packetLossPercentage = value;
1420             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
1421         }
1422         break;
1423         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1424         {
1425             opus_int32 *value = va_arg(ap, opus_int32*);
1426             *value = st->silk_mode.packetLossPercentage;
1427         }
1428         break;
1429         case OPUS_SET_VBR_REQUEST:
1430         {
1431             opus_int32 value = va_arg(ap, opus_int32);
1432             if(value<0 || value>1)
1433                 return OPUS_BAD_ARG;
1434             st->use_vbr = value;
1435             st->silk_mode.useCBR = 1-value;
1436         }
1437         break;
1438         case OPUS_GET_VBR_REQUEST:
1439         {
1440             opus_int32 *value = va_arg(ap, opus_int32*);
1441             *value = st->use_vbr;
1442         }
1443         break;
1444         case OPUS_SET_VOICE_RATIO_REQUEST:
1445         {
1446             opus_int32 value = va_arg(ap, opus_int32);
1447             if (value>100 || value<-1)
1448                 goto bad_arg;
1449             st->voice_ratio = value;
1450         }
1451         break;
1452         case OPUS_GET_VOICE_RATIO_REQUEST:
1453         {
1454             opus_int32 *value = va_arg(ap, opus_int32*);
1455             *value = st->voice_ratio;
1456         }
1457         break;
1458         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1459         {
1460             opus_int32 value = va_arg(ap, opus_int32);
1461             if(value<0 || value>1)
1462                 return OPUS_BAD_ARG;
1463             st->vbr_constraint = value;
1464         }
1465         break;
1466         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1467         {
1468             opus_int32 *value = va_arg(ap, opus_int32*);
1469             *value = st->vbr_constraint;
1470         }
1471         break;
1472         case OPUS_SET_SIGNAL_REQUEST:
1473         {
1474             opus_int32 value = va_arg(ap, opus_int32);
1475             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
1476                 return OPUS_BAD_ARG;
1477             st->signal_type = value;
1478         }
1479         break;
1480         case OPUS_GET_SIGNAL_REQUEST:
1481         {
1482             opus_int32 *value = va_arg(ap, opus_int32*);
1483             *value = st->signal_type;
1484         }
1485         break;
1486         case OPUS_GET_LOOKAHEAD_REQUEST:
1487         {
1488             opus_int32 *value = va_arg(ap, opus_int32*);
1489             *value = st->Fs/400;
1490             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1491                 *value += st->delay_compensation;
1492         }
1493         break;
1494         case OPUS_GET_FINAL_RANGE_REQUEST:
1495         {
1496             opus_uint32 *value = va_arg(ap, opus_uint32*);
1497             *value = st->rangeFinal;
1498         }
1499         break;
1500         case OPUS_RESET_STATE:
1501         {
1502            void *silk_enc;
1503            silk_EncControlStruct dummy;
1504            silk_enc = (char*)st+st->silk_enc_offset;
1505
1506            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
1507                  sizeof(OpusEncoder)-
1508                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
1509
1510            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1511            silk_InitEncoder( silk_enc, &dummy );
1512            st->stream_channels = st->channels;
1513            st->hybrid_stereo_width_Q14 = 1 << 14;
1514            st->first = 1;
1515            st->mode = MODE_HYBRID;
1516            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
1517            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1518         }
1519         break;
1520         case OPUS_SET_FORCE_MODE_REQUEST:
1521         {
1522             opus_int32 value = va_arg(ap, opus_int32);
1523             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
1524                goto bad_arg;
1525             st->user_forced_mode = value;
1526         }
1527         break;
1528         default:
1529             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
1530             ret = OPUS_UNIMPLEMENTED;
1531             break;
1532     }
1533     va_end(ap);
1534     return ret;
1535 bad_arg:
1536     va_end(ap);
1537     return OPUS_BAD_ARG;
1538 }
1539
1540 void opus_encoder_destroy(OpusEncoder *st)
1541 {
1542     opus_free(st);
1543 }