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