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