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