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