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