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