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