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