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