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