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