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