Fixes int vs opus_int32 compile errors on C5x
[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 opus_int32 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     opus_int32 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           {
783              RESTORE_STACK;
784              return OPUS_INTERNAL_ERROR;
785           }
786           ret = opus_repacketizer_cat(&rp, tmp_data+i*bytes_per_frame, tmp_len);
787           if (ret<0)
788           {
789              RESTORE_STACK;
790              return OPUS_INTERNAL_ERROR;
791           }
792        }
793        ret = opus_repacketizer_out(&rp, data, out_data_bytes);
794        if (ret<0)
795        {
796           RESTORE_STACK;
797           return OPUS_INTERNAL_ERROR;
798        }
799        st->user_forced_mode = bak_mode;
800        st->user_bandwidth = bak_bandwidth;
801        st->force_channels = bak_channels;
802        st->silk_mode.toMono = bak_to_mono;
803        RESTORE_STACK;
804        return ret;
805     }
806
807     curr_bandwidth = st->bandwidth;
808
809     /* Chooses the appropriate mode for speech
810        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
811     if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND)
812         st->mode = MODE_HYBRID;
813     if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
814         st->mode = MODE_SILK_ONLY;
815
816     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
817     bytes_target = IMIN(max_data_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
818
819     data += 1;
820
821     ec_enc_init(&enc, data, max_data_bytes-1);
822
823     ALLOC(pcm_buf, (delay_compensation+frame_size)*st->channels, opus_val16);
824     for (i=0;i<delay_compensation*st->channels;i++)
825        pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-delay_compensation)*st->channels+i];
826
827     if (st->mode == MODE_CELT_ONLY)
828        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
829     else
830        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
831
832     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
833           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
834
835     /* convert from log scale to Hertz */
836     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
837
838     if (st->application == OPUS_APPLICATION_VOIP)
839     {
840        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[delay_compensation*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
841     } else {
842        for (i=0;i<frame_size*st->channels;i++)
843           pcm_buf[delay_compensation*st->channels + i] = pcm[i];
844     }
845
846     /* SILK processing */
847     if (st->mode != MODE_CELT_ONLY)
848     {
849 #ifdef FIXED_POINT
850        const opus_int16 *pcm_silk;
851 #else
852        VARDECL(opus_int16, pcm_silk);
853        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
854 #endif
855         st->silk_mode.bitRate = 8*bytes_target*frame_rate;
856         if( st->mode == MODE_HYBRID ) {
857             st->silk_mode.bitRate /= st->stream_channels;
858             if( curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
859                 if( st->Fs == 100 * frame_size ) {
860                     /* 24 kHz, 10 ms */
861                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 2000 + st->use_vbr * 1000 ) * 2 ) / 3;
862                 } else {
863                     /* 24 kHz, 20 ms */
864                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 1000 + st->use_vbr * 1000 ) * 2 ) / 3;
865                 }
866             } else {
867                 if( st->Fs == 100 * frame_size ) {
868                     /* 48 kHz, 10 ms */
869                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 8000 + st->use_vbr * 3000 ) / 2;
870                 } else {
871                     /* 48 kHz, 20 ms */
872                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 9000 + st->use_vbr * 1000 ) / 2;
873                 }
874             }
875             st->silk_mode.bitRate *= st->stream_channels;
876             /* don't let SILK use more than 80% */
877             if( st->silk_mode.bitRate > ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5 ) {
878                 st->silk_mode.bitRate = ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5;
879             }
880         }
881
882         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
883         st->silk_mode.nChannelsAPI = st->channels;
884         st->silk_mode.nChannelsInternal = st->stream_channels;
885         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
886             st->silk_mode.desiredInternalSampleRate = 8000;
887         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
888             st->silk_mode.desiredInternalSampleRate = 12000;
889         } else {
890             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
891             st->silk_mode.desiredInternalSampleRate = 16000;
892         }
893         if( st->mode == MODE_HYBRID ) {
894             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
895             st->silk_mode.minInternalSampleRate = 16000;
896         } else {
897             st->silk_mode.minInternalSampleRate = 8000;
898         }
899
900         if (st->mode == MODE_SILK_ONLY)
901         {
902            opus_int32 effective_max_rate = max_rate;
903            st->silk_mode.maxInternalSampleRate = 16000;
904            if (frame_rate > 50)
905               effective_max_rate = effective_max_rate*2/3;
906            if (effective_max_rate < 13000)
907            {
908               st->silk_mode.maxInternalSampleRate = 12000;
909               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
910            }
911            if (effective_max_rate < 9600)
912            {
913               st->silk_mode.maxInternalSampleRate = 8000;
914               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
915            }
916         } else {
917            st->silk_mode.maxInternalSampleRate = 16000;
918         }
919
920         st->silk_mode.useCBR = !st->use_vbr;
921
922         /* Call SILK encoder for the low band */
923         nBytes = IMIN(1275, max_data_bytes-1);
924
925         st->silk_mode.maxBits = nBytes*8;
926         /* Only allow up to 90% of the bits for hybrid mode*/
927         if (st->mode == MODE_HYBRID)
928            st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
929         if (st->silk_mode.useCBR)
930         {
931            st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
932            /* Reduce the initial target to make it easier to reach the CBR rate */
933            st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000);
934         }
935         if (redundancy)
936            st->silk_mode.maxBits -= st->silk_mode.maxBits/(1 + frame_size/(st->Fs/200));
937
938         if (prefill)
939         {
940             opus_int32 zero=0;
941 #ifdef FIXED_POINT
942             pcm_silk = st->delay_buffer;
943 #else
944             for (i=0;i<st->encoder_buffer*st->channels;i++)
945                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
946 #endif
947             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
948         }
949
950 #ifdef FIXED_POINT
951         pcm_silk = pcm_buf+delay_compensation*st->channels;
952 #else
953         for (i=0;i<frame_size*st->channels;i++)
954             pcm_silk[i] = FLOAT2INT16(pcm_buf[delay_compensation*st->channels + i]);
955 #endif
956         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
957         if( ret ) {
958             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
959             /* Handle error */
960            RESTORE_STACK;
961            return OPUS_INTERNAL_ERROR;
962         }
963         if (nBytes==0)
964         {
965            st->rangeFinal = 0;
966            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
967            RESTORE_STACK;
968            return 1;
969         }
970         /* Extract SILK internal bandwidth for signaling in first byte */
971         if( st->mode == MODE_SILK_ONLY ) {
972             if( st->silk_mode.internalSampleRate == 8000 ) {
973                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
974             } else if( st->silk_mode.internalSampleRate == 12000 ) {
975                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
976             } else if( st->silk_mode.internalSampleRate == 16000 ) {
977                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
978             }
979         } else {
980             silk_assert( st->silk_mode.internalSampleRate == 16000 );
981         }
982
983         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
984         if (st->silk_mode.opusCanSwitch)
985         {
986            redundancy = 1;
987            celt_to_silk = 0;
988            st->silk_bw_switch = 1;
989         }
990     }
991
992     /* CELT processing */
993     {
994         int endband=21;
995
996         switch(curr_bandwidth)
997         {
998             case OPUS_BANDWIDTH_NARROWBAND:
999                 endband = 13;
1000                 break;
1001             case OPUS_BANDWIDTH_MEDIUMBAND:
1002             case OPUS_BANDWIDTH_WIDEBAND:
1003                 endband = 17;
1004                 break;
1005             case OPUS_BANDWIDTH_SUPERWIDEBAND:
1006                 endband = 19;
1007                 break;
1008             case OPUS_BANDWIDTH_FULLBAND:
1009                 endband = 21;
1010                 break;
1011         }
1012         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
1013         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
1014     }
1015     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1016     if (st->mode != MODE_SILK_ONLY)
1017     {
1018         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1019         /* Allow prediction unless we decide to disable it later */
1020         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
1021
1022         if (st->mode == MODE_HYBRID)
1023         {
1024             int len;
1025
1026             len = (ec_tell(&enc)+7)>>3;
1027             if (redundancy)
1028                len += st->mode == MODE_HYBRID ? 3 : 1;
1029             if( st->use_vbr ) {
1030                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
1031             } else {
1032                 /* check if SILK used up too much */
1033                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
1034             }
1035         } else {
1036             if (st->use_vbr)
1037             {
1038                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
1039                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
1040                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps));
1041                 nb_compr_bytes = max_data_bytes-1;
1042             } else {
1043                 nb_compr_bytes = bytes_target;
1044             }
1045         }
1046
1047     } else {
1048         nb_compr_bytes = 0;
1049     }
1050
1051     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
1052     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
1053     {
1054        for (i=0;i<st->channels*st->Fs/400;i++)
1055           tmp_prefill[i] = st->delay_buffer[(st->encoder_buffer-st->delay_compensation-st->Fs/400)*st->channels + i];
1056     }
1057
1058     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+delay_compensation));i++)
1059         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
1060     for (;i<st->encoder_buffer*st->channels;i++)
1061         st->delay_buffer[i] = pcm_buf[(frame_size+delay_compensation-st->encoder_buffer)*st->channels+i];
1062
1063
1064     if (st->mode != MODE_HYBRID || st->stream_channels==1)
1065        st->silk_mode.stereoWidth_Q14 = 1<<14;
1066     if( st->channels == 2 ) {
1067         /* Apply stereo width reduction (at low bitrates) */
1068         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1069             opus_val16 g1, g2;
1070             const CELTMode *celt_mode;
1071
1072             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1073             g1 = st->hybrid_stereo_width_Q14;
1074             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1075 #ifdef FIXED_POINT
1076             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
1077             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
1078 #else
1079             g1 *= (1./16384);
1080             g2 *= (1./16384);
1081 #endif
1082             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
1083                   frame_size, st->channels, celt_mode->window, st->Fs);
1084             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1085         }
1086     }
1087
1088     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
1089     {
1090         /* For SILK mode, the redundancy is inferred from the length */
1091         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
1092            ec_enc_bit_logp(&enc, redundancy, 12);
1093         if (redundancy)
1094         {
1095             int max_redundancy;
1096             ec_enc_bit_logp(&enc, celt_to_silk, 1);
1097             if (st->mode == MODE_HYBRID)
1098                max_redundancy = (max_data_bytes-1)-nb_compr_bytes-1;
1099             else
1100                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1101             /* Target the same bit-rate for redundancy as for the rest,
1102                up to a max of 257 bytes */
1103             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
1104             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
1105             if (st->mode == MODE_HYBRID)
1106                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
1107         }
1108     } else {
1109         redundancy = 0;
1110     }
1111
1112     if (!redundancy)
1113        st->silk_bw_switch = 0;
1114
1115     if (st->mode != MODE_CELT_ONLY)start_band=17;
1116
1117     if (st->mode == MODE_SILK_ONLY)
1118     {
1119         ret = (ec_tell(&enc)+7)>>3;
1120         ec_enc_done(&enc);
1121         nb_compr_bytes = ret;
1122     } else {
1123        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
1124        ec_enc_shrink(&enc, nb_compr_bytes);
1125     }
1126
1127
1128     /* 5 ms redundant frame for CELT->SILK */
1129     if (redundancy && celt_to_silk)
1130     {
1131         int err;
1132         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1133         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1134         err = celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
1135         if (err < 0)
1136         {
1137            RESTORE_STACK;
1138            return OPUS_INTERNAL_ERROR;
1139         }
1140         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1141         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1142     }
1143
1144     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
1145
1146     if (st->mode != MODE_SILK_ONLY)
1147     {
1148         if (st->mode != st->prev_mode && st->prev_mode > 0)
1149         {
1150            unsigned char dummy[2];
1151            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1152
1153            /* Prefilling */
1154            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
1155            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1156         }
1157         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
1158         if (ec_tell(&enc) <= 8*nb_compr_bytes)
1159         {
1160            ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
1161            if (ret < 0)
1162            {
1163               RESTORE_STACK;
1164               return OPUS_INTERNAL_ERROR;
1165            }
1166         }
1167     }
1168
1169     /* 5 ms redundant frame for SILK->CELT */
1170     if (redundancy && !celt_to_silk)
1171     {
1172         int err;
1173         unsigned char dummy[2];
1174         int N2, N4;
1175         N2 = st->Fs/200;
1176         N4 = st->Fs/400;
1177
1178         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1179         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1180         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1181
1182         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1183         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL);
1184
1185         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1186         if (err < 0)
1187         {
1188            RESTORE_STACK;
1189            return OPUS_INTERNAL_ERROR;
1190         }
1191         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1192     }
1193
1194
1195
1196     /* Signalling the mode in the first byte */
1197     data--;
1198     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1199
1200     st->rangeFinal = enc.rng ^ redundant_rng;
1201
1202     if (to_celt)
1203         st->prev_mode = MODE_CELT_ONLY;
1204     else
1205         st->prev_mode = st->mode;
1206     st->prev_channels = st->stream_channels;
1207     st->prev_framesize = frame_size;
1208
1209     st->first = 0;
1210
1211     /* In the unlikely case that the SILK encoder busted its target, tell
1212        the decoder to call the PLC */
1213     if (ec_tell(&enc) > (max_data_bytes-1)*8)
1214     {
1215        if (max_data_bytes < 2)
1216        {
1217           RESTORE_STACK;
1218           return OPUS_BUFFER_TOO_SMALL;
1219        }
1220        data[1] = 0;
1221        ret = 1;
1222        st->rangeFinal = 0;
1223     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
1224     {
1225        /*When in LPC only mode it's perfectly
1226          reasonable to strip off trailing zero bytes as
1227          the required range decoder behavior is to
1228          fill these in. This can't be done when the MDCT
1229          modes are used because the decoder needs to know
1230          the actual length for allocation purposes.*/
1231        while(ret>2&&data[ret]==0)ret--;
1232     }
1233     /* Count ToC and redundancy */
1234     ret += 1+redundancy_bytes;
1235     if (!st->use_vbr && ret >= 3)
1236     {
1237        if (pad_frame(data, ret, max_data_bytes))
1238        {
1239           RESTORE_STACK;
1240           return OPUS_INTERNAL_ERROR;
1241        }
1242        ret = max_data_bytes;
1243     }
1244     RESTORE_STACK;
1245     return ret;
1246 }
1247
1248 #ifdef FIXED_POINT
1249
1250 #ifndef DISABLE_FLOAT_API
1251 int opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1252       unsigned char *data, opus_int32 max_data_bytes)
1253 {
1254    int i, ret;
1255    VARDECL(opus_int16, in);
1256    ALLOC_STACK;
1257
1258    if(frame_size<0)
1259    {
1260       RESTORE_STACK;
1261       return OPUS_BAD_ARG;
1262    }
1263
1264    ALLOC(in, frame_size*st->channels, opus_int16);
1265
1266    for (i=0;i<frame_size*st->channels;i++)
1267       in[i] = FLOAT2INT16(pcm[i]);
1268    ret = opus_encode(st, in, frame_size, data, max_data_bytes);
1269    RESTORE_STACK;
1270    return ret;
1271 }
1272 #endif
1273
1274 #else
1275 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1276       unsigned char *data, opus_int32 max_data_bytes)
1277 {
1278    int i, ret;
1279    VARDECL(float, in);
1280    ALLOC_STACK;
1281
1282    ALLOC(in, frame_size*st->channels, float);
1283
1284    for (i=0;i<frame_size*st->channels;i++)
1285       in[i] = (1.0f/32768)*pcm[i];
1286    ret = opus_encode_float(st, in, frame_size, data, max_data_bytes);
1287    RESTORE_STACK;
1288    return ret;
1289 }
1290 #endif
1291
1292
1293 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
1294 {
1295     int ret;
1296     CELTEncoder *celt_enc;
1297     va_list ap;
1298
1299     ret = OPUS_OK;
1300     va_start(ap, request);
1301
1302     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1303
1304     switch (request)
1305     {
1306         case OPUS_SET_APPLICATION_REQUEST:
1307         {
1308             opus_int32 value = va_arg(ap, opus_int32);
1309             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
1310                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1311                || (!st->first && st->application != value))
1312             {
1313                ret = OPUS_BAD_ARG;
1314                break;
1315             }
1316             st->application = value;
1317         }
1318         break;
1319         case OPUS_GET_APPLICATION_REQUEST:
1320         {
1321             opus_int32 *value = va_arg(ap, opus_int32*);
1322             *value = st->application;
1323         }
1324         break;
1325         case OPUS_SET_BITRATE_REQUEST:
1326         {
1327             opus_int32 value = va_arg(ap, opus_int32);
1328             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1329             {
1330                 if (value <= 0)
1331                     goto bad_arg;
1332                 else if (value <= 500)
1333                     value = 500;
1334                 else if (value > (opus_int32)300000*st->channels)
1335                     value = (opus_int32)300000*st->channels;
1336             }
1337             st->user_bitrate_bps = value;
1338         }
1339         break;
1340         case OPUS_GET_BITRATE_REQUEST:
1341         {
1342             opus_int32 *value = va_arg(ap, opus_int32*);
1343             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
1344         }
1345         break;
1346         case OPUS_SET_FORCE_CHANNELS_REQUEST:
1347         {
1348             opus_int32 value = va_arg(ap, opus_int32);
1349             if((value<1 || value>st->channels) && value != OPUS_AUTO)
1350                 return OPUS_BAD_ARG;
1351             st->force_channels = value;
1352         }
1353         break;
1354         case OPUS_GET_FORCE_CHANNELS_REQUEST:
1355         {
1356             opus_int32 *value = va_arg(ap, opus_int32*);
1357             *value = st->force_channels;
1358         }
1359         break;
1360         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
1361         {
1362             opus_int32 value = va_arg(ap, opus_int32);
1363             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND)
1364                 return OPUS_BAD_ARG;
1365             st->max_bandwidth = value;
1366             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1367                 st->silk_mode.maxInternalSampleRate = 8000;
1368             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1369                 st->silk_mode.maxInternalSampleRate = 12000;
1370             } else {
1371                 st->silk_mode.maxInternalSampleRate = 16000;
1372             }
1373         }
1374         break;
1375         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
1376         {
1377             opus_int32 *value = va_arg(ap, opus_int32*);
1378             *value = st->max_bandwidth;
1379         }
1380         break;
1381         case OPUS_SET_BANDWIDTH_REQUEST:
1382         {
1383             opus_int32 value = va_arg(ap, opus_int32);
1384             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
1385                 return OPUS_BAD_ARG;
1386             st->user_bandwidth = value;
1387             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1388                 st->silk_mode.maxInternalSampleRate = 8000;
1389             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1390                 st->silk_mode.maxInternalSampleRate = 12000;
1391             } else {
1392                 st->silk_mode.maxInternalSampleRate = 16000;
1393             }
1394         }
1395         break;
1396         case OPUS_GET_BANDWIDTH_REQUEST:
1397         {
1398             opus_int32 *value = va_arg(ap, opus_int32*);
1399             *value = st->bandwidth;
1400         }
1401         break;
1402         case OPUS_SET_DTX_REQUEST:
1403         {
1404             opus_int32 value = va_arg(ap, opus_int32);
1405             if(value<0 || value>1)
1406                 return OPUS_BAD_ARG;
1407             st->silk_mode.useDTX = value;
1408         }
1409         break;
1410         case OPUS_GET_DTX_REQUEST:
1411         {
1412             opus_int32 *value = va_arg(ap, opus_int32*);
1413             *value = st->silk_mode.useDTX;
1414         }
1415         break;
1416         case OPUS_SET_COMPLEXITY_REQUEST:
1417         {
1418             opus_int32 value = va_arg(ap, opus_int32);
1419             if(value<0 || value>10)
1420                 return OPUS_BAD_ARG;
1421             st->silk_mode.complexity = value;
1422             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
1423         }
1424         break;
1425         case OPUS_GET_COMPLEXITY_REQUEST:
1426         {
1427             opus_int32 *value = va_arg(ap, opus_int32*);
1428             *value = st->silk_mode.complexity;
1429         }
1430         break;
1431         case OPUS_SET_INBAND_FEC_REQUEST:
1432         {
1433             opus_int32 value = va_arg(ap, opus_int32);
1434             if(value<0 || value>1)
1435                 return OPUS_BAD_ARG;
1436             st->silk_mode.useInBandFEC = value;
1437         }
1438         break;
1439         case OPUS_GET_INBAND_FEC_REQUEST:
1440         {
1441             opus_int32 *value = va_arg(ap, opus_int32*);
1442             *value = st->silk_mode.useInBandFEC;
1443         }
1444         break;
1445         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1446         {
1447             opus_int32 value = va_arg(ap, opus_int32);
1448             if (value < 0 || value > 100)
1449                 return OPUS_BAD_ARG;
1450             st->silk_mode.packetLossPercentage = value;
1451             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
1452         }
1453         break;
1454         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1455         {
1456             opus_int32 *value = va_arg(ap, opus_int32*);
1457             *value = st->silk_mode.packetLossPercentage;
1458         }
1459         break;
1460         case OPUS_SET_VBR_REQUEST:
1461         {
1462             opus_int32 value = va_arg(ap, opus_int32);
1463             if(value<0 || value>1)
1464                 return OPUS_BAD_ARG;
1465             st->use_vbr = value;
1466             st->silk_mode.useCBR = 1-value;
1467         }
1468         break;
1469         case OPUS_GET_VBR_REQUEST:
1470         {
1471             opus_int32 *value = va_arg(ap, opus_int32*);
1472             *value = st->use_vbr;
1473         }
1474         break;
1475         case OPUS_SET_VOICE_RATIO_REQUEST:
1476         {
1477             opus_int32 value = va_arg(ap, opus_int32);
1478             if (value>100 || value<-1)
1479                 goto bad_arg;
1480             st->voice_ratio = value;
1481         }
1482         break;
1483         case OPUS_GET_VOICE_RATIO_REQUEST:
1484         {
1485             opus_int32 *value = va_arg(ap, opus_int32*);
1486             *value = st->voice_ratio;
1487         }
1488         break;
1489         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1490         {
1491             opus_int32 value = va_arg(ap, opus_int32);
1492             if(value<0 || value>1)
1493                 return OPUS_BAD_ARG;
1494             st->vbr_constraint = value;
1495         }
1496         break;
1497         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1498         {
1499             opus_int32 *value = va_arg(ap, opus_int32*);
1500             *value = st->vbr_constraint;
1501         }
1502         break;
1503         case OPUS_SET_SIGNAL_REQUEST:
1504         {
1505             opus_int32 value = va_arg(ap, opus_int32);
1506             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
1507                 return OPUS_BAD_ARG;
1508             st->signal_type = value;
1509         }
1510         break;
1511         case OPUS_GET_SIGNAL_REQUEST:
1512         {
1513             opus_int32 *value = va_arg(ap, opus_int32*);
1514             *value = st->signal_type;
1515         }
1516         break;
1517         case OPUS_GET_LOOKAHEAD_REQUEST:
1518         {
1519             opus_int32 *value = va_arg(ap, opus_int32*);
1520             *value = st->Fs/400;
1521             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1522                 *value += st->delay_compensation;
1523         }
1524         break;
1525         case OPUS_GET_FINAL_RANGE_REQUEST:
1526         {
1527             opus_uint32 *value = va_arg(ap, opus_uint32*);
1528             *value = st->rangeFinal;
1529         }
1530         break;
1531         case OPUS_RESET_STATE:
1532         {
1533            void *silk_enc;
1534            silk_EncControlStruct dummy;
1535            silk_enc = (char*)st+st->silk_enc_offset;
1536
1537            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
1538                  sizeof(OpusEncoder)-
1539                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
1540
1541            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1542            silk_InitEncoder( silk_enc, &dummy );
1543            st->stream_channels = st->channels;
1544            st->hybrid_stereo_width_Q14 = 1 << 14;
1545            st->first = 1;
1546            st->mode = MODE_HYBRID;
1547            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
1548            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1549         }
1550         break;
1551         case OPUS_SET_FORCE_MODE_REQUEST:
1552         {
1553             opus_int32 value = va_arg(ap, opus_int32);
1554             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
1555                goto bad_arg;
1556             st->user_forced_mode = value;
1557         }
1558         break;
1559         default:
1560             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
1561             ret = OPUS_UNIMPLEMENTED;
1562             break;
1563     }
1564     va_end(ap);
1565     return ret;
1566 bad_arg:
1567     va_end(ap);
1568     return OPUS_BAD_ARG;
1569 }
1570
1571 void opus_encoder_destroy(OpusEncoder *st)
1572 {
1573     opus_free(st);
1574 }