NLSF VQ now uses absolute error, and prediction
[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 "pitch.h"
42 #include "opus_private.h"
43 #include "os_support.h"
44 #include "cpu_support.h"
45 #include "analysis.h"
46 #include "mathops.h"
47 #include "tuning_parameters.h"
48 #ifdef FIXED_POINT
49 #include "fixed/structs_FIX.h"
50 #else
51 #include "float/structs_FLP.h"
52 #endif
53
54 #define MAX_ENCODER_BUFFER 480
55
56 typedef struct {
57    opus_val32 XX, XY, YY;
58    opus_val16 smoothed_width;
59    opus_val16 max_follower;
60 } StereoWidthState;
61
62 struct OpusEncoder {
63     int          celt_enc_offset;
64     int          silk_enc_offset;
65     silk_EncControlStruct silk_mode;
66     int          application;
67     int          channels;
68     int          delay_compensation;
69     int          force_channels;
70     int          signal_type;
71     int          user_bandwidth;
72     int          max_bandwidth;
73     int          user_forced_mode;
74     int          voice_ratio;
75     opus_int32   Fs;
76     int          use_vbr;
77     int          vbr_constraint;
78     int          variable_duration;
79     opus_int32   bitrate_bps;
80     opus_int32   user_bitrate_bps;
81     int          lsb_depth;
82     int          encoder_buffer;
83     int          lfe;
84     int          arch;
85 #ifndef DISABLE_FLOAT_API
86     TonalityAnalysisState analysis;
87 #endif
88
89 #define OPUS_ENCODER_RESET_START stream_channels
90     int          stream_channels;
91     opus_int16   hybrid_stereo_width_Q14;
92     opus_int32   variable_HP_smth2_Q15;
93     opus_val16   prev_HB_gain;
94     opus_val32   hp_mem[4];
95     int          mode;
96     int          prev_mode;
97     int          prev_channels;
98     int          prev_framesize;
99     int          bandwidth;
100     int          silk_bw_switch;
101     /* Sampling rate (at the API level) */
102     int          first;
103     opus_val16 * energy_masking;
104     StereoWidthState width_mem;
105     opus_val16   delay_buffer[MAX_ENCODER_BUFFER*2];
106 #ifndef DISABLE_FLOAT_API
107     int          detected_bandwidth;
108 #endif
109     opus_uint32  rangeFinal;
110 };
111
112 /* Transition tables for the voice and music. First column is the
113    middle (memoriless) threshold. The second column is the hysteresis
114    (difference with the middle) */
115 static const opus_int32 mono_voice_bandwidth_thresholds[8] = {
116         11000, 1000, /* NB<->MB */
117         12500, 1000, /* MB<->WB */
118         14000, 1000, /* WB<->SWB */
119         15000, 2000, /* SWB<->FB */
120 };
121 static const opus_int32 mono_music_bandwidth_thresholds[8] = {
122         11000, 1000, /* NB<->MB */
123         12500, 1000, /* MB<->WB */
124         14000, 1000, /* WB<->SWB */
125         15000, 2000, /* SWB<->FB */
126 };
127 static const opus_int32 stereo_voice_bandwidth_thresholds[8] = {
128         11000, 1000, /* NB<->MB */
129         12500, 1000, /* MB<->WB */
130         14000, 1000, /* WB<->SWB */
131         15000, 2000, /* SWB<->FB */
132 };
133 static const opus_int32 stereo_music_bandwidth_thresholds[8] = {
134         11000, 1000, /* NB<->MB */
135         12500, 1000, /* MB<->WB */
136         14000, 1000, /* WB<->SWB */
137         15000, 2000, /* SWB<->FB */
138 };
139 /* Threshold bit-rates for switching between mono and stereo */
140 static const opus_int32 stereo_voice_threshold = 24000;
141 static const opus_int32 stereo_music_threshold = 24000;
142
143 /* Threshold bit-rate for switching between SILK/hybrid and CELT-only */
144 static const opus_int32 mode_thresholds[2][2] = {
145       /* voice */ /* music */
146       {  64000,      16000}, /* mono */
147       {  36000,      16000}, /* stereo */
148 };
149
150 int opus_encoder_get_size(int channels)
151 {
152     int silkEncSizeBytes, celtEncSizeBytes;
153     int ret;
154     if (channels<1 || channels > 2)
155         return 0;
156     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
157     if (ret)
158         return 0;
159     silkEncSizeBytes = align(silkEncSizeBytes);
160     celtEncSizeBytes = celt_encoder_get_size(channels);
161     return align(sizeof(OpusEncoder))+silkEncSizeBytes+celtEncSizeBytes;
162 }
163
164 int opus_encoder_init(OpusEncoder* st, opus_int32 Fs, int channels, int application)
165 {
166     void *silk_enc;
167     CELTEncoder *celt_enc;
168     int err;
169     int ret, silkEncSizeBytes;
170
171    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
172         (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
173         && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
174         return OPUS_BAD_ARG;
175
176     OPUS_CLEAR((char*)st, opus_encoder_get_size(channels));
177     /* Create SILK encoder */
178     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
179     if (ret)
180         return OPUS_BAD_ARG;
181     silkEncSizeBytes = align(silkEncSizeBytes);
182     st->silk_enc_offset = align(sizeof(OpusEncoder));
183     st->celt_enc_offset = st->silk_enc_offset+silkEncSizeBytes;
184     silk_enc = (char*)st+st->silk_enc_offset;
185     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
186
187     st->stream_channels = st->channels = channels;
188
189     st->Fs = Fs;
190
191     st->arch = opus_select_arch();
192
193     ret = silk_InitEncoder( silk_enc, st->arch, &st->silk_mode );
194     if(ret)return OPUS_INTERNAL_ERROR;
195
196     /* default SILK parameters */
197     st->silk_mode.nChannelsAPI              = channels;
198     st->silk_mode.nChannelsInternal         = channels;
199     st->silk_mode.API_sampleRate            = st->Fs;
200     st->silk_mode.maxInternalSampleRate     = 16000;
201     st->silk_mode.minInternalSampleRate     = 8000;
202     st->silk_mode.desiredInternalSampleRate = 16000;
203     st->silk_mode.payloadSize_ms            = 20;
204     st->silk_mode.bitRate                   = 25000;
205     st->silk_mode.packetLossPercentage      = 0;
206     st->silk_mode.complexity                = 9;
207     st->silk_mode.useInBandFEC              = 0;
208     st->silk_mode.useDTX                    = 0;
209     st->silk_mode.useCBR                    = 0;
210     st->silk_mode.reducedDependency         = 0;
211
212     /* Create CELT encoder */
213     /* Initialize CELT encoder */
214     err = celt_encoder_init(celt_enc, Fs, channels, st->arch);
215     if(err!=OPUS_OK)return OPUS_INTERNAL_ERROR;
216
217     celt_encoder_ctl(celt_enc, CELT_SET_SIGNALLING(0));
218     celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(st->silk_mode.complexity));
219
220     st->use_vbr = 1;
221     /* Makes constrained VBR the default (safer for real-time use) */
222     st->vbr_constraint = 1;
223     st->user_bitrate_bps = OPUS_AUTO;
224     st->bitrate_bps = 3000+Fs*channels;
225     st->application = application;
226     st->signal_type = OPUS_AUTO;
227     st->user_bandwidth = OPUS_AUTO;
228     st->max_bandwidth = OPUS_BANDWIDTH_FULLBAND;
229     st->force_channels = OPUS_AUTO;
230     st->user_forced_mode = OPUS_AUTO;
231     st->voice_ratio = -1;
232     st->encoder_buffer = st->Fs/100;
233     st->lsb_depth = 24;
234     st->variable_duration = OPUS_FRAMESIZE_ARG;
235
236     /* Delay compensation of 4 ms (2.5 ms for SILK's extra look-ahead
237        + 1.5 ms for SILK resamplers and stereo prediction) */
238     st->delay_compensation = st->Fs/250;
239
240     st->hybrid_stereo_width_Q14 = 1 << 14;
241     st->prev_HB_gain = Q15ONE;
242     st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
243     st->first = 1;
244     st->mode = MODE_HYBRID;
245     st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
246
247 #ifndef DISABLE_FLOAT_API
248     tonality_analysis_init(&st->analysis);
249 #endif
250
251     return OPUS_OK;
252 }
253
254 static unsigned char gen_toc(int mode, int framerate, int bandwidth, int channels)
255 {
256    int period;
257    unsigned char toc;
258    period = 0;
259    while (framerate < 400)
260    {
261        framerate <<= 1;
262        period++;
263    }
264    if (mode == MODE_SILK_ONLY)
265    {
266        toc = (bandwidth-OPUS_BANDWIDTH_NARROWBAND)<<5;
267        toc |= (period-2)<<3;
268    } else if (mode == MODE_CELT_ONLY)
269    {
270        int tmp = bandwidth-OPUS_BANDWIDTH_MEDIUMBAND;
271        if (tmp < 0)
272            tmp = 0;
273        toc = 0x80;
274        toc |= tmp << 5;
275        toc |= period<<3;
276    } else /* Hybrid */
277    {
278        toc = 0x60;
279        toc |= (bandwidth-OPUS_BANDWIDTH_SUPERWIDEBAND)<<4;
280        toc |= (period-2)<<3;
281    }
282    toc |= (channels==2)<<2;
283    return toc;
284 }
285
286 #ifndef FIXED_POINT
287 static void silk_biquad_float(
288     const opus_val16      *in,            /* I:    Input signal                   */
289     const opus_int32      *B_Q28,         /* I:    MA coefficients [3]            */
290     const opus_int32      *A_Q28,         /* I:    AR coefficients [2]            */
291     opus_val32            *S,             /* I/O:  State vector [2]               */
292     opus_val16            *out,           /* O:    Output signal                  */
293     const opus_int32      len,            /* I:    Signal length (must be even)   */
294     int stride
295 )
296 {
297     /* DIRECT FORM II TRANSPOSED (uses 2 element state vector) */
298     opus_int   k;
299     opus_val32 vout;
300     opus_val32 inval;
301     opus_val32 A[2], B[3];
302
303     A[0] = (opus_val32)(A_Q28[0] * (1.f/((opus_int32)1<<28)));
304     A[1] = (opus_val32)(A_Q28[1] * (1.f/((opus_int32)1<<28)));
305     B[0] = (opus_val32)(B_Q28[0] * (1.f/((opus_int32)1<<28)));
306     B[1] = (opus_val32)(B_Q28[1] * (1.f/((opus_int32)1<<28)));
307     B[2] = (opus_val32)(B_Q28[2] * (1.f/((opus_int32)1<<28)));
308
309     /* Negate A_Q28 values and split in two parts */
310
311     for( k = 0; k < len; k++ ) {
312         /* S[ 0 ], S[ 1 ]: Q12 */
313         inval = in[ k*stride ];
314         vout = S[ 0 ] + B[0]*inval;
315
316         S[ 0 ] = S[1] - vout*A[0] + B[1]*inval;
317
318         S[ 1 ] = - vout*A[1] + B[2]*inval + VERY_SMALL;
319
320         /* Scale back to Q0 and saturate */
321         out[ k*stride ] = vout;
322     }
323 }
324 #endif
325
326 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)
327 {
328    opus_int32 B_Q28[ 3 ], A_Q28[ 2 ];
329    opus_int32 Fc_Q19, r_Q28, r_Q22;
330
331    silk_assert( cutoff_Hz <= silk_int32_MAX / SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ) );
332    Fc_Q19 = silk_DIV32_16( silk_SMULBB( SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ), cutoff_Hz ), Fs/1000 );
333    silk_assert( Fc_Q19 > 0 && Fc_Q19 < 32768 );
334
335    r_Q28 = SILK_FIX_CONST( 1.0, 28 ) - silk_MUL( SILK_FIX_CONST( 0.92, 9 ), Fc_Q19 );
336
337    /* b = r * [ 1; -2; 1 ]; */
338    /* a = [ 1; -2 * r * ( 1 - 0.5 * Fc^2 ); r^2 ]; */
339    B_Q28[ 0 ] = r_Q28;
340    B_Q28[ 1 ] = silk_LSHIFT( -r_Q28, 1 );
341    B_Q28[ 2 ] = r_Q28;
342
343    /* -r * ( 2 - Fc * Fc ); */
344    r_Q22  = silk_RSHIFT( r_Q28, 6 );
345    A_Q28[ 0 ] = silk_SMULWW( r_Q22, silk_SMULWW( Fc_Q19, Fc_Q19 ) - SILK_FIX_CONST( 2.0,  22 ) );
346    A_Q28[ 1 ] = silk_SMULWW( r_Q22, r_Q22 );
347
348 #ifdef FIXED_POINT
349    silk_biquad_alt( in, B_Q28, A_Q28, hp_mem, out, len, channels );
350    if( channels == 2 ) {
351        silk_biquad_alt( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
352    }
353 #else
354    silk_biquad_float( in, B_Q28, A_Q28, hp_mem, out, len, channels );
355    if( channels == 2 ) {
356        silk_biquad_float( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
357    }
358 #endif
359 }
360
361 #ifdef FIXED_POINT
362 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)
363 {
364    int c, i;
365    int shift;
366
367    /* Approximates -round(log2(4.*cutoff_Hz/Fs)) */
368    shift=celt_ilog2(Fs/(cutoff_Hz*3));
369    for (c=0;c<channels;c++)
370    {
371       for (i=0;i<len;i++)
372       {
373          opus_val32 x, tmp, y;
374          x = SHL32(EXTEND32(in[channels*i+c]), 15);
375          /* First stage */
376          tmp = x-hp_mem[2*c];
377          hp_mem[2*c] = hp_mem[2*c] + PSHR32(x - hp_mem[2*c], shift);
378          /* Second stage */
379          y = tmp - hp_mem[2*c+1];
380          hp_mem[2*c+1] = hp_mem[2*c+1] + PSHR32(tmp - hp_mem[2*c+1], shift);
381          out[channels*i+c] = EXTRACT16(SATURATE(PSHR32(y, 15), 32767));
382       }
383    }
384 }
385
386 #else
387 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)
388 {
389    int c, i;
390    float coef;
391
392    coef = 4.0f*cutoff_Hz/Fs;
393    for (c=0;c<channels;c++)
394    {
395       for (i=0;i<len;i++)
396       {
397          opus_val32 x, tmp, y;
398          x = in[channels*i+c];
399          /* First stage */
400          tmp = x-hp_mem[2*c];
401          hp_mem[2*c] = hp_mem[2*c] + coef*(x - hp_mem[2*c]) + VERY_SMALL;
402          /* Second stage */
403          y = tmp - hp_mem[2*c+1];
404          hp_mem[2*c+1] = hp_mem[2*c+1] + coef*(tmp - hp_mem[2*c+1]) + VERY_SMALL;
405          out[channels*i+c] = y;
406       }
407    }
408 }
409 #endif
410
411 static void stereo_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2,
412         int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
413 {
414     int i;
415     int overlap;
416     int inc;
417     inc = 48000/Fs;
418     overlap=overlap48/inc;
419     g1 = Q15ONE-g1;
420     g2 = Q15ONE-g2;
421     for (i=0;i<overlap;i++)
422     {
423        opus_val32 diff;
424        opus_val16 g, w;
425        w = MULT16_16_Q15(window[i*inc], window[i*inc]);
426        g = SHR32(MAC16_16(MULT16_16(w,g2),
427              Q15ONE-w, g1), 15);
428        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
429        diff = MULT16_16_Q15(g, diff);
430        out[i*channels] = out[i*channels] - diff;
431        out[i*channels+1] = out[i*channels+1] + diff;
432     }
433     for (;i<frame_size;i++)
434     {
435        opus_val32 diff;
436        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
437        diff = MULT16_16_Q15(g2, diff);
438        out[i*channels] = out[i*channels] - diff;
439        out[i*channels+1] = out[i*channels+1] + diff;
440     }
441 }
442
443 static void gain_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2,
444         int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
445 {
446     int i;
447     int inc;
448     int overlap;
449     int c;
450     inc = 48000/Fs;
451     overlap=overlap48/inc;
452     if (channels==1)
453     {
454        for (i=0;i<overlap;i++)
455        {
456           opus_val16 g, w;
457           w = MULT16_16_Q15(window[i*inc], window[i*inc]);
458           g = SHR32(MAC16_16(MULT16_16(w,g2),
459                 Q15ONE-w, g1), 15);
460           out[i] = MULT16_16_Q15(g, in[i]);
461        }
462     } else {
463        for (i=0;i<overlap;i++)
464        {
465           opus_val16 g, w;
466           w = MULT16_16_Q15(window[i*inc], window[i*inc]);
467           g = SHR32(MAC16_16(MULT16_16(w,g2),
468                 Q15ONE-w, g1), 15);
469           out[i*2] = MULT16_16_Q15(g, in[i*2]);
470           out[i*2+1] = MULT16_16_Q15(g, in[i*2+1]);
471        }
472     }
473     c=0;do {
474        for (i=overlap;i<frame_size;i++)
475        {
476           out[i*channels+c] = MULT16_16_Q15(g2, in[i*channels+c]);
477        }
478     }
479     while (++c<channels);
480 }
481
482 OpusEncoder *opus_encoder_create(opus_int32 Fs, int channels, int application, int *error)
483 {
484    int ret;
485    OpusEncoder *st;
486    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
487        (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
488        && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
489    {
490       if (error)
491          *error = OPUS_BAD_ARG;
492       return NULL;
493    }
494    st = (OpusEncoder *)opus_alloc(opus_encoder_get_size(channels));
495    if (st == NULL)
496    {
497       if (error)
498          *error = OPUS_ALLOC_FAIL;
499       return NULL;
500    }
501    ret = opus_encoder_init(st, Fs, channels, application);
502    if (error)
503       *error = ret;
504    if (ret != OPUS_OK)
505    {
506       opus_free(st);
507       st = NULL;
508    }
509    return st;
510 }
511
512 static opus_int32 user_bitrate_to_bitrate(OpusEncoder *st, int frame_size, int max_data_bytes)
513 {
514   if(!frame_size)frame_size=st->Fs/400;
515   if (st->user_bitrate_bps==OPUS_AUTO)
516     return 60*st->Fs/frame_size + st->Fs*st->channels;
517   else if (st->user_bitrate_bps==OPUS_BITRATE_MAX)
518     return max_data_bytes*8*st->Fs/frame_size;
519   else
520     return st->user_bitrate_bps;
521 }
522
523 #ifndef DISABLE_FLOAT_API
524 /* Don't use more than 60 ms for the frame size analysis */
525 #define MAX_DYNAMIC_FRAMESIZE 24
526 /* Estimates how much the bitrate will be boosted based on the sub-frame energy */
527 static float transient_boost(const float *E, const float *E_1, int LM, int maxM)
528 {
529    int i;
530    int M;
531    float sumE=0, sumE_1=0;
532    float metric;
533
534    M = IMIN(maxM, (1<<LM)+1);
535    for (i=0;i<M;i++)
536    {
537       sumE += E[i];
538       sumE_1 += E_1[i];
539    }
540    metric = sumE*sumE_1/(M*M);
541    /*if (LM==3)
542       printf("%f\n", metric);*/
543    /*return metric>10 ? 1 : 0;*/
544    /*return MAX16(0,1-exp(-.25*(metric-2.)));*/
545    return MIN16(1,(float)sqrt(MAX16(0,.05f*(metric-2))));
546 }
547
548 /* Viterbi decoding trying to find the best frame size combination using look-ahead
549
550    State numbering:
551     0: unused
552     1:  2.5 ms
553     2:  5 ms (#1)
554     3:  5 ms (#2)
555     4: 10 ms (#1)
556     5: 10 ms (#2)
557     6: 10 ms (#3)
558     7: 10 ms (#4)
559     8: 20 ms (#1)
560     9: 20 ms (#2)
561    10: 20 ms (#3)
562    11: 20 ms (#4)
563    12: 20 ms (#5)
564    13: 20 ms (#6)
565    14: 20 ms (#7)
566    15: 20 ms (#8)
567 */
568 static int transient_viterbi(const float *E, const float *E_1, int N, int frame_cost, int rate)
569 {
570    int i;
571    float cost[MAX_DYNAMIC_FRAMESIZE][16];
572    int states[MAX_DYNAMIC_FRAMESIZE][16];
573    float best_cost;
574    int best_state;
575    float factor;
576    /* Take into account that we damp VBR in the 32 kb/s to 64 kb/s range. */
577    if (rate<80)
578       factor=0;
579    else if (rate>160)
580       factor=1;
581    else
582       factor = (rate-80.f)/80.f;
583    /* Makes variable framesize less aggressive at lower bitrates, but I can't
584       find any valid theoretical justification for this (other than it seems
585       to help) */
586    for (i=0;i<16;i++)
587    {
588       /* Impossible state */
589       states[0][i] = -1;
590       cost[0][i] = 1e10;
591    }
592    for (i=0;i<4;i++)
593    {
594       cost[0][1<<i] = (frame_cost + rate*(1<<i))*(1+factor*transient_boost(E, E_1, i, N+1));
595       states[0][1<<i] = i;
596    }
597    for (i=1;i<N;i++)
598    {
599       int j;
600
601       /* Follow continuations */
602       for (j=2;j<16;j++)
603       {
604          cost[i][j] = cost[i-1][j-1];
605          states[i][j] = j-1;
606       }
607
608       /* New frames */
609       for(j=0;j<4;j++)
610       {
611          int k;
612          float min_cost;
613          float curr_cost;
614          states[i][1<<j] = 1;
615          min_cost = cost[i-1][1];
616          for(k=1;k<4;k++)
617          {
618             float tmp = cost[i-1][(1<<(k+1))-1];
619             if (tmp < min_cost)
620             {
621                states[i][1<<j] = (1<<(k+1))-1;
622                min_cost = tmp;
623             }
624          }
625          curr_cost = (frame_cost + rate*(1<<j))*(1+factor*transient_boost(E+i, E_1+i, j, N-i+1));
626          cost[i][1<<j] = min_cost;
627          /* If part of the frame is outside the analysis window, only count part of the cost */
628          if (N-i < (1<<j))
629             cost[i][1<<j] += curr_cost*(float)(N-i)/(1<<j);
630          else
631             cost[i][1<<j] += curr_cost;
632       }
633    }
634
635    best_state=1;
636    best_cost = cost[N-1][1];
637    /* Find best end state (doesn't force a frame to end at N-1) */
638    for (i=2;i<16;i++)
639    {
640       if (cost[N-1][i]<best_cost)
641       {
642          best_cost = cost[N-1][i];
643          best_state = i;
644       }
645    }
646
647    /* Follow transitions back */
648    for (i=N-1;i>=0;i--)
649    {
650       /*printf("%d ", best_state);*/
651       best_state = states[i][best_state];
652    }
653    /*printf("%d\n", best_state);*/
654    return best_state;
655 }
656
657 static int optimize_framesize(const void *x, int len, int C, opus_int32 Fs,
658                 int bitrate, opus_val16 tonality, float *mem, int buffering,
659                 downmix_func downmix)
660 {
661    int N;
662    int i;
663    float e[MAX_DYNAMIC_FRAMESIZE+4];
664    float e_1[MAX_DYNAMIC_FRAMESIZE+3];
665    opus_val32 memx;
666    int bestLM=0;
667    int subframe;
668    int pos;
669    int offset;
670    VARDECL(opus_val32, sub);
671
672    subframe = Fs/400;
673    ALLOC(sub, subframe, opus_val32);
674    e[0]=mem[0];
675    e_1[0]=1.f/(EPSILON+mem[0]);
676    if (buffering)
677    {
678       /* Consider the CELT delay when not in restricted-lowdelay */
679       /* We assume the buffering is between 2.5 and 5 ms */
680       offset = 2*subframe - buffering;
681       celt_assert(offset>=0 && offset <= subframe);
682       len -= offset;
683       e[1]=mem[1];
684       e_1[1]=1.f/(EPSILON+mem[1]);
685       e[2]=mem[2];
686       e_1[2]=1.f/(EPSILON+mem[2]);
687       pos = 3;
688    } else {
689       pos=1;
690       offset=0;
691    }
692    N=IMIN(len/subframe, MAX_DYNAMIC_FRAMESIZE);
693    /* Just silencing a warning, it's really initialized later */
694    memx = 0;
695    for (i=0;i<N;i++)
696    {
697       float tmp;
698       opus_val32 tmpx;
699       int j;
700       tmp=EPSILON;
701
702       downmix(x, sub, subframe, i*subframe+offset, 0, -2, C);
703       if (i==0)
704          memx = sub[0];
705       for (j=0;j<subframe;j++)
706       {
707          tmpx = sub[j];
708          tmp += (tmpx-memx)*(float)(tmpx-memx);
709          memx = tmpx;
710       }
711       e[i+pos] = tmp;
712       e_1[i+pos] = 1.f/tmp;
713    }
714    /* Hack to get 20 ms working with APPLICATION_AUDIO
715       The real problem is that the corresponding memory needs to use 1.5 ms
716       from this frame and 1 ms from the next frame */
717    e[i+pos] = e[i+pos-1];
718    if (buffering)
719       N=IMIN(MAX_DYNAMIC_FRAMESIZE, N+2);
720    bestLM = transient_viterbi(e, e_1, N, (int)((1.f+.5f*tonality)*(60*C+40)), bitrate/400);
721    mem[0] = e[1<<bestLM];
722    if (buffering)
723    {
724       mem[1] = e[(1<<bestLM)+1];
725       mem[2] = e[(1<<bestLM)+2];
726    }
727    return bestLM;
728 }
729
730 #endif
731
732 #ifndef DISABLE_FLOAT_API
733 #ifdef FIXED_POINT
734 #define PCM2VAL(x) FLOAT2INT16(x)
735 #else
736 #define PCM2VAL(x) SCALEIN(x)
737 #endif
738 void downmix_float(const void *_x, opus_val32 *sub, int subframe, int offset, int c1, int c2, int C)
739 {
740    const float *x;
741    opus_val32 scale;
742    int j;
743    x = (const float *)_x;
744    for (j=0;j<subframe;j++)
745       sub[j] = PCM2VAL(x[(j+offset)*C+c1]);
746    if (c2>-1)
747    {
748       for (j=0;j<subframe;j++)
749          sub[j] += PCM2VAL(x[(j+offset)*C+c2]);
750    } else if (c2==-2)
751    {
752       int c;
753       for (c=1;c<C;c++)
754       {
755          for (j=0;j<subframe;j++)
756             sub[j] += PCM2VAL(x[(j+offset)*C+c]);
757       }
758    }
759 #ifdef FIXED_POINT
760    scale = (1<<SIG_SHIFT);
761 #else
762    scale = 1.f;
763 #endif
764    if (C==-2)
765       scale /= C;
766    else
767       scale /= 2;
768    for (j=0;j<subframe;j++)
769       sub[j] *= scale;
770 }
771 #endif
772
773 void downmix_int(const void *_x, opus_val32 *sub, int subframe, int offset, int c1, int c2, int C)
774 {
775    const opus_int16 *x;
776    opus_val32 scale;
777    int j;
778    x = (const opus_int16 *)_x;
779    for (j=0;j<subframe;j++)
780       sub[j] = x[(j+offset)*C+c1];
781    if (c2>-1)
782    {
783       for (j=0;j<subframe;j++)
784          sub[j] += x[(j+offset)*C+c2];
785    } else if (c2==-2)
786    {
787       int c;
788       for (c=1;c<C;c++)
789       {
790          for (j=0;j<subframe;j++)
791             sub[j] += x[(j+offset)*C+c];
792       }
793    }
794 #ifdef FIXED_POINT
795    scale = (1<<SIG_SHIFT);
796 #else
797    scale = 1.f/32768;
798 #endif
799    if (C==-2)
800       scale /= C;
801    else
802       scale /= 2;
803    for (j=0;j<subframe;j++)
804       sub[j] *= scale;
805 }
806
807 opus_int32 frame_size_select(opus_int32 frame_size, int variable_duration, opus_int32 Fs)
808 {
809    int new_size;
810    if (frame_size<Fs/400)
811       return -1;
812    if (variable_duration == OPUS_FRAMESIZE_ARG)
813       new_size = frame_size;
814    else if (variable_duration == OPUS_FRAMESIZE_VARIABLE)
815       new_size = Fs/50;
816    else if (variable_duration >= OPUS_FRAMESIZE_2_5_MS && variable_duration <= OPUS_FRAMESIZE_60_MS)
817       new_size = IMIN(3*Fs/50, (Fs/400)<<(variable_duration-OPUS_FRAMESIZE_2_5_MS));
818    else
819       return -1;
820    if (new_size>frame_size)
821       return -1;
822    if (400*new_size!=Fs && 200*new_size!=Fs && 100*new_size!=Fs &&
823             50*new_size!=Fs && 25*new_size!=Fs && 50*new_size!=3*Fs)
824       return -1;
825    return new_size;
826 }
827
828 opus_int32 compute_frame_size(const void *analysis_pcm, int frame_size,
829       int variable_duration, int C, opus_int32 Fs, int bitrate_bps,
830       int delay_compensation, downmix_func downmix
831 #ifndef DISABLE_FLOAT_API
832       , float *subframe_mem
833 #endif
834       )
835 {
836 #ifndef DISABLE_FLOAT_API
837    if (variable_duration == OPUS_FRAMESIZE_VARIABLE && frame_size >= Fs/200)
838    {
839       int LM = 3;
840       LM = optimize_framesize(analysis_pcm, frame_size, C, Fs, bitrate_bps,
841             0, subframe_mem, delay_compensation, downmix);
842       while ((Fs/400<<LM)>frame_size)
843          LM--;
844       frame_size = (Fs/400<<LM);
845    } else
846 #else
847    (void)analysis_pcm;
848    (void)C;
849    (void)bitrate_bps;
850    (void)delay_compensation;
851    (void)downmix;
852 #endif
853    {
854       frame_size = frame_size_select(frame_size, variable_duration, Fs);
855    }
856    if (frame_size<0)
857       return -1;
858    return frame_size;
859 }
860
861 opus_val16 compute_stereo_width(const opus_val16 *pcm, int frame_size, opus_int32 Fs, StereoWidthState *mem)
862 {
863    opus_val32 xx, xy, yy;
864    opus_val16 sqrt_xx, sqrt_yy;
865    opus_val16 qrrt_xx, qrrt_yy;
866    int frame_rate;
867    int i;
868    opus_val16 short_alpha;
869
870    frame_rate = Fs/frame_size;
871    short_alpha = Q15ONE - MULT16_16(25, Q15ONE)/IMAX(50,frame_rate);
872    xx=xy=yy=0;
873    /* Unroll by 4. The frame size is always a multiple of 4 *except* for
874       2.5 ms frames at 12 kHz. Since this setting is very rare (and very
875       stupid), we just discard the last two samples. */
876    for (i=0;i<frame_size-3;i+=4)
877    {
878       opus_val32 pxx=0;
879       opus_val32 pxy=0;
880       opus_val32 pyy=0;
881       opus_val16 x, y;
882       x = pcm[2*i];
883       y = pcm[2*i+1];
884       pxx = SHR32(MULT16_16(x,x),2);
885       pxy = SHR32(MULT16_16(x,y),2);
886       pyy = SHR32(MULT16_16(y,y),2);
887       x = pcm[2*i+2];
888       y = pcm[2*i+3];
889       pxx += SHR32(MULT16_16(x,x),2);
890       pxy += SHR32(MULT16_16(x,y),2);
891       pyy += SHR32(MULT16_16(y,y),2);
892       x = pcm[2*i+4];
893       y = pcm[2*i+5];
894       pxx += SHR32(MULT16_16(x,x),2);
895       pxy += SHR32(MULT16_16(x,y),2);
896       pyy += SHR32(MULT16_16(y,y),2);
897       x = pcm[2*i+6];
898       y = pcm[2*i+7];
899       pxx += SHR32(MULT16_16(x,x),2);
900       pxy += SHR32(MULT16_16(x,y),2);
901       pyy += SHR32(MULT16_16(y,y),2);
902
903       xx += SHR32(pxx, 10);
904       xy += SHR32(pxy, 10);
905       yy += SHR32(pyy, 10);
906    }
907    mem->XX += MULT16_32_Q15(short_alpha, xx-mem->XX);
908    mem->XY += MULT16_32_Q15(short_alpha, xy-mem->XY);
909    mem->YY += MULT16_32_Q15(short_alpha, yy-mem->YY);
910    mem->XX = MAX32(0, mem->XX);
911    mem->XY = MAX32(0, mem->XY);
912    mem->YY = MAX32(0, mem->YY);
913    if (MAX32(mem->XX, mem->YY)>QCONST16(8e-4f, 18))
914    {
915       opus_val16 corr;
916       opus_val16 ldiff;
917       opus_val16 width;
918       sqrt_xx = celt_sqrt(mem->XX);
919       sqrt_yy = celt_sqrt(mem->YY);
920       qrrt_xx = celt_sqrt(sqrt_xx);
921       qrrt_yy = celt_sqrt(sqrt_yy);
922       /* Inter-channel correlation */
923       mem->XY = MIN32(mem->XY, sqrt_xx*sqrt_yy);
924       corr = SHR32(frac_div32(mem->XY,EPSILON+MULT16_16(sqrt_xx,sqrt_yy)),16);
925       /* Approximate loudness difference */
926       ldiff = MULT16_16(Q15ONE, ABS16(qrrt_xx-qrrt_yy))/(EPSILON+qrrt_xx+qrrt_yy);
927       width = MULT16_16_Q15(celt_sqrt(QCONST32(1.f,30)-MULT16_16(corr,corr)), ldiff);
928       /* Smoothing over one second */
929       mem->smoothed_width += (width-mem->smoothed_width)/frame_rate;
930       /* Peak follower */
931       mem->max_follower = MAX16(mem->max_follower-QCONST16(.02f,15)/frame_rate, mem->smoothed_width);
932    }
933    /*printf("%f %f %f %f %f ", corr/(float)Q15ONE, ldiff/(float)Q15ONE, width/(float)Q15ONE, mem->smoothed_width/(float)Q15ONE, mem->max_follower/(float)Q15ONE);*/
934    return EXTRACT16(MIN32(Q15ONE, MULT16_16(20, mem->max_follower)));
935 }
936
937 static int compute_silk_rate_for_hybrid(int rate, int bandwidth, int frame20ms, int vbr) {
938    int entry;
939    int i;
940    int N;
941    int silk_rate;
942    static int rate_table[][5] = {
943   /*  |total| |-------- SILK------------|
944               SWB-10  FB-10 SWB-20  FB-20 */
945       {    0,     0,     0,     0,     0},
946       {12000, 10000, 10000, 10000, 10000},
947       {16000, 14000, 14000, 14000, 14000},
948       {20000, 16000, 16000, 16000, 16000},
949       {24000, 18000, 18000, 18000, 18000},
950       {32000, 22000, 22000, 22000, 22000},
951       {64000, 38000, 38000, 38000, 38000}
952    };
953    entry = 1 + 2*frame20ms + (bandwidth==OPUS_BANDWIDTH_FULLBAND);
954    N = sizeof(rate_table)/sizeof(rate_table[0]);
955    for (i=1;i<N;i++)
956    {
957       if (rate_table[i][0] > rate) break;
958    }
959    if (i == N)
960    {
961       silk_rate = rate_table[i-1][entry];
962       /* For now, just give 50% of the extra bits to SILK. */
963       silk_rate += (rate-rate_table[i-1][0])/2;
964    } else {
965       opus_int32 lo, hi, x0, x1;
966       lo = rate_table[i-1][entry];
967       hi = rate_table[i][entry];
968       x0 = rate_table[i-1][0];
969       x1 = rate_table[i][0];
970       silk_rate = (lo*(x1-rate) + hi*(rate-x0))/(x1-x0);
971    }
972    if (!vbr)
973    {
974       if (silk_rate > 8000)
975          silk_rate -= 1000;
976    }
977    return silk_rate;
978 }
979
980 /* Returns the equivalent bitrate corresponding to 20 ms frames,
981    complexity 10 VBR operation. */
982 static opus_int32 compute_equiv_rate(opus_int32 bitrate, int channels,
983       int frame_rate, int vbr, int mode, int complexity)
984 {
985    int equiv;
986    equiv = bitrate;
987    /* Take into account overhead from smaller frames. */
988    equiv -= (40*channels+20)*(frame_rate - 50);
989    /* CBR is about a 10% penalty for both SILK and CELT. */
990    if (!vbr)
991       equiv = equiv*9/10;
992    /* Complexity makes about 10% difference (from 0 to 10) in general. */
993    equiv = equiv * (90+complexity)/100;
994    if (mode == MODE_SILK_ONLY || mode == MODE_HYBRID)
995    {
996       /* SILK complexity 0-3 uses the non-delayed-decision NSQ, which
997          costs about 20%. */
998       if (complexity<4)
999          equiv = equiv*4/5;
1000    } else if (mode == MODE_CELT_ONLY) {
1001       /* CELT complexity 0-4 doesn't have the pitch filter, which costs
1002          about 10%. */
1003       if (complexity<5)
1004          equiv = equiv*9/10;
1005    } else {
1006       /* Mode not known yet */
1007    }
1008    return equiv;
1009 }
1010
1011 opus_int32 opus_encode_native(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
1012                 unsigned char *data, opus_int32 out_data_bytes, int lsb_depth,
1013                 const void *analysis_pcm, opus_int32 analysis_size, int c1, int c2,
1014                 int analysis_channels, downmix_func downmix, int float_api)
1015 {
1016     void *silk_enc;
1017     CELTEncoder *celt_enc;
1018     int i;
1019     int ret=0;
1020     opus_int32 nBytes;
1021     ec_enc enc;
1022     int bytes_target;
1023     int prefill=0;
1024     int start_band = 0;
1025     int redundancy = 0;
1026     int redundancy_bytes = 0; /* Number of bytes to use for redundancy frame */
1027     int celt_to_silk = 0;
1028     VARDECL(opus_val16, pcm_buf);
1029     int nb_compr_bytes;
1030     int to_celt = 0;
1031     opus_uint32 redundant_rng = 0;
1032     int cutoff_Hz, hp_freq_smth1;
1033     int voice_est; /* Probability of voice in Q7 */
1034     opus_int32 equiv_rate;
1035     int delay_compensation;
1036     int frame_rate;
1037     opus_int32 max_rate; /* Max bitrate we're allowed to use */
1038     int curr_bandwidth;
1039     opus_val16 HB_gain;
1040     opus_int32 max_data_bytes; /* Max number of bytes we're allowed to use */
1041     int total_buffer;
1042     opus_val16 stereo_width;
1043     const CELTMode *celt_mode;
1044 #ifndef DISABLE_FLOAT_API
1045     AnalysisInfo analysis_info;
1046     int analysis_read_pos_bak=-1;
1047     int analysis_read_subframe_bak=-1;
1048 #endif
1049     VARDECL(opus_val16, tmp_prefill);
1050
1051     ALLOC_STACK;
1052
1053     max_data_bytes = IMIN(1276, out_data_bytes);
1054
1055     st->rangeFinal = 0;
1056     if ((!st->variable_duration && 400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
1057          50*frame_size != st->Fs &&  25*frame_size != st->Fs &&  50*frame_size != 3*st->Fs)
1058          || (400*frame_size < st->Fs)
1059          || max_data_bytes<=0
1060          )
1061     {
1062        RESTORE_STACK;
1063        return OPUS_BAD_ARG;
1064     }
1065     silk_enc = (char*)st+st->silk_enc_offset;
1066     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1067     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1068        delay_compensation = 0;
1069     else
1070        delay_compensation = st->delay_compensation;
1071
1072     lsb_depth = IMIN(lsb_depth, st->lsb_depth);
1073
1074     celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1075 #ifndef DISABLE_FLOAT_API
1076     analysis_info.valid = 0;
1077 #ifdef FIXED_POINT
1078     if (st->silk_mode.complexity >= 10 && st->Fs==48000)
1079 #else
1080     if (st->silk_mode.complexity >= 7 && st->Fs==48000)
1081 #endif
1082     {
1083        analysis_read_pos_bak = st->analysis.read_pos;
1084        analysis_read_subframe_bak = st->analysis.read_subframe;
1085        run_analysis(&st->analysis, celt_mode, analysis_pcm, analysis_size, frame_size,
1086              c1, c2, analysis_channels, st->Fs,
1087              lsb_depth, downmix, &analysis_info);
1088     }
1089 #else
1090     (void)analysis_pcm;
1091     (void)analysis_size;
1092 #endif
1093
1094     st->voice_ratio = -1;
1095
1096 #ifndef DISABLE_FLOAT_API
1097     st->detected_bandwidth = 0;
1098     if (analysis_info.valid)
1099     {
1100        int analysis_bandwidth;
1101        if (st->signal_type == OPUS_AUTO)
1102           st->voice_ratio = (int)floor(.5+100*(1-analysis_info.music_prob));
1103
1104        analysis_bandwidth = analysis_info.bandwidth;
1105        if (analysis_bandwidth<=12)
1106           st->detected_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1107        else if (analysis_bandwidth<=14)
1108           st->detected_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1109        else if (analysis_bandwidth<=16)
1110           st->detected_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1111        else if (analysis_bandwidth<=18)
1112           st->detected_bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1113        else
1114           st->detected_bandwidth = OPUS_BANDWIDTH_FULLBAND;
1115     }
1116 #endif
1117
1118     if (st->channels==2 && st->force_channels!=1)
1119        stereo_width = compute_stereo_width(pcm, frame_size, st->Fs, &st->width_mem);
1120     else
1121        stereo_width = 0;
1122     total_buffer = delay_compensation;
1123     st->bitrate_bps = user_bitrate_to_bitrate(st, frame_size, max_data_bytes);
1124
1125     frame_rate = st->Fs/frame_size;
1126     if (!st->use_vbr)
1127     {
1128        int cbrBytes;
1129        /* Multiply by 3 to make sure the division is exact. */
1130        int frame_rate3 = 3*st->Fs/frame_size;
1131        /* We need to make sure that "int" values always fit in 16 bits. */
1132        cbrBytes = IMIN( (3*st->bitrate_bps/8 + frame_rate3/2)/frame_rate3, max_data_bytes);
1133        st->bitrate_bps = cbrBytes*(opus_int32)frame_rate3*8/3;
1134        max_data_bytes = cbrBytes;
1135     }
1136     if (max_data_bytes<3 || st->bitrate_bps < 3*frame_rate*8
1137        || (frame_rate<50 && (max_data_bytes*frame_rate<300 || st->bitrate_bps < 2400)))
1138     {
1139        /*If the space is too low to do something useful, emit 'PLC' frames.*/
1140        int tocmode = st->mode;
1141        int bw = st->bandwidth == 0 ? OPUS_BANDWIDTH_NARROWBAND : st->bandwidth;
1142        if (tocmode==0)
1143           tocmode = MODE_SILK_ONLY;
1144        if (frame_rate>100)
1145           tocmode = MODE_CELT_ONLY;
1146        if (frame_rate < 50)
1147           tocmode = MODE_SILK_ONLY;
1148        if(tocmode==MODE_SILK_ONLY&&bw>OPUS_BANDWIDTH_WIDEBAND)
1149           bw=OPUS_BANDWIDTH_WIDEBAND;
1150        else if (tocmode==MODE_CELT_ONLY&&bw==OPUS_BANDWIDTH_MEDIUMBAND)
1151           bw=OPUS_BANDWIDTH_NARROWBAND;
1152        else if (tocmode==MODE_HYBRID&&bw<=OPUS_BANDWIDTH_SUPERWIDEBAND)
1153           bw=OPUS_BANDWIDTH_SUPERWIDEBAND;
1154        data[0] = gen_toc(tocmode, frame_rate, bw, st->stream_channels);
1155        ret = 1;
1156        if (!st->use_vbr)
1157        {
1158           ret = opus_packet_pad(data, ret, max_data_bytes);
1159           if (ret == OPUS_OK)
1160              ret = max_data_bytes;
1161        }
1162        RESTORE_STACK;
1163        return ret;
1164     }
1165     max_rate = frame_rate*max_data_bytes*8;
1166
1167     /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */
1168     equiv_rate = compute_equiv_rate(st->bitrate_bps, st->channels, st->Fs/frame_size,
1169           st->use_vbr, 0, st->silk_mode.complexity);
1170
1171     if (st->signal_type == OPUS_SIGNAL_VOICE)
1172        voice_est = 127;
1173     else if (st->signal_type == OPUS_SIGNAL_MUSIC)
1174        voice_est = 0;
1175     else if (st->voice_ratio >= 0)
1176     {
1177        voice_est = st->voice_ratio*327>>8;
1178        /* For AUDIO, never be more than 90% confident of having speech */
1179        if (st->application == OPUS_APPLICATION_AUDIO)
1180           voice_est = IMIN(voice_est, 115);
1181     } else if (st->application == OPUS_APPLICATION_VOIP)
1182        voice_est = 115;
1183     else
1184        voice_est = 48;
1185
1186     if (st->force_channels!=OPUS_AUTO && st->channels == 2)
1187     {
1188         st->stream_channels = st->force_channels;
1189     } else {
1190 #ifdef FUZZING
1191        /* Random mono/stereo decision */
1192        if (st->channels == 2 && (rand()&0x1F)==0)
1193           st->stream_channels = 3-st->stream_channels;
1194 #else
1195        /* Rate-dependent mono-stereo decision */
1196        if (st->channels == 2)
1197        {
1198           opus_int32 stereo_threshold;
1199           stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14);
1200           if (st->stream_channels == 2)
1201              stereo_threshold -= 1000;
1202           else
1203              stereo_threshold += 1000;
1204           st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1;
1205        } else {
1206           st->stream_channels = st->channels;
1207        }
1208 #endif
1209     }
1210     /* Update equivalent rate for channels decision. */
1211     equiv_rate = compute_equiv_rate(st->bitrate_bps, st->stream_channels, st->Fs/frame_size,
1212           st->use_vbr, 0, st->silk_mode.complexity);
1213
1214     /* Mode selection depending on application and signal type */
1215     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1216     {
1217        st->mode = MODE_CELT_ONLY;
1218     } else if (st->user_forced_mode == OPUS_AUTO)
1219     {
1220 #ifdef FUZZING
1221        /* Random mode switching */
1222        if ((rand()&0xF)==0)
1223        {
1224           if ((rand()&0x1)==0)
1225              st->mode = MODE_CELT_ONLY;
1226           else
1227              st->mode = MODE_SILK_ONLY;
1228        } else {
1229           if (st->prev_mode==MODE_CELT_ONLY)
1230              st->mode = MODE_CELT_ONLY;
1231           else
1232              st->mode = MODE_SILK_ONLY;
1233        }
1234 #else
1235        opus_int32 mode_voice, mode_music;
1236        opus_int32 threshold;
1237
1238        /* Interpolate based on stereo width */
1239        mode_voice = (opus_int32)(MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[0][0])
1240              + MULT16_32_Q15(stereo_width,mode_thresholds[1][0]));
1241        mode_music = (opus_int32)(MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[1][1])
1242              + MULT16_32_Q15(stereo_width,mode_thresholds[1][1]));
1243        /* Interpolate based on speech/music probability */
1244        threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14);
1245        /* Bias towards SILK for VoIP because of some useful features */
1246        if (st->application == OPUS_APPLICATION_VOIP)
1247           threshold += 8000;
1248
1249        /*printf("%f %d\n", stereo_width/(float)Q15ONE, threshold);*/
1250        /* Hysteresis */
1251        if (st->prev_mode == MODE_CELT_ONLY)
1252            threshold -= 4000;
1253        else if (st->prev_mode>0)
1254            threshold += 4000;
1255
1256        st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY;
1257
1258        /* When FEC is enabled and there's enough packet loss, use SILK */
1259        if (st->silk_mode.useInBandFEC && st->silk_mode.packetLossPercentage > (128-voice_est)>>4)
1260           st->mode = MODE_SILK_ONLY;
1261        /* When encoding voice and DTX is enabled, set the encoder to SILK mode (at least for now) */
1262        if (st->silk_mode.useDTX && voice_est > 100)
1263           st->mode = MODE_SILK_ONLY;
1264 #endif
1265     } else {
1266        st->mode = st->user_forced_mode;
1267     }
1268
1269     /* Override the chosen mode to make sure we meet the requested frame size */
1270     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
1271        st->mode = MODE_CELT_ONLY;
1272     if (st->lfe)
1273        st->mode = MODE_CELT_ONLY;
1274     /* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */
1275     if (max_data_bytes < (frame_rate > 50 ? 12000 : 8000)*frame_size / (st->Fs * 8))
1276        st->mode = MODE_CELT_ONLY;
1277
1278     if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0
1279           && st->mode != MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)
1280     {
1281        /* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */
1282        st->silk_mode.toMono = 1;
1283        st->stream_channels = 2;
1284     } else {
1285        st->silk_mode.toMono = 0;
1286     }
1287
1288     if (st->prev_mode > 0 &&
1289         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
1290     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
1291     {
1292         redundancy = 1;
1293         celt_to_silk = (st->mode != MODE_CELT_ONLY);
1294         if (!celt_to_silk)
1295         {
1296             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
1297             if (frame_size >= st->Fs/100)
1298             {
1299                 st->mode = st->prev_mode;
1300                 to_celt = 1;
1301             } else {
1302                 redundancy=0;
1303             }
1304         }
1305     }
1306
1307     /* Update equivalent rate with mode decision. */
1308     equiv_rate = compute_equiv_rate(st->bitrate_bps, st->stream_channels, st->Fs/frame_size,
1309           st->use_vbr, st->mode, st->silk_mode.complexity);
1310
1311     /* For the first frame at a new SILK bandwidth */
1312     if (st->silk_bw_switch)
1313     {
1314        redundancy = 1;
1315        celt_to_silk = 1;
1316        st->silk_bw_switch = 0;
1317        prefill=1;
1318     }
1319
1320     if (redundancy)
1321     {
1322        /* Fair share of the max size allowed */
1323        redundancy_bytes = IMIN(257, max_data_bytes*(opus_int32)(st->Fs/200)/(frame_size+st->Fs/200));
1324        /* For VBR, target the actual bitrate (subject to the limit above) */
1325        if (st->use_vbr)
1326           redundancy_bytes = IMIN(redundancy_bytes, st->bitrate_bps/1600);
1327     }
1328
1329     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
1330     {
1331         silk_EncControlStruct dummy;
1332         silk_InitEncoder( silk_enc, st->arch, &dummy);
1333         prefill=1;
1334     }
1335
1336     /* Automatic (rate-dependent) bandwidth selection */
1337     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
1338     {
1339         const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds;
1340         opus_int32 bandwidth_thresholds[8];
1341         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
1342
1343         if (st->channels==2 && st->force_channels!=1)
1344         {
1345            voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds;
1346            music_bandwidth_thresholds = stereo_music_bandwidth_thresholds;
1347         } else {
1348            voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds;
1349            music_bandwidth_thresholds = mono_music_bandwidth_thresholds;
1350         }
1351         /* Interpolate bandwidth thresholds depending on voice estimation */
1352         for (i=0;i<8;i++)
1353         {
1354            bandwidth_thresholds[i] = music_bandwidth_thresholds[i]
1355                     + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14);
1356         }
1357         do {
1358             int threshold, hysteresis;
1359             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
1360             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
1361             if (!st->first)
1362             {
1363                 if (st->bandwidth >= bandwidth)
1364                     threshold -= hysteresis;
1365                 else
1366                     threshold += hysteresis;
1367             }
1368             if (equiv_rate >= threshold)
1369                 break;
1370         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
1371         st->bandwidth = bandwidth;
1372         /* Prevents any transition to SWB/FB until the SILK layer has fully
1373            switched to WB mode and turned the variable LP filter off */
1374         if (!st->first && st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1375             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1376     }
1377
1378     if (st->bandwidth>st->max_bandwidth)
1379        st->bandwidth = st->max_bandwidth;
1380
1381     if (st->user_bandwidth != OPUS_AUTO)
1382         st->bandwidth = st->user_bandwidth;
1383
1384     /* This prevents us from using hybrid at unsafe CBR/max rates */
1385     if (st->mode != MODE_CELT_ONLY && max_rate < 15000)
1386     {
1387        st->bandwidth = IMIN(st->bandwidth, OPUS_BANDWIDTH_WIDEBAND);
1388     }
1389
1390     /* Prevents Opus from wasting bits on frequencies that are above
1391        the Nyquist rate of the input signal */
1392     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
1393         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1394     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1395         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1396     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
1397         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1398     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
1399         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1400 #ifndef DISABLE_FLOAT_API
1401     /* Use detected bandwidth to reduce the encoded bandwidth. */
1402     if (st->detected_bandwidth && st->user_bandwidth == OPUS_AUTO)
1403     {
1404        int min_detected_bandwidth;
1405        /* Makes bandwidth detection more conservative just in case the detector
1406           gets it wrong when we could have coded a high bandwidth transparently.
1407           When operating in SILK/hybrid mode, we don't go below wideband to avoid
1408           more complicated switches that require redundancy. */
1409        if (equiv_rate <= 18000*st->stream_channels && st->mode == MODE_CELT_ONLY)
1410           min_detected_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1411        else if (equiv_rate <= 24000*st->stream_channels && st->mode == MODE_CELT_ONLY)
1412           min_detected_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1413        else if (equiv_rate <= 30000*st->stream_channels)
1414           min_detected_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1415        else if (equiv_rate <= 44000*st->stream_channels)
1416           min_detected_bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1417        else
1418           min_detected_bandwidth = OPUS_BANDWIDTH_FULLBAND;
1419
1420        st->detected_bandwidth = IMAX(st->detected_bandwidth, min_detected_bandwidth);
1421        st->bandwidth = IMIN(st->bandwidth, st->detected_bandwidth);
1422     }
1423 #endif
1424     celt_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(lsb_depth));
1425
1426     /* CELT mode doesn't support mediumband, use wideband instead */
1427     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1428         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1429     if (st->lfe)
1430        st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1431
1432     /* Can't support higher than wideband for >20 ms frames */
1433     if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND))
1434     {
1435        VARDECL(unsigned char, tmp_data);
1436        int nb_frames;
1437        int bak_mode, bak_bandwidth, bak_channels, bak_to_mono;
1438        VARDECL(OpusRepacketizer, rp);
1439        opus_int32 bytes_per_frame;
1440        opus_int32 repacketize_len;
1441
1442 #ifndef DISABLE_FLOAT_API
1443        if (analysis_read_pos_bak!= -1)
1444        {
1445           st->analysis.read_pos = analysis_read_pos_bak;
1446           st->analysis.read_subframe = analysis_read_subframe_bak;
1447        }
1448 #endif
1449
1450        nb_frames = frame_size > st->Fs/25 ? 3 : 2;
1451        bytes_per_frame = IMIN(1276,(out_data_bytes-3)/nb_frames);
1452
1453        ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char);
1454
1455        ALLOC(rp, 1, OpusRepacketizer);
1456        opus_repacketizer_init(rp);
1457
1458        bak_mode = st->user_forced_mode;
1459        bak_bandwidth = st->user_bandwidth;
1460        bak_channels = st->force_channels;
1461
1462        st->user_forced_mode = st->mode;
1463        st->user_bandwidth = st->bandwidth;
1464        st->force_channels = st->stream_channels;
1465        bak_to_mono = st->silk_mode.toMono;
1466
1467        if (bak_to_mono)
1468           st->force_channels = 1;
1469        else
1470           st->prev_channels = st->stream_channels;
1471        for (i=0;i<nb_frames;i++)
1472        {
1473           int tmp_len;
1474           st->silk_mode.toMono = 0;
1475           /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
1476           if (to_celt && i==nb_frames-1)
1477              st->user_forced_mode = MODE_CELT_ONLY;
1478           tmp_len = opus_encode_native(st, pcm+i*(st->channels*st->Fs/50), st->Fs/50,
1479                 tmp_data+i*bytes_per_frame, bytes_per_frame, lsb_depth,
1480                 NULL, 0, c1, c2, analysis_channels, downmix, float_api);
1481           if (tmp_len<0)
1482           {
1483              RESTORE_STACK;
1484              return OPUS_INTERNAL_ERROR;
1485           }
1486           ret = opus_repacketizer_cat(rp, tmp_data+i*bytes_per_frame, tmp_len);
1487           if (ret<0)
1488           {
1489              RESTORE_STACK;
1490              return OPUS_INTERNAL_ERROR;
1491           }
1492        }
1493        if (st->use_vbr)
1494           repacketize_len = out_data_bytes;
1495        else
1496           repacketize_len = IMIN(3*st->bitrate_bps/(3*8*50/nb_frames), out_data_bytes);
1497        ret = opus_repacketizer_out_range_impl(rp, 0, nb_frames, data, repacketize_len, 0, !st->use_vbr);
1498        if (ret<0)
1499        {
1500           RESTORE_STACK;
1501           return OPUS_INTERNAL_ERROR;
1502        }
1503        st->user_forced_mode = bak_mode;
1504        st->user_bandwidth = bak_bandwidth;
1505        st->force_channels = bak_channels;
1506        st->silk_mode.toMono = bak_to_mono;
1507        RESTORE_STACK;
1508        return ret;
1509     }
1510     curr_bandwidth = st->bandwidth;
1511
1512     /* Chooses the appropriate mode for speech
1513        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
1514     if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1515         st->mode = MODE_HYBRID;
1516     if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
1517         st->mode = MODE_SILK_ONLY;
1518
1519     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
1520     bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
1521
1522     data += 1;
1523
1524     ec_enc_init(&enc, data, max_data_bytes-1);
1525
1526     ALLOC(pcm_buf, (total_buffer+frame_size)*st->channels, opus_val16);
1527     OPUS_COPY(pcm_buf, &st->delay_buffer[(st->encoder_buffer-total_buffer)*st->channels], total_buffer*st->channels);
1528
1529     if (st->mode == MODE_CELT_ONLY)
1530        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1531     else
1532        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
1533
1534     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
1535           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
1536
1537     /* convert from log scale to Hertz */
1538     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
1539
1540     if (st->application == OPUS_APPLICATION_VOIP)
1541     {
1542        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1543     } else {
1544        dc_reject(pcm, 3, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1545     }
1546 #ifndef FIXED_POINT
1547     if (float_api)
1548     {
1549        opus_val32 sum;
1550        sum = celt_inner_prod(&pcm_buf[total_buffer*st->channels], &pcm_buf[total_buffer*st->channels], frame_size*st->channels, st->arch);
1551        /* This should filter out both NaNs and ridiculous signals that could
1552           cause NaNs further down. */
1553        if (!(sum < 1e9f) || celt_isnan(sum))
1554        {
1555           OPUS_CLEAR(&pcm_buf[total_buffer*st->channels], frame_size*st->channels);
1556           st->hp_mem[0] = st->hp_mem[1] = st->hp_mem[2] = st->hp_mem[3] = 0;
1557        }
1558     }
1559 #endif
1560
1561
1562     /* SILK processing */
1563     HB_gain = Q15ONE;
1564     if (st->mode != MODE_CELT_ONLY)
1565     {
1566         opus_int32 total_bitRate, celt_rate;
1567 #ifdef FIXED_POINT
1568        const opus_int16 *pcm_silk;
1569 #else
1570        VARDECL(opus_int16, pcm_silk);
1571        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
1572 #endif
1573
1574         /* Distribute bits between SILK and CELT */
1575         total_bitRate = 8 * bytes_target * frame_rate;
1576         if( st->mode == MODE_HYBRID ) {
1577             /* Base rate for SILK */
1578             st->silk_mode.bitRate = compute_silk_rate_for_hybrid(total_bitRate,
1579                   curr_bandwidth, st->Fs == 50 * frame_size, st->use_vbr);
1580             if (!st->energy_masking)
1581             {
1582                /* Increasingly attenuate high band when it gets allocated fewer bits */
1583                celt_rate = total_bitRate - st->silk_mode.bitRate;
1584                HB_gain = Q15ONE - SHR32(celt_exp2(-celt_rate * QCONST16(1.f/1024, 10)), 1);
1585             }
1586         } else {
1587             /* SILK gets all bits */
1588             st->silk_mode.bitRate = total_bitRate;
1589         }
1590
1591         /* Surround masking for SILK */
1592         if (st->energy_masking && st->use_vbr && !st->lfe)
1593         {
1594            opus_val32 mask_sum=0;
1595            opus_val16 masking_depth;
1596            opus_int32 rate_offset;
1597            int c;
1598            int end = 17;
1599            opus_int16 srate = 16000;
1600            if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND)
1601            {
1602               end = 13;
1603               srate = 8000;
1604            } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1605            {
1606               end = 15;
1607               srate = 12000;
1608            }
1609            for (c=0;c<st->channels;c++)
1610            {
1611               for(i=0;i<end;i++)
1612               {
1613                  opus_val16 mask;
1614                  mask = MAX16(MIN16(st->energy_masking[21*c+i],
1615                         QCONST16(.5f, DB_SHIFT)), -QCONST16(2.0f, DB_SHIFT));
1616                  if (mask > 0)
1617                     mask = HALF16(mask);
1618                  mask_sum += mask;
1619               }
1620            }
1621            /* Conservative rate reduction, we cut the masking in half */
1622            masking_depth = mask_sum / end*st->channels;
1623            masking_depth += QCONST16(.2f, DB_SHIFT);
1624            rate_offset = (opus_int32)PSHR32(MULT16_16(srate, masking_depth), DB_SHIFT);
1625            rate_offset = MAX32(rate_offset, -2*st->silk_mode.bitRate/3);
1626            /* Split the rate change between the SILK and CELT part for hybrid. */
1627            if (st->bandwidth==OPUS_BANDWIDTH_SUPERWIDEBAND || st->bandwidth==OPUS_BANDWIDTH_FULLBAND)
1628               st->silk_mode.bitRate += 3*rate_offset/5;
1629            else
1630               st->silk_mode.bitRate += rate_offset;
1631            bytes_target += rate_offset * frame_size / (8 * st->Fs);
1632         }
1633
1634         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
1635         st->silk_mode.nChannelsAPI = st->channels;
1636         st->silk_mode.nChannelsInternal = st->stream_channels;
1637         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1638             st->silk_mode.desiredInternalSampleRate = 8000;
1639         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1640             st->silk_mode.desiredInternalSampleRate = 12000;
1641         } else {
1642             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
1643             st->silk_mode.desiredInternalSampleRate = 16000;
1644         }
1645         if( st->mode == MODE_HYBRID ) {
1646             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
1647             st->silk_mode.minInternalSampleRate = 16000;
1648         } else {
1649             st->silk_mode.minInternalSampleRate = 8000;
1650         }
1651
1652         if (st->mode == MODE_SILK_ONLY)
1653         {
1654            opus_int32 effective_max_rate = max_rate;
1655            st->silk_mode.maxInternalSampleRate = 16000;
1656            if (frame_rate > 50)
1657               effective_max_rate = effective_max_rate*2/3;
1658            if (effective_max_rate < 13000)
1659            {
1660               st->silk_mode.maxInternalSampleRate = 12000;
1661               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
1662            }
1663            if (effective_max_rate < 9600)
1664            {
1665               st->silk_mode.maxInternalSampleRate = 8000;
1666               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
1667            }
1668         } else {
1669            st->silk_mode.maxInternalSampleRate = 16000;
1670         }
1671
1672         st->silk_mode.useCBR = !st->use_vbr;
1673
1674         /* Call SILK encoder for the low band */
1675         nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes);
1676
1677         st->silk_mode.maxBits = nBytes*8;
1678         /* Only allow up to 90% of the bits for hybrid mode*/
1679         if (st->mode == MODE_HYBRID)
1680            st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
1681         if (st->silk_mode.useCBR)
1682         {
1683            st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
1684            /* Reduce the initial target to make it easier to reach the CBR rate */
1685            st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000);
1686         }
1687
1688         if (prefill)
1689         {
1690             opus_int32 zero=0;
1691             int prefill_offset;
1692             /* Use a smooth onset for the SILK prefill to avoid the encoder trying to encode
1693                a discontinuity. The exact location is what we need to avoid leaving any "gap"
1694                in the audio when mixing with the redundant CELT frame. Here we can afford to
1695                overwrite st->delay_buffer because the only thing that uses it before it gets
1696                rewritten is tmp_prefill[] and even then only the part after the ramp really
1697                gets used (rather than sent to the encoder and discarded) */
1698             prefill_offset = st->channels*(st->encoder_buffer-st->delay_compensation-st->Fs/400);
1699             gain_fade(st->delay_buffer+prefill_offset, st->delay_buffer+prefill_offset,
1700                   0, Q15ONE, celt_mode->overlap, st->Fs/400, st->channels, celt_mode->window, st->Fs);
1701             OPUS_CLEAR(st->delay_buffer, prefill_offset);
1702 #ifdef FIXED_POINT
1703             pcm_silk = st->delay_buffer;
1704 #else
1705             for (i=0;i<st->encoder_buffer*st->channels;i++)
1706                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
1707 #endif
1708             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
1709         }
1710
1711 #ifdef FIXED_POINT
1712         pcm_silk = pcm_buf+total_buffer*st->channels;
1713 #else
1714         for (i=0;i<frame_size*st->channels;i++)
1715             pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
1716 #endif
1717         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
1718         if( ret ) {
1719             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
1720             /* Handle error */
1721            RESTORE_STACK;
1722            return OPUS_INTERNAL_ERROR;
1723         }
1724         if (nBytes==0)
1725         {
1726            st->rangeFinal = 0;
1727            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1728            RESTORE_STACK;
1729            return 1;
1730         }
1731         /* Extract SILK internal bandwidth for signaling in first byte */
1732         if( st->mode == MODE_SILK_ONLY ) {
1733             if( st->silk_mode.internalSampleRate == 8000 ) {
1734                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1735             } else if( st->silk_mode.internalSampleRate == 12000 ) {
1736                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1737             } else if( st->silk_mode.internalSampleRate == 16000 ) {
1738                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1739             }
1740         } else {
1741             silk_assert( st->silk_mode.internalSampleRate == 16000 );
1742         }
1743
1744         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
1745         /* FIXME: How do we allocate the redundancy for CBR? */
1746         if (st->silk_mode.opusCanSwitch)
1747         {
1748            redundancy = 1;
1749            celt_to_silk = 0;
1750            st->silk_bw_switch = 1;
1751         }
1752     }
1753
1754     /* CELT processing */
1755     {
1756         int endband=21;
1757
1758         switch(curr_bandwidth)
1759         {
1760             case OPUS_BANDWIDTH_NARROWBAND:
1761                 endband = 13;
1762                 break;
1763             case OPUS_BANDWIDTH_MEDIUMBAND:
1764             case OPUS_BANDWIDTH_WIDEBAND:
1765                 endband = 17;
1766                 break;
1767             case OPUS_BANDWIDTH_SUPERWIDEBAND:
1768                 endband = 19;
1769                 break;
1770             case OPUS_BANDWIDTH_FULLBAND:
1771                 endband = 21;
1772                 break;
1773         }
1774         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
1775         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
1776     }
1777     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1778     if (st->mode != MODE_SILK_ONLY)
1779     {
1780         opus_val32 celt_pred=2;
1781         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1782         /* We may still decide to disable prediction later */
1783         if (st->silk_mode.reducedDependency)
1784            celt_pred = 0;
1785         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(celt_pred));
1786
1787         if (st->mode == MODE_HYBRID)
1788         {
1789             int len;
1790
1791             len = (ec_tell(&enc)+7)>>3;
1792             if (redundancy)
1793                len += st->mode == MODE_HYBRID ? 3 : 1;
1794             if( st->use_vbr ) {
1795                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps-st->silk_mode.bitRate));
1796                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
1797                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(0));
1798             } else {
1799                 /* check if SILK used up too much */
1800                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
1801             }
1802         } else {
1803             if (st->use_vbr)
1804             {
1805                 opus_int32 bonus=0;
1806 #ifndef DISABLE_FLOAT_API
1807                 if (st->variable_duration==OPUS_FRAMESIZE_VARIABLE && frame_size != st->Fs/50)
1808                 {
1809                    bonus = (60*st->stream_channels+40)*(st->Fs/frame_size-50);
1810                    if (analysis_info.valid)
1811                       bonus = (opus_int32)(bonus*(1.f+.5f*analysis_info.tonality));
1812                 }
1813 #endif
1814                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
1815                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
1816                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps+bonus));
1817                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
1818             } else {
1819                 nb_compr_bytes = bytes_target;
1820             }
1821         }
1822
1823     } else {
1824         nb_compr_bytes = 0;
1825     }
1826
1827     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
1828     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
1829     {
1830        OPUS_COPY(tmp_prefill, &st->delay_buffer[(st->encoder_buffer-total_buffer-st->Fs/400)*st->channels], st->channels*st->Fs/400);
1831     }
1832
1833     if (st->channels*(st->encoder_buffer-(frame_size+total_buffer)) > 0)
1834     {
1835        OPUS_MOVE(st->delay_buffer, &st->delay_buffer[st->channels*frame_size], st->channels*(st->encoder_buffer-frame_size-total_buffer));
1836        OPUS_COPY(&st->delay_buffer[st->channels*(st->encoder_buffer-frame_size-total_buffer)],
1837              &pcm_buf[0],
1838              (frame_size+total_buffer)*st->channels);
1839     } else {
1840        OPUS_COPY(st->delay_buffer, &pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels], st->encoder_buffer*st->channels);
1841     }
1842     /* gain_fade() and stereo_fade() need to be after the buffer copying
1843        because we don't want any of this to affect the SILK part */
1844     if( st->prev_HB_gain < Q15ONE || HB_gain < Q15ONE ) {
1845        gain_fade(pcm_buf, pcm_buf,
1846              st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs);
1847     }
1848     st->prev_HB_gain = HB_gain;
1849     if (st->mode != MODE_HYBRID || st->stream_channels==1)
1850        st->silk_mode.stereoWidth_Q14 = IMIN((1<<14),2*IMAX(0,equiv_rate-24000));
1851     if( !st->energy_masking && st->channels == 2 ) {
1852         /* Apply stereo width reduction (at low bitrates) */
1853         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1854             opus_val16 g1, g2;
1855             g1 = st->hybrid_stereo_width_Q14;
1856             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1857 #ifdef FIXED_POINT
1858             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
1859             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
1860 #else
1861             g1 *= (1.f/16384);
1862             g2 *= (1.f/16384);
1863 #endif
1864             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
1865                   frame_size, st->channels, celt_mode->window, st->Fs);
1866             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1867         }
1868     }
1869
1870     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
1871     {
1872         /* For SILK mode, the redundancy is inferred from the length */
1873         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
1874            ec_enc_bit_logp(&enc, redundancy, 12);
1875         if (redundancy)
1876         {
1877             int max_redundancy;
1878             ec_enc_bit_logp(&enc, celt_to_silk, 1);
1879             if (st->mode == MODE_HYBRID)
1880                max_redundancy = (max_data_bytes-1)-nb_compr_bytes;
1881             else
1882                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1883             /* Target the same bit-rate for redundancy as for the rest,
1884                up to a max of 257 bytes */
1885             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
1886             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
1887             if (st->mode == MODE_HYBRID)
1888                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
1889         }
1890     } else {
1891         redundancy = 0;
1892     }
1893
1894     if (!redundancy)
1895     {
1896        st->silk_bw_switch = 0;
1897        redundancy_bytes = 0;
1898     }
1899     if (st->mode != MODE_CELT_ONLY)start_band=17;
1900
1901     if (st->mode == MODE_SILK_ONLY)
1902     {
1903         ret = (ec_tell(&enc)+7)>>3;
1904         ec_enc_done(&enc);
1905         nb_compr_bytes = ret;
1906     } else {
1907        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
1908        ec_enc_shrink(&enc, nb_compr_bytes);
1909     }
1910
1911 #ifndef DISABLE_FLOAT_API
1912     if (redundancy || st->mode != MODE_SILK_ONLY)
1913        celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(&analysis_info));
1914 #endif
1915     if (st->mode == MODE_HYBRID) {
1916        SILKInfo info;
1917        info.signalType = st->silk_mode.signalType;
1918        info.offset = st->silk_mode.offset;
1919        celt_encoder_ctl(celt_enc, CELT_SET_SILK_INFO(&info));
1920     } else {
1921        celt_encoder_ctl(celt_enc, CELT_SET_SILK_INFO((SILKInfo*)NULL));
1922     }
1923
1924     /* 5 ms redundant frame for CELT->SILK */
1925     if (redundancy && celt_to_silk)
1926     {
1927         int err;
1928         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1929         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1930         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1931         err = celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
1932         if (err < 0)
1933         {
1934            RESTORE_STACK;
1935            return OPUS_INTERNAL_ERROR;
1936         }
1937         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1938         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1939     }
1940
1941     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
1942
1943     if (st->mode != MODE_SILK_ONLY)
1944     {
1945         if (st->mode != st->prev_mode && st->prev_mode > 0)
1946         {
1947            unsigned char dummy[2];
1948            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1949
1950            /* Prefilling */
1951            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
1952            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1953         }
1954         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
1955         if (ec_tell(&enc) <= 8*nb_compr_bytes)
1956         {
1957            /* Set the bitrate again if it was overridden in the redundancy code above*/
1958            if (redundancy && celt_to_silk && st->mode==MODE_HYBRID && st->use_vbr)
1959               celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps-st->silk_mode.bitRate));
1960            celt_encoder_ctl(celt_enc, OPUS_SET_VBR(st->use_vbr));
1961            ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
1962            if (ret < 0)
1963            {
1964               RESTORE_STACK;
1965               return OPUS_INTERNAL_ERROR;
1966            }
1967            /* Put CELT->SILK redundancy data in the right place. */
1968            if (redundancy && celt_to_silk && st->mode==MODE_HYBRID && st->use_vbr)
1969            {
1970               OPUS_COPY(data+ret, data+nb_compr_bytes, redundancy_bytes);
1971               nb_compr_bytes = nb_compr_bytes+redundancy_bytes;
1972            }
1973         }
1974     }
1975
1976     /* 5 ms redundant frame for SILK->CELT */
1977     if (redundancy && !celt_to_silk)
1978     {
1979         int err;
1980         unsigned char dummy[2];
1981         int N2, N4;
1982         N2 = st->Fs/200;
1983         N4 = st->Fs/400;
1984
1985         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1986         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1987         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1988         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1989         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1990
1991         if (st->mode == MODE_HYBRID)
1992         {
1993            /* Shrink packet to what the encoder actually used. */
1994            nb_compr_bytes = ret;
1995            ec_enc_shrink(&enc, nb_compr_bytes);
1996         }
1997         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1998         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL);
1999
2000         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
2001         if (err < 0)
2002         {
2003            RESTORE_STACK;
2004            return OPUS_INTERNAL_ERROR;
2005         }
2006         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
2007     }
2008
2009
2010
2011     /* Signalling the mode in the first byte */
2012     data--;
2013     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
2014
2015     st->rangeFinal = enc.rng ^ redundant_rng;
2016
2017     if (to_celt)
2018         st->prev_mode = MODE_CELT_ONLY;
2019     else
2020         st->prev_mode = st->mode;
2021     st->prev_channels = st->stream_channels;
2022     st->prev_framesize = frame_size;
2023
2024     st->first = 0;
2025
2026     /* In the unlikely case that the SILK encoder busted its target, tell
2027        the decoder to call the PLC */
2028     if (ec_tell(&enc) > (max_data_bytes-1)*8)
2029     {
2030        if (max_data_bytes < 2)
2031        {
2032           RESTORE_STACK;
2033           return OPUS_BUFFER_TOO_SMALL;
2034        }
2035        data[1] = 0;
2036        ret = 1;
2037        st->rangeFinal = 0;
2038     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
2039     {
2040        /*When in LPC only mode it's perfectly
2041          reasonable to strip off trailing zero bytes as
2042          the required range decoder behavior is to
2043          fill these in. This can't be done when the MDCT
2044          modes are used because the decoder needs to know
2045          the actual length for allocation purposes.*/
2046        while(ret>2&&data[ret]==0)ret--;
2047     }
2048     /* Count ToC and redundancy */
2049     ret += 1+redundancy_bytes;
2050     if (!st->use_vbr)
2051     {
2052        if (opus_packet_pad(data, ret, max_data_bytes) != OPUS_OK)
2053
2054        {
2055           RESTORE_STACK;
2056           return OPUS_INTERNAL_ERROR;
2057        }
2058        ret = max_data_bytes;
2059     }
2060     RESTORE_STACK;
2061     return ret;
2062 }
2063
2064 #ifdef FIXED_POINT
2065
2066 #ifndef DISABLE_FLOAT_API
2067 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int analysis_frame_size,
2068       unsigned char *data, opus_int32 max_data_bytes)
2069 {
2070    int i, ret;
2071    int frame_size;
2072    int delay_compensation;
2073    VARDECL(opus_int16, in);
2074    ALLOC_STACK;
2075
2076    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2077       delay_compensation = 0;
2078    else
2079       delay_compensation = st->delay_compensation;
2080    frame_size = compute_frame_size(pcm, analysis_frame_size,
2081          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2082          delay_compensation, downmix_float, st->analysis.subframe_mem);
2083
2084    ALLOC(in, frame_size*st->channels, opus_int16);
2085
2086    for (i=0;i<frame_size*st->channels;i++)
2087       in[i] = FLOAT2INT16(pcm[i]);
2088    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16,
2089                             pcm, analysis_frame_size, 0, -2, st->channels, downmix_float, 1);
2090    RESTORE_STACK;
2091    return ret;
2092 }
2093 #endif
2094
2095 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int analysis_frame_size,
2096                 unsigned char *data, opus_int32 out_data_bytes)
2097 {
2098    int frame_size;
2099    int delay_compensation;
2100    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2101       delay_compensation = 0;
2102    else
2103       delay_compensation = st->delay_compensation;
2104    frame_size = compute_frame_size(pcm, analysis_frame_size,
2105          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2106          delay_compensation, downmix_int
2107 #ifndef DISABLE_FLOAT_API
2108          , st->analysis.subframe_mem
2109 #endif
2110          );
2111    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 16,
2112                              pcm, analysis_frame_size, 0, -2, st->channels, downmix_int, 0);
2113 }
2114
2115 #else
2116 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int analysis_frame_size,
2117       unsigned char *data, opus_int32 max_data_bytes)
2118 {
2119    int i, ret;
2120    int frame_size;
2121    int delay_compensation;
2122    VARDECL(float, in);
2123    ALLOC_STACK;
2124
2125    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2126       delay_compensation = 0;
2127    else
2128       delay_compensation = st->delay_compensation;
2129    frame_size = compute_frame_size(pcm, analysis_frame_size,
2130          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2131          delay_compensation, downmix_int, st->analysis.subframe_mem);
2132
2133    ALLOC(in, frame_size*st->channels, float);
2134
2135    for (i=0;i<frame_size*st->channels;i++)
2136       in[i] = (1.0f/32768)*pcm[i];
2137    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16,
2138                             pcm, analysis_frame_size, 0, -2, st->channels, downmix_int, 0);
2139    RESTORE_STACK;
2140    return ret;
2141 }
2142 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int analysis_frame_size,
2143                       unsigned char *data, opus_int32 out_data_bytes)
2144 {
2145    int frame_size;
2146    int delay_compensation;
2147    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2148       delay_compensation = 0;
2149    else
2150       delay_compensation = st->delay_compensation;
2151    frame_size = compute_frame_size(pcm, analysis_frame_size,
2152          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2153          delay_compensation, downmix_float, st->analysis.subframe_mem);
2154    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 24,
2155                              pcm, analysis_frame_size, 0, -2, st->channels, downmix_float, 1);
2156 }
2157 #endif
2158
2159
2160 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
2161 {
2162     int ret;
2163     CELTEncoder *celt_enc;
2164     va_list ap;
2165
2166     ret = OPUS_OK;
2167     va_start(ap, request);
2168
2169     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
2170
2171     switch (request)
2172     {
2173         case OPUS_SET_APPLICATION_REQUEST:
2174         {
2175             opus_int32 value = va_arg(ap, opus_int32);
2176             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
2177                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2178                || (!st->first && st->application != value))
2179             {
2180                ret = OPUS_BAD_ARG;
2181                break;
2182             }
2183             st->application = value;
2184         }
2185         break;
2186         case OPUS_GET_APPLICATION_REQUEST:
2187         {
2188             opus_int32 *value = va_arg(ap, opus_int32*);
2189             if (!value)
2190             {
2191                goto bad_arg;
2192             }
2193             *value = st->application;
2194         }
2195         break;
2196         case OPUS_SET_BITRATE_REQUEST:
2197         {
2198             opus_int32 value = va_arg(ap, opus_int32);
2199             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
2200             {
2201                 if (value <= 0)
2202                     goto bad_arg;
2203                 else if (value <= 500)
2204                     value = 500;
2205                 else if (value > (opus_int32)300000*st->channels)
2206                     value = (opus_int32)300000*st->channels;
2207             }
2208             st->user_bitrate_bps = value;
2209         }
2210         break;
2211         case OPUS_GET_BITRATE_REQUEST:
2212         {
2213             opus_int32 *value = va_arg(ap, opus_int32*);
2214             if (!value)
2215             {
2216                goto bad_arg;
2217             }
2218             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
2219         }
2220         break;
2221         case OPUS_SET_FORCE_CHANNELS_REQUEST:
2222         {
2223             opus_int32 value = va_arg(ap, opus_int32);
2224             if((value<1 || value>st->channels) && value != OPUS_AUTO)
2225             {
2226                goto bad_arg;
2227             }
2228             st->force_channels = value;
2229         }
2230         break;
2231         case OPUS_GET_FORCE_CHANNELS_REQUEST:
2232         {
2233             opus_int32 *value = va_arg(ap, opus_int32*);
2234             if (!value)
2235             {
2236                goto bad_arg;
2237             }
2238             *value = st->force_channels;
2239         }
2240         break;
2241         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
2242         {
2243             opus_int32 value = va_arg(ap, opus_int32);
2244             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND)
2245             {
2246                goto bad_arg;
2247             }
2248             st->max_bandwidth = value;
2249             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2250                 st->silk_mode.maxInternalSampleRate = 8000;
2251             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2252                 st->silk_mode.maxInternalSampleRate = 12000;
2253             } else {
2254                 st->silk_mode.maxInternalSampleRate = 16000;
2255             }
2256         }
2257         break;
2258         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
2259         {
2260             opus_int32 *value = va_arg(ap, opus_int32*);
2261             if (!value)
2262             {
2263                goto bad_arg;
2264             }
2265             *value = st->max_bandwidth;
2266         }
2267         break;
2268         case OPUS_SET_BANDWIDTH_REQUEST:
2269         {
2270             opus_int32 value = va_arg(ap, opus_int32);
2271             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
2272             {
2273                goto bad_arg;
2274             }
2275             st->user_bandwidth = value;
2276             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2277                 st->silk_mode.maxInternalSampleRate = 8000;
2278             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2279                 st->silk_mode.maxInternalSampleRate = 12000;
2280             } else {
2281                 st->silk_mode.maxInternalSampleRate = 16000;
2282             }
2283         }
2284         break;
2285         case OPUS_GET_BANDWIDTH_REQUEST:
2286         {
2287             opus_int32 *value = va_arg(ap, opus_int32*);
2288             if (!value)
2289             {
2290                goto bad_arg;
2291             }
2292             *value = st->bandwidth;
2293         }
2294         break;
2295         case OPUS_SET_DTX_REQUEST:
2296         {
2297             opus_int32 value = va_arg(ap, opus_int32);
2298             if(value<0 || value>1)
2299             {
2300                goto bad_arg;
2301             }
2302             st->silk_mode.useDTX = value;
2303         }
2304         break;
2305         case OPUS_GET_DTX_REQUEST:
2306         {
2307             opus_int32 *value = va_arg(ap, opus_int32*);
2308             if (!value)
2309             {
2310                goto bad_arg;
2311             }
2312             *value = st->silk_mode.useDTX;
2313         }
2314         break;
2315         case OPUS_SET_COMPLEXITY_REQUEST:
2316         {
2317             opus_int32 value = va_arg(ap, opus_int32);
2318             if(value<0 || value>10)
2319             {
2320                goto bad_arg;
2321             }
2322             st->silk_mode.complexity = value;
2323             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
2324         }
2325         break;
2326         case OPUS_GET_COMPLEXITY_REQUEST:
2327         {
2328             opus_int32 *value = va_arg(ap, opus_int32*);
2329             if (!value)
2330             {
2331                goto bad_arg;
2332             }
2333             *value = st->silk_mode.complexity;
2334         }
2335         break;
2336         case OPUS_SET_INBAND_FEC_REQUEST:
2337         {
2338             opus_int32 value = va_arg(ap, opus_int32);
2339             if(value<0 || value>1)
2340             {
2341                goto bad_arg;
2342             }
2343             st->silk_mode.useInBandFEC = value;
2344         }
2345         break;
2346         case OPUS_GET_INBAND_FEC_REQUEST:
2347         {
2348             opus_int32 *value = va_arg(ap, opus_int32*);
2349             if (!value)
2350             {
2351                goto bad_arg;
2352             }
2353             *value = st->silk_mode.useInBandFEC;
2354         }
2355         break;
2356         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
2357         {
2358             opus_int32 value = va_arg(ap, opus_int32);
2359             if (value < 0 || value > 100)
2360             {
2361                goto bad_arg;
2362             }
2363             st->silk_mode.packetLossPercentage = value;
2364             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
2365         }
2366         break;
2367         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
2368         {
2369             opus_int32 *value = va_arg(ap, opus_int32*);
2370             if (!value)
2371             {
2372                goto bad_arg;
2373             }
2374             *value = st->silk_mode.packetLossPercentage;
2375         }
2376         break;
2377         case OPUS_SET_VBR_REQUEST:
2378         {
2379             opus_int32 value = va_arg(ap, opus_int32);
2380             if(value<0 || value>1)
2381             {
2382                goto bad_arg;
2383             }
2384             st->use_vbr = value;
2385             st->silk_mode.useCBR = 1-value;
2386         }
2387         break;
2388         case OPUS_GET_VBR_REQUEST:
2389         {
2390             opus_int32 *value = va_arg(ap, opus_int32*);
2391             if (!value)
2392             {
2393                goto bad_arg;
2394             }
2395             *value = st->use_vbr;
2396         }
2397         break;
2398         case OPUS_SET_VOICE_RATIO_REQUEST:
2399         {
2400             opus_int32 value = va_arg(ap, opus_int32);
2401             if (value<-1 || value>100)
2402             {
2403                goto bad_arg;
2404             }
2405             st->voice_ratio = value;
2406         }
2407         break;
2408         case OPUS_GET_VOICE_RATIO_REQUEST:
2409         {
2410             opus_int32 *value = va_arg(ap, opus_int32*);
2411             if (!value)
2412             {
2413                goto bad_arg;
2414             }
2415             *value = st->voice_ratio;
2416         }
2417         break;
2418         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
2419         {
2420             opus_int32 value = va_arg(ap, opus_int32);
2421             if(value<0 || value>1)
2422             {
2423                goto bad_arg;
2424             }
2425             st->vbr_constraint = value;
2426         }
2427         break;
2428         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
2429         {
2430             opus_int32 *value = va_arg(ap, opus_int32*);
2431             if (!value)
2432             {
2433                goto bad_arg;
2434             }
2435             *value = st->vbr_constraint;
2436         }
2437         break;
2438         case OPUS_SET_SIGNAL_REQUEST:
2439         {
2440             opus_int32 value = va_arg(ap, opus_int32);
2441             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
2442             {
2443                goto bad_arg;
2444             }
2445             st->signal_type = value;
2446         }
2447         break;
2448         case OPUS_GET_SIGNAL_REQUEST:
2449         {
2450             opus_int32 *value = va_arg(ap, opus_int32*);
2451             if (!value)
2452             {
2453                goto bad_arg;
2454             }
2455             *value = st->signal_type;
2456         }
2457         break;
2458         case OPUS_GET_LOOKAHEAD_REQUEST:
2459         {
2460             opus_int32 *value = va_arg(ap, opus_int32*);
2461             if (!value)
2462             {
2463                goto bad_arg;
2464             }
2465             *value = st->Fs/400;
2466             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2467                 *value += st->delay_compensation;
2468         }
2469         break;
2470         case OPUS_GET_SAMPLE_RATE_REQUEST:
2471         {
2472             opus_int32 *value = va_arg(ap, opus_int32*);
2473             if (!value)
2474             {
2475                goto bad_arg;
2476             }
2477             *value = st->Fs;
2478         }
2479         break;
2480         case OPUS_GET_FINAL_RANGE_REQUEST:
2481         {
2482             opus_uint32 *value = va_arg(ap, opus_uint32*);
2483             if (!value)
2484             {
2485                goto bad_arg;
2486             }
2487             *value = st->rangeFinal;
2488         }
2489         break;
2490         case OPUS_SET_LSB_DEPTH_REQUEST:
2491         {
2492             opus_int32 value = va_arg(ap, opus_int32);
2493             if (value<8 || value>24)
2494             {
2495                goto bad_arg;
2496             }
2497             st->lsb_depth=value;
2498         }
2499         break;
2500         case OPUS_GET_LSB_DEPTH_REQUEST:
2501         {
2502             opus_int32 *value = va_arg(ap, opus_int32*);
2503             if (!value)
2504             {
2505                goto bad_arg;
2506             }
2507             *value = st->lsb_depth;
2508         }
2509         break;
2510         case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
2511         {
2512             opus_int32 value = va_arg(ap, opus_int32);
2513             if (value != OPUS_FRAMESIZE_ARG   && value != OPUS_FRAMESIZE_2_5_MS &&
2514                 value != OPUS_FRAMESIZE_5_MS  && value != OPUS_FRAMESIZE_10_MS  &&
2515                 value != OPUS_FRAMESIZE_20_MS && value != OPUS_FRAMESIZE_40_MS  &&
2516                 value != OPUS_FRAMESIZE_60_MS && value != OPUS_FRAMESIZE_VARIABLE)
2517             {
2518                goto bad_arg;
2519             }
2520             st->variable_duration = value;
2521             celt_encoder_ctl(celt_enc, OPUS_SET_EXPERT_FRAME_DURATION(value));
2522         }
2523         break;
2524         case OPUS_GET_EXPERT_FRAME_DURATION_REQUEST:
2525         {
2526             opus_int32 *value = va_arg(ap, opus_int32*);
2527             if (!value)
2528             {
2529                goto bad_arg;
2530             }
2531             *value = st->variable_duration;
2532         }
2533         break;
2534         case OPUS_SET_PREDICTION_DISABLED_REQUEST:
2535         {
2536            opus_int32 value = va_arg(ap, opus_int32);
2537            if (value > 1 || value < 0)
2538               goto bad_arg;
2539            st->silk_mode.reducedDependency = value;
2540         }
2541         break;
2542         case OPUS_GET_PREDICTION_DISABLED_REQUEST:
2543         {
2544            opus_int32 *value = va_arg(ap, opus_int32*);
2545            if (!value)
2546               goto bad_arg;
2547            *value = st->silk_mode.reducedDependency;
2548         }
2549         break;
2550         case OPUS_RESET_STATE:
2551         {
2552            void *silk_enc;
2553            silk_EncControlStruct dummy;
2554            char *start;
2555            silk_enc = (char*)st+st->silk_enc_offset;
2556 #ifndef DISABLE_FLOAT_API
2557            tonality_analysis_reset(&st->analysis);
2558 #endif
2559
2560            start = (char*)&st->OPUS_ENCODER_RESET_START;
2561            OPUS_CLEAR(start, sizeof(OpusEncoder) - (start - (char*)st));
2562
2563            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2564            silk_InitEncoder( silk_enc, st->arch, &dummy );
2565            st->stream_channels = st->channels;
2566            st->hybrid_stereo_width_Q14 = 1 << 14;
2567            st->prev_HB_gain = Q15ONE;
2568            st->first = 1;
2569            st->mode = MODE_HYBRID;
2570            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
2571            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
2572         }
2573         break;
2574         case OPUS_SET_FORCE_MODE_REQUEST:
2575         {
2576             opus_int32 value = va_arg(ap, opus_int32);
2577             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
2578             {
2579                goto bad_arg;
2580             }
2581             st->user_forced_mode = value;
2582         }
2583         break;
2584         case OPUS_SET_LFE_REQUEST:
2585         {
2586             opus_int32 value = va_arg(ap, opus_int32);
2587             st->lfe = value;
2588             ret = celt_encoder_ctl(celt_enc, OPUS_SET_LFE(value));
2589         }
2590         break;
2591         case OPUS_SET_ENERGY_MASK_REQUEST:
2592         {
2593             opus_val16 *value = va_arg(ap, opus_val16*);
2594             st->energy_masking = value;
2595             ret = celt_encoder_ctl(celt_enc, OPUS_SET_ENERGY_MASK(value));
2596         }
2597         break;
2598
2599         case CELT_GET_MODE_REQUEST:
2600         {
2601            const CELTMode ** value = va_arg(ap, const CELTMode**);
2602            if (!value)
2603            {
2604               goto bad_arg;
2605            }
2606            ret = celt_encoder_ctl(celt_enc, CELT_GET_MODE(value));
2607         }
2608         break;
2609         default:
2610             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
2611             ret = OPUS_UNIMPLEMENTED;
2612             break;
2613     }
2614     va_end(ap);
2615     return ret;
2616 bad_arg:
2617     va_end(ap);
2618     return OPUS_BAD_ARG;
2619 }
2620
2621 void opus_encoder_destroy(OpusEncoder *st)
2622 {
2623     opus_free(st);
2624 }