Re-enable analysis for 40- and 60-ms frames
[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.h"
44 #include "mathops.h"
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     int          variable_duration;
71     opus_int32   bitrate_bps;
72     opus_int32   user_bitrate_bps;
73     int          lsb_depth;
74     int          encoder_buffer;
75
76 #define OPUS_ENCODER_RESET_START stream_channels
77     int          stream_channels;
78     opus_int16   hybrid_stereo_width_Q14;
79     opus_int32   variable_HP_smth2_Q15;
80     opus_val16   prev_HB_gain;
81     opus_val32   hp_mem[4];
82     int          mode;
83     int          prev_mode;
84     int          prev_channels;
85     int          prev_framesize;
86     int          bandwidth;
87     int          silk_bw_switch;
88     /* Sampling rate (at the API level) */
89     int          first;
90     opus_val16   delay_buffer[MAX_ENCODER_BUFFER*2];
91 #ifndef FIXED_POINT
92     opus_val32   subframe_mem[3];
93     TonalityAnalysisState analysis;
94     int                   detected_bandwidth;
95 #endif
96     opus_uint32  rangeFinal;
97 };
98
99 /* Transition tables for the voice and music. First column is the
100    middle (memoriless) threshold. The second column is the hysteresis
101    (difference with the middle) */
102 static const opus_int32 mono_voice_bandwidth_thresholds[8] = {
103         11000, 1000, /* NB<->MB */
104         14000, 1000, /* MB<->WB */
105         17000, 1000, /* WB<->SWB */
106         20000, 1000, /* SWB<->FB */
107 };
108 static const opus_int32 mono_music_bandwidth_thresholds[8] = {
109         14000, 1000, /* MB not allowed */
110         18000, 2000, /* MB<->WB */
111         24000, 2000, /* WB<->SWB */
112         33000, 2000, /* SWB<->FB */
113 };
114 static const opus_int32 stereo_voice_bandwidth_thresholds[8] = {
115         11000, 1000, /* NB<->MB */
116         14000, 1000, /* MB<->WB */
117         21000, 2000, /* WB<->SWB */
118         32000, 2000, /* SWB<->FB */
119 };
120 static const opus_int32 stereo_music_bandwidth_thresholds[8] = {
121         14000, 1000, /* MB not allowed */
122         18000, 2000, /* MB<->WB */
123         24000, 2000, /* WB<->SWB */
124         48000, 2000, /* SWB<->FB */
125 };
126 /* Threshold bit-rates for switching between mono and stereo */
127 static const opus_int32 stereo_voice_threshold = 26000;
128 static const opus_int32 stereo_music_threshold = 36000;
129
130 /* Threshold bit-rate for switching between SILK/hybrid and CELT-only */
131 static const opus_int32 mode_thresholds[2][2] = {
132       /* voice */ /* music */
133       {  48000,      24000}, /* mono */
134       {  48000,      24000}, /* stereo */
135 };
136
137 int opus_encoder_get_size(int channels)
138 {
139     int silkEncSizeBytes, celtEncSizeBytes;
140     int ret;
141     if (channels<1 || channels > 2)
142         return 0;
143     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
144     if (ret)
145         return 0;
146     silkEncSizeBytes = align(silkEncSizeBytes);
147     celtEncSizeBytes = celt_encoder_get_size(channels);
148     return align(sizeof(OpusEncoder))+silkEncSizeBytes+celtEncSizeBytes;
149 }
150
151 int opus_encoder_init(OpusEncoder* st, opus_int32 Fs, int channels, int application)
152 {
153     void *silk_enc;
154     CELTEncoder *celt_enc;
155     int err;
156     int ret, silkEncSizeBytes;
157
158    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
159         (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
160         && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
161         return OPUS_BAD_ARG;
162
163     OPUS_CLEAR((char*)st, opus_encoder_get_size(channels));
164     /* Create SILK encoder */
165     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
166     if (ret)
167         return OPUS_BAD_ARG;
168     silkEncSizeBytes = align(silkEncSizeBytes);
169     st->silk_enc_offset = align(sizeof(OpusEncoder));
170     st->celt_enc_offset = st->silk_enc_offset+silkEncSizeBytes;
171     silk_enc = (char*)st+st->silk_enc_offset;
172     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
173
174     st->stream_channels = st->channels = channels;
175
176     st->Fs = Fs;
177
178     ret = silk_InitEncoder( silk_enc, &st->silk_mode );
179     if(ret)return OPUS_INTERNAL_ERROR;
180
181     /* default SILK parameters */
182     st->silk_mode.nChannelsAPI              = channels;
183     st->silk_mode.nChannelsInternal         = channels;
184     st->silk_mode.API_sampleRate            = st->Fs;
185     st->silk_mode.maxInternalSampleRate     = 16000;
186     st->silk_mode.minInternalSampleRate     = 8000;
187     st->silk_mode.desiredInternalSampleRate = 16000;
188     st->silk_mode.payloadSize_ms            = 20;
189     st->silk_mode.bitRate                   = 25000;
190     st->silk_mode.packetLossPercentage      = 0;
191     st->silk_mode.complexity                = 10;
192     st->silk_mode.useInBandFEC              = 0;
193     st->silk_mode.useDTX                    = 0;
194     st->silk_mode.useCBR                    = 0;
195
196     /* Create CELT encoder */
197     /* Initialize CELT encoder */
198     err = celt_encoder_init(celt_enc, Fs, channels);
199     if(err!=OPUS_OK)return OPUS_INTERNAL_ERROR;
200
201     celt_encoder_ctl(celt_enc, CELT_SET_SIGNALLING(0));
202     celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(10));
203
204     st->use_vbr = 1;
205     /* Makes constrained VBR the default (safer for real-time use) */
206     st->vbr_constraint = 1;
207     st->user_bitrate_bps = OPUS_AUTO;
208     st->bitrate_bps = 3000+Fs*channels;
209     st->application = application;
210     st->signal_type = OPUS_AUTO;
211     st->user_bandwidth = OPUS_AUTO;
212     st->max_bandwidth = OPUS_BANDWIDTH_FULLBAND;
213     st->force_channels = OPUS_AUTO;
214     st->user_forced_mode = OPUS_AUTO;
215     st->voice_ratio = -1;
216     st->encoder_buffer = st->Fs/100;
217     st->lsb_depth = 24;
218
219     /* Delay compensation of 4 ms (2.5 ms for SILK's extra look-ahead 
220        + 1.5 ms for SILK resamplers and stereo prediction) */
221     st->delay_compensation = st->Fs/250;
222
223     st->hybrid_stereo_width_Q14 = 1 << 14;
224     st->prev_HB_gain = Q15ONE;
225     st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
226     st->first = 1;
227     st->mode = MODE_HYBRID;
228     st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
229
230     return OPUS_OK;
231 }
232
233 static int pad_frame(unsigned char *data, opus_int32 len, opus_int32 new_len)
234 {
235    if (len == new_len)
236       return 0;
237    if (len > new_len)
238       return 1;
239
240    if ((data[0]&0x3)==0)
241    {
242       int i;
243       int padding, nb_255s;
244
245       padding = new_len - len;
246       if (padding >= 2)
247       {
248          nb_255s = (padding-2)/255;
249
250          for (i=len-1;i>=1;i--)
251             data[i+nb_255s+2] = data[i];
252          data[0] |= 0x3;
253          data[1] = 0x41;
254          for (i=0;i<nb_255s;i++)
255             data[i+2] = 255;
256          data[nb_255s+2] = padding-255*nb_255s-2;
257          for (i=len+3+nb_255s;i<new_len;i++)
258             data[i] = 0;
259       } else {
260          for (i=len-1;i>=1;i--)
261             data[i+1] = data[i];
262          data[0] |= 0x3;
263          data[1] = 1;
264       }
265       return 0;
266    } else {
267       return 1;
268    }
269 }
270
271 static unsigned char gen_toc(int mode, int framerate, int bandwidth, int channels)
272 {
273    int period;
274    unsigned char toc;
275    period = 0;
276    while (framerate < 400)
277    {
278        framerate <<= 1;
279        period++;
280    }
281    if (mode == MODE_SILK_ONLY)
282    {
283        toc = (bandwidth-OPUS_BANDWIDTH_NARROWBAND)<<5;
284        toc |= (period-2)<<3;
285    } else if (mode == MODE_CELT_ONLY)
286    {
287        int tmp = bandwidth-OPUS_BANDWIDTH_MEDIUMBAND;
288        if (tmp < 0)
289            tmp = 0;
290        toc = 0x80;
291        toc |= tmp << 5;
292        toc |= period<<3;
293    } else /* Hybrid */
294    {
295        toc = 0x60;
296        toc |= (bandwidth-OPUS_BANDWIDTH_SUPERWIDEBAND)<<4;
297        toc |= (period-2)<<3;
298    }
299    toc |= (channels==2)<<2;
300    return toc;
301 }
302
303 #ifndef FIXED_POINT
304 static void silk_biquad_float(
305     const opus_val16      *in,            /* I:    Input signal                   */
306     const opus_int32      *B_Q28,         /* I:    MA coefficients [3]            */
307     const opus_int32      *A_Q28,         /* I:    AR coefficients [2]            */
308     opus_val32            *S,             /* I/O:  State vector [2]               */
309     opus_val16            *out,           /* O:    Output signal                  */
310     const opus_int32      len,            /* I:    Signal length (must be even)   */
311     int stride
312 )
313 {
314     /* DIRECT FORM II TRANSPOSED (uses 2 element state vector) */
315     opus_int   k;
316     opus_val32 vout;
317     opus_val32 inval;
318     opus_val32 A[2], B[3];
319
320     A[0] = (opus_val32)(A_Q28[0] * (1.f/((opus_int32)1<<28)));
321     A[1] = (opus_val32)(A_Q28[1] * (1.f/((opus_int32)1<<28)));
322     B[0] = (opus_val32)(B_Q28[0] * (1.f/((opus_int32)1<<28)));
323     B[1] = (opus_val32)(B_Q28[1] * (1.f/((opus_int32)1<<28)));
324     B[2] = (opus_val32)(B_Q28[2] * (1.f/((opus_int32)1<<28)));
325
326     /* Negate A_Q28 values and split in two parts */
327
328     for( k = 0; k < len; k++ ) {
329         /* S[ 0 ], S[ 1 ]: Q12 */
330         inval = in[ k*stride ];
331         vout = S[ 0 ] + B[0]*inval;
332
333         S[ 0 ] = S[1] - vout*A[0] + B[1]*inval;
334
335         S[ 1 ] = - vout*A[1] + B[2]*inval;
336
337         /* Scale back to Q0 and saturate */
338         out[ k*stride ] = vout;
339     }
340 }
341 #endif
342
343 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)
344 {
345    opus_int32 B_Q28[ 3 ], A_Q28[ 2 ];
346    opus_int32 Fc_Q19, r_Q28, r_Q22;
347
348    silk_assert( cutoff_Hz <= silk_int32_MAX / SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ) );
349    Fc_Q19 = silk_DIV32_16( silk_SMULBB( SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ), cutoff_Hz ), Fs/1000 );
350    silk_assert( Fc_Q19 > 0 && Fc_Q19 < 32768 );
351
352    r_Q28 = SILK_FIX_CONST( 1.0, 28 ) - silk_MUL( SILK_FIX_CONST( 0.92, 9 ), Fc_Q19 );
353
354    /* b = r * [ 1; -2; 1 ]; */
355    /* a = [ 1; -2 * r * ( 1 - 0.5 * Fc^2 ); r^2 ]; */
356    B_Q28[ 0 ] = r_Q28;
357    B_Q28[ 1 ] = silk_LSHIFT( -r_Q28, 1 );
358    B_Q28[ 2 ] = r_Q28;
359
360    /* -r * ( 2 - Fc * Fc ); */
361    r_Q22  = silk_RSHIFT( r_Q28, 6 );
362    A_Q28[ 0 ] = silk_SMULWW( r_Q22, silk_SMULWW( Fc_Q19, Fc_Q19 ) - SILK_FIX_CONST( 2.0,  22 ) );
363    A_Q28[ 1 ] = silk_SMULWW( r_Q22, r_Q22 );
364
365 #ifdef FIXED_POINT
366    silk_biquad_alt( in, B_Q28, A_Q28, hp_mem, out, len, channels );
367    if( channels == 2 ) {
368        silk_biquad_alt( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
369    }
370 #else
371    silk_biquad_float( in, B_Q28, A_Q28, hp_mem, out, len, channels );
372    if( channels == 2 ) {
373        silk_biquad_float( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
374    }
375 #endif
376 }
377
378 #ifdef FIXED_POINT
379 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)
380 {
381    int c, i;
382    int shift;
383
384    /* Approximates -round(log2(4.*cutoff_Hz/Fs)) */
385    shift=celt_ilog2(Fs/(cutoff_Hz*3));
386    for (c=0;c<channels;c++)
387    {
388       for (i=0;i<len;i++)
389       {
390          opus_val32 x, tmp, y;
391          x = SHL32(EXTEND32(in[channels*i+c]), 15);
392          /* First stage */
393          tmp = x-hp_mem[2*c];
394          hp_mem[2*c] = hp_mem[2*c] + PSHR32(x - hp_mem[2*c], shift);
395          /* Second stage */
396          y = tmp - hp_mem[2*c+1];
397          hp_mem[2*c+1] = hp_mem[2*c+1] + PSHR32(tmp - hp_mem[2*c+1], shift);
398          out[channels*i+c] = EXTRACT16(SATURATE(PSHR32(y, 15), 32767));
399       }
400    }
401 }
402
403 #else
404 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)
405 {
406    int c, i;
407    float coef;
408
409    coef = 4.0f*cutoff_Hz/Fs;
410    for (c=0;c<channels;c++)
411    {
412       for (i=0;i<len;i++)
413       {
414          opus_val32 x, tmp, y;
415          x = in[channels*i+c];
416          /* First stage */
417          tmp = x-hp_mem[2*c];
418          hp_mem[2*c] = hp_mem[2*c] + coef*(x - hp_mem[2*c]);
419          /* Second stage */
420          y = tmp - hp_mem[2*c+1];
421          hp_mem[2*c+1] = hp_mem[2*c+1] + coef*(tmp - hp_mem[2*c+1]);
422          out[channels*i+c] = y;
423       }
424    }
425 }
426 #endif
427
428 static void stereo_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2,
429         int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
430 {
431     int i;
432     int overlap;
433     int inc;
434     inc = 48000/Fs;
435     overlap=overlap48/inc;
436     g1 = Q15ONE-g1;
437     g2 = Q15ONE-g2;
438     for (i=0;i<overlap;i++)
439     {
440        opus_val32 diff;
441        opus_val16 g, w;
442        w = MULT16_16_Q15(window[i*inc], window[i*inc]);
443        g = SHR32(MAC16_16(MULT16_16(w,g2),
444              Q15ONE-w, g1), 15);
445        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
446        diff = MULT16_16_Q15(g, diff);
447        out[i*channels] = out[i*channels] - diff;
448        out[i*channels+1] = out[i*channels+1] + diff;
449     }
450     for (;i<frame_size;i++)
451     {
452        opus_val32 diff;
453        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
454        diff = MULT16_16_Q15(g2, diff);
455        out[i*channels] = out[i*channels] - diff;
456        out[i*channels+1] = out[i*channels+1] + diff;
457     }
458 }
459
460 static void gain_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2,
461         int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
462 {
463     int i;
464     int inc;
465     int overlap;
466     int c;
467     inc = 48000/Fs;
468     overlap=overlap48/inc;
469     if (channels==1)
470     {
471        for (i=0;i<overlap;i++)
472        {
473           opus_val16 g, w;
474           w = MULT16_16_Q15(window[i*inc], window[i*inc]);
475           g = SHR32(MAC16_16(MULT16_16(w,g2),
476                 Q15ONE-w, g1), 15);
477           out[i] = MULT16_16_Q15(g, in[i]);
478        }
479     } else {
480        for (i=0;i<overlap;i++)
481        {
482           opus_val16 g, w;
483           w = MULT16_16_Q15(window[i*inc], window[i*inc]);
484           g = SHR32(MAC16_16(MULT16_16(w,g2),
485                 Q15ONE-w, g1), 15);
486           out[i*2] = MULT16_16_Q15(g, in[i*2]);
487           out[i*2+1] = MULT16_16_Q15(g, in[i*2+1]);
488        }
489     }
490     c=0;do {
491        for (i=overlap;i<frame_size;i++)
492        {
493           out[i*channels+c] = MULT16_16_Q15(g2, in[i*channels+c]);
494        }
495     }
496     while (++c<channels);
497 }
498
499 OpusEncoder *opus_encoder_create(opus_int32 Fs, int channels, int application, int *error)
500 {
501    int ret;
502    OpusEncoder *st;
503    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
504        (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
505        && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
506    {
507       if (error)
508          *error = OPUS_BAD_ARG;
509       return NULL;
510    }
511    st = (OpusEncoder *)opus_alloc(opus_encoder_get_size(channels));
512    if (st == NULL)
513    {
514       if (error)
515          *error = OPUS_ALLOC_FAIL;
516       return NULL;
517    }
518    ret = opus_encoder_init(st, Fs, channels, application);
519    if (error)
520       *error = ret;
521    if (ret != OPUS_OK)
522    {
523       opus_free(st);
524       st = NULL;
525    }
526    return st;
527 }
528
529 static opus_int32 user_bitrate_to_bitrate(OpusEncoder *st, int frame_size, int max_data_bytes)
530 {
531   if(!frame_size)frame_size=st->Fs/400;
532   if (st->user_bitrate_bps==OPUS_AUTO)
533     return 60*st->Fs/frame_size + st->Fs*st->channels;
534   else if (st->user_bitrate_bps==OPUS_BITRATE_MAX)
535     return max_data_bytes*8*st->Fs/frame_size;
536   else
537     return st->user_bitrate_bps;
538 }
539
540 #ifndef FIXED_POINT
541 /* Don't use more than 60 ms for the frame size analysis */
542 #define MAX_DYNAMIC_FRAMESIZE 24
543 /* Estimates how much the bitrate will be boosted based on the sub-frame energy */
544 static float transient_boost(const float *E, const float *E_1, int LM, int maxM)
545 {
546    int i;
547    int M;
548    float sumE=0, sumE_1=0;
549    float metric;
550
551    M = IMIN(maxM, (1<<LM)+1);
552    for (i=0;i<M;i++)
553    {
554       sumE += E[i];
555       sumE_1 += E_1[i];
556    }
557    metric = sumE*sumE_1/(M*M);
558    /*if (LM==3)
559       printf("%f\n", metric);*/
560    /*return metric>10 ? 1 : 0;*/
561    /*return MAX16(0,1-exp(-.25*(metric-2.)));*/
562    return MIN16(1,sqrt(MAX16(0,.05*(metric-2))));
563 }
564
565 /* Viterbi decoding trying to find the best frame size combination using look-ahead
566
567    State numbering:
568     0: unused
569     1:  2.5 ms
570     2:  5 ms (#1)
571     3:  5 ms (#2)
572     4: 10 ms (#1)
573     5: 10 ms (#2)
574     6: 10 ms (#3)
575     7: 10 ms (#4)
576     8: 20 ms (#1)
577     9: 20 ms (#2)
578    10: 20 ms (#3)
579    11: 20 ms (#4)
580    12: 20 ms (#5)
581    13: 20 ms (#6)
582    14: 20 ms (#7)
583    15: 20 ms (#8)
584 */
585 static int transient_viterbi(const float *E, const float *E_1, int N, int frame_cost, int rate)
586 {
587    int i;
588    float cost[MAX_DYNAMIC_FRAMESIZE][16];
589    int states[MAX_DYNAMIC_FRAMESIZE][16];
590    float best_cost;
591    int best_state;
592
593    for (i=0;i<16;i++)
594    {
595       /* Impossible state */
596       states[0][i] = -1;
597       cost[0][i] = 1e10;
598    }
599    for (i=0;i<4;i++)
600    {
601       cost[0][1<<i] = frame_cost + rate*(1<<i)*transient_boost(E, E_1, i, N+1);
602       states[0][1<<i] = i;
603    }
604    for (i=1;i<N;i++)
605    {
606       int j;
607
608       /* Follow continuations */
609       for (j=2;j<16;j++)
610       {
611          cost[i][j] = cost[i-1][j-1];
612          states[i][j] = j-1;
613       }
614
615       /* New frames */
616       for(j=0;j<4;j++)
617       {
618          int k;
619          float min_cost;
620          float curr_cost;
621          states[i][1<<j] = 1;
622          min_cost = cost[i-1][1];
623          for(k=1;k<4;k++)
624          {
625             float tmp = cost[i-1][(1<<(k+1))-1];
626             if (tmp < min_cost)
627             {
628                states[i][1<<j] = (1<<(k+1))-1;
629                min_cost = tmp;
630             }
631          }
632          curr_cost = frame_cost+rate*(1<<j)*transient_boost(E+i, E_1+i, j, N-i+1);
633          cost[i][1<<j] = min_cost;
634          /* If part of the frame is outside the analysis window, only count part of the cost */
635          if (N-i < (1<<j))
636             cost[i][1<<j] += curr_cost*(float)(N-i)/(1<<j);
637          else
638             cost[i][1<<j] += curr_cost;
639       }
640    }
641
642    best_state=1;
643    best_cost = cost[N-1][1];
644    /* Find best end state (doesn't force a frame to end at N-1) */
645    for (i=2;i<16;i++)
646    {
647       if (cost[N-1][i]<best_cost)
648       {
649          best_cost = cost[N-1][i];
650          best_state = i;
651       }
652    }
653
654    /* Follow transitions back */
655    for (i=N-1;i>=0;i--)
656    {
657       /*printf("%d ", best_state);*/
658       best_state = states[i][best_state];
659    }
660    /*printf("%d\n", best_state);*/
661    return best_state;
662 }
663
664 static int optimize_framesize(const opus_val16 *x, int len, int C, opus_int32 Fs,
665                 int bitrate, opus_val16 tonality, opus_val32 *mem, int buffering)
666 {
667    int N;
668    int i;
669    float e[MAX_DYNAMIC_FRAMESIZE+4];
670    float e_1[MAX_DYNAMIC_FRAMESIZE+3];
671    float memx;
672    int bestLM=0;
673    int subframe;
674    int pos;
675
676    subframe = Fs/400;
677    e[0]=mem[0];
678    e_1[0]=1./(EPSILON+mem[0]);
679    if (buffering)
680    {
681       /* Consider the CELT delay when not in restricted-lowdelay */
682       /* We assume the buffering is between 2.5 and 5 ms */
683       int offset = 2*subframe - buffering;
684       celt_assert(offset>=0 && offset <= subframe);
685       x += C*offset;
686       len -= offset;
687       e[1]=mem[1];
688       e_1[1]=1./(EPSILON+mem[1]);
689       e[2]=mem[2];
690       e_1[2]=1./(EPSILON+mem[2]);
691       pos = 3;
692    } else {
693       pos=1;
694    }
695    N=IMIN(len/subframe, MAX_DYNAMIC_FRAMESIZE);
696    memx = x[0];
697    for (i=0;i<N;i++)
698    {
699       float tmp;
700       float tmpx;
701       int j;
702       tmp=EPSILON;
703       if (C==1)
704       {
705          for (j=0;j<subframe;j++)
706          {
707             tmpx = x[subframe*i+j];
708             tmp += (tmpx-memx)*(tmpx-memx);
709             memx = tmpx;
710          }
711       } else {
712          for (j=0;j<subframe;j++)
713          {
714             tmpx = x[(subframe*i+j)*2]+x[(subframe*i+j)*2+1];
715             tmp += (tmpx-memx)*(tmpx-memx);
716             memx = tmpx;
717          }
718       }
719       e[i+pos] = tmp;
720       e_1[i+pos] = 1.f/tmp;
721    }
722    /* Hack to get 20 ms working with APPLICATION_AUDIO
723       The real problem is that the corresponding memory needs to use 1.5 ms
724       from this frame and 1 ms from the next frame */
725    e[i+pos] = e[i+pos-1];
726    if (buffering)
727       N=IMIN(MAX_DYNAMIC_FRAMESIZE, N+2);
728    bestLM = transient_viterbi(e, e_1, N, (1.f+.5*tonality)*(40*C+40), bitrate/400);
729    mem[0] = e[1<<bestLM];
730    if (buffering)
731    {
732       mem[1] = e[(1<<bestLM)+1];
733       mem[2] = e[(1<<bestLM)+2];
734    }
735    return bestLM;
736 }
737 #endif
738
739 opus_int32 opus_encode_native(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
740                 unsigned char *data, opus_int32 out_data_bytes, int lsb_depth)
741 {
742     void *silk_enc;
743     CELTEncoder *celt_enc;
744     int i;
745     int ret=0;
746     opus_int32 nBytes;
747     ec_enc enc;
748     int bytes_target;
749     int prefill=0;
750     int start_band = 0;
751     int redundancy = 0;
752     int redundancy_bytes = 0; /* Number of bytes to use for redundancy frame */
753     int celt_to_silk = 0;
754     VARDECL(opus_val16, pcm_buf);
755     int nb_compr_bytes;
756     int to_celt = 0;
757     opus_uint32 redundant_rng = 0;
758     int cutoff_Hz, hp_freq_smth1;
759     int voice_est; /* Probability of voice in Q7 */
760     opus_int32 equiv_rate;
761     int delay_compensation;
762     int frame_rate;
763     opus_int32 max_rate; /* Max bitrate we're allowed to use */
764     int curr_bandwidth;
765     opus_val16 HB_gain;
766     opus_int32 max_data_bytes; /* Max number of bytes we're allowed to use */
767     int extra_buffer, total_buffer;
768     int perform_analysis=0;
769     int orig_frame_size;
770 #ifndef FIXED_POINT
771     AnalysisInfo analysis_info;
772 #endif
773     VARDECL(opus_val16, tmp_prefill);
774
775     ALLOC_STACK;
776
777     max_data_bytes = IMIN(1276, out_data_bytes);
778
779     st->rangeFinal = 0;
780     if ((!st->variable_duration && 400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
781          50*frame_size != st->Fs &&  25*frame_size != st->Fs &&  50*frame_size != 3*st->Fs)
782          || (400*frame_size < st->Fs)
783          || max_data_bytes<=0
784          )
785     {
786        RESTORE_STACK;
787        return OPUS_BAD_ARG;
788     }
789     silk_enc = (char*)st+st->silk_enc_offset;
790     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
791     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
792        delay_compensation = 0;
793     else
794        delay_compensation = st->delay_compensation;
795
796     lsb_depth = IMIN(lsb_depth, st->lsb_depth);
797
798     orig_frame_size = IMIN(frame_size,st->Fs/50);
799     if (st->variable_duration)
800     {
801        int LM = 3;
802 #ifndef FIXED_POINT
803        LM = optimize_framesize(pcm, frame_size, st->channels, st->Fs, st->bitrate_bps,
804              st->analysis.prev_tonality, st->subframe_mem, delay_compensation);
805 #endif
806        while ((st->Fs/400<<LM)>frame_size)
807           LM--;
808        frame_size = (st->Fs/400<<LM);
809     }
810 #ifndef FIXED_POINT
811     /* Only perform analysis up to 20-ms frames. Longer ones will be split if
812        they're in CELT-only mode. */
813     analysis_info.valid = 0;
814     perform_analysis = st->silk_mode.complexity >= 7 && st->Fs==48000;
815     if (!perform_analysis)
816     {
817        st->voice_ratio = -1;
818        st->detected_bandwidth = 0;
819     } else if (frame_size <= st->Fs/50)
820     {
821        tonality_analysis(&st->analysis, &analysis_info, celt_enc, pcm, IMIN(480, frame_size), st->channels, lsb_depth);
822        if (frame_size > st->Fs/100)
823           tonality_analysis(&st->analysis, &analysis_info, celt_enc, pcm+(st->Fs/100)*st->channels, 480, st->channels, lsb_depth);
824        if (analysis_info.valid)
825        {
826           if (st->signal_type == OPUS_AUTO)
827              st->voice_ratio = (int)floor(.5+100*(1-analysis_info.music_prob));
828           st->detected_bandwidth = analysis_info.opus_bandwidth;
829        }
830     }
831 #endif
832
833     total_buffer = delay_compensation;
834     extra_buffer = total_buffer-delay_compensation;
835     st->bitrate_bps = user_bitrate_to_bitrate(st, frame_size, max_data_bytes);
836
837     frame_rate = st->Fs/frame_size;
838     if (max_data_bytes<3 || st->bitrate_bps < 3*frame_rate*8
839        || (frame_rate<50 && (max_data_bytes*frame_rate<300 || st->bitrate_bps < 2400)))
840     {
841        /*If the space is too low to do something useful, emit 'PLC' frames.*/
842        int tocmode = st->mode;
843        int bw = st->bandwidth == 0 ? OPUS_BANDWIDTH_NARROWBAND : st->bandwidth;
844        if (tocmode==0)
845           tocmode = MODE_SILK_ONLY;
846        if (frame_rate>100)
847           tocmode = MODE_CELT_ONLY;
848        if (frame_rate < 50)
849           tocmode = MODE_SILK_ONLY;
850        if(tocmode==MODE_SILK_ONLY&&bw>OPUS_BANDWIDTH_WIDEBAND)
851           bw=OPUS_BANDWIDTH_WIDEBAND;
852        else if (tocmode==MODE_CELT_ONLY&&bw==OPUS_BANDWIDTH_MEDIUMBAND)
853           bw=OPUS_BANDWIDTH_NARROWBAND;
854        else if (bw<=OPUS_BANDWIDTH_SUPERWIDEBAND)
855           bw=OPUS_BANDWIDTH_SUPERWIDEBAND;
856        data[0] = gen_toc(tocmode, frame_rate, bw, st->stream_channels);
857        RESTORE_STACK;
858        return 1;
859     }
860     if (!st->use_vbr)
861     {
862        int cbrBytes;
863        cbrBytes = IMIN( (st->bitrate_bps + 4*frame_rate)/(8*frame_rate) , max_data_bytes);
864        st->bitrate_bps = cbrBytes * (8*frame_rate);
865        max_data_bytes = cbrBytes;
866     }
867     max_rate = frame_rate*max_data_bytes*8;
868
869     /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */
870     equiv_rate = st->bitrate_bps - 60*(st->Fs/frame_size - 50);
871
872     if (st->signal_type == OPUS_SIGNAL_VOICE)
873        voice_est = 127;
874     else if (st->signal_type == OPUS_SIGNAL_MUSIC)
875        voice_est = 0;
876     else if (st->voice_ratio >= 0)
877        voice_est = st->voice_ratio*327>>8;
878     else if (st->application == OPUS_APPLICATION_VOIP)
879        voice_est = 115;
880     else
881        voice_est = 48;
882
883     if (st->force_channels!=OPUS_AUTO && st->channels == 2)
884     {
885         st->stream_channels = st->force_channels;
886     } else {
887 #ifdef FUZZING
888        /* Random mono/stereo decision */
889        if (st->channels == 2 && (rand()&0x1F)==0)
890           st->stream_channels = 3-st->stream_channels;
891 #else
892        /* Rate-dependent mono-stereo decision */
893        if (st->channels == 2)
894        {
895           opus_int32 stereo_threshold;
896           stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14);
897           if (st->stream_channels == 2)
898              stereo_threshold -= 4000;
899           else
900              stereo_threshold += 4000;
901           st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1;
902        } else {
903           st->stream_channels = st->channels;
904        }
905 #endif
906     }
907
908     /* Mode selection depending on application and signal type */
909     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
910     {
911        st->mode = MODE_CELT_ONLY;
912     } else if (st->user_forced_mode == OPUS_AUTO)
913     {
914 #ifdef FUZZING
915        /* Random mode switching */
916        if ((rand()&0xF)==0)
917        {
918           if ((rand()&0x1)==0)
919              st->mode = MODE_CELT_ONLY;
920           else
921              st->mode = MODE_SILK_ONLY;
922        } else {
923           if (st->prev_mode==MODE_CELT_ONLY)
924              st->mode = MODE_CELT_ONLY;
925           else
926              st->mode = MODE_SILK_ONLY;
927        }
928 #else
929        int chan;
930        opus_int32 mode_voice, mode_music;
931        opus_int32 threshold;
932
933        chan = (st->channels==2) && st->force_channels!=1;
934        mode_voice = mode_thresholds[chan][0];
935        mode_music = mode_thresholds[chan][1];
936        threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14);
937
938        /* Hysteresis */
939        if (st->prev_mode == MODE_CELT_ONLY)
940            threshold -= 4000;
941        else if (st->prev_mode>0)
942            threshold += 4000;
943
944        st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY;
945
946        /* When FEC is enabled and there's enough packet loss, use SILK */
947        if (st->silk_mode.useInBandFEC && st->silk_mode.packetLossPercentage > (128-voice_est)>>4)
948           st->mode = MODE_SILK_ONLY;
949        /* When encoding voice and DTX is enabled, set the encoder to SILK mode (at least for now) */
950        if (st->silk_mode.useDTX && voice_est > 100)
951           st->mode = MODE_SILK_ONLY;
952 #endif
953     } else {
954        st->mode = st->user_forced_mode;
955     }
956
957     /* Override the chosen mode to make sure we meet the requested frame size */
958     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
959        st->mode = MODE_CELT_ONLY;
960
961     if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0
962           && st->mode != MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)
963     {
964        /* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */
965        st->silk_mode.toMono = 1;
966        st->stream_channels = 2;
967     } else {
968        st->silk_mode.toMono = 0;
969     }
970
971     if (st->prev_mode > 0 &&
972         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
973     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
974     {
975         redundancy = 1;
976         celt_to_silk = (st->mode != MODE_CELT_ONLY);
977         if (!celt_to_silk)
978         {
979             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
980             if (frame_size >= st->Fs/100)
981             {
982                 st->mode = st->prev_mode;
983                 to_celt = 1;
984             } else {
985                 redundancy=0;
986             }
987         }
988     }
989     /* For the first frame at a new SILK bandwidth */
990     if (st->silk_bw_switch)
991     {
992        redundancy = 1;
993        celt_to_silk = 1;
994        st->silk_bw_switch = 0;
995     }
996
997     if (redundancy)
998     {
999        /* Fair share of the max size allowed */
1000        redundancy_bytes = IMIN(257, max_data_bytes*(opus_int32)(st->Fs/200)/(frame_size+st->Fs/200));
1001        /* For VBR, target the actual bitrate (subject to the limit above) */
1002        if (st->use_vbr)
1003           redundancy_bytes = IMIN(redundancy_bytes, st->bitrate_bps/1600);
1004     }
1005
1006     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
1007     {
1008         silk_EncControlStruct dummy;
1009         silk_InitEncoder( silk_enc, &dummy);
1010         prefill=1;
1011     }
1012
1013     /* Automatic (rate-dependent) bandwidth selection */
1014     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
1015     {
1016         const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds;
1017         opus_int32 bandwidth_thresholds[8];
1018         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
1019         opus_int32 equiv_rate2;
1020
1021         equiv_rate2 = equiv_rate;
1022         if (st->mode != MODE_CELT_ONLY)
1023         {
1024            /* Adjust the threshold +/- 10% depending on complexity */
1025            equiv_rate2 = equiv_rate2 * (45+st->silk_mode.complexity)/50;
1026            /* CBR is less efficient by ~1 kb/s */
1027            if (!st->use_vbr)
1028               equiv_rate2 -= 1000;
1029         }
1030         if (st->channels==2 && st->force_channels!=1)
1031         {
1032            voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds;
1033            music_bandwidth_thresholds = stereo_music_bandwidth_thresholds;
1034         } else {
1035            voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds;
1036            music_bandwidth_thresholds = mono_music_bandwidth_thresholds;
1037         }
1038         /* Interpolate bandwidth thresholds depending on voice estimation */
1039         for (i=0;i<8;i++)
1040         {
1041            bandwidth_thresholds[i] = music_bandwidth_thresholds[i]
1042                     + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14);
1043         }
1044         do {
1045             int threshold, hysteresis;
1046             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
1047             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
1048             if (!st->first)
1049             {
1050                 if (st->bandwidth >= bandwidth)
1051                     threshold -= hysteresis;
1052                 else
1053                     threshold += hysteresis;
1054             }
1055             if (equiv_rate2 >= threshold)
1056                 break;
1057         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
1058         st->bandwidth = bandwidth;
1059         /* Prevents any transition to SWB/FB until the SILK layer has fully
1060            switched to WB mode and turned the variable LP filter off */
1061         if (!st->first && st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1062             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1063     }
1064
1065     if (st->bandwidth>st->max_bandwidth)
1066        st->bandwidth = st->max_bandwidth;
1067
1068     if (st->user_bandwidth != OPUS_AUTO)
1069         st->bandwidth = st->user_bandwidth;
1070
1071     /* This prevents us from using hybrid at unsafe CBR/max rates */
1072     if (st->mode != MODE_CELT_ONLY && max_rate < 15000)
1073     {
1074        st->bandwidth = IMIN(st->bandwidth, OPUS_BANDWIDTH_WIDEBAND);
1075     }
1076
1077     /* Prevents Opus from wasting bits on frequencies that are above
1078        the Nyquist rate of the input signal */
1079     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
1080         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1081     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1082         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1083     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
1084         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1085     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
1086         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1087 #ifndef FIXED_POINT
1088     if (st->detected_bandwidth && st->user_bandwidth == OPUS_AUTO)
1089     {
1090        st->bandwidth = IMIN(st->bandwidth, st->detected_bandwidth);
1091     }
1092 #endif
1093     celt_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(lsb_depth));
1094
1095     /* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */
1096     if (max_data_bytes < (frame_rate > 50 ? 12000 : 8000)*frame_size / (st->Fs * 8))
1097        st->mode = MODE_CELT_ONLY;
1098
1099     /* CELT mode doesn't support mediumband, use wideband instead */
1100     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1101         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1102
1103     /* Can't support higher than wideband for >20 ms frames */
1104     if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND))
1105     {
1106        VARDECL(unsigned char, tmp_data);
1107        int nb_frames;
1108        int bak_mode, bak_bandwidth, bak_channels, bak_to_mono;
1109        OpusRepacketizer rp;
1110        opus_int32 bytes_per_frame;
1111
1112
1113        nb_frames = frame_size > st->Fs/25 ? 3 : 2;
1114        bytes_per_frame = IMIN(1276,(out_data_bytes-3)/nb_frames);
1115
1116        ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char);
1117
1118        opus_repacketizer_init(&rp);
1119
1120        bak_mode = st->user_forced_mode;
1121        bak_bandwidth = st->user_bandwidth;
1122        bak_channels = st->force_channels;
1123
1124        st->user_forced_mode = st->mode;
1125        st->user_bandwidth = st->bandwidth;
1126        st->force_channels = st->stream_channels;
1127        bak_to_mono = st->silk_mode.toMono;
1128
1129        if (bak_to_mono)
1130           st->force_channels = 1;
1131        else
1132           st->prev_channels = st->stream_channels;
1133        for (i=0;i<nb_frames;i++)
1134        {
1135           int tmp_len;
1136           st->silk_mode.toMono = 0;
1137           /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
1138           if (to_celt && i==nb_frames-1)
1139              st->user_forced_mode = MODE_CELT_ONLY;
1140           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, lsb_depth);
1141           if (tmp_len<0)
1142           {
1143              RESTORE_STACK;
1144              return OPUS_INTERNAL_ERROR;
1145           }
1146           ret = opus_repacketizer_cat(&rp, tmp_data+i*bytes_per_frame, tmp_len);
1147           if (ret<0)
1148           {
1149              RESTORE_STACK;
1150              return OPUS_INTERNAL_ERROR;
1151           }
1152        }
1153        ret = opus_repacketizer_out(&rp, data, out_data_bytes);
1154        if (ret<0)
1155        {
1156           RESTORE_STACK;
1157           return OPUS_INTERNAL_ERROR;
1158        }
1159        st->user_forced_mode = bak_mode;
1160        st->user_bandwidth = bak_bandwidth;
1161        st->force_channels = bak_channels;
1162        st->silk_mode.toMono = bak_to_mono;
1163        RESTORE_STACK;
1164        return ret;
1165     }
1166     /* Perform analysis for 40-60 ms frames */
1167     if (perform_analysis && frame_size > st->Fs/50)
1168     {
1169        int nb_analysis = frame_size/(st->Fs/100);
1170        for (i=0;i<nb_analysis;i++)
1171           tonality_analysis(&st->analysis, &analysis_info, celt_enc, pcm+i*(st->Fs/100)*st->channels, 480, st->channels, lsb_depth);
1172        st->voice_ratio = (int)floor(.5+100*(1-analysis_info.music_prob));
1173     }
1174
1175     curr_bandwidth = st->bandwidth;
1176
1177     /* Chooses the appropriate mode for speech
1178        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
1179     if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1180         st->mode = MODE_HYBRID;
1181     if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
1182         st->mode = MODE_SILK_ONLY;
1183
1184     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
1185     bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
1186
1187     data += 1;
1188
1189     ec_enc_init(&enc, data, max_data_bytes-1);
1190
1191     ALLOC(pcm_buf, (total_buffer+frame_size)*st->channels, opus_val16);
1192     for (i=0;i<total_buffer*st->channels;i++)
1193        pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-total_buffer)*st->channels+i];
1194
1195     if (st->mode == MODE_CELT_ONLY)
1196        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1197     else
1198        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
1199
1200     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
1201           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
1202
1203     /* convert from log scale to Hertz */
1204     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
1205
1206     if (st->application == OPUS_APPLICATION_VOIP)
1207     {
1208        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1209     } else {
1210        dc_reject(pcm, 3, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1211     }
1212
1213
1214
1215     /* SILK processing */
1216     HB_gain = Q15ONE;
1217     if (st->mode != MODE_CELT_ONLY)
1218     {
1219         opus_int32 total_bitRate, celt_rate;
1220 #ifdef FIXED_POINT
1221        const opus_int16 *pcm_silk;
1222 #else
1223        VARDECL(opus_int16, pcm_silk);
1224        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
1225 #endif
1226
1227         /* Distribute bits between SILK and CELT */
1228         total_bitRate = 8 * bytes_target * frame_rate;
1229         if( st->mode == MODE_HYBRID ) {
1230             int HB_gain_ref;
1231             /* Base rate for SILK */
1232             st->silk_mode.bitRate = st->stream_channels * ( 5000 + 1000 * ( st->Fs == 100 * frame_size ) );
1233             if( curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
1234                 /* SILK gets 2/3 of the remaining bits */
1235                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 2 / 3;
1236             } else { /* FULLBAND */
1237                 /* SILK gets 3/5 of the remaining bits */
1238                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 3 / 5;
1239             }
1240             /* Don't let SILK use more than 80% */
1241             if( st->silk_mode.bitRate > total_bitRate * 4/5 ) {
1242                 st->silk_mode.bitRate = total_bitRate * 4/5;
1243             }
1244             /* Increasingly attenuate high band when it gets allocated fewer bits */
1245             celt_rate = total_bitRate - st->silk_mode.bitRate;
1246             HB_gain_ref = (curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND) ? 2000 : 2400;
1247             HB_gain = SHL32((opus_val32)celt_rate, 9) / SHR32((opus_val32)celt_rate + st->stream_channels*HB_gain_ref, 6);
1248         } else {
1249             /* SILK gets all bits */
1250             st->silk_mode.bitRate = total_bitRate;
1251         }
1252
1253         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
1254         st->silk_mode.nChannelsAPI = st->channels;
1255         st->silk_mode.nChannelsInternal = st->stream_channels;
1256         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1257             st->silk_mode.desiredInternalSampleRate = 8000;
1258         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1259             st->silk_mode.desiredInternalSampleRate = 12000;
1260         } else {
1261             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
1262             st->silk_mode.desiredInternalSampleRate = 16000;
1263         }
1264         if( st->mode == MODE_HYBRID ) {
1265             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
1266             st->silk_mode.minInternalSampleRate = 16000;
1267         } else {
1268             st->silk_mode.minInternalSampleRate = 8000;
1269         }
1270
1271         if (st->mode == MODE_SILK_ONLY)
1272         {
1273            opus_int32 effective_max_rate = max_rate;
1274            st->silk_mode.maxInternalSampleRate = 16000;
1275            if (frame_rate > 50)
1276               effective_max_rate = effective_max_rate*2/3;
1277            if (effective_max_rate < 13000)
1278            {
1279               st->silk_mode.maxInternalSampleRate = 12000;
1280               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
1281            }
1282            if (effective_max_rate < 9600)
1283            {
1284               st->silk_mode.maxInternalSampleRate = 8000;
1285               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
1286            }
1287         } else {
1288            st->silk_mode.maxInternalSampleRate = 16000;
1289         }
1290
1291         st->silk_mode.useCBR = !st->use_vbr;
1292
1293         /* Call SILK encoder for the low band */
1294         nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes);
1295
1296         st->silk_mode.maxBits = nBytes*8;
1297         /* Only allow up to 90% of the bits for hybrid mode*/
1298         if (st->mode == MODE_HYBRID)
1299            st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
1300         if (st->silk_mode.useCBR)
1301         {
1302            st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
1303            /* Reduce the initial target to make it easier to reach the CBR rate */
1304            st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000);
1305         }
1306
1307         if (prefill)
1308         {
1309             opus_int32 zero=0;
1310             const CELTMode *celt_mode;
1311             int prefill_offset;
1312             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1313             /* Use a smooth onset for the SILK prefill to avoid the encoder trying to encode
1314                a discontinuity. The exact location is what we need to avoid leaving any "gap"
1315                in the audio when mixing with the redundant CELT frame. Here we can afford to
1316                overwrite st->delay_buffer because the only thing that uses it before it gets
1317                rewritten is tmp_prefill[] and even then only the part after the ramp really
1318                gets used (rather than sent to the encoder and discarded) */
1319             prefill_offset = st->channels*(st->encoder_buffer-st->delay_compensation-st->Fs/400);
1320             gain_fade(st->delay_buffer+prefill_offset, st->delay_buffer+prefill_offset,
1321                   0, Q15ONE, celt_mode->overlap, st->Fs/400, st->channels, celt_mode->window, st->Fs);
1322             for(i=0;i<prefill_offset;i++)
1323                st->delay_buffer[i]=0;
1324 #ifdef FIXED_POINT
1325             pcm_silk = st->delay_buffer;
1326 #else
1327             for (i=0;i<st->encoder_buffer*st->channels;i++)
1328                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
1329 #endif
1330             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
1331         }
1332
1333 #ifdef FIXED_POINT
1334         pcm_silk = pcm_buf+total_buffer*st->channels;
1335 #else
1336         for (i=0;i<frame_size*st->channels;i++)
1337             pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
1338 #endif
1339         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
1340         if( ret ) {
1341             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
1342             /* Handle error */
1343            RESTORE_STACK;
1344            return OPUS_INTERNAL_ERROR;
1345         }
1346         if (nBytes==0)
1347         {
1348            st->rangeFinal = 0;
1349            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1350            RESTORE_STACK;
1351            return 1;
1352         }
1353         /* Extract SILK internal bandwidth for signaling in first byte */
1354         if( st->mode == MODE_SILK_ONLY ) {
1355             if( st->silk_mode.internalSampleRate == 8000 ) {
1356                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1357             } else if( st->silk_mode.internalSampleRate == 12000 ) {
1358                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1359             } else if( st->silk_mode.internalSampleRate == 16000 ) {
1360                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1361             }
1362         } else {
1363             silk_assert( st->silk_mode.internalSampleRate == 16000 );
1364         }
1365
1366         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
1367         /* FIXME: How do we allocate the redundancy for CBR? */
1368         if (st->silk_mode.opusCanSwitch)
1369         {
1370            redundancy = 1;
1371            celt_to_silk = 0;
1372            st->silk_bw_switch = 1;
1373         }
1374     }
1375
1376     /* CELT processing */
1377     {
1378         int endband=21;
1379
1380         switch(curr_bandwidth)
1381         {
1382             case OPUS_BANDWIDTH_NARROWBAND:
1383                 endband = 13;
1384                 break;
1385             case OPUS_BANDWIDTH_MEDIUMBAND:
1386             case OPUS_BANDWIDTH_WIDEBAND:
1387                 endband = 17;
1388                 break;
1389             case OPUS_BANDWIDTH_SUPERWIDEBAND:
1390                 endband = 19;
1391                 break;
1392             case OPUS_BANDWIDTH_FULLBAND:
1393                 endband = 21;
1394                 break;
1395         }
1396         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
1397         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
1398     }
1399     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1400     if (st->mode != MODE_SILK_ONLY)
1401     {
1402         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1403         /* Allow prediction unless we decide to disable it later */
1404         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
1405
1406         if (st->mode == MODE_HYBRID)
1407         {
1408             int len;
1409
1410             len = (ec_tell(&enc)+7)>>3;
1411             if (redundancy)
1412                len += st->mode == MODE_HYBRID ? 3 : 1;
1413             if( st->use_vbr ) {
1414                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
1415             } else {
1416                 /* check if SILK used up too much */
1417                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
1418             }
1419         } else {
1420             if (st->use_vbr)
1421             {
1422                 opus_int32 bonus=0;
1423 #ifndef FIXED_POINT
1424                 if (orig_frame_size != frame_size)
1425                 {
1426                    bonus = (40*st->stream_channels+40)*(48000/frame_size-48000/orig_frame_size);
1427                    if (analysis_info.valid)
1428                       bonus = bonus*(1.f+.5*analysis_info.tonality);
1429                 }
1430 #endif
1431                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
1432                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
1433                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps+bonus));
1434                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
1435             } else {
1436                 nb_compr_bytes = bytes_target;
1437             }
1438         }
1439
1440     } else {
1441         nb_compr_bytes = 0;
1442     }
1443
1444     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
1445     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
1446     {
1447        for (i=0;i<st->channels*st->Fs/400;i++)
1448           tmp_prefill[i] = st->delay_buffer[(extra_buffer+st->encoder_buffer-total_buffer-st->Fs/400)*st->channels + i];
1449     }
1450
1451     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+total_buffer));i++)
1452         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
1453     for (;i<st->encoder_buffer*st->channels;i++)
1454         st->delay_buffer[i] = pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels+i];
1455
1456     /* gain_fade() and stereo_fade() need to be after the buffer copying
1457        because we don't want any of this to affect the SILK part */
1458     if( st->prev_HB_gain < Q15ONE || HB_gain < Q15ONE ) {
1459        const CELTMode *celt_mode;
1460
1461        celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1462        gain_fade(pcm_buf+extra_buffer*st->channels, pcm_buf+extra_buffer*st->channels,
1463              st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs);
1464     }
1465     st->prev_HB_gain = HB_gain;
1466     if (st->mode != MODE_HYBRID || st->stream_channels==1)
1467        st->silk_mode.stereoWidth_Q14 = 1<<14;
1468     if( st->channels == 2 ) {
1469         /* Apply stereo width reduction (at low bitrates) */
1470         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1471             opus_val16 g1, g2;
1472             const CELTMode *celt_mode;
1473
1474             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1475             g1 = st->hybrid_stereo_width_Q14;
1476             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1477 #ifdef FIXED_POINT
1478             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
1479             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
1480 #else
1481             g1 *= (1.f/16384);
1482             g2 *= (1.f/16384);
1483 #endif
1484             stereo_fade(pcm_buf+extra_buffer*st->channels, pcm_buf+extra_buffer*st->channels, g1, g2, celt_mode->overlap,
1485                   frame_size, st->channels, celt_mode->window, st->Fs);
1486             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1487         }
1488     }
1489
1490     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
1491     {
1492         /* For SILK mode, the redundancy is inferred from the length */
1493         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
1494            ec_enc_bit_logp(&enc, redundancy, 12);
1495         if (redundancy)
1496         {
1497             int max_redundancy;
1498             ec_enc_bit_logp(&enc, celt_to_silk, 1);
1499             if (st->mode == MODE_HYBRID)
1500                max_redundancy = (max_data_bytes-1)-nb_compr_bytes-1;
1501             else
1502                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1503             /* Target the same bit-rate for redundancy as for the rest,
1504                up to a max of 257 bytes */
1505             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
1506             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
1507             if (st->mode == MODE_HYBRID)
1508                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
1509         }
1510     } else {
1511         redundancy = 0;
1512     }
1513
1514     if (!redundancy)
1515     {
1516        st->silk_bw_switch = 0;
1517        redundancy_bytes = 0;
1518     }
1519     if (st->mode != MODE_CELT_ONLY)start_band=17;
1520
1521     if (st->mode == MODE_SILK_ONLY)
1522     {
1523         ret = (ec_tell(&enc)+7)>>3;
1524         ec_enc_done(&enc);
1525         nb_compr_bytes = ret;
1526     } else {
1527        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
1528        ec_enc_shrink(&enc, nb_compr_bytes);
1529     }
1530
1531
1532     /* 5 ms redundant frame for CELT->SILK */
1533     if (redundancy && celt_to_silk)
1534     {
1535         int err;
1536         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1537         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1538         err = celt_encode_with_ec(celt_enc, pcm_buf+extra_buffer*st->channels, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
1539         if (err < 0)
1540         {
1541            RESTORE_STACK;
1542            return OPUS_INTERNAL_ERROR;
1543         }
1544         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1545         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1546     }
1547
1548     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
1549
1550     if (st->mode != MODE_SILK_ONLY)
1551     {
1552         if (st->mode != st->prev_mode && st->prev_mode > 0)
1553         {
1554            unsigned char dummy[2];
1555            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1556
1557            /* Prefilling */
1558            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
1559            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1560         }
1561         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
1562         if (ec_tell(&enc) <= 8*nb_compr_bytes)
1563         {
1564 #ifndef FIXED_POINT
1565            if (perform_analysis)
1566               celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(&analysis_info));
1567 #endif
1568            ret = celt_encode_with_ec(celt_enc, pcm_buf+extra_buffer*st->channels, frame_size, NULL, nb_compr_bytes, &enc);
1569            if (ret < 0)
1570            {
1571               RESTORE_STACK;
1572               return OPUS_INTERNAL_ERROR;
1573            }
1574         }
1575     }
1576
1577     /* 5 ms redundant frame for SILK->CELT */
1578     if (redundancy && !celt_to_silk)
1579     {
1580         int err;
1581         unsigned char dummy[2];
1582         int N2, N4;
1583         N2 = st->Fs/200;
1584         N4 = st->Fs/400;
1585
1586         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1587         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1588         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1589
1590         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1591         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(extra_buffer+frame_size-N2-N4), N4, dummy, 2, NULL);
1592
1593         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(extra_buffer+frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1594         if (err < 0)
1595         {
1596            RESTORE_STACK;
1597            return OPUS_INTERNAL_ERROR;
1598         }
1599         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1600     }
1601
1602
1603
1604     /* Signalling the mode in the first byte */
1605     data--;
1606     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1607
1608     st->rangeFinal = enc.rng ^ redundant_rng;
1609
1610     if (to_celt)
1611         st->prev_mode = MODE_CELT_ONLY;
1612     else
1613         st->prev_mode = st->mode;
1614     st->prev_channels = st->stream_channels;
1615     st->prev_framesize = frame_size;
1616
1617     st->first = 0;
1618
1619     /* In the unlikely case that the SILK encoder busted its target, tell
1620        the decoder to call the PLC */
1621     if (ec_tell(&enc) > (max_data_bytes-1)*8)
1622     {
1623        if (max_data_bytes < 2)
1624        {
1625           RESTORE_STACK;
1626           return OPUS_BUFFER_TOO_SMALL;
1627        }
1628        data[1] = 0;
1629        ret = 1;
1630        st->rangeFinal = 0;
1631     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
1632     {
1633        /*When in LPC only mode it's perfectly
1634          reasonable to strip off trailing zero bytes as
1635          the required range decoder behavior is to
1636          fill these in. This can't be done when the MDCT
1637          modes are used because the decoder needs to know
1638          the actual length for allocation purposes.*/
1639        while(ret>2&&data[ret]==0)ret--;
1640     }
1641     /* Count ToC and redundancy */
1642     ret += 1+redundancy_bytes;
1643     if (!st->use_vbr && ret >= 3)
1644     {
1645        if (pad_frame(data, ret, max_data_bytes))
1646        {
1647           RESTORE_STACK;
1648           return OPUS_INTERNAL_ERROR;
1649        }
1650        ret = max_data_bytes;
1651     }
1652     RESTORE_STACK;
1653     return ret;
1654 }
1655
1656 #ifdef FIXED_POINT
1657
1658 #ifndef DISABLE_FLOAT_API
1659 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1660       unsigned char *data, opus_int32 max_data_bytes)
1661 {
1662    int i, ret;
1663    VARDECL(opus_int16, in);
1664    ALLOC_STACK;
1665
1666    if(frame_size<0)
1667    {
1668       RESTORE_STACK;
1669       return OPUS_BAD_ARG;
1670    }
1671
1672    ALLOC(in, frame_size*st->channels, opus_int16);
1673
1674    for (i=0;i<frame_size*st->channels;i++)
1675       in[i] = FLOAT2INT16(pcm[i]);
1676    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16);
1677    RESTORE_STACK;
1678    return ret;
1679 }
1680 #endif
1681
1682 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1683                 unsigned char *data, opus_int32 out_data_bytes)
1684 {
1685    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 16);
1686 }
1687
1688 #else
1689 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1690       unsigned char *data, opus_int32 max_data_bytes)
1691 {
1692    int i, ret;
1693    VARDECL(float, in);
1694    ALLOC_STACK;
1695
1696    ALLOC(in, frame_size*st->channels, float);
1697
1698    for (i=0;i<frame_size*st->channels;i++)
1699       in[i] = (1.0f/32768)*pcm[i];
1700    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16);
1701    RESTORE_STACK;
1702    return ret;
1703 }
1704 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1705                       unsigned char *data, opus_int32 out_data_bytes)
1706 {
1707    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 24);
1708
1709 }
1710 #endif
1711
1712
1713 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
1714 {
1715     int ret;
1716     CELTEncoder *celt_enc;
1717     va_list ap;
1718
1719     ret = OPUS_OK;
1720     va_start(ap, request);
1721
1722     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1723
1724     switch (request)
1725     {
1726         case OPUS_SET_APPLICATION_REQUEST:
1727         {
1728             opus_int32 value = va_arg(ap, opus_int32);
1729             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
1730                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1731                || (!st->first && st->application != value))
1732             {
1733                ret = OPUS_BAD_ARG;
1734                break;
1735             }
1736             st->application = value;
1737         }
1738         break;
1739         case OPUS_GET_APPLICATION_REQUEST:
1740         {
1741             opus_int32 *value = va_arg(ap, opus_int32*);
1742             *value = st->application;
1743         }
1744         break;
1745         case OPUS_SET_BITRATE_REQUEST:
1746         {
1747             opus_int32 value = va_arg(ap, opus_int32);
1748             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1749             {
1750                 if (value <= 0)
1751                     goto bad_arg;
1752                 else if (value <= 500)
1753                     value = 500;
1754                 else if (value > (opus_int32)300000*st->channels)
1755                     value = (opus_int32)300000*st->channels;
1756             }
1757             st->user_bitrate_bps = value;
1758         }
1759         break;
1760         case OPUS_GET_BITRATE_REQUEST:
1761         {
1762             opus_int32 *value = va_arg(ap, opus_int32*);
1763             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
1764         }
1765         break;
1766         case OPUS_SET_FORCE_CHANNELS_REQUEST:
1767         {
1768             opus_int32 value = va_arg(ap, opus_int32);
1769             if((value<1 || value>st->channels) && value != OPUS_AUTO)
1770                 return OPUS_BAD_ARG;
1771             st->force_channels = value;
1772         }
1773         break;
1774         case OPUS_GET_FORCE_CHANNELS_REQUEST:
1775         {
1776             opus_int32 *value = va_arg(ap, opus_int32*);
1777             *value = st->force_channels;
1778         }
1779         break;
1780         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
1781         {
1782             opus_int32 value = va_arg(ap, opus_int32);
1783             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND)
1784                 return OPUS_BAD_ARG;
1785             st->max_bandwidth = value;
1786             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1787                 st->silk_mode.maxInternalSampleRate = 8000;
1788             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1789                 st->silk_mode.maxInternalSampleRate = 12000;
1790             } else {
1791                 st->silk_mode.maxInternalSampleRate = 16000;
1792             }
1793         }
1794         break;
1795         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
1796         {
1797             opus_int32 *value = va_arg(ap, opus_int32*);
1798             *value = st->max_bandwidth;
1799         }
1800         break;
1801         case OPUS_SET_BANDWIDTH_REQUEST:
1802         {
1803             opus_int32 value = va_arg(ap, opus_int32);
1804             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
1805                 return OPUS_BAD_ARG;
1806             st->user_bandwidth = value;
1807             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1808                 st->silk_mode.maxInternalSampleRate = 8000;
1809             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1810                 st->silk_mode.maxInternalSampleRate = 12000;
1811             } else {
1812                 st->silk_mode.maxInternalSampleRate = 16000;
1813             }
1814         }
1815         break;
1816         case OPUS_GET_BANDWIDTH_REQUEST:
1817         {
1818             opus_int32 *value = va_arg(ap, opus_int32*);
1819             *value = st->bandwidth;
1820         }
1821         break;
1822         case OPUS_SET_DTX_REQUEST:
1823         {
1824             opus_int32 value = va_arg(ap, opus_int32);
1825             if(value<0 || value>1)
1826                 return OPUS_BAD_ARG;
1827             st->silk_mode.useDTX = value;
1828         }
1829         break;
1830         case OPUS_GET_DTX_REQUEST:
1831         {
1832             opus_int32 *value = va_arg(ap, opus_int32*);
1833             *value = st->silk_mode.useDTX;
1834         }
1835         break;
1836         case OPUS_SET_COMPLEXITY_REQUEST:
1837         {
1838             opus_int32 value = va_arg(ap, opus_int32);
1839             if(value<0 || value>10)
1840                 return OPUS_BAD_ARG;
1841             st->silk_mode.complexity = value;
1842             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
1843         }
1844         break;
1845         case OPUS_GET_COMPLEXITY_REQUEST:
1846         {
1847             opus_int32 *value = va_arg(ap, opus_int32*);
1848             *value = st->silk_mode.complexity;
1849         }
1850         break;
1851         case OPUS_SET_INBAND_FEC_REQUEST:
1852         {
1853             opus_int32 value = va_arg(ap, opus_int32);
1854             if(value<0 || value>1)
1855                 return OPUS_BAD_ARG;
1856             st->silk_mode.useInBandFEC = value;
1857         }
1858         break;
1859         case OPUS_GET_INBAND_FEC_REQUEST:
1860         {
1861             opus_int32 *value = va_arg(ap, opus_int32*);
1862             *value = st->silk_mode.useInBandFEC;
1863         }
1864         break;
1865         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1866         {
1867             opus_int32 value = va_arg(ap, opus_int32);
1868             if (value < 0 || value > 100)
1869                 return OPUS_BAD_ARG;
1870             st->silk_mode.packetLossPercentage = value;
1871             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
1872         }
1873         break;
1874         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1875         {
1876             opus_int32 *value = va_arg(ap, opus_int32*);
1877             *value = st->silk_mode.packetLossPercentage;
1878         }
1879         break;
1880         case OPUS_SET_VBR_REQUEST:
1881         {
1882             opus_int32 value = va_arg(ap, opus_int32);
1883             if(value<0 || value>1)
1884                 return OPUS_BAD_ARG;
1885             st->use_vbr = value;
1886             st->silk_mode.useCBR = 1-value;
1887         }
1888         break;
1889         case OPUS_GET_VBR_REQUEST:
1890         {
1891             opus_int32 *value = va_arg(ap, opus_int32*);
1892             *value = st->use_vbr;
1893         }
1894         break;
1895         case OPUS_SET_VOICE_RATIO_REQUEST:
1896         {
1897             opus_int32 value = va_arg(ap, opus_int32);
1898             if (value>100 || value<-1)
1899                 goto bad_arg;
1900             st->voice_ratio = value;
1901         }
1902         break;
1903         case OPUS_GET_VOICE_RATIO_REQUEST:
1904         {
1905             opus_int32 *value = va_arg(ap, opus_int32*);
1906             *value = st->voice_ratio;
1907         }
1908         break;
1909         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1910         {
1911             opus_int32 value = va_arg(ap, opus_int32);
1912             if(value<0 || value>1)
1913                 return OPUS_BAD_ARG;
1914             st->vbr_constraint = value;
1915         }
1916         break;
1917         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1918         {
1919             opus_int32 *value = va_arg(ap, opus_int32*);
1920             *value = st->vbr_constraint;
1921         }
1922         break;
1923         case OPUS_SET_SIGNAL_REQUEST:
1924         {
1925             opus_int32 value = va_arg(ap, opus_int32);
1926             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
1927                 return OPUS_BAD_ARG;
1928             st->signal_type = value;
1929         }
1930         break;
1931         case OPUS_GET_SIGNAL_REQUEST:
1932         {
1933             opus_int32 *value = va_arg(ap, opus_int32*);
1934             *value = st->signal_type;
1935         }
1936         break;
1937         case OPUS_GET_LOOKAHEAD_REQUEST:
1938         {
1939             opus_int32 *value = va_arg(ap, opus_int32*);
1940             *value = st->Fs/400;
1941             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1942                 *value += st->delay_compensation;
1943         }
1944         break;
1945         case OPUS_GET_SAMPLE_RATE_REQUEST:
1946         {
1947             opus_int32 *value = va_arg(ap, opus_int32*);
1948             if (value==NULL)
1949             {
1950                 ret = OPUS_BAD_ARG;
1951                 break;
1952             }
1953             *value = st->Fs;
1954         }
1955         break;
1956         case OPUS_GET_FINAL_RANGE_REQUEST:
1957         {
1958             opus_uint32 *value = va_arg(ap, opus_uint32*);
1959             *value = st->rangeFinal;
1960         }
1961         break;
1962         case OPUS_SET_LSB_DEPTH_REQUEST:
1963         {
1964             opus_int32 value = va_arg(ap, opus_int32);
1965             if (value<8 || value>24)
1966                goto bad_arg;
1967             st->lsb_depth=value;
1968         }
1969         break;
1970         case OPUS_GET_LSB_DEPTH_REQUEST:
1971         {
1972             opus_int32 *value = va_arg(ap, opus_int32*);
1973             *value = st->lsb_depth;
1974         }
1975         break;
1976         case OPUS_SET_EXPERT_VARIABLE_DURATION_REQUEST:
1977         {
1978             opus_int32 value = va_arg(ap, opus_int32);
1979             if (value<0 || value>1)
1980                goto bad_arg;
1981             st->variable_duration = value;
1982         }
1983         break;
1984         case OPUS_GET_EXPERT_VARIABLE_DURATION_REQUEST:
1985         {
1986             opus_int32 *value = va_arg(ap, opus_int32*);
1987             *value = st->variable_duration;
1988         }
1989         break;
1990         case OPUS_RESET_STATE:
1991         {
1992            void *silk_enc;
1993            silk_EncControlStruct dummy;
1994            silk_enc = (char*)st+st->silk_enc_offset;
1995
1996            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
1997                  sizeof(OpusEncoder)-
1998                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
1999
2000            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2001            silk_InitEncoder( silk_enc, &dummy );
2002            st->stream_channels = st->channels;
2003            st->hybrid_stereo_width_Q14 = 1 << 14;
2004            st->prev_HB_gain = Q15ONE;
2005            st->first = 1;
2006            st->mode = MODE_HYBRID;
2007            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
2008            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
2009         }
2010         break;
2011         case OPUS_SET_FORCE_MODE_REQUEST:
2012         {
2013             opus_int32 value = va_arg(ap, opus_int32);
2014             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
2015                goto bad_arg;
2016             st->user_forced_mode = value;
2017         }
2018         break;
2019         default:
2020             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
2021             ret = OPUS_UNIMPLEMENTED;
2022             break;
2023     }
2024     va_end(ap);
2025     return ret;
2026 bad_arg:
2027     va_end(ap);
2028     return OPUS_BAD_ARG;
2029 }
2030
2031 void opus_encoder_destroy(OpusEncoder *st)
2032 {
2033     opus_free(st);
2034 }