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