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