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