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