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