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