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