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