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