Some SILK CBR tuning
[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          user_forced_mode;
64     int          voice_ratio;
65     opus_int32   Fs;
66     int          use_vbr;
67     int          vbr_constraint;
68     opus_int32   bitrate_bps;
69     opus_int32   user_bitrate_bps;
70     int          encoder_buffer;
71
72 #define OPUS_ENCODER_RESET_START stream_channels
73     int          stream_channels;
74     opus_int16   hybrid_stereo_width_Q14;
75     opus_int32   variable_HP_smth2_Q15;
76     opus_val32   hp_mem[4];
77     int          mode;
78     int          prev_mode;
79     int          prev_channels;
80     int          prev_framesize;
81     int          bandwidth;
82     int          silk_bw_switch;
83     /* Sampling rate (at the API level) */
84     int          first;
85     opus_val16   delay_buffer[MAX_ENCODER_BUFFER*2];
86
87     opus_uint32  rangeFinal;
88 };
89
90 /* Transition tables for the voice and music. First column is the
91    middle (memoriless) threshold. The second column is the hysteresis
92    (difference with the middle) */
93 static const opus_int32 mono_voice_bandwidth_thresholds[8] = {
94         11000, 1000, /* NB<->MB */
95         14000, 1000, /* MB<->WB */
96         21000, 2000, /* WB<->SWB */
97         29000, 2000, /* SWB<->FB */
98 };
99 static const opus_int32 mono_music_bandwidth_thresholds[8] = {
100         14000, 1000, /* MB not allowed */
101         18000, 2000, /* MB<->WB */
102         24000, 2000, /* WB<->SWB */
103         33000, 2000, /* SWB<->FB */
104 };
105 static const opus_int32 stereo_voice_bandwidth_thresholds[8] = {
106         11000, 1000, /* NB<->MB */
107         14000, 1000, /* MB<->WB */
108         21000, 2000, /* WB<->SWB */
109         32000, 2000, /* SWB<->FB */
110 };
111 static const opus_int32 stereo_music_bandwidth_thresholds[8] = {
112         14000, 1000, /* MB not allowed */
113         18000, 2000, /* MB<->WB */
114         24000, 2000, /* WB<->SWB */
115         48000, 2000, /* SWB<->FB */
116 };
117 /* Threshold bit-rates for switching between mono and stereo */
118 static const opus_int32 stereo_voice_threshold = 26000;
119 static const opus_int32 stereo_music_threshold = 36000;
120
121 /* Threshold bit-rate for switching between SILK/hybrid and CELT-only */
122 static const opus_int32 mode_thresholds[2][2] = {
123       /* voice */ /* music */
124       {  48000,      24000}, /* mono */
125       {  48000,      24000}, /* stereo */
126 };
127
128 static const int celt_delay_table[5] = {
129 /* API 8  12  16  24  48 */
130       10, 16, 21, 27, 55
131 };
132 int opus_encoder_get_size(int channels)
133 {
134     int silkEncSizeBytes, celtEncSizeBytes;
135     int ret;
136     if (channels<1 || channels > 2)
137         return 0;
138     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
139     if (ret)
140         return 0;
141     silkEncSizeBytes = align(silkEncSizeBytes);
142     celtEncSizeBytes = celt_encoder_get_size(channels);
143     return align(sizeof(OpusEncoder))+silkEncSizeBytes+celtEncSizeBytes;
144 }
145
146 int opus_encoder_init(OpusEncoder* st, opus_int32 Fs, int channels, int application)
147 {
148     void *silk_enc;
149     CELTEncoder *celt_enc;
150     int err;
151     int ret, silkEncSizeBytes;
152
153    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
154         (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
155         && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
156         return OPUS_BAD_ARG;
157
158     OPUS_CLEAR((char*)st, opus_encoder_get_size(channels));
159     /* Create SILK encoder */
160     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
161     if (ret)
162         return OPUS_BAD_ARG;
163     silkEncSizeBytes = align(silkEncSizeBytes);
164     st->silk_enc_offset = align(sizeof(OpusEncoder));
165     st->celt_enc_offset = st->silk_enc_offset+silkEncSizeBytes;
166     silk_enc = (char*)st+st->silk_enc_offset;
167     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
168
169     st->stream_channels = st->channels = channels;
170
171     st->Fs = Fs;
172
173     ret = silk_InitEncoder( silk_enc, &st->silk_mode );
174     if(ret)return OPUS_INTERNAL_ERROR;
175
176     /* default SILK parameters */
177     st->silk_mode.nChannelsAPI              = channels;
178     st->silk_mode.nChannelsInternal         = channels;
179     st->silk_mode.API_sampleRate            = st->Fs;
180     st->silk_mode.maxInternalSampleRate     = 16000;
181     st->silk_mode.minInternalSampleRate     = 8000;
182     st->silk_mode.desiredInternalSampleRate = 16000;
183     st->silk_mode.payloadSize_ms            = 20;
184     st->silk_mode.bitRate                   = 25000;
185     st->silk_mode.packetLossPercentage      = 0;
186     st->silk_mode.complexity                = 10;
187     st->silk_mode.useInBandFEC              = 0;
188     st->silk_mode.useDTX                    = 0;
189     st->silk_mode.useCBR                    = 0;
190
191     /* Create CELT encoder */
192     /* Initialize CELT encoder */
193     err = celt_encoder_init(celt_enc, Fs, channels);
194     if(err!=OPUS_OK)return OPUS_INTERNAL_ERROR;
195
196     celt_encoder_ctl(celt_enc, CELT_SET_SIGNALLING(0));
197     celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(10));
198
199     st->use_vbr = 1;
200     st->user_bitrate_bps = OPUS_AUTO;
201     st->bitrate_bps = 3000+Fs*channels;
202     st->application = application;
203     st->signal_type = OPUS_AUTO;
204     st->user_bandwidth = OPUS_AUTO;
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     st->delay_compensation = st->Fs/400;
211
212     st->delay_compensation += celt_delay_table[rateID(st->Fs)];
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, int len, int 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, int max_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, int max_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     VARDECL(opus_val16, tmp_prefill);
472
473     ALLOC_STACK;
474
475     max_data_bytes = IMIN(1276, max_data_bytes);
476
477     st->rangeFinal = 0;
478     if (400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
479          50*frame_size != st->Fs &&  25*frame_size != st->Fs &&  50*frame_size != 3*st->Fs)
480     {
481        RESTORE_STACK;
482        return OPUS_BAD_ARG;
483     }
484     silk_enc = (char*)st+st->silk_enc_offset;
485     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
486
487     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
488        delay_compensation = 0;
489     else
490        delay_compensation = st->delay_compensation;
491
492     st->bitrate_bps = user_bitrate_to_bitrate(st, frame_size, max_data_bytes);
493
494     frame_rate = st->Fs/frame_size;
495     if (!st->use_vbr)
496     {
497        int cbrBytes;
498        cbrBytes = IMIN( (st->bitrate_bps + 4*frame_rate)/(8*frame_rate) , max_data_bytes);
499        st->bitrate_bps = cbrBytes * (8*frame_rate);
500        max_data_bytes = cbrBytes;
501     }
502     max_rate = frame_rate*max_data_bytes*8;
503
504     /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */
505     equiv_rate = st->bitrate_bps - 60*(st->Fs/frame_size - 50);
506
507     if (st->signal_type == OPUS_SIGNAL_VOICE)
508        voice_est = 127;
509     else if (st->signal_type == OPUS_SIGNAL_MUSIC)
510        voice_est = 0;
511     else if (st->voice_ratio >= 0)
512        voice_est = st->voice_ratio*327>>8;
513     else if (st->application == OPUS_APPLICATION_VOIP)
514        voice_est = 115;
515     else
516        voice_est = 64;
517
518     if (st->force_channels!=OPUS_AUTO && st->channels == 2)
519     {
520         st->stream_channels = st->force_channels;
521     } else {
522 #ifdef FUZZING
523        /* Random mono/stereo decision */
524        if (st->channels == 2 && (rand()&0x1F)==0)
525           st->stream_channels = 3-st->stream_channels;
526 #else
527        /* Rate-dependent mono-stereo decision */
528        if (st->channels == 2)
529        {
530           opus_int32 stereo_threshold;
531           stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14);
532           if (st->stream_channels == 2)
533              stereo_threshold -= 4000;
534           else
535              stereo_threshold += 4000;
536           st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1;
537        } else {
538           st->stream_channels = st->channels;
539        }
540 #endif
541     }
542
543     /* Mode selection depending on application and signal type */
544     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
545     {
546        st->mode = MODE_CELT_ONLY;
547     } else if (st->user_forced_mode == OPUS_AUTO)
548     {
549 #ifdef FUZZING
550        /* Random mode switching */
551        if ((rand()&0xF)==0)
552        {
553           if ((rand()&0x1)==0)
554              st->mode = MODE_CELT_ONLY;
555           else
556              st->mode = MODE_SILK_ONLY;
557        } else {
558           if (st->prev_mode==MODE_CELT_ONLY)
559              st->mode = MODE_CELT_ONLY;
560           else
561              st->mode = MODE_SILK_ONLY;
562        }
563 #else
564        int chan;
565        opus_int32 mode_voice, mode_music;
566        opus_int32 threshold;
567
568        chan = (st->channels==2) && st->force_channels!=1;
569        mode_voice = mode_thresholds[chan][0];
570        mode_music = mode_thresholds[chan][1];
571        threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14);
572
573        /* Hysteresis */
574        if (st->prev_mode == MODE_CELT_ONLY)
575            threshold -= 4000;
576        else if (st->prev_mode>0)
577            threshold += 4000;
578
579        st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY;
580 #endif
581     } else {
582        st->mode = st->user_forced_mode;
583     }
584
585     /* Override the chosen mode to make sure we meet the requested frame size */
586     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
587        st->mode = MODE_CELT_ONLY;
588
589     if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0
590           && st->mode != MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)
591     {
592        /* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */
593        st->silk_mode.toMono = 1;
594        st->stream_channels = 2;
595     } else {
596        st->silk_mode.toMono = 0;
597     }
598
599     if (st->prev_mode > 0 &&
600         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
601     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
602     {
603         redundancy = 1;
604         celt_to_silk = (st->mode != MODE_CELT_ONLY);
605         if (!celt_to_silk)
606         {
607             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
608             if (frame_size >= st->Fs/100)
609             {
610                 st->mode = st->prev_mode;
611                 to_celt = 1;
612             } else {
613                 redundancy=0;
614             }
615         }
616     }
617     if (st->silk_bw_switch)
618     {
619        redundancy = 1;
620        celt_to_silk = 1;
621        st->silk_bw_switch = 0;
622     }
623
624     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
625     {
626         silk_EncControlStruct dummy;
627         silk_InitEncoder( silk_enc, &dummy);
628         prefill=1;
629     }
630
631     /* Automatic (rate-dependent) bandwidth selection */
632     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
633     {
634         const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds;
635         opus_int32 bandwidth_thresholds[8];
636         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
637
638         if (st->channels==2 && st->force_channels!=1)
639         {
640            voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds;
641            music_bandwidth_thresholds = stereo_music_bandwidth_thresholds;
642         } else {
643            voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds;
644            music_bandwidth_thresholds = mono_music_bandwidth_thresholds;
645         }
646         /* Interpolate bandwidth thresholds depending on voice estimation */
647         for (i=0;i<8;i++)
648         {
649            bandwidth_thresholds[i] = music_bandwidth_thresholds[i]
650                     + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14);
651         }
652         do {
653             int threshold, hysteresis;
654             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
655             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
656             if (!st->first)
657             {
658                 if (st->bandwidth >= bandwidth)
659                     threshold -= hysteresis;
660                 else
661                     threshold += hysteresis;
662             }
663             if (equiv_rate >= threshold)
664                 break;
665         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
666         st->bandwidth = bandwidth;
667         /* Prevents any transition to SWB/FB until the SILK layer has fully
668            switched to WB mode and turned the variable LP filter off */
669         if (st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
670             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
671     }
672
673     if (st->user_bandwidth != OPUS_AUTO)
674         st->bandwidth = st->user_bandwidth;
675
676     /* This prevents us from using hybrid at unsafe CBR/max rates */
677     if (st->mode != MODE_CELT_ONLY && max_rate < 15000)
678     {
679        st->bandwidth = IMIN(st->bandwidth, OPUS_BANDWIDTH_WIDEBAND);
680     }
681
682     /* Prevents Opus from wasting bits on frequencies that are above
683        the Nyquist rate of the input signal */
684     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
685         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
686     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
687         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
688     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
689         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
690     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
691         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
692
693     /* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */
694     if (max_data_bytes < (frame_rate > 50 ? 12000 : 8000)*frame_size / (st->Fs * 8))
695        st->mode = MODE_CELT_ONLY;
696
697     /* CELT mode doesn't support mediumband, use wideband instead */
698     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
699         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
700
701     /* Can't support higher than wideband for >20 ms frames */
702     if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND))
703     {
704        VARDECL(unsigned char, tmp_data);
705        VARDECL(unsigned char, rp_);
706        int nb_frames;
707        int bak_mode, bak_bandwidth, bak_channels, bak_to_mono;
708        OpusRepacketizer *rp;
709        int bytes_per_frame;
710
711
712        nb_frames = frame_size > st->Fs/25 ? 3 : 2;
713        bytes_per_frame = max_data_bytes/nb_frames-3;
714
715        ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char);
716        ALLOC(rp_, opus_repacketizer_get_size(), unsigned char);
717
718        rp = opus_repacketizer_init((OpusRepacketizer*)rp_);
719
720        bak_mode = st->user_forced_mode;
721        bak_bandwidth = st->user_bandwidth;
722        bak_channels = st->force_channels;
723
724        st->user_forced_mode = st->mode;
725        st->user_bandwidth = st->bandwidth;
726        st->force_channels = st->stream_channels;
727        bak_to_mono = st->silk_mode.toMono;
728
729        if (bak_to_mono)
730           st->force_channels = 1;
731        else
732           st->prev_channels = st->stream_channels;
733        for (i=0;i<nb_frames;i++)
734        {
735           int tmp_len;
736           st->silk_mode.toMono = 0;
737           /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
738           if (to_celt && i==nb_frames-1)
739              st->user_forced_mode = MODE_CELT_ONLY;
740           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);
741           ret = opus_repacketizer_cat(rp, tmp_data+i*bytes_per_frame, tmp_len);
742        }
743        ret = opus_repacketizer_out(rp, data, max_data_bytes);
744
745        st->user_forced_mode = bak_mode;
746        st->user_bandwidth = bak_bandwidth;
747        st->force_channels = bak_channels;
748        st->silk_mode.toMono = bak_to_mono;
749        RESTORE_STACK;
750        return ret;
751     }
752
753     curr_bandwidth = st->bandwidth;
754
755     /* Chooses the appropriate mode for speech
756        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
757     if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND)
758         st->mode = MODE_HYBRID;
759     if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
760         st->mode = MODE_SILK_ONLY;
761
762     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
763     bytes_target = IMIN(max_data_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
764
765     data += 1;
766
767     ec_enc_init(&enc, data, max_data_bytes-1);
768
769     ALLOC(pcm_buf, (delay_compensation+frame_size)*st->channels, opus_val16);
770     for (i=0;i<delay_compensation*st->channels;i++)
771        pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-delay_compensation)*st->channels+i];
772
773     if (st->mode == MODE_CELT_ONLY)
774        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
775     else
776        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
777
778     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
779           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
780
781     /* convert from log scale to Hertz */
782     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
783
784     if (st->application == OPUS_APPLICATION_VOIP)
785     {
786        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[delay_compensation*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
787     } else {
788        for (i=0;i<frame_size*st->channels;i++)
789           pcm_buf[delay_compensation*st->channels + i] = pcm[i];
790     }
791
792     /* SILK processing */
793     if (st->mode != MODE_CELT_ONLY)
794     {
795 #ifdef FIXED_POINT
796        const opus_int16 *pcm_silk;
797 #else
798        VARDECL(opus_int16, pcm_silk);
799        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
800 #endif
801         st->silk_mode.bitRate = st->bitrate_bps - 8*st->Fs/frame_size;
802         if( st->mode == MODE_HYBRID ) {
803             st->silk_mode.bitRate /= st->stream_channels;
804             if( curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
805                 if( st->Fs == 100 * frame_size ) {
806                     /* 24 kHz, 10 ms */
807                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 2000 + st->use_vbr * 1000 ) * 2 ) / 3;
808                 } else {
809                     /* 24 kHz, 20 ms */
810                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 1000 + st->use_vbr * 1000 ) * 2 ) / 3;
811                 }
812             } else {
813                 if( st->Fs == 100 * frame_size ) {
814                     /* 48 kHz, 10 ms */
815                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 8000 + st->use_vbr * 3000 ) / 2;
816                 } else {
817                     /* 48 kHz, 20 ms */
818                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 9000 + st->use_vbr * 1000 ) / 2;
819                 }
820             }
821             st->silk_mode.bitRate *= st->stream_channels;
822             /* don't let SILK use more than 80% */
823             if( st->silk_mode.bitRate > ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5 ) {
824                 st->silk_mode.bitRate = ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5;
825             }
826         }
827
828         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
829         st->silk_mode.nChannelsAPI = st->channels;
830         st->silk_mode.nChannelsInternal = st->stream_channels;
831         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
832             st->silk_mode.desiredInternalSampleRate = 8000;
833         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
834             st->silk_mode.desiredInternalSampleRate = 12000;
835         } else {
836             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
837             st->silk_mode.desiredInternalSampleRate = 16000;
838         }
839         if( st->mode == MODE_HYBRID ) {
840             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
841             st->silk_mode.minInternalSampleRate = 16000;
842         } else {
843             st->silk_mode.minInternalSampleRate = 8000;
844         }
845
846         if (st->mode == MODE_SILK_ONLY)
847         {
848            opus_int32 effective_max_rate = max_rate;
849            if (frame_rate > 50)
850               effective_max_rate = effective_max_rate*2/3;
851            if (effective_max_rate < 13000)
852            {
853               st->silk_mode.maxInternalSampleRate = 12000;
854               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
855            }
856            if (effective_max_rate < 9600)
857            {
858               st->silk_mode.maxInternalSampleRate = 8000;
859               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
860            }
861         } else {
862            st->silk_mode.maxInternalSampleRate = 16000;
863         }
864
865         st->silk_mode.useCBR = !st->use_vbr;
866
867         /* Call SILK encoder for the low band */
868         nBytes = IMIN(1275, max_data_bytes-1);
869
870         st->silk_mode.maxBits = nBytes*8;
871         /* Only allow up to 90% of the bits for hybrid mode*/
872         if (st->mode == MODE_HYBRID)
873            st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
874         if (st->silk_mode.useCBR)
875         {
876            st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
877            /* Reduce the initial target to make it easier to reach the CBR rate */
878            st->silk_mode.bitRate = 1;
879         }
880         if (redundancy)
881            st->silk_mode.maxBits -= st->silk_mode.maxBits/(1 + frame_size/(st->Fs/200));
882
883         if (prefill)
884         {
885             int zero=0;
886 #ifdef FIXED_POINT
887             pcm_silk = st->delay_buffer;
888 #else
889             for (i=0;i<st->encoder_buffer*st->channels;i++)
890                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
891 #endif
892             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
893         }
894
895 #ifdef FIXED_POINT
896         pcm_silk = pcm_buf+delay_compensation*st->channels;
897 #else
898         for (i=0;i<frame_size*st->channels;i++)
899             pcm_silk[i] = FLOAT2INT16(pcm_buf[delay_compensation*st->channels + i]);
900 #endif
901         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
902         if( ret ) {
903             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
904             /* Handle error */
905            return OPUS_INTERNAL_ERROR;
906         }
907         if (nBytes==0)
908         {
909            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
910            RESTORE_STACK;
911            return 1;
912         }
913         /* Extract SILK internal bandwidth for signaling in first byte */
914         if( st->mode == MODE_SILK_ONLY ) {
915             if( st->silk_mode.internalSampleRate == 8000 ) {
916                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
917             } else if( st->silk_mode.internalSampleRate == 12000 ) {
918                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
919             } else if( st->silk_mode.internalSampleRate == 16000 ) {
920                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
921             }
922         } else {
923             silk_assert( st->silk_mode.internalSampleRate == 16000 );
924         }
925
926         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
927         if (st->silk_mode.opusCanSwitch)
928         {
929            redundancy = 1;
930            celt_to_silk = 0;
931            st->silk_bw_switch = 1;
932         }
933     }
934
935     /* CELT processing */
936     {
937         int endband=21;
938
939         switch(curr_bandwidth)
940         {
941             case OPUS_BANDWIDTH_NARROWBAND:
942                 endband = 13;
943                 break;
944             case OPUS_BANDWIDTH_MEDIUMBAND:
945             case OPUS_BANDWIDTH_WIDEBAND:
946                 endband = 17;
947                 break;
948             case OPUS_BANDWIDTH_SUPERWIDEBAND:
949                 endband = 19;
950                 break;
951             case OPUS_BANDWIDTH_FULLBAND:
952                 endband = 21;
953                 break;
954         }
955         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
956         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
957     }
958     if (st->mode != MODE_SILK_ONLY)
959     {
960         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
961         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
962         /* Allow prediction unless we decide to disable it later */
963         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
964
965         if (st->mode == MODE_HYBRID)
966         {
967             int len;
968
969             len = (ec_tell(&enc)+7)>>3;
970             if (redundancy)
971                len += st->mode == MODE_HYBRID ? 3 : 1;
972             if( st->use_vbr ) {
973                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
974             } else {
975                 /* check if SILK used up too much */
976                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
977             }
978         } else {
979             if (st->use_vbr)
980             {
981                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
982                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
983                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps));
984                 nb_compr_bytes = max_data_bytes-1;
985             } else {
986                 nb_compr_bytes = bytes_target;
987             }
988         }
989
990     } else {
991         nb_compr_bytes = 0;
992     }
993
994     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
995     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
996     {
997        for (i=0;i<st->channels*st->Fs/400;i++)
998           tmp_prefill[i] = st->delay_buffer[(st->encoder_buffer-st->delay_compensation-st->Fs/400)*st->channels + i];
999     }
1000
1001     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+delay_compensation));i++)
1002         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
1003     for (;i<st->encoder_buffer*st->channels;i++)
1004         st->delay_buffer[i] = pcm_buf[(frame_size+delay_compensation-st->encoder_buffer)*st->channels+i];
1005
1006
1007     if (st->mode != MODE_HYBRID || st->stream_channels==1)
1008        st->silk_mode.stereoWidth_Q14 = 1<<14;
1009     if( st->channels == 2 ) {
1010         /* Apply stereo width reduction (at low bitrates) */
1011         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1012             opus_val16 g1, g2;
1013             const CELTMode *celt_mode;
1014
1015             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1016             g1 = st->hybrid_stereo_width_Q14;
1017             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1018 #ifdef FIXED_POINT
1019             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
1020             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
1021 #else
1022             g1 *= (1./16384);
1023             g2 *= (1./16384);
1024 #endif
1025             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
1026                   frame_size, st->channels, celt_mode->window, st->Fs);
1027             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1028         }
1029     }
1030
1031     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
1032     {
1033         /* For SILK mode, the redundancy is inferred from the length */
1034         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
1035            ec_enc_bit_logp(&enc, redundancy, 12);
1036         if (redundancy)
1037         {
1038             int max_redundancy;
1039             ec_enc_bit_logp(&enc, celt_to_silk, 1);
1040             if (st->mode == MODE_HYBRID)
1041                max_redundancy = (max_data_bytes-1)-nb_compr_bytes-1;
1042             else
1043                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1044             /* Target the same bit-rate for redundancy as for the rest,
1045                up to a max of 257 bytes */
1046             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
1047             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
1048             if (st->mode == MODE_HYBRID)
1049                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
1050         }
1051     } else {
1052         redundancy = 0;
1053     }
1054
1055     if (!redundancy)
1056        st->silk_bw_switch = 0;
1057
1058     if (st->mode != MODE_CELT_ONLY)start_band=17;
1059
1060     if (st->mode == MODE_SILK_ONLY)
1061     {
1062         ret = (ec_tell(&enc)+7)>>3;
1063         ec_enc_done(&enc);
1064         /*When in LPC only mode it's perfectly
1065           reasonable to strip off trailing zero bytes as
1066           the required range decoder behavior is to
1067           fill these in. This can't be done when the MDCT
1068           modes are used because the decoder needs to know
1069           the actual length for allocation purposes.*/
1070         if(!redundancy)
1071             while(ret>2&&data[ret-1]==0)ret--;
1072         nb_compr_bytes = ret;
1073     } else {
1074        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
1075        ec_enc_shrink(&enc, nb_compr_bytes);
1076     }
1077
1078
1079     /* 5 ms redundant frame for CELT->SILK */
1080     if (redundancy && celt_to_silk)
1081     {
1082         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1083         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1084         celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
1085         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1086         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1087     }
1088
1089     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
1090
1091     if (st->mode != MODE_SILK_ONLY)
1092     {
1093         if (st->mode != st->prev_mode && st->prev_mode > 0)
1094         {
1095            unsigned char dummy[2];
1096            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1097
1098            /* Prefilling */
1099            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
1100            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1101         }
1102         ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
1103         if (ret < 0)
1104            return OPUS_INTERNAL_ERROR;
1105     }
1106
1107     /* 5 ms redundant frame for SILK->CELT */
1108     if (redundancy && !celt_to_silk)
1109     {
1110         unsigned char dummy[2];
1111         int N2, N4;
1112         N2 = st->Fs/200;
1113         N4 = st->Fs/400;
1114
1115         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1116         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1117         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1118
1119         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1120         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL);
1121
1122         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1123         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1124     }
1125
1126
1127
1128     /* Signalling the mode in the first byte */
1129     data--;
1130     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1131
1132     st->rangeFinal = enc.rng ^ redundant_rng;
1133
1134     if (to_celt)
1135         st->prev_mode = MODE_CELT_ONLY;
1136     else
1137         st->prev_mode = st->mode;
1138     st->prev_channels = st->stream_channels;
1139     st->prev_framesize = frame_size;
1140
1141     st->first = 0;
1142     if (!redundancy && st->mode==MODE_SILK_ONLY && ret >= 2)
1143     {
1144        /* In the unlikely case that the SILK encoder busted its target, tell
1145           the decoder to call the PLC */
1146        if (ec_tell(&enc) > (max_data_bytes-1)*8)
1147        {
1148           data[1] = 0;
1149           ret = 1;
1150           st->rangeFinal = 0;
1151        }
1152        if (!st->use_vbr)
1153        {
1154           pad_frame(data, ret+1, max_data_bytes);
1155           ret = max_data_bytes - 1;
1156        }
1157     }
1158     RESTORE_STACK;
1159     return ret+1+redundancy_bytes;
1160 }
1161
1162 #ifdef FIXED_POINT
1163
1164 #ifndef DISABLE_FLOAT_API
1165 int opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1166       unsigned char *data, int max_data_bytes)
1167 {
1168    int i, ret;
1169    VARDECL(opus_int16, in);
1170    ALLOC_STACK;
1171
1172    ALLOC(in, frame_size*st->channels, opus_int16);
1173
1174    for (i=0;i<frame_size*st->channels;i++)
1175       in[i] = FLOAT2INT16(pcm[i]);
1176    ret = opus_encode(st, in, frame_size, data, max_data_bytes);
1177    RESTORE_STACK;
1178    return ret;
1179 }
1180 #endif
1181
1182 #else
1183 int opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1184       unsigned char *data, int max_data_bytes)
1185 {
1186    int i, ret;
1187    VARDECL(float, in);
1188    ALLOC_STACK;
1189
1190    ALLOC(in, frame_size*st->channels, float);
1191
1192    for (i=0;i<frame_size*st->channels;i++)
1193       in[i] = (1.0f/32768)*pcm[i];
1194    ret = opus_encode_float(st, in, frame_size, data, max_data_bytes);
1195    RESTORE_STACK;
1196    return ret;
1197 }
1198 #endif
1199
1200
1201 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
1202 {
1203     int ret;
1204     CELTEncoder *celt_enc;
1205     va_list ap;
1206
1207     ret = OPUS_OK;
1208     va_start(ap, request);
1209
1210     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1211
1212     switch (request)
1213     {
1214         case OPUS_SET_APPLICATION_REQUEST:
1215         {
1216             opus_int32 value = va_arg(ap, opus_int32);
1217             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
1218                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1219                || (!st->first && st->application != value))
1220             {
1221                ret = OPUS_BAD_ARG;
1222                break;
1223             }
1224             st->application = value;
1225         }
1226         break;
1227         case OPUS_GET_APPLICATION_REQUEST:
1228         {
1229             opus_int32 *value = va_arg(ap, opus_int32*);
1230             *value = st->application;
1231         }
1232         break;
1233         case OPUS_SET_BITRATE_REQUEST:
1234         {
1235             opus_int32 value = va_arg(ap, opus_int32);
1236             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1237             {
1238                 if (value <= 0)
1239                     goto bad_arg;
1240                 else if (value <= 500)
1241                     value = 500;
1242                 else if (value > (opus_int32)300000*st->channels)
1243                     value = (opus_int32)300000*st->channels;
1244             }
1245             st->user_bitrate_bps = value;
1246         }
1247         break;
1248         case OPUS_GET_BITRATE_REQUEST:
1249         {
1250             opus_int32 *value = va_arg(ap, opus_int32*);
1251             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
1252         }
1253         break;
1254         case OPUS_SET_FORCE_CHANNELS_REQUEST:
1255         {
1256             opus_int32 value = va_arg(ap, opus_int32);
1257             if((value<1 || value>st->channels) && value != OPUS_AUTO)
1258                 return OPUS_BAD_ARG;
1259             st->force_channels = value;
1260         }
1261         break;
1262         case OPUS_GET_FORCE_CHANNELS_REQUEST:
1263         {
1264             opus_int32 *value = va_arg(ap, opus_int32*);
1265             *value = st->force_channels;
1266         }
1267         break;
1268         case OPUS_SET_BANDWIDTH_REQUEST:
1269         {
1270             opus_int32 value = va_arg(ap, opus_int32);
1271             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
1272                 return OPUS_BAD_ARG;
1273             st->user_bandwidth = value;
1274             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1275                 st->silk_mode.maxInternalSampleRate = 8000;
1276             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1277                 st->silk_mode.maxInternalSampleRate = 12000;
1278             } else {
1279                 st->silk_mode.maxInternalSampleRate = 16000;
1280             }
1281         }
1282         break;
1283         case OPUS_GET_BANDWIDTH_REQUEST:
1284         {
1285             opus_int32 *value = va_arg(ap, opus_int32*);
1286             *value = st->bandwidth;
1287         }
1288         break;
1289         case OPUS_SET_DTX_REQUEST:
1290         {
1291             opus_int32 value = va_arg(ap, opus_int32);
1292             if(value<0 || value>1)
1293                 return OPUS_BAD_ARG;
1294             st->silk_mode.useDTX = value;
1295         }
1296         break;
1297         case OPUS_GET_DTX_REQUEST:
1298         {
1299             opus_int32 *value = va_arg(ap, opus_int32*);
1300             *value = st->silk_mode.useDTX;
1301         }
1302         break;
1303         case OPUS_SET_COMPLEXITY_REQUEST:
1304         {
1305             opus_int32 value = va_arg(ap, opus_int32);
1306             if(value<0 || value>10)
1307                 return OPUS_BAD_ARG;
1308             st->silk_mode.complexity = value;
1309             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
1310         }
1311         break;
1312         case OPUS_GET_COMPLEXITY_REQUEST:
1313         {
1314             opus_int32 *value = va_arg(ap, opus_int32*);
1315             *value = st->silk_mode.complexity;
1316         }
1317         break;
1318         case OPUS_SET_INBAND_FEC_REQUEST:
1319         {
1320             opus_int32 value = va_arg(ap, opus_int32);
1321             if(value<0 || value>1)
1322                 return OPUS_BAD_ARG;
1323             st->silk_mode.useInBandFEC = value;
1324         }
1325         break;
1326         case OPUS_GET_INBAND_FEC_REQUEST:
1327         {
1328             opus_int32 *value = va_arg(ap, opus_int32*);
1329             *value = st->silk_mode.useInBandFEC;
1330         }
1331         break;
1332         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1333         {
1334             opus_int32 value = va_arg(ap, opus_int32);
1335             if (value < 0 || value > 100)
1336                 return OPUS_BAD_ARG;
1337             st->silk_mode.packetLossPercentage = value;
1338             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
1339         }
1340         break;
1341         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1342         {
1343             opus_int32 *value = va_arg(ap, opus_int32*);
1344             *value = st->silk_mode.packetLossPercentage;
1345         }
1346         break;
1347         case OPUS_SET_VBR_REQUEST:
1348         {
1349             opus_int32 value = va_arg(ap, opus_int32);
1350             if(value<0 || value>1)
1351                 return OPUS_BAD_ARG;
1352             st->use_vbr = value;
1353             st->silk_mode.useCBR = 1-value;
1354         }
1355         break;
1356         case OPUS_GET_VBR_REQUEST:
1357         {
1358             opus_int32 *value = va_arg(ap, opus_int32*);
1359             *value = st->use_vbr;
1360         }
1361         break;
1362         case OPUS_SET_VOICE_RATIO_REQUEST:
1363         {
1364             opus_int32 value = va_arg(ap, opus_int32);
1365             if (value>100 || value<-1)
1366                 goto bad_arg;
1367             st->voice_ratio = value;
1368         }
1369         break;
1370         case OPUS_GET_VOICE_RATIO_REQUEST:
1371         {
1372             opus_int32 *value = va_arg(ap, opus_int32*);
1373             *value = st->voice_ratio;
1374         }
1375         break;
1376         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1377         {
1378             opus_int32 value = va_arg(ap, opus_int32);
1379             if(value<0 || value>1)
1380                 return OPUS_BAD_ARG;
1381             st->vbr_constraint = value;
1382         }
1383         break;
1384         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1385         {
1386             opus_int32 *value = va_arg(ap, opus_int32*);
1387             *value = st->vbr_constraint;
1388         }
1389         break;
1390         case OPUS_SET_SIGNAL_REQUEST:
1391         {
1392             opus_int32 value = va_arg(ap, opus_int32);
1393             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
1394                 return OPUS_BAD_ARG;
1395             st->signal_type = value;
1396         }
1397         break;
1398         case OPUS_GET_SIGNAL_REQUEST:
1399         {
1400             opus_int32 *value = va_arg(ap, opus_int32*);
1401             *value = st->signal_type;
1402         }
1403         break;
1404         case OPUS_GET_LOOKAHEAD_REQUEST:
1405         {
1406             opus_int32 *value = va_arg(ap, opus_int32*);
1407             *value = st->Fs/400;
1408             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1409                 *value += st->delay_compensation;
1410         }
1411         break;
1412         case OPUS_GET_FINAL_RANGE_REQUEST:
1413         {
1414             opus_uint32 *value = va_arg(ap, opus_uint32*);
1415             *value = st->rangeFinal;
1416         }
1417         break;
1418         case OPUS_RESET_STATE:
1419         {
1420            void *silk_enc;
1421            silk_EncControlStruct dummy;
1422            silk_enc = (char*)st+st->silk_enc_offset;
1423
1424            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
1425                  sizeof(OpusEncoder)-
1426                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
1427
1428            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1429            silk_InitEncoder( silk_enc, &dummy );
1430            st->stream_channels = st->channels;
1431            st->hybrid_stereo_width_Q14 = 1 << 14;
1432            st->first = 1;
1433            st->mode = MODE_HYBRID;
1434            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
1435            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1436         }
1437         break;
1438         case OPUS_SET_FORCE_MODE_REQUEST:
1439         {
1440             opus_int32 value = va_arg(ap, opus_int32);
1441             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
1442                goto bad_arg;
1443             st->user_forced_mode = value;
1444         }
1445         break;
1446         default:
1447             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
1448             ret = OPUS_UNIMPLEMENTED;
1449             break;
1450     }
1451     va_end(ap);
1452     return ret;
1453 bad_arg:
1454     va_end(ap);
1455     return OPUS_BAD_ARG;
1456 }
1457
1458 void opus_encoder_destroy(OpusEncoder *st)
1459 {
1460     opus_free(st);
1461 }