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