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