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