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