Quality: Adds SILK rate interpolation function
[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         14000, 1000, /* MB<->WB */
118         17000, 1000, /* WB<->SWB */
119         21000, 2000, /* SWB<->FB */
120 };
121 static const opus_int32 mono_music_bandwidth_thresholds[8] = {
122         12000, 1000, /* NB<->MB */
123         15000, 1000, /* MB<->WB */
124         18000, 2000, /* WB<->SWB */
125         22000, 2000, /* SWB<->FB */
126 };
127 static const opus_int32 stereo_voice_bandwidth_thresholds[8] = {
128         11000, 1000, /* NB<->MB */
129         14000, 1000, /* MB<->WB */
130         21000, 2000, /* WB<->SWB */
131         28000, 2000, /* SWB<->FB */
132 };
133 static const opus_int32 stereo_music_bandwidth_thresholds[8] = {
134         12000, 1000, /* NB<->MB */
135         18000, 2000, /* MB<->WB */
136         20000, 2000, /* WB<->SWB */
137         24000, 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 opus_int32 opus_encode_native(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
981                 unsigned char *data, opus_int32 out_data_bytes, int lsb_depth,
982                 const void *analysis_pcm, opus_int32 analysis_size, int c1, int c2,
983                 int analysis_channels, downmix_func downmix, int float_api)
984 {
985     void *silk_enc;
986     CELTEncoder *celt_enc;
987     int i;
988     int ret=0;
989     opus_int32 nBytes;
990     ec_enc enc;
991     int bytes_target;
992     int prefill=0;
993     int start_band = 0;
994     int redundancy = 0;
995     int redundancy_bytes = 0; /* Number of bytes to use for redundancy frame */
996     int celt_to_silk = 0;
997     VARDECL(opus_val16, pcm_buf);
998     int nb_compr_bytes;
999     int to_celt = 0;
1000     opus_uint32 redundant_rng = 0;
1001     int cutoff_Hz, hp_freq_smth1;
1002     int voice_est; /* Probability of voice in Q7 */
1003     opus_int32 equiv_rate;
1004     int delay_compensation;
1005     int frame_rate;
1006     opus_int32 max_rate; /* Max bitrate we're allowed to use */
1007     int curr_bandwidth;
1008     opus_val16 HB_gain;
1009     opus_int32 max_data_bytes; /* Max number of bytes we're allowed to use */
1010     int total_buffer;
1011     opus_val16 stereo_width;
1012     const CELTMode *celt_mode;
1013 #ifndef DISABLE_FLOAT_API
1014     AnalysisInfo analysis_info;
1015     int analysis_read_pos_bak=-1;
1016     int analysis_read_subframe_bak=-1;
1017 #endif
1018     VARDECL(opus_val16, tmp_prefill);
1019
1020     ALLOC_STACK;
1021
1022     max_data_bytes = IMIN(1276, out_data_bytes);
1023
1024     st->rangeFinal = 0;
1025     if ((!st->variable_duration && 400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
1026          50*frame_size != st->Fs &&  25*frame_size != st->Fs &&  50*frame_size != 3*st->Fs)
1027          || (400*frame_size < st->Fs)
1028          || max_data_bytes<=0
1029          )
1030     {
1031        RESTORE_STACK;
1032        return OPUS_BAD_ARG;
1033     }
1034     silk_enc = (char*)st+st->silk_enc_offset;
1035     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1036     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1037        delay_compensation = 0;
1038     else
1039        delay_compensation = st->delay_compensation;
1040
1041     lsb_depth = IMIN(lsb_depth, st->lsb_depth);
1042
1043     celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1044 #ifndef DISABLE_FLOAT_API
1045     analysis_info.valid = 0;
1046 #ifdef FIXED_POINT
1047     if (st->silk_mode.complexity >= 10 && st->Fs==48000)
1048 #else
1049     if (st->silk_mode.complexity >= 7 && st->Fs==48000)
1050 #endif
1051     {
1052        analysis_read_pos_bak = st->analysis.read_pos;
1053        analysis_read_subframe_bak = st->analysis.read_subframe;
1054        run_analysis(&st->analysis, celt_mode, analysis_pcm, analysis_size, frame_size,
1055              c1, c2, analysis_channels, st->Fs,
1056              lsb_depth, downmix, &analysis_info);
1057     }
1058 #else
1059     (void)analysis_pcm;
1060     (void)analysis_size;
1061 #endif
1062
1063     st->voice_ratio = -1;
1064
1065 #ifndef DISABLE_FLOAT_API
1066     st->detected_bandwidth = 0;
1067     if (analysis_info.valid)
1068     {
1069        int analysis_bandwidth;
1070        if (st->signal_type == OPUS_AUTO)
1071           st->voice_ratio = (int)floor(.5+100*(1-analysis_info.music_prob));
1072
1073        analysis_bandwidth = analysis_info.bandwidth;
1074        if (analysis_bandwidth<=12)
1075           st->detected_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1076        else if (analysis_bandwidth<=14)
1077           st->detected_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1078        else if (analysis_bandwidth<=16)
1079           st->detected_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1080        else if (analysis_bandwidth<=18)
1081           st->detected_bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1082        else
1083           st->detected_bandwidth = OPUS_BANDWIDTH_FULLBAND;
1084     }
1085 #endif
1086
1087     if (st->channels==2 && st->force_channels!=1)
1088        stereo_width = compute_stereo_width(pcm, frame_size, st->Fs, &st->width_mem);
1089     else
1090        stereo_width = 0;
1091     total_buffer = delay_compensation;
1092     st->bitrate_bps = user_bitrate_to_bitrate(st, frame_size, max_data_bytes);
1093
1094     frame_rate = st->Fs/frame_size;
1095     if (!st->use_vbr)
1096     {
1097        int cbrBytes;
1098        /* Multiply by 3 to make sure the division is exact. */
1099        int frame_rate3 = 3*st->Fs/frame_size;
1100        /* We need to make sure that "int" values always fit in 16 bits. */
1101        cbrBytes = IMIN( (3*st->bitrate_bps/8 + frame_rate3/2)/frame_rate3, max_data_bytes);
1102        st->bitrate_bps = cbrBytes*(opus_int32)frame_rate3*8/3;
1103        max_data_bytes = cbrBytes;
1104     }
1105     if (max_data_bytes<3 || st->bitrate_bps < 3*frame_rate*8
1106        || (frame_rate<50 && (max_data_bytes*frame_rate<300 || st->bitrate_bps < 2400)))
1107     {
1108        /*If the space is too low to do something useful, emit 'PLC' frames.*/
1109        int tocmode = st->mode;
1110        int bw = st->bandwidth == 0 ? OPUS_BANDWIDTH_NARROWBAND : st->bandwidth;
1111        if (tocmode==0)
1112           tocmode = MODE_SILK_ONLY;
1113        if (frame_rate>100)
1114           tocmode = MODE_CELT_ONLY;
1115        if (frame_rate < 50)
1116           tocmode = MODE_SILK_ONLY;
1117        if(tocmode==MODE_SILK_ONLY&&bw>OPUS_BANDWIDTH_WIDEBAND)
1118           bw=OPUS_BANDWIDTH_WIDEBAND;
1119        else if (tocmode==MODE_CELT_ONLY&&bw==OPUS_BANDWIDTH_MEDIUMBAND)
1120           bw=OPUS_BANDWIDTH_NARROWBAND;
1121        else if (tocmode==MODE_HYBRID&&bw<=OPUS_BANDWIDTH_SUPERWIDEBAND)
1122           bw=OPUS_BANDWIDTH_SUPERWIDEBAND;
1123        data[0] = gen_toc(tocmode, frame_rate, bw, st->stream_channels);
1124        ret = 1;
1125        if (!st->use_vbr)
1126        {
1127           ret = opus_packet_pad(data, ret, max_data_bytes);
1128           if (ret == OPUS_OK)
1129              ret = max_data_bytes;
1130        }
1131        RESTORE_STACK;
1132        return ret;
1133     }
1134     max_rate = frame_rate*max_data_bytes*8;
1135
1136     /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */
1137     equiv_rate = st->bitrate_bps - (40*st->channels+20)*(st->Fs/frame_size - 50);
1138
1139     if (st->signal_type == OPUS_SIGNAL_VOICE)
1140        voice_est = 127;
1141     else if (st->signal_type == OPUS_SIGNAL_MUSIC)
1142        voice_est = 0;
1143     else if (st->voice_ratio >= 0)
1144     {
1145        voice_est = st->voice_ratio*327>>8;
1146        /* For AUDIO, never be more than 90% confident of having speech */
1147        if (st->application == OPUS_APPLICATION_AUDIO)
1148           voice_est = IMIN(voice_est, 115);
1149     } else if (st->application == OPUS_APPLICATION_VOIP)
1150        voice_est = 115;
1151     else
1152        voice_est = 48;
1153
1154     if (st->force_channels!=OPUS_AUTO && st->channels == 2)
1155     {
1156         st->stream_channels = st->force_channels;
1157     } else {
1158 #ifdef FUZZING
1159        /* Random mono/stereo decision */
1160        if (st->channels == 2 && (rand()&0x1F)==0)
1161           st->stream_channels = 3-st->stream_channels;
1162 #else
1163        /* Rate-dependent mono-stereo decision */
1164        if (st->channels == 2)
1165        {
1166           opus_int32 stereo_threshold;
1167           stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14);
1168           if (st->stream_channels == 2)
1169              stereo_threshold -= 1000;
1170           else
1171              stereo_threshold += 1000;
1172           st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1;
1173        } else {
1174           st->stream_channels = st->channels;
1175        }
1176 #endif
1177     }
1178     equiv_rate = st->bitrate_bps - (40*st->stream_channels+20)*(st->Fs/frame_size - 50);
1179
1180     /* Mode selection depending on application and signal type */
1181     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1182     {
1183        st->mode = MODE_CELT_ONLY;
1184     } else if (st->user_forced_mode == OPUS_AUTO)
1185     {
1186 #ifdef FUZZING
1187        /* Random mode switching */
1188        if ((rand()&0xF)==0)
1189        {
1190           if ((rand()&0x1)==0)
1191              st->mode = MODE_CELT_ONLY;
1192           else
1193              st->mode = MODE_SILK_ONLY;
1194        } else {
1195           if (st->prev_mode==MODE_CELT_ONLY)
1196              st->mode = MODE_CELT_ONLY;
1197           else
1198              st->mode = MODE_SILK_ONLY;
1199        }
1200 #else
1201        opus_int32 mode_voice, mode_music;
1202        opus_int32 threshold;
1203
1204        /* Interpolate based on stereo width */
1205        mode_voice = (opus_int32)(MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[0][0])
1206              + MULT16_32_Q15(stereo_width,mode_thresholds[1][0]));
1207        mode_music = (opus_int32)(MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[1][1])
1208              + MULT16_32_Q15(stereo_width,mode_thresholds[1][1]));
1209        /* Interpolate based on speech/music probability */
1210        threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14);
1211        /* Bias towards SILK for VoIP because of some useful features */
1212        if (st->application == OPUS_APPLICATION_VOIP)
1213           threshold += 8000;
1214
1215        /*printf("%f %d\n", stereo_width/(float)Q15ONE, threshold);*/
1216        /* Hysteresis */
1217        if (st->prev_mode == MODE_CELT_ONLY)
1218            threshold -= 4000;
1219        else if (st->prev_mode>0)
1220            threshold += 4000;
1221
1222        st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY;
1223
1224        /* When FEC is enabled and there's enough packet loss, use SILK */
1225        if (st->silk_mode.useInBandFEC && st->silk_mode.packetLossPercentage > (128-voice_est)>>4)
1226           st->mode = MODE_SILK_ONLY;
1227        /* When encoding voice and DTX is enabled, set the encoder to SILK mode (at least for now) */
1228        if (st->silk_mode.useDTX && voice_est > 100)
1229           st->mode = MODE_SILK_ONLY;
1230 #endif
1231     } else {
1232        st->mode = st->user_forced_mode;
1233     }
1234
1235     /* Override the chosen mode to make sure we meet the requested frame size */
1236     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
1237        st->mode = MODE_CELT_ONLY;
1238     if (st->lfe)
1239        st->mode = MODE_CELT_ONLY;
1240     /* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */
1241     if (max_data_bytes < (frame_rate > 50 ? 12000 : 8000)*frame_size / (st->Fs * 8))
1242        st->mode = MODE_CELT_ONLY;
1243
1244     if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0
1245           && st->mode != MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)
1246     {
1247        /* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */
1248        st->silk_mode.toMono = 1;
1249        st->stream_channels = 2;
1250     } else {
1251        st->silk_mode.toMono = 0;
1252     }
1253
1254     if (st->prev_mode > 0 &&
1255         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
1256     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
1257     {
1258         redundancy = 1;
1259         celt_to_silk = (st->mode != MODE_CELT_ONLY);
1260         if (!celt_to_silk)
1261         {
1262             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
1263             if (frame_size >= st->Fs/100)
1264             {
1265                 st->mode = st->prev_mode;
1266                 to_celt = 1;
1267             } else {
1268                 redundancy=0;
1269             }
1270         }
1271     }
1272     /* For the first frame at a new SILK bandwidth */
1273     if (st->silk_bw_switch)
1274     {
1275        redundancy = 1;
1276        celt_to_silk = 1;
1277        st->silk_bw_switch = 0;
1278        prefill=1;
1279     }
1280
1281     if (redundancy)
1282     {
1283        /* Fair share of the max size allowed */
1284        redundancy_bytes = IMIN(257, max_data_bytes*(opus_int32)(st->Fs/200)/(frame_size+st->Fs/200));
1285        /* For VBR, target the actual bitrate (subject to the limit above) */
1286        if (st->use_vbr)
1287           redundancy_bytes = IMIN(redundancy_bytes, st->bitrate_bps/1600);
1288     }
1289
1290     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
1291     {
1292         silk_EncControlStruct dummy;
1293         silk_InitEncoder( silk_enc, st->arch, &dummy);
1294         prefill=1;
1295     }
1296
1297     /* Automatic (rate-dependent) bandwidth selection */
1298     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
1299     {
1300         const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds;
1301         opus_int32 bandwidth_thresholds[8];
1302         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
1303         opus_int32 equiv_rate2;
1304
1305         equiv_rate2 = equiv_rate;
1306         if (st->mode != MODE_CELT_ONLY)
1307         {
1308            /* Adjust the threshold +/- 10% depending on complexity */
1309            equiv_rate2 = equiv_rate2 * (45+st->silk_mode.complexity)/50;
1310            /* CBR is less efficient by ~1 kb/s */
1311            if (!st->use_vbr)
1312               equiv_rate2 -= 1000;
1313         }
1314         if (st->channels==2 && st->force_channels!=1)
1315         {
1316            voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds;
1317            music_bandwidth_thresholds = stereo_music_bandwidth_thresholds;
1318         } else {
1319            voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds;
1320            music_bandwidth_thresholds = mono_music_bandwidth_thresholds;
1321         }
1322         /* Interpolate bandwidth thresholds depending on voice estimation */
1323         for (i=0;i<8;i++)
1324         {
1325            bandwidth_thresholds[i] = music_bandwidth_thresholds[i]
1326                     + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14);
1327         }
1328         do {
1329             int threshold, hysteresis;
1330             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
1331             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
1332             if (!st->first)
1333             {
1334                 if (st->bandwidth >= bandwidth)
1335                     threshold -= hysteresis;
1336                 else
1337                     threshold += hysteresis;
1338             }
1339             if (equiv_rate2 >= threshold)
1340                 break;
1341         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
1342         st->bandwidth = bandwidth;
1343         /* Prevents any transition to SWB/FB until the SILK layer has fully
1344            switched to WB mode and turned the variable LP filter off */
1345         if (!st->first && st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1346             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1347     }
1348
1349     if (st->bandwidth>st->max_bandwidth)
1350        st->bandwidth = st->max_bandwidth;
1351
1352     if (st->user_bandwidth != OPUS_AUTO)
1353         st->bandwidth = st->user_bandwidth;
1354
1355     /* This prevents us from using hybrid at unsafe CBR/max rates */
1356     if (st->mode != MODE_CELT_ONLY && max_rate < 15000)
1357     {
1358        st->bandwidth = IMIN(st->bandwidth, OPUS_BANDWIDTH_WIDEBAND);
1359     }
1360
1361     /* Prevents Opus from wasting bits on frequencies that are above
1362        the Nyquist rate of the input signal */
1363     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
1364         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1365     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1366         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1367     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
1368         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1369     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
1370         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1371 #ifndef DISABLE_FLOAT_API
1372     /* Use detected bandwidth to reduce the encoded bandwidth. */
1373     if (st->detected_bandwidth && st->user_bandwidth == OPUS_AUTO)
1374     {
1375        int min_detected_bandwidth;
1376        /* Makes bandwidth detection more conservative just in case the detector
1377           gets it wrong when we could have coded a high bandwidth transparently.
1378           When operating in SILK/hybrid mode, we don't go below wideband to avoid
1379           more complicated switches that require redundancy. */
1380        if (equiv_rate <= 18000*st->stream_channels && st->mode == MODE_CELT_ONLY)
1381           min_detected_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1382        else if (equiv_rate <= 24000*st->stream_channels && st->mode == MODE_CELT_ONLY)
1383           min_detected_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1384        else if (equiv_rate <= 30000*st->stream_channels)
1385           min_detected_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1386        else if (equiv_rate <= 44000*st->stream_channels)
1387           min_detected_bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1388        else
1389           min_detected_bandwidth = OPUS_BANDWIDTH_FULLBAND;
1390
1391        st->detected_bandwidth = IMAX(st->detected_bandwidth, min_detected_bandwidth);
1392        st->bandwidth = IMIN(st->bandwidth, st->detected_bandwidth);
1393     }
1394 #endif
1395     celt_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(lsb_depth));
1396
1397     /* CELT mode doesn't support mediumband, use wideband instead */
1398     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1399         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1400     if (st->lfe)
1401        st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1402
1403     /* Can't support higher than wideband for >20 ms frames */
1404     if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND))
1405     {
1406        VARDECL(unsigned char, tmp_data);
1407        int nb_frames;
1408        int bak_mode, bak_bandwidth, bak_channels, bak_to_mono;
1409        VARDECL(OpusRepacketizer, rp);
1410        opus_int32 bytes_per_frame;
1411        opus_int32 repacketize_len;
1412
1413 #ifndef DISABLE_FLOAT_API
1414        if (analysis_read_pos_bak!= -1)
1415        {
1416           st->analysis.read_pos = analysis_read_pos_bak;
1417           st->analysis.read_subframe = analysis_read_subframe_bak;
1418        }
1419 #endif
1420
1421        nb_frames = frame_size > st->Fs/25 ? 3 : 2;
1422        bytes_per_frame = IMIN(1276,(out_data_bytes-3)/nb_frames);
1423
1424        ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char);
1425
1426        ALLOC(rp, 1, OpusRepacketizer);
1427        opus_repacketizer_init(rp);
1428
1429        bak_mode = st->user_forced_mode;
1430        bak_bandwidth = st->user_bandwidth;
1431        bak_channels = st->force_channels;
1432
1433        st->user_forced_mode = st->mode;
1434        st->user_bandwidth = st->bandwidth;
1435        st->force_channels = st->stream_channels;
1436        bak_to_mono = st->silk_mode.toMono;
1437
1438        if (bak_to_mono)
1439           st->force_channels = 1;
1440        else
1441           st->prev_channels = st->stream_channels;
1442        for (i=0;i<nb_frames;i++)
1443        {
1444           int tmp_len;
1445           st->silk_mode.toMono = 0;
1446           /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
1447           if (to_celt && i==nb_frames-1)
1448              st->user_forced_mode = MODE_CELT_ONLY;
1449           tmp_len = opus_encode_native(st, pcm+i*(st->channels*st->Fs/50), st->Fs/50,
1450                 tmp_data+i*bytes_per_frame, bytes_per_frame, lsb_depth,
1451                 NULL, 0, c1, c2, analysis_channels, downmix, float_api);
1452           if (tmp_len<0)
1453           {
1454              RESTORE_STACK;
1455              return OPUS_INTERNAL_ERROR;
1456           }
1457           ret = opus_repacketizer_cat(rp, tmp_data+i*bytes_per_frame, tmp_len);
1458           if (ret<0)
1459           {
1460              RESTORE_STACK;
1461              return OPUS_INTERNAL_ERROR;
1462           }
1463        }
1464        if (st->use_vbr)
1465           repacketize_len = out_data_bytes;
1466        else
1467           repacketize_len = IMIN(3*st->bitrate_bps/(3*8*50/nb_frames), out_data_bytes);
1468        ret = opus_repacketizer_out_range_impl(rp, 0, nb_frames, data, repacketize_len, 0, !st->use_vbr);
1469        if (ret<0)
1470        {
1471           RESTORE_STACK;
1472           return OPUS_INTERNAL_ERROR;
1473        }
1474        st->user_forced_mode = bak_mode;
1475        st->user_bandwidth = bak_bandwidth;
1476        st->force_channels = bak_channels;
1477        st->silk_mode.toMono = bak_to_mono;
1478        RESTORE_STACK;
1479        return ret;
1480     }
1481     curr_bandwidth = st->bandwidth;
1482
1483     /* Chooses the appropriate mode for speech
1484        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
1485     if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1486         st->mode = MODE_HYBRID;
1487     if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
1488         st->mode = MODE_SILK_ONLY;
1489
1490     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
1491     bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
1492
1493     data += 1;
1494
1495     ec_enc_init(&enc, data, max_data_bytes-1);
1496
1497     ALLOC(pcm_buf, (total_buffer+frame_size)*st->channels, opus_val16);
1498     OPUS_COPY(pcm_buf, &st->delay_buffer[(st->encoder_buffer-total_buffer)*st->channels], total_buffer*st->channels);
1499
1500     if (st->mode == MODE_CELT_ONLY)
1501        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1502     else
1503        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
1504
1505     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
1506           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
1507
1508     /* convert from log scale to Hertz */
1509     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
1510
1511     if (st->application == OPUS_APPLICATION_VOIP)
1512     {
1513        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1514     } else {
1515        dc_reject(pcm, 3, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1516     }
1517 #ifndef FIXED_POINT
1518     if (float_api)
1519     {
1520        opus_val32 sum;
1521        sum = celt_inner_prod(&pcm_buf[total_buffer*st->channels], &pcm_buf[total_buffer*st->channels], frame_size*st->channels, st->arch);
1522        /* This should filter out both NaNs and ridiculous signals that could
1523           cause NaNs further down. */
1524        if (!(sum < 1e9f) || celt_isnan(sum))
1525        {
1526           OPUS_CLEAR(&pcm_buf[total_buffer*st->channels], frame_size*st->channels);
1527           st->hp_mem[0] = st->hp_mem[1] = st->hp_mem[2] = st->hp_mem[3] = 0;
1528        }
1529     }
1530 #endif
1531
1532
1533     /* SILK processing */
1534     HB_gain = Q15ONE;
1535     if (st->mode != MODE_CELT_ONLY)
1536     {
1537         opus_int32 total_bitRate, celt_rate;
1538 #ifdef FIXED_POINT
1539        const opus_int16 *pcm_silk;
1540 #else
1541        VARDECL(opus_int16, pcm_silk);
1542        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
1543 #endif
1544
1545         /* Distribute bits between SILK and CELT */
1546         total_bitRate = 8 * bytes_target * frame_rate;
1547         if( st->mode == MODE_HYBRID ) {
1548             int HB_gain_ref;
1549             /* Base rate for SILK */
1550             st->silk_mode.bitRate = compute_silk_rate_for_hybrid(total_bitRate,
1551                   curr_bandwidth, st->Fs == 50 * frame_size, st->use_vbr);
1552             if (!st->energy_masking)
1553             {
1554                /* Increasingly attenuate high band when it gets allocated fewer bits */
1555                celt_rate = total_bitRate - st->silk_mode.bitRate;
1556                HB_gain_ref = (curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND) ? 3000 : 3600;
1557                HB_gain = SHL32((opus_val32)celt_rate, 9) / SHR32((opus_val32)celt_rate + st->stream_channels * HB_gain_ref, 6);
1558                HB_gain = HB_gain < (opus_val32)Q15ONE*6/7 ? HB_gain + Q15ONE/7 : Q15ONE;
1559             }
1560         } else {
1561             /* SILK gets all bits */
1562             st->silk_mode.bitRate = total_bitRate;
1563         }
1564
1565         /* Surround masking for SILK */
1566         if (st->energy_masking && st->use_vbr && !st->lfe)
1567         {
1568            opus_val32 mask_sum=0;
1569            opus_val16 masking_depth;
1570            opus_int32 rate_offset;
1571            int c;
1572            int end = 17;
1573            opus_int16 srate = 16000;
1574            if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND)
1575            {
1576               end = 13;
1577               srate = 8000;
1578            } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1579            {
1580               end = 15;
1581               srate = 12000;
1582            }
1583            for (c=0;c<st->channels;c++)
1584            {
1585               for(i=0;i<end;i++)
1586               {
1587                  opus_val16 mask;
1588                  mask = MAX16(MIN16(st->energy_masking[21*c+i],
1589                         QCONST16(.5f, DB_SHIFT)), -QCONST16(2.0f, DB_SHIFT));
1590                  if (mask > 0)
1591                     mask = HALF16(mask);
1592                  mask_sum += mask;
1593               }
1594            }
1595            /* Conservative rate reduction, we cut the masking in half */
1596            masking_depth = mask_sum / end*st->channels;
1597            masking_depth += QCONST16(.2f, DB_SHIFT);
1598            rate_offset = (opus_int32)PSHR32(MULT16_16(srate, masking_depth), DB_SHIFT);
1599            rate_offset = MAX32(rate_offset, -2*st->silk_mode.bitRate/3);
1600            /* Split the rate change between the SILK and CELT part for hybrid. */
1601            if (st->bandwidth==OPUS_BANDWIDTH_SUPERWIDEBAND || st->bandwidth==OPUS_BANDWIDTH_FULLBAND)
1602               st->silk_mode.bitRate += 3*rate_offset/5;
1603            else
1604               st->silk_mode.bitRate += rate_offset;
1605            bytes_target += rate_offset * frame_size / (8 * st->Fs);
1606         }
1607
1608         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
1609         st->silk_mode.nChannelsAPI = st->channels;
1610         st->silk_mode.nChannelsInternal = st->stream_channels;
1611         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1612             st->silk_mode.desiredInternalSampleRate = 8000;
1613         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1614             st->silk_mode.desiredInternalSampleRate = 12000;
1615         } else {
1616             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
1617             st->silk_mode.desiredInternalSampleRate = 16000;
1618         }
1619         if( st->mode == MODE_HYBRID ) {
1620             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
1621             st->silk_mode.minInternalSampleRate = 16000;
1622         } else {
1623             st->silk_mode.minInternalSampleRate = 8000;
1624         }
1625
1626         if (st->mode == MODE_SILK_ONLY)
1627         {
1628            opus_int32 effective_max_rate = max_rate;
1629            st->silk_mode.maxInternalSampleRate = 16000;
1630            if (frame_rate > 50)
1631               effective_max_rate = effective_max_rate*2/3;
1632            if (effective_max_rate < 13000)
1633            {
1634               st->silk_mode.maxInternalSampleRate = 12000;
1635               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
1636            }
1637            if (effective_max_rate < 9600)
1638            {
1639               st->silk_mode.maxInternalSampleRate = 8000;
1640               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
1641            }
1642         } else {
1643            st->silk_mode.maxInternalSampleRate = 16000;
1644         }
1645
1646         st->silk_mode.useCBR = !st->use_vbr;
1647
1648         /* Call SILK encoder for the low band */
1649         nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes);
1650
1651         st->silk_mode.maxBits = nBytes*8;
1652         /* Only allow up to 90% of the bits for hybrid mode*/
1653         if (st->mode == MODE_HYBRID)
1654            st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
1655         if (st->silk_mode.useCBR)
1656         {
1657            st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
1658            /* Reduce the initial target to make it easier to reach the CBR rate */
1659            st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000);
1660         }
1661
1662         if (prefill)
1663         {
1664             opus_int32 zero=0;
1665             int prefill_offset;
1666             /* Use a smooth onset for the SILK prefill to avoid the encoder trying to encode
1667                a discontinuity. The exact location is what we need to avoid leaving any "gap"
1668                in the audio when mixing with the redundant CELT frame. Here we can afford to
1669                overwrite st->delay_buffer because the only thing that uses it before it gets
1670                rewritten is tmp_prefill[] and even then only the part after the ramp really
1671                gets used (rather than sent to the encoder and discarded) */
1672             prefill_offset = st->channels*(st->encoder_buffer-st->delay_compensation-st->Fs/400);
1673             gain_fade(st->delay_buffer+prefill_offset, st->delay_buffer+prefill_offset,
1674                   0, Q15ONE, celt_mode->overlap, st->Fs/400, st->channels, celt_mode->window, st->Fs);
1675             OPUS_CLEAR(st->delay_buffer, prefill_offset);
1676 #ifdef FIXED_POINT
1677             pcm_silk = st->delay_buffer;
1678 #else
1679             for (i=0;i<st->encoder_buffer*st->channels;i++)
1680                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
1681 #endif
1682             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
1683         }
1684
1685 #ifdef FIXED_POINT
1686         pcm_silk = pcm_buf+total_buffer*st->channels;
1687 #else
1688         for (i=0;i<frame_size*st->channels;i++)
1689             pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
1690 #endif
1691         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
1692         if( ret ) {
1693             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
1694             /* Handle error */
1695            RESTORE_STACK;
1696            return OPUS_INTERNAL_ERROR;
1697         }
1698         if (nBytes==0)
1699         {
1700            st->rangeFinal = 0;
1701            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1702            RESTORE_STACK;
1703            return 1;
1704         }
1705         /* Extract SILK internal bandwidth for signaling in first byte */
1706         if( st->mode == MODE_SILK_ONLY ) {
1707             if( st->silk_mode.internalSampleRate == 8000 ) {
1708                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1709             } else if( st->silk_mode.internalSampleRate == 12000 ) {
1710                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1711             } else if( st->silk_mode.internalSampleRate == 16000 ) {
1712                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1713             }
1714         } else {
1715             silk_assert( st->silk_mode.internalSampleRate == 16000 );
1716         }
1717
1718         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
1719         /* FIXME: How do we allocate the redundancy for CBR? */
1720         if (st->silk_mode.opusCanSwitch)
1721         {
1722            redundancy = 1;
1723            celt_to_silk = 0;
1724            st->silk_bw_switch = 1;
1725         }
1726     }
1727
1728     /* CELT processing */
1729     {
1730         int endband=21;
1731
1732         switch(curr_bandwidth)
1733         {
1734             case OPUS_BANDWIDTH_NARROWBAND:
1735                 endband = 13;
1736                 break;
1737             case OPUS_BANDWIDTH_MEDIUMBAND:
1738             case OPUS_BANDWIDTH_WIDEBAND:
1739                 endband = 17;
1740                 break;
1741             case OPUS_BANDWIDTH_SUPERWIDEBAND:
1742                 endband = 19;
1743                 break;
1744             case OPUS_BANDWIDTH_FULLBAND:
1745                 endband = 21;
1746                 break;
1747         }
1748         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
1749         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
1750     }
1751     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1752     if (st->mode != MODE_SILK_ONLY)
1753     {
1754         opus_val32 celt_pred=2;
1755         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1756         /* We may still decide to disable prediction later */
1757         if (st->silk_mode.reducedDependency)
1758            celt_pred = 0;
1759         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(celt_pred));
1760
1761         if (st->mode == MODE_HYBRID)
1762         {
1763             int len;
1764
1765             len = (ec_tell(&enc)+7)>>3;
1766             if (redundancy)
1767                len += st->mode == MODE_HYBRID ? 3 : 1;
1768             if( st->use_vbr ) {
1769                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps-st->silk_mode.bitRate));
1770                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
1771                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(0));
1772             } else {
1773                 /* check if SILK used up too much */
1774                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
1775             }
1776         } else {
1777             if (st->use_vbr)
1778             {
1779                 opus_int32 bonus=0;
1780 #ifndef DISABLE_FLOAT_API
1781                 if (st->variable_duration==OPUS_FRAMESIZE_VARIABLE && frame_size != st->Fs/50)
1782                 {
1783                    bonus = (60*st->stream_channels+40)*(st->Fs/frame_size-50);
1784                    if (analysis_info.valid)
1785                       bonus = (opus_int32)(bonus*(1.f+.5f*analysis_info.tonality));
1786                 }
1787 #endif
1788                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
1789                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
1790                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps+bonus));
1791                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
1792             } else {
1793                 nb_compr_bytes = bytes_target;
1794             }
1795         }
1796
1797     } else {
1798         nb_compr_bytes = 0;
1799     }
1800
1801     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
1802     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
1803     {
1804        OPUS_COPY(tmp_prefill, &st->delay_buffer[(st->encoder_buffer-total_buffer-st->Fs/400)*st->channels], st->channels*st->Fs/400);
1805     }
1806
1807     if (st->channels*(st->encoder_buffer-(frame_size+total_buffer)) > 0)
1808     {
1809        OPUS_MOVE(st->delay_buffer, &st->delay_buffer[st->channels*frame_size], st->channels*(st->encoder_buffer-frame_size-total_buffer));
1810        OPUS_COPY(&st->delay_buffer[st->channels*(st->encoder_buffer-frame_size-total_buffer)],
1811              &pcm_buf[0],
1812              (frame_size+total_buffer)*st->channels);
1813     } else {
1814        OPUS_COPY(st->delay_buffer, &pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels], st->encoder_buffer*st->channels);
1815     }
1816     /* gain_fade() and stereo_fade() need to be after the buffer copying
1817        because we don't want any of this to affect the SILK part */
1818     if( st->prev_HB_gain < Q15ONE || HB_gain < Q15ONE ) {
1819        gain_fade(pcm_buf, pcm_buf,
1820              st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs);
1821     }
1822     st->prev_HB_gain = HB_gain;
1823     if (st->mode != MODE_HYBRID || st->stream_channels==1)
1824        st->silk_mode.stereoWidth_Q14 = IMIN((1<<14),2*IMAX(0,equiv_rate-24000));
1825     if( !st->energy_masking && st->channels == 2 ) {
1826         /* Apply stereo width reduction (at low bitrates) */
1827         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1828             opus_val16 g1, g2;
1829             g1 = st->hybrid_stereo_width_Q14;
1830             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1831 #ifdef FIXED_POINT
1832             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
1833             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
1834 #else
1835             g1 *= (1.f/16384);
1836             g2 *= (1.f/16384);
1837 #endif
1838             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
1839                   frame_size, st->channels, celt_mode->window, st->Fs);
1840             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1841         }
1842     }
1843
1844     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
1845     {
1846         /* For SILK mode, the redundancy is inferred from the length */
1847         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
1848            ec_enc_bit_logp(&enc, redundancy, 12);
1849         if (redundancy)
1850         {
1851             int max_redundancy;
1852             ec_enc_bit_logp(&enc, celt_to_silk, 1);
1853             if (st->mode == MODE_HYBRID)
1854                max_redundancy = (max_data_bytes-1)-nb_compr_bytes;
1855             else
1856                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1857             /* Target the same bit-rate for redundancy as for the rest,
1858                up to a max of 257 bytes */
1859             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
1860             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
1861             if (st->mode == MODE_HYBRID)
1862                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
1863         }
1864     } else {
1865         redundancy = 0;
1866     }
1867
1868     if (!redundancy)
1869     {
1870        st->silk_bw_switch = 0;
1871        redundancy_bytes = 0;
1872     }
1873     if (st->mode != MODE_CELT_ONLY)start_band=17;
1874
1875     if (st->mode == MODE_SILK_ONLY)
1876     {
1877         ret = (ec_tell(&enc)+7)>>3;
1878         ec_enc_done(&enc);
1879         nb_compr_bytes = ret;
1880     } else {
1881        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
1882        ec_enc_shrink(&enc, nb_compr_bytes);
1883     }
1884
1885 #ifndef DISABLE_FLOAT_API
1886     if (redundancy || st->mode != MODE_SILK_ONLY)
1887        celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(&analysis_info));
1888 #endif
1889
1890     /* 5 ms redundant frame for CELT->SILK */
1891     if (redundancy && celt_to_silk)
1892     {
1893         int err;
1894         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1895         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1896         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1897         err = celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
1898         if (err < 0)
1899         {
1900            RESTORE_STACK;
1901            return OPUS_INTERNAL_ERROR;
1902         }
1903         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1904         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1905     }
1906
1907     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
1908
1909     if (st->mode != MODE_SILK_ONLY)
1910     {
1911         if (st->mode != st->prev_mode && st->prev_mode > 0)
1912         {
1913            unsigned char dummy[2];
1914            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1915
1916            /* Prefilling */
1917            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
1918            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1919         }
1920         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
1921         if (ec_tell(&enc) <= 8*nb_compr_bytes)
1922         {
1923            /* Set the bitrate again if it was overridden in the redundancy code above*/
1924            if (redundancy && celt_to_silk && st->mode==MODE_HYBRID && st->use_vbr)
1925               celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps-st->silk_mode.bitRate));
1926            celt_encoder_ctl(celt_enc, OPUS_SET_VBR(st->use_vbr));
1927            ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
1928            if (ret < 0)
1929            {
1930               RESTORE_STACK;
1931               return OPUS_INTERNAL_ERROR;
1932            }
1933            /* Put CELT->SILK redundancy data in the right place. */
1934            if (redundancy && celt_to_silk && st->mode==MODE_HYBRID && st->use_vbr)
1935            {
1936               OPUS_COPY(data+ret, data+nb_compr_bytes, redundancy_bytes);
1937               nb_compr_bytes = nb_compr_bytes+redundancy_bytes;
1938            }
1939         }
1940     }
1941
1942     /* 5 ms redundant frame for SILK->CELT */
1943     if (redundancy && !celt_to_silk)
1944     {
1945         int err;
1946         unsigned char dummy[2];
1947         int N2, N4;
1948         N2 = st->Fs/200;
1949         N4 = st->Fs/400;
1950
1951         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1952         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1953         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1954         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1955         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1956
1957         if (st->mode == MODE_HYBRID)
1958         {
1959            /* Shrink packet to what the encoder actually used. */
1960            nb_compr_bytes = ret;
1961            ec_enc_shrink(&enc, nb_compr_bytes);
1962         }
1963         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1964         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL);
1965
1966         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1967         if (err < 0)
1968         {
1969            RESTORE_STACK;
1970            return OPUS_INTERNAL_ERROR;
1971         }
1972         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1973     }
1974
1975
1976
1977     /* Signalling the mode in the first byte */
1978     data--;
1979     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1980
1981     st->rangeFinal = enc.rng ^ redundant_rng;
1982
1983     if (to_celt)
1984         st->prev_mode = MODE_CELT_ONLY;
1985     else
1986         st->prev_mode = st->mode;
1987     st->prev_channels = st->stream_channels;
1988     st->prev_framesize = frame_size;
1989
1990     st->first = 0;
1991
1992     /* In the unlikely case that the SILK encoder busted its target, tell
1993        the decoder to call the PLC */
1994     if (ec_tell(&enc) > (max_data_bytes-1)*8)
1995     {
1996        if (max_data_bytes < 2)
1997        {
1998           RESTORE_STACK;
1999           return OPUS_BUFFER_TOO_SMALL;
2000        }
2001        data[1] = 0;
2002        ret = 1;
2003        st->rangeFinal = 0;
2004     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
2005     {
2006        /*When in LPC only mode it's perfectly
2007          reasonable to strip off trailing zero bytes as
2008          the required range decoder behavior is to
2009          fill these in. This can't be done when the MDCT
2010          modes are used because the decoder needs to know
2011          the actual length for allocation purposes.*/
2012        while(ret>2&&data[ret]==0)ret--;
2013     }
2014     /* Count ToC and redundancy */
2015     ret += 1+redundancy_bytes;
2016     if (!st->use_vbr)
2017     {
2018        if (opus_packet_pad(data, ret, max_data_bytes) != OPUS_OK)
2019
2020        {
2021           RESTORE_STACK;
2022           return OPUS_INTERNAL_ERROR;
2023        }
2024        ret = max_data_bytes;
2025     }
2026     RESTORE_STACK;
2027     return ret;
2028 }
2029
2030 #ifdef FIXED_POINT
2031
2032 #ifndef DISABLE_FLOAT_API
2033 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int analysis_frame_size,
2034       unsigned char *data, opus_int32 max_data_bytes)
2035 {
2036    int i, ret;
2037    int frame_size;
2038    int delay_compensation;
2039    VARDECL(opus_int16, in);
2040    ALLOC_STACK;
2041
2042    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2043       delay_compensation = 0;
2044    else
2045       delay_compensation = st->delay_compensation;
2046    frame_size = compute_frame_size(pcm, analysis_frame_size,
2047          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2048          delay_compensation, downmix_float, st->analysis.subframe_mem);
2049
2050    ALLOC(in, frame_size*st->channels, opus_int16);
2051
2052    for (i=0;i<frame_size*st->channels;i++)
2053       in[i] = FLOAT2INT16(pcm[i]);
2054    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16,
2055                             pcm, analysis_frame_size, 0, -2, st->channels, downmix_float, 1);
2056    RESTORE_STACK;
2057    return ret;
2058 }
2059 #endif
2060
2061 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int analysis_frame_size,
2062                 unsigned char *data, opus_int32 out_data_bytes)
2063 {
2064    int frame_size;
2065    int delay_compensation;
2066    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2067       delay_compensation = 0;
2068    else
2069       delay_compensation = st->delay_compensation;
2070    frame_size = compute_frame_size(pcm, analysis_frame_size,
2071          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2072          delay_compensation, downmix_int
2073 #ifndef DISABLE_FLOAT_API
2074          , st->analysis.subframe_mem
2075 #endif
2076          );
2077    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 16,
2078                              pcm, analysis_frame_size, 0, -2, st->channels, downmix_int, 0);
2079 }
2080
2081 #else
2082 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int analysis_frame_size,
2083       unsigned char *data, opus_int32 max_data_bytes)
2084 {
2085    int i, ret;
2086    int frame_size;
2087    int delay_compensation;
2088    VARDECL(float, in);
2089    ALLOC_STACK;
2090
2091    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2092       delay_compensation = 0;
2093    else
2094       delay_compensation = st->delay_compensation;
2095    frame_size = compute_frame_size(pcm, analysis_frame_size,
2096          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2097          delay_compensation, downmix_int, st->analysis.subframe_mem);
2098
2099    ALLOC(in, frame_size*st->channels, float);
2100
2101    for (i=0;i<frame_size*st->channels;i++)
2102       in[i] = (1.0f/32768)*pcm[i];
2103    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16,
2104                             pcm, analysis_frame_size, 0, -2, st->channels, downmix_int, 0);
2105    RESTORE_STACK;
2106    return ret;
2107 }
2108 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int analysis_frame_size,
2109                       unsigned char *data, opus_int32 out_data_bytes)
2110 {
2111    int frame_size;
2112    int delay_compensation;
2113    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2114       delay_compensation = 0;
2115    else
2116       delay_compensation = st->delay_compensation;
2117    frame_size = compute_frame_size(pcm, analysis_frame_size,
2118          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2119          delay_compensation, downmix_float, st->analysis.subframe_mem);
2120    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 24,
2121                              pcm, analysis_frame_size, 0, -2, st->channels, downmix_float, 1);
2122 }
2123 #endif
2124
2125
2126 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
2127 {
2128     int ret;
2129     CELTEncoder *celt_enc;
2130     va_list ap;
2131
2132     ret = OPUS_OK;
2133     va_start(ap, request);
2134
2135     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
2136
2137     switch (request)
2138     {
2139         case OPUS_SET_APPLICATION_REQUEST:
2140         {
2141             opus_int32 value = va_arg(ap, opus_int32);
2142             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
2143                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2144                || (!st->first && st->application != value))
2145             {
2146                ret = OPUS_BAD_ARG;
2147                break;
2148             }
2149             st->application = value;
2150         }
2151         break;
2152         case OPUS_GET_APPLICATION_REQUEST:
2153         {
2154             opus_int32 *value = va_arg(ap, opus_int32*);
2155             if (!value)
2156             {
2157                goto bad_arg;
2158             }
2159             *value = st->application;
2160         }
2161         break;
2162         case OPUS_SET_BITRATE_REQUEST:
2163         {
2164             opus_int32 value = va_arg(ap, opus_int32);
2165             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
2166             {
2167                 if (value <= 0)
2168                     goto bad_arg;
2169                 else if (value <= 500)
2170                     value = 500;
2171                 else if (value > (opus_int32)300000*st->channels)
2172                     value = (opus_int32)300000*st->channels;
2173             }
2174             st->user_bitrate_bps = value;
2175         }
2176         break;
2177         case OPUS_GET_BITRATE_REQUEST:
2178         {
2179             opus_int32 *value = va_arg(ap, opus_int32*);
2180             if (!value)
2181             {
2182                goto bad_arg;
2183             }
2184             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
2185         }
2186         break;
2187         case OPUS_SET_FORCE_CHANNELS_REQUEST:
2188         {
2189             opus_int32 value = va_arg(ap, opus_int32);
2190             if((value<1 || value>st->channels) && value != OPUS_AUTO)
2191             {
2192                goto bad_arg;
2193             }
2194             st->force_channels = value;
2195         }
2196         break;
2197         case OPUS_GET_FORCE_CHANNELS_REQUEST:
2198         {
2199             opus_int32 *value = va_arg(ap, opus_int32*);
2200             if (!value)
2201             {
2202                goto bad_arg;
2203             }
2204             *value = st->force_channels;
2205         }
2206         break;
2207         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
2208         {
2209             opus_int32 value = va_arg(ap, opus_int32);
2210             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND)
2211             {
2212                goto bad_arg;
2213             }
2214             st->max_bandwidth = value;
2215             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2216                 st->silk_mode.maxInternalSampleRate = 8000;
2217             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2218                 st->silk_mode.maxInternalSampleRate = 12000;
2219             } else {
2220                 st->silk_mode.maxInternalSampleRate = 16000;
2221             }
2222         }
2223         break;
2224         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
2225         {
2226             opus_int32 *value = va_arg(ap, opus_int32*);
2227             if (!value)
2228             {
2229                goto bad_arg;
2230             }
2231             *value = st->max_bandwidth;
2232         }
2233         break;
2234         case OPUS_SET_BANDWIDTH_REQUEST:
2235         {
2236             opus_int32 value = va_arg(ap, opus_int32);
2237             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
2238             {
2239                goto bad_arg;
2240             }
2241             st->user_bandwidth = value;
2242             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2243                 st->silk_mode.maxInternalSampleRate = 8000;
2244             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2245                 st->silk_mode.maxInternalSampleRate = 12000;
2246             } else {
2247                 st->silk_mode.maxInternalSampleRate = 16000;
2248             }
2249         }
2250         break;
2251         case OPUS_GET_BANDWIDTH_REQUEST:
2252         {
2253             opus_int32 *value = va_arg(ap, opus_int32*);
2254             if (!value)
2255             {
2256                goto bad_arg;
2257             }
2258             *value = st->bandwidth;
2259         }
2260         break;
2261         case OPUS_SET_DTX_REQUEST:
2262         {
2263             opus_int32 value = va_arg(ap, opus_int32);
2264             if(value<0 || value>1)
2265             {
2266                goto bad_arg;
2267             }
2268             st->silk_mode.useDTX = value;
2269         }
2270         break;
2271         case OPUS_GET_DTX_REQUEST:
2272         {
2273             opus_int32 *value = va_arg(ap, opus_int32*);
2274             if (!value)
2275             {
2276                goto bad_arg;
2277             }
2278             *value = st->silk_mode.useDTX;
2279         }
2280         break;
2281         case OPUS_SET_COMPLEXITY_REQUEST:
2282         {
2283             opus_int32 value = va_arg(ap, opus_int32);
2284             if(value<0 || value>10)
2285             {
2286                goto bad_arg;
2287             }
2288             st->silk_mode.complexity = value;
2289             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
2290         }
2291         break;
2292         case OPUS_GET_COMPLEXITY_REQUEST:
2293         {
2294             opus_int32 *value = va_arg(ap, opus_int32*);
2295             if (!value)
2296             {
2297                goto bad_arg;
2298             }
2299             *value = st->silk_mode.complexity;
2300         }
2301         break;
2302         case OPUS_SET_INBAND_FEC_REQUEST:
2303         {
2304             opus_int32 value = va_arg(ap, opus_int32);
2305             if(value<0 || value>1)
2306             {
2307                goto bad_arg;
2308             }
2309             st->silk_mode.useInBandFEC = value;
2310         }
2311         break;
2312         case OPUS_GET_INBAND_FEC_REQUEST:
2313         {
2314             opus_int32 *value = va_arg(ap, opus_int32*);
2315             if (!value)
2316             {
2317                goto bad_arg;
2318             }
2319             *value = st->silk_mode.useInBandFEC;
2320         }
2321         break;
2322         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
2323         {
2324             opus_int32 value = va_arg(ap, opus_int32);
2325             if (value < 0 || value > 100)
2326             {
2327                goto bad_arg;
2328             }
2329             st->silk_mode.packetLossPercentage = value;
2330             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
2331         }
2332         break;
2333         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
2334         {
2335             opus_int32 *value = va_arg(ap, opus_int32*);
2336             if (!value)
2337             {
2338                goto bad_arg;
2339             }
2340             *value = st->silk_mode.packetLossPercentage;
2341         }
2342         break;
2343         case OPUS_SET_VBR_REQUEST:
2344         {
2345             opus_int32 value = va_arg(ap, opus_int32);
2346             if(value<0 || value>1)
2347             {
2348                goto bad_arg;
2349             }
2350             st->use_vbr = value;
2351             st->silk_mode.useCBR = 1-value;
2352         }
2353         break;
2354         case OPUS_GET_VBR_REQUEST:
2355         {
2356             opus_int32 *value = va_arg(ap, opus_int32*);
2357             if (!value)
2358             {
2359                goto bad_arg;
2360             }
2361             *value = st->use_vbr;
2362         }
2363         break;
2364         case OPUS_SET_VOICE_RATIO_REQUEST:
2365         {
2366             opus_int32 value = va_arg(ap, opus_int32);
2367             if (value<-1 || value>100)
2368             {
2369                goto bad_arg;
2370             }
2371             st->voice_ratio = value;
2372         }
2373         break;
2374         case OPUS_GET_VOICE_RATIO_REQUEST:
2375         {
2376             opus_int32 *value = va_arg(ap, opus_int32*);
2377             if (!value)
2378             {
2379                goto bad_arg;
2380             }
2381             *value = st->voice_ratio;
2382         }
2383         break;
2384         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
2385         {
2386             opus_int32 value = va_arg(ap, opus_int32);
2387             if(value<0 || value>1)
2388             {
2389                goto bad_arg;
2390             }
2391             st->vbr_constraint = value;
2392         }
2393         break;
2394         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
2395         {
2396             opus_int32 *value = va_arg(ap, opus_int32*);
2397             if (!value)
2398             {
2399                goto bad_arg;
2400             }
2401             *value = st->vbr_constraint;
2402         }
2403         break;
2404         case OPUS_SET_SIGNAL_REQUEST:
2405         {
2406             opus_int32 value = va_arg(ap, opus_int32);
2407             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
2408             {
2409                goto bad_arg;
2410             }
2411             st->signal_type = value;
2412         }
2413         break;
2414         case OPUS_GET_SIGNAL_REQUEST:
2415         {
2416             opus_int32 *value = va_arg(ap, opus_int32*);
2417             if (!value)
2418             {
2419                goto bad_arg;
2420             }
2421             *value = st->signal_type;
2422         }
2423         break;
2424         case OPUS_GET_LOOKAHEAD_REQUEST:
2425         {
2426             opus_int32 *value = va_arg(ap, opus_int32*);
2427             if (!value)
2428             {
2429                goto bad_arg;
2430             }
2431             *value = st->Fs/400;
2432             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2433                 *value += st->delay_compensation;
2434         }
2435         break;
2436         case OPUS_GET_SAMPLE_RATE_REQUEST:
2437         {
2438             opus_int32 *value = va_arg(ap, opus_int32*);
2439             if (!value)
2440             {
2441                goto bad_arg;
2442             }
2443             *value = st->Fs;
2444         }
2445         break;
2446         case OPUS_GET_FINAL_RANGE_REQUEST:
2447         {
2448             opus_uint32 *value = va_arg(ap, opus_uint32*);
2449             if (!value)
2450             {
2451                goto bad_arg;
2452             }
2453             *value = st->rangeFinal;
2454         }
2455         break;
2456         case OPUS_SET_LSB_DEPTH_REQUEST:
2457         {
2458             opus_int32 value = va_arg(ap, opus_int32);
2459             if (value<8 || value>24)
2460             {
2461                goto bad_arg;
2462             }
2463             st->lsb_depth=value;
2464         }
2465         break;
2466         case OPUS_GET_LSB_DEPTH_REQUEST:
2467         {
2468             opus_int32 *value = va_arg(ap, opus_int32*);
2469             if (!value)
2470             {
2471                goto bad_arg;
2472             }
2473             *value = st->lsb_depth;
2474         }
2475         break;
2476         case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
2477         {
2478             opus_int32 value = va_arg(ap, opus_int32);
2479             if (value != OPUS_FRAMESIZE_ARG   && value != OPUS_FRAMESIZE_2_5_MS &&
2480                 value != OPUS_FRAMESIZE_5_MS  && value != OPUS_FRAMESIZE_10_MS  &&
2481                 value != OPUS_FRAMESIZE_20_MS && value != OPUS_FRAMESIZE_40_MS  &&
2482                 value != OPUS_FRAMESIZE_60_MS && value != OPUS_FRAMESIZE_VARIABLE)
2483             {
2484                goto bad_arg;
2485             }
2486             st->variable_duration = value;
2487             celt_encoder_ctl(celt_enc, OPUS_SET_EXPERT_FRAME_DURATION(value));
2488         }
2489         break;
2490         case OPUS_GET_EXPERT_FRAME_DURATION_REQUEST:
2491         {
2492             opus_int32 *value = va_arg(ap, opus_int32*);
2493             if (!value)
2494             {
2495                goto bad_arg;
2496             }
2497             *value = st->variable_duration;
2498         }
2499         break;
2500         case OPUS_SET_PREDICTION_DISABLED_REQUEST:
2501         {
2502            opus_int32 value = va_arg(ap, opus_int32);
2503            if (value > 1 || value < 0)
2504               goto bad_arg;
2505            st->silk_mode.reducedDependency = value;
2506         }
2507         break;
2508         case OPUS_GET_PREDICTION_DISABLED_REQUEST:
2509         {
2510            opus_int32 *value = va_arg(ap, opus_int32*);
2511            if (!value)
2512               goto bad_arg;
2513            *value = st->silk_mode.reducedDependency;
2514         }
2515         break;
2516         case OPUS_RESET_STATE:
2517         {
2518            void *silk_enc;
2519            silk_EncControlStruct dummy;
2520            char *start;
2521            silk_enc = (char*)st+st->silk_enc_offset;
2522 #ifndef DISABLE_FLOAT_API
2523            tonality_analysis_reset(&st->analysis);
2524 #endif
2525
2526            start = (char*)&st->OPUS_ENCODER_RESET_START;
2527            OPUS_CLEAR(start, sizeof(OpusEncoder) - (start - (char*)st));
2528
2529            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2530            silk_InitEncoder( silk_enc, st->arch, &dummy );
2531            st->stream_channels = st->channels;
2532            st->hybrid_stereo_width_Q14 = 1 << 14;
2533            st->prev_HB_gain = Q15ONE;
2534            st->first = 1;
2535            st->mode = MODE_HYBRID;
2536            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
2537            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
2538         }
2539         break;
2540         case OPUS_SET_FORCE_MODE_REQUEST:
2541         {
2542             opus_int32 value = va_arg(ap, opus_int32);
2543             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
2544             {
2545                goto bad_arg;
2546             }
2547             st->user_forced_mode = value;
2548         }
2549         break;
2550         case OPUS_SET_LFE_REQUEST:
2551         {
2552             opus_int32 value = va_arg(ap, opus_int32);
2553             st->lfe = value;
2554             ret = celt_encoder_ctl(celt_enc, OPUS_SET_LFE(value));
2555         }
2556         break;
2557         case OPUS_SET_ENERGY_MASK_REQUEST:
2558         {
2559             opus_val16 *value = va_arg(ap, opus_val16*);
2560             st->energy_masking = value;
2561             ret = celt_encoder_ctl(celt_enc, OPUS_SET_ENERGY_MASK(value));
2562         }
2563         break;
2564
2565         case CELT_GET_MODE_REQUEST:
2566         {
2567            const CELTMode ** value = va_arg(ap, const CELTMode**);
2568            if (!value)
2569            {
2570               goto bad_arg;
2571            }
2572            ret = celt_encoder_ctl(celt_enc, CELT_GET_MODE(value));
2573         }
2574         break;
2575         default:
2576             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
2577             ret = OPUS_UNIMPLEMENTED;
2578             break;
2579     }
2580     va_end(ap);
2581     return ret;
2582 bad_arg:
2583     va_end(ap);
2584     return OPUS_BAD_ARG;
2585 }
2586
2587 void opus_encoder_destroy(OpusEncoder *st)
2588 {
2589     opus_free(st);
2590 }