Optimization of the CBR loop
[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 < 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            if (max_rate < 13000)
849            {
850               st->silk_mode.maxInternalSampleRate = 12000;
851               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
852            }
853            if (max_rate < 9600)
854            {
855               st->silk_mode.maxInternalSampleRate = 8000;
856               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
857            }
858         } else {
859            st->silk_mode.maxInternalSampleRate = 16000;
860         }
861
862         st->silk_mode.useCBR = !st->use_vbr;
863
864         /* Call SILK encoder for the low band */
865         nBytes = IMIN(1275, max_data_bytes-1);
866
867         st->silk_mode.maxBits = nBytes*8;
868         /* Only allow up to 90% of the bits for hybrid mode*/
869         if (st->mode == MODE_HYBRID)
870            st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
871         if (st->silk_mode.useCBR)
872         {
873            st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
874            /* Reduce the initial target to make it easier to reach the CBR rate */
875            st->silk_mode.bitRate = 1;
876         }
877         if (redundancy)
878            st->silk_mode.maxBits -= st->silk_mode.maxBits/(1 + frame_size/(st->Fs/200));
879
880         if (prefill)
881         {
882             int zero=0;
883 #ifdef FIXED_POINT
884             pcm_silk = st->delay_buffer;
885 #else
886             for (i=0;i<st->encoder_buffer*st->channels;i++)
887                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
888 #endif
889             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
890         }
891
892 #ifdef FIXED_POINT
893         pcm_silk = pcm_buf+delay_compensation*st->channels;
894 #else
895         for (i=0;i<frame_size*st->channels;i++)
896             pcm_silk[i] = FLOAT2INT16(pcm_buf[delay_compensation*st->channels + i]);
897 #endif
898         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
899         if( ret ) {
900             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
901             /* Handle error */
902            return OPUS_INTERNAL_ERROR;
903         }
904         if (nBytes==0)
905         {
906            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
907            RESTORE_STACK;
908            return 1;
909         }
910         /* Extract SILK internal bandwidth for signaling in first byte */
911         if( st->mode == MODE_SILK_ONLY ) {
912             if( st->silk_mode.internalSampleRate == 8000 ) {
913                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
914             } else if( st->silk_mode.internalSampleRate == 12000 ) {
915                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
916             } else if( st->silk_mode.internalSampleRate == 16000 ) {
917                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
918             }
919         } else {
920             silk_assert( st->silk_mode.internalSampleRate == 16000 );
921         }
922
923         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
924         if (st->silk_mode.opusCanSwitch)
925         {
926            redundancy = 1;
927            celt_to_silk = 0;
928            st->silk_bw_switch = 1;
929         }
930     }
931
932     /* CELT processing */
933     {
934         int endband=21;
935
936         switch(curr_bandwidth)
937         {
938             case OPUS_BANDWIDTH_NARROWBAND:
939                 endband = 13;
940                 break;
941             case OPUS_BANDWIDTH_MEDIUMBAND:
942             case OPUS_BANDWIDTH_WIDEBAND:
943                 endband = 17;
944                 break;
945             case OPUS_BANDWIDTH_SUPERWIDEBAND:
946                 endband = 19;
947                 break;
948             case OPUS_BANDWIDTH_FULLBAND:
949                 endband = 21;
950                 break;
951         }
952         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
953         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
954     }
955     if (st->mode != MODE_SILK_ONLY)
956     {
957         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
958         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
959         /* Allow prediction unless we decide to disable it later */
960         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
961
962         if (st->mode == MODE_HYBRID)
963         {
964             int len;
965
966             len = (ec_tell(&enc)+7)>>3;
967             if (redundancy)
968                len += st->mode == MODE_HYBRID ? 3 : 1;
969             if( st->use_vbr ) {
970                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
971             } else {
972                 /* check if SILK used up too much */
973                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
974             }
975         } else {
976             if (st->use_vbr)
977             {
978                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
979                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
980                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps));
981                 nb_compr_bytes = max_data_bytes-1;
982             } else {
983                 nb_compr_bytes = bytes_target;
984             }
985         }
986
987     } else {
988         nb_compr_bytes = 0;
989     }
990
991     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
992     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
993     {
994        for (i=0;i<st->channels*st->Fs/400;i++)
995           tmp_prefill[i] = st->delay_buffer[(st->encoder_buffer-st->delay_compensation-st->Fs/400)*st->channels + i];
996     }
997
998     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+delay_compensation));i++)
999         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
1000     for (;i<st->encoder_buffer*st->channels;i++)
1001         st->delay_buffer[i] = pcm_buf[(frame_size+delay_compensation-st->encoder_buffer)*st->channels+i];
1002
1003
1004     if (st->mode != MODE_HYBRID || st->stream_channels==1)
1005        st->silk_mode.stereoWidth_Q14 = 1<<14;
1006     if( st->channels == 2 ) {
1007         /* Apply stereo width reduction (at low bitrates) */
1008         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1009             opus_val16 g1, g2;
1010             const CELTMode *celt_mode;
1011
1012             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1013             g1 = st->hybrid_stereo_width_Q14;
1014             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1015 #ifdef FIXED_POINT
1016             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
1017             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
1018 #else
1019             g1 *= (1./16384);
1020             g2 *= (1./16384);
1021 #endif
1022             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
1023                   frame_size, st->channels, celt_mode->window, st->Fs);
1024             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1025         }
1026     }
1027
1028     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
1029     {
1030         /* For SILK mode, the redundancy is inferred from the length */
1031         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
1032            ec_enc_bit_logp(&enc, redundancy, 12);
1033         if (redundancy)
1034         {
1035             int max_redundancy;
1036             ec_enc_bit_logp(&enc, celt_to_silk, 1);
1037             if (st->mode == MODE_HYBRID)
1038                max_redundancy = (max_data_bytes-1)-nb_compr_bytes-1;
1039             else
1040                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1041             /* Target the same bit-rate for redundancy as for the rest,
1042                up to a max of 257 bytes */
1043             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
1044             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
1045             if (st->mode == MODE_HYBRID)
1046                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
1047         }
1048     } else {
1049         redundancy = 0;
1050     }
1051
1052     if (!redundancy)
1053        st->silk_bw_switch = 0;
1054
1055     if (st->mode != MODE_CELT_ONLY)start_band=17;
1056
1057     if (st->mode == MODE_SILK_ONLY)
1058     {
1059         ret = (ec_tell(&enc)+7)>>3;
1060         ec_enc_done(&enc);
1061         /*When in LPC only mode it's perfectly
1062           reasonable to strip off trailing zero bytes as
1063           the required range decoder behavior is to
1064           fill these in. This can't be done when the MDCT
1065           modes are used because the decoder needs to know
1066           the actual length for allocation purposes.*/
1067         if(!redundancy)
1068             while(ret>2&&data[ret-1]==0)ret--;
1069         nb_compr_bytes = ret;
1070     } else {
1071        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
1072        ec_enc_shrink(&enc, nb_compr_bytes);
1073     }
1074
1075
1076     /* 5 ms redundant frame for CELT->SILK */
1077     if (redundancy && celt_to_silk)
1078     {
1079         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1080         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1081         celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
1082         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1083         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1084     }
1085
1086     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
1087
1088     if (st->mode != MODE_SILK_ONLY)
1089     {
1090         if (st->mode != st->prev_mode && st->prev_mode > 0)
1091         {
1092            unsigned char dummy[2];
1093            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1094
1095            /* Prefilling */
1096            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
1097            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1098         }
1099         ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
1100         if (ret < 0)
1101            return OPUS_INTERNAL_ERROR;
1102     }
1103
1104     /* 5 ms redundant frame for SILK->CELT */
1105     if (redundancy && !celt_to_silk)
1106     {
1107         unsigned char dummy[2];
1108         int N2, N4;
1109         N2 = st->Fs/200;
1110         N4 = st->Fs/400;
1111
1112         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1113         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1114         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1115
1116         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1117         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL);
1118
1119         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1120         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1121     }
1122
1123
1124
1125     /* Signalling the mode in the first byte */
1126     data--;
1127     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1128
1129     st->rangeFinal = enc.rng ^ redundant_rng;
1130
1131     if (to_celt)
1132         st->prev_mode = MODE_CELT_ONLY;
1133     else
1134         st->prev_mode = st->mode;
1135     st->prev_channels = st->stream_channels;
1136     st->prev_framesize = frame_size;
1137
1138     st->first = 0;
1139     if (!redundancy && st->mode==MODE_SILK_ONLY && !st->use_vbr && ret >= 2)
1140     {
1141        /* In the unlikely case that the SILK encoder busted its target, tell
1142           the decoder to call the PLC */
1143        if (ec_tell(&enc) > (max_data_bytes-1)*8)
1144        {
1145           data[1] = 0;
1146           ret = 1;
1147           st->rangeFinal = 0;
1148        }
1149        pad_frame(data, ret+1, max_data_bytes);
1150        return max_data_bytes;
1151     }
1152     RESTORE_STACK;
1153     return ret+1+redundancy_bytes;
1154 }
1155
1156 #ifdef FIXED_POINT
1157
1158 #ifndef DISABLE_FLOAT_API
1159 int opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1160       unsigned char *data, int max_data_bytes)
1161 {
1162    int i, ret;
1163    VARDECL(opus_int16, in);
1164    ALLOC_STACK;
1165
1166    ALLOC(in, frame_size*st->channels, opus_int16);
1167
1168    for (i=0;i<frame_size*st->channels;i++)
1169       in[i] = FLOAT2INT16(pcm[i]);
1170    ret = opus_encode(st, in, frame_size, data, max_data_bytes);
1171    RESTORE_STACK;
1172    return ret;
1173 }
1174 #endif
1175
1176 #else
1177 int opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1178       unsigned char *data, int max_data_bytes)
1179 {
1180    int i, ret;
1181    VARDECL(float, in);
1182    ALLOC_STACK;
1183
1184    ALLOC(in, frame_size*st->channels, float);
1185
1186    for (i=0;i<frame_size*st->channels;i++)
1187       in[i] = (1.0f/32768)*pcm[i];
1188    ret = opus_encode_float(st, in, frame_size, data, max_data_bytes);
1189    RESTORE_STACK;
1190    return ret;
1191 }
1192 #endif
1193
1194
1195 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
1196 {
1197     int ret;
1198     CELTEncoder *celt_enc;
1199     va_list ap;
1200
1201     ret = OPUS_OK;
1202     va_start(ap, request);
1203
1204     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1205
1206     switch (request)
1207     {
1208         case OPUS_SET_APPLICATION_REQUEST:
1209         {
1210             opus_int32 value = va_arg(ap, opus_int32);
1211             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
1212                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1213                || (!st->first && st->application != value))
1214             {
1215                ret = OPUS_BAD_ARG;
1216                break;
1217             }
1218             st->application = value;
1219         }
1220         break;
1221         case OPUS_GET_APPLICATION_REQUEST:
1222         {
1223             opus_int32 *value = va_arg(ap, opus_int32*);
1224             *value = st->application;
1225         }
1226         break;
1227         case OPUS_SET_BITRATE_REQUEST:
1228         {
1229             opus_int32 value = va_arg(ap, opus_int32);
1230             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1231             {
1232                 if (value <= 0)
1233                     goto bad_arg;
1234                 else if (value <= 500)
1235                     value = 500;
1236                 else if (value > (opus_int32)300000*st->channels)
1237                     value = (opus_int32)300000*st->channels;
1238             }
1239             st->user_bitrate_bps = value;
1240         }
1241         break;
1242         case OPUS_GET_BITRATE_REQUEST:
1243         {
1244             opus_int32 *value = va_arg(ap, opus_int32*);
1245             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
1246         }
1247         break;
1248         case OPUS_SET_FORCE_CHANNELS_REQUEST:
1249         {
1250             opus_int32 value = va_arg(ap, opus_int32);
1251             if((value<1 || value>st->channels) && value != OPUS_AUTO)
1252                 return OPUS_BAD_ARG;
1253             st->force_channels = value;
1254         }
1255         break;
1256         case OPUS_GET_FORCE_CHANNELS_REQUEST:
1257         {
1258             opus_int32 *value = va_arg(ap, opus_int32*);
1259             *value = st->force_channels;
1260         }
1261         break;
1262         case OPUS_SET_BANDWIDTH_REQUEST:
1263         {
1264             opus_int32 value = va_arg(ap, opus_int32);
1265             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
1266                 return OPUS_BAD_ARG;
1267             st->user_bandwidth = value;
1268             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1269                 st->silk_mode.maxInternalSampleRate = 8000;
1270             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1271                 st->silk_mode.maxInternalSampleRate = 12000;
1272             } else {
1273                 st->silk_mode.maxInternalSampleRate = 16000;
1274             }
1275         }
1276         break;
1277         case OPUS_GET_BANDWIDTH_REQUEST:
1278         {
1279             opus_int32 *value = va_arg(ap, opus_int32*);
1280             *value = st->bandwidth;
1281         }
1282         break;
1283         case OPUS_SET_DTX_REQUEST:
1284         {
1285             opus_int32 value = va_arg(ap, opus_int32);
1286             if(value<0 || value>1)
1287                 return OPUS_BAD_ARG;
1288             st->silk_mode.useDTX = value;
1289         }
1290         break;
1291         case OPUS_GET_DTX_REQUEST:
1292         {
1293             opus_int32 *value = va_arg(ap, opus_int32*);
1294             *value = st->silk_mode.useDTX;
1295         }
1296         break;
1297         case OPUS_SET_COMPLEXITY_REQUEST:
1298         {
1299             opus_int32 value = va_arg(ap, opus_int32);
1300             if(value<0 || value>10)
1301                 return OPUS_BAD_ARG;
1302             st->silk_mode.complexity = value;
1303             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
1304         }
1305         break;
1306         case OPUS_GET_COMPLEXITY_REQUEST:
1307         {
1308             opus_int32 *value = va_arg(ap, opus_int32*);
1309             *value = st->silk_mode.complexity;
1310         }
1311         break;
1312         case OPUS_SET_INBAND_FEC_REQUEST:
1313         {
1314             opus_int32 value = va_arg(ap, opus_int32);
1315             if(value<0 || value>1)
1316                 return OPUS_BAD_ARG;
1317             st->silk_mode.useInBandFEC = value;
1318         }
1319         break;
1320         case OPUS_GET_INBAND_FEC_REQUEST:
1321         {
1322             opus_int32 *value = va_arg(ap, opus_int32*);
1323             *value = st->silk_mode.useInBandFEC;
1324         }
1325         break;
1326         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1327         {
1328             opus_int32 value = va_arg(ap, opus_int32);
1329             if (value < 0 || value > 100)
1330                 return OPUS_BAD_ARG;
1331             st->silk_mode.packetLossPercentage = value;
1332             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
1333         }
1334         break;
1335         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1336         {
1337             opus_int32 *value = va_arg(ap, opus_int32*);
1338             *value = st->silk_mode.packetLossPercentage;
1339         }
1340         break;
1341         case OPUS_SET_VBR_REQUEST:
1342         {
1343             opus_int32 value = va_arg(ap, opus_int32);
1344             if(value<0 || value>1)
1345                 return OPUS_BAD_ARG;
1346             st->use_vbr = value;
1347             st->silk_mode.useCBR = 1-value;
1348         }
1349         break;
1350         case OPUS_GET_VBR_REQUEST:
1351         {
1352             opus_int32 *value = va_arg(ap, opus_int32*);
1353             *value = st->use_vbr;
1354         }
1355         break;
1356         case OPUS_SET_VOICE_RATIO_REQUEST:
1357         {
1358             opus_int32 value = va_arg(ap, opus_int32);
1359             if (value>100 || value<-1)
1360                 goto bad_arg;
1361             st->voice_ratio = value;
1362         }
1363         break;
1364         case OPUS_GET_VOICE_RATIO_REQUEST:
1365         {
1366             opus_int32 *value = va_arg(ap, opus_int32*);
1367             *value = st->voice_ratio;
1368         }
1369         break;
1370         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1371         {
1372             opus_int32 value = va_arg(ap, opus_int32);
1373             if(value<0 || value>1)
1374                 return OPUS_BAD_ARG;
1375             st->vbr_constraint = value;
1376         }
1377         break;
1378         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1379         {
1380             opus_int32 *value = va_arg(ap, opus_int32*);
1381             *value = st->vbr_constraint;
1382         }
1383         break;
1384         case OPUS_SET_SIGNAL_REQUEST:
1385         {
1386             opus_int32 value = va_arg(ap, opus_int32);
1387             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
1388                 return OPUS_BAD_ARG;
1389             st->signal_type = value;
1390         }
1391         break;
1392         case OPUS_GET_SIGNAL_REQUEST:
1393         {
1394             opus_int32 *value = va_arg(ap, opus_int32*);
1395             *value = st->signal_type;
1396         }
1397         break;
1398         case OPUS_GET_LOOKAHEAD_REQUEST:
1399         {
1400             opus_int32 *value = va_arg(ap, opus_int32*);
1401             *value = st->Fs/400;
1402             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1403                 *value += st->delay_compensation;
1404         }
1405         break;
1406         case OPUS_GET_FINAL_RANGE_REQUEST:
1407         {
1408             opus_uint32 *value = va_arg(ap, opus_uint32*);
1409             *value = st->rangeFinal;
1410         }
1411         break;
1412         case OPUS_RESET_STATE:
1413         {
1414            void *silk_enc;
1415            silk_EncControlStruct dummy;
1416            silk_enc = (char*)st+st->silk_enc_offset;
1417
1418            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
1419                  sizeof(OpusEncoder)-
1420                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
1421
1422            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1423            silk_InitEncoder( silk_enc, &dummy );
1424            st->stream_channels = st->channels;
1425            st->hybrid_stereo_width_Q14 = 1 << 14;
1426            st->first = 1;
1427            st->mode = MODE_HYBRID;
1428            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
1429            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1430         }
1431         break;
1432         case OPUS_SET_FORCE_MODE_REQUEST:
1433         {
1434             opus_int32 value = va_arg(ap, opus_int32);
1435             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
1436                goto bad_arg;
1437             st->user_forced_mode = value;
1438         }
1439         break;
1440         default:
1441             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
1442             ret = OPUS_UNIMPLEMENTED;
1443             break;
1444     }
1445     va_end(ap);
1446     return ret;
1447 bad_arg:
1448     va_end(ap);
1449     return OPUS_BAD_ARG;
1450 }
1451
1452 void opus_encoder_destroy(OpusEncoder *st)
1453 {
1454     opus_free(st);
1455 }