Fix warnings in pedantic build.
[opus.git] / src / opus_encoder.c
1 /* Copyright (c) 2010-2011 Xiph.Org Foundation, Skype Limited
2    Written by Jean-Marc Valin and Koen Vos */
3 /*
4    Redistribution and use in source and binary forms, with or without
5    modification, are permitted provided that the following conditions
6    are met:
7
8    - Redistributions of source code must retain the above copyright
9    notice, this list of conditions and the following disclaimer.
10
11    - Redistributions in binary form must reproduce the above copyright
12    notice, this list of conditions and the following disclaimer in the
13    documentation and/or other materials provided with the distribution.
14
15    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
18    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
19    OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
23    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
24    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #ifdef HAVE_CONFIG_H
29 #include "config.h"
30 #endif
31
32 #include <stdarg.h>
33 #include "celt.h"
34 #include "entenc.h"
35 #include "modes.h"
36 #include "API.h"
37 #include "stack_alloc.h"
38 #include "float_cast.h"
39 #include "opus.h"
40 #include "arch.h"
41 #include "pitch.h"
42 #include "opus_private.h"
43 #include "os_support.h"
44 #include "cpu_support.h"
45 #include "analysis.h"
46 #include "mathops.h"
47 #include "tuning_parameters.h"
48 #ifdef FIXED_POINT
49 #include "fixed/structs_FIX.h"
50 #else
51 #include "float/structs_FLP.h"
52 #endif
53
54 #define MAX_ENCODER_BUFFER 480
55
56 typedef struct {
57    opus_val32 XX, XY, YY;
58    opus_val16 smoothed_width;
59    opus_val16 max_follower;
60 } StereoWidthState;
61
62 struct OpusEncoder {
63     int          celt_enc_offset;
64     int          silk_enc_offset;
65     silk_EncControlStruct silk_mode;
66     int          application;
67     int          channels;
68     int          delay_compensation;
69     int          force_channels;
70     int          signal_type;
71     int          user_bandwidth;
72     int          max_bandwidth;
73     int          user_forced_mode;
74     int          voice_ratio;
75     opus_int32   Fs;
76     int          use_vbr;
77     int          vbr_constraint;
78     int          variable_duration;
79     opus_int32   bitrate_bps;
80     opus_int32   user_bitrate_bps;
81     int          lsb_depth;
82     int          encoder_buffer;
83     int          lfe;
84
85 #define OPUS_ENCODER_RESET_START stream_channels
86     int          stream_channels;
87     opus_int16   hybrid_stereo_width_Q14;
88     opus_int32   variable_HP_smth2_Q15;
89     opus_val16   prev_HB_gain;
90     opus_val32   hp_mem[4];
91     int          mode;
92     int          prev_mode;
93     int          prev_channels;
94     int          prev_framesize;
95     int          bandwidth;
96     int          silk_bw_switch;
97     /* Sampling rate (at the API level) */
98     int          first;
99     opus_val16 * energy_masking;
100     StereoWidthState width_mem;
101     opus_val16   delay_buffer[MAX_ENCODER_BUFFER*2];
102 #ifndef DISABLE_FLOAT_API
103     TonalityAnalysisState analysis;
104     int          detected_bandwidth;
105     int          analysis_offset;
106 #endif
107     opus_uint32  rangeFinal;
108     int          arch;
109 };
110
111 /* Transition tables for the voice and music. First column is the
112    middle (memoriless) threshold. The second column is the hysteresis
113    (difference with the middle) */
114 static const opus_int32 mono_voice_bandwidth_thresholds[8] = {
115         11000, 1000, /* NB<->MB */
116         14000, 1000, /* MB<->WB */
117         17000, 1000, /* WB<->SWB */
118         21000, 2000, /* SWB<->FB */
119 };
120 static const opus_int32 mono_music_bandwidth_thresholds[8] = {
121         12000, 1000, /* NB<->MB */
122         15000, 1000, /* MB<->WB */
123         18000, 2000, /* WB<->SWB */
124         22000, 2000, /* SWB<->FB */
125 };
126 static const opus_int32 stereo_voice_bandwidth_thresholds[8] = {
127         11000, 1000, /* NB<->MB */
128         14000, 1000, /* MB<->WB */
129         21000, 2000, /* WB<->SWB */
130         28000, 2000, /* SWB<->FB */
131 };
132 static const opus_int32 stereo_music_bandwidth_thresholds[8] = {
133         12000, 1000, /* NB<->MB */
134         18000, 2000, /* MB<->WB */
135         21000, 2000, /* WB<->SWB */
136         30000, 2000, /* SWB<->FB */
137 };
138 /* Threshold bit-rates for switching between mono and stereo */
139 static const opus_int32 stereo_voice_threshold = 30000;
140 static const opus_int32 stereo_music_threshold = 30000;
141
142 /* Threshold bit-rate for switching between SILK/hybrid and CELT-only */
143 static const opus_int32 mode_thresholds[2][2] = {
144       /* voice */ /* music */
145       {  64000,      16000}, /* mono */
146       {  36000,      16000}, /* stereo */
147 };
148
149 int opus_encoder_get_size(int channels)
150 {
151     int silkEncSizeBytes, celtEncSizeBytes;
152     int ret;
153     if (channels<1 || channels > 2)
154         return 0;
155     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
156     if (ret)
157         return 0;
158     silkEncSizeBytes = align(silkEncSizeBytes);
159     celtEncSizeBytes = celt_encoder_get_size(channels);
160     return align(sizeof(OpusEncoder))+silkEncSizeBytes+celtEncSizeBytes;
161 }
162
163 int opus_encoder_init(OpusEncoder* st, opus_int32 Fs, int channels, int application)
164 {
165     void *silk_enc;
166     CELTEncoder *celt_enc;
167     int err;
168     int ret, silkEncSizeBytes;
169
170    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
171         (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
172         && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
173         return OPUS_BAD_ARG;
174
175     OPUS_CLEAR((char*)st, opus_encoder_get_size(channels));
176     /* Create SILK encoder */
177     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
178     if (ret)
179         return OPUS_BAD_ARG;
180     silkEncSizeBytes = align(silkEncSizeBytes);
181     st->silk_enc_offset = align(sizeof(OpusEncoder));
182     st->celt_enc_offset = st->silk_enc_offset+silkEncSizeBytes;
183     silk_enc = (char*)st+st->silk_enc_offset;
184     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
185
186     st->stream_channels = st->channels = channels;
187
188     st->Fs = Fs;
189
190     st->arch = opus_select_arch();
191
192     ret = silk_InitEncoder( silk_enc, st->arch, &st->silk_mode );
193     if(ret)return OPUS_INTERNAL_ERROR;
194
195     /* default SILK parameters */
196     st->silk_mode.nChannelsAPI              = channels;
197     st->silk_mode.nChannelsInternal         = channels;
198     st->silk_mode.API_sampleRate            = st->Fs;
199     st->silk_mode.maxInternalSampleRate     = 16000;
200     st->silk_mode.minInternalSampleRate     = 8000;
201     st->silk_mode.desiredInternalSampleRate = 16000;
202     st->silk_mode.payloadSize_ms            = 20;
203     st->silk_mode.bitRate                   = 25000;
204     st->silk_mode.packetLossPercentage      = 0;
205     st->silk_mode.complexity                = 9;
206     st->silk_mode.useInBandFEC              = 0;
207     st->silk_mode.useDTX                    = 0;
208     st->silk_mode.useCBR                    = 0;
209     st->silk_mode.reducedDependency         = 0;
210
211     /* Create CELT encoder */
212     /* Initialize CELT encoder */
213     err = celt_encoder_init(celt_enc, Fs, channels, st->arch);
214     if(err!=OPUS_OK)return OPUS_INTERNAL_ERROR;
215
216     celt_encoder_ctl(celt_enc, CELT_SET_SIGNALLING(0));
217     celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(st->silk_mode.complexity));
218
219     st->use_vbr = 1;
220     /* Makes constrained VBR the default (safer for real-time use) */
221     st->vbr_constraint = 1;
222     st->user_bitrate_bps = OPUS_AUTO;
223     st->bitrate_bps = 3000+Fs*channels;
224     st->application = application;
225     st->signal_type = OPUS_AUTO;
226     st->user_bandwidth = OPUS_AUTO;
227     st->max_bandwidth = OPUS_BANDWIDTH_FULLBAND;
228     st->force_channels = OPUS_AUTO;
229     st->user_forced_mode = OPUS_AUTO;
230     st->voice_ratio = -1;
231     st->encoder_buffer = st->Fs/100;
232     st->lsb_depth = 24;
233     st->variable_duration = OPUS_FRAMESIZE_ARG;
234
235     /* Delay compensation of 4 ms (2.5 ms for SILK's extra look-ahead
236        + 1.5 ms for SILK resamplers and stereo prediction) */
237     st->delay_compensation = st->Fs/250;
238
239     st->hybrid_stereo_width_Q14 = 1 << 14;
240     st->prev_HB_gain = Q15ONE;
241     st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
242     st->first = 1;
243     st->mode = MODE_HYBRID;
244     st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
245
246     return OPUS_OK;
247 }
248
249 static unsigned char gen_toc(int mode, int framerate, int bandwidth, int channels)
250 {
251    int period;
252    unsigned char toc;
253    period = 0;
254    while (framerate < 400)
255    {
256        framerate <<= 1;
257        period++;
258    }
259    if (mode == MODE_SILK_ONLY)
260    {
261        toc = (bandwidth-OPUS_BANDWIDTH_NARROWBAND)<<5;
262        toc |= (period-2)<<3;
263    } else if (mode == MODE_CELT_ONLY)
264    {
265        int tmp = bandwidth-OPUS_BANDWIDTH_MEDIUMBAND;
266        if (tmp < 0)
267            tmp = 0;
268        toc = 0x80;
269        toc |= tmp << 5;
270        toc |= period<<3;
271    } else /* Hybrid */
272    {
273        toc = 0x60;
274        toc |= (bandwidth-OPUS_BANDWIDTH_SUPERWIDEBAND)<<4;
275        toc |= (period-2)<<3;
276    }
277    toc |= (channels==2)<<2;
278    return toc;
279 }
280
281 #ifndef FIXED_POINT
282 static void silk_biquad_float(
283     const opus_val16      *in,            /* I:    Input signal                   */
284     const opus_int32      *B_Q28,         /* I:    MA coefficients [3]            */
285     const opus_int32      *A_Q28,         /* I:    AR coefficients [2]            */
286     opus_val32            *S,             /* I/O:  State vector [2]               */
287     opus_val16            *out,           /* O:    Output signal                  */
288     const opus_int32      len,            /* I:    Signal length (must be even)   */
289     int stride
290 )
291 {
292     /* DIRECT FORM II TRANSPOSED (uses 2 element state vector) */
293     opus_int   k;
294     opus_val32 vout;
295     opus_val32 inval;
296     opus_val32 A[2], B[3];
297
298     A[0] = (opus_val32)(A_Q28[0] * (1.f/((opus_int32)1<<28)));
299     A[1] = (opus_val32)(A_Q28[1] * (1.f/((opus_int32)1<<28)));
300     B[0] = (opus_val32)(B_Q28[0] * (1.f/((opus_int32)1<<28)));
301     B[1] = (opus_val32)(B_Q28[1] * (1.f/((opus_int32)1<<28)));
302     B[2] = (opus_val32)(B_Q28[2] * (1.f/((opus_int32)1<<28)));
303
304     /* Negate A_Q28 values and split in two parts */
305
306     for( k = 0; k < len; k++ ) {
307         /* S[ 0 ], S[ 1 ]: Q12 */
308         inval = in[ k*stride ];
309         vout = S[ 0 ] + B[0]*inval;
310
311         S[ 0 ] = S[1] - vout*A[0] + B[1]*inval;
312
313         S[ 1 ] = - vout*A[1] + B[2]*inval + VERY_SMALL;
314
315         /* Scale back to Q0 and saturate */
316         out[ k*stride ] = vout;
317     }
318 }
319 #endif
320
321 static void hp_cutoff(const opus_val16 *in, opus_int32 cutoff_Hz, opus_val16 *out, opus_val32 *hp_mem, int len, int channels, opus_int32 Fs)
322 {
323    opus_int32 B_Q28[ 3 ], A_Q28[ 2 ];
324    opus_int32 Fc_Q19, r_Q28, r_Q22;
325
326    silk_assert( cutoff_Hz <= silk_int32_MAX / SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ) );
327    Fc_Q19 = silk_DIV32_16( silk_SMULBB( SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ), cutoff_Hz ), Fs/1000 );
328    silk_assert( Fc_Q19 > 0 && Fc_Q19 < 32768 );
329
330    r_Q28 = SILK_FIX_CONST( 1.0, 28 ) - silk_MUL( SILK_FIX_CONST( 0.92, 9 ), Fc_Q19 );
331
332    /* b = r * [ 1; -2; 1 ]; */
333    /* a = [ 1; -2 * r * ( 1 - 0.5 * Fc^2 ); r^2 ]; */
334    B_Q28[ 0 ] = r_Q28;
335    B_Q28[ 1 ] = silk_LSHIFT( -r_Q28, 1 );
336    B_Q28[ 2 ] = r_Q28;
337
338    /* -r * ( 2 - Fc * Fc ); */
339    r_Q22  = silk_RSHIFT( r_Q28, 6 );
340    A_Q28[ 0 ] = silk_SMULWW( r_Q22, silk_SMULWW( Fc_Q19, Fc_Q19 ) - SILK_FIX_CONST( 2.0,  22 ) );
341    A_Q28[ 1 ] = silk_SMULWW( r_Q22, r_Q22 );
342
343 #ifdef FIXED_POINT
344    silk_biquad_alt( in, B_Q28, A_Q28, hp_mem, out, len, channels );
345    if( channels == 2 ) {
346        silk_biquad_alt( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
347    }
348 #else
349    silk_biquad_float( in, B_Q28, A_Q28, hp_mem, out, len, channels );
350    if( channels == 2 ) {
351        silk_biquad_float( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
352    }
353 #endif
354 }
355
356 #ifdef FIXED_POINT
357 static void dc_reject(const opus_val16 *in, opus_int32 cutoff_Hz, opus_val16 *out, opus_val32 *hp_mem, int len, int channels, opus_int32 Fs)
358 {
359    int c, i;
360    int shift;
361
362    /* Approximates -round(log2(4.*cutoff_Hz/Fs)) */
363    shift=celt_ilog2(Fs/(cutoff_Hz*3));
364    for (c=0;c<channels;c++)
365    {
366       for (i=0;i<len;i++)
367       {
368          opus_val32 x, tmp, y;
369          x = SHL32(EXTEND32(in[channels*i+c]), 15);
370          /* First stage */
371          tmp = x-hp_mem[2*c];
372          hp_mem[2*c] = hp_mem[2*c] + PSHR32(x - hp_mem[2*c], shift);
373          /* Second stage */
374          y = tmp - hp_mem[2*c+1];
375          hp_mem[2*c+1] = hp_mem[2*c+1] + PSHR32(tmp - hp_mem[2*c+1], shift);
376          out[channels*i+c] = EXTRACT16(SATURATE(PSHR32(y, 15), 32767));
377       }
378    }
379 }
380
381 #else
382 static void dc_reject(const opus_val16 *in, opus_int32 cutoff_Hz, opus_val16 *out, opus_val32 *hp_mem, int len, int channels, opus_int32 Fs)
383 {
384    int c, i;
385    float coef;
386
387    coef = 4.0f*cutoff_Hz/Fs;
388    for (c=0;c<channels;c++)
389    {
390       for (i=0;i<len;i++)
391       {
392          opus_val32 x, tmp, y;
393          x = in[channels*i+c];
394          /* First stage */
395          tmp = x-hp_mem[2*c];
396          hp_mem[2*c] = hp_mem[2*c] + coef*(x - hp_mem[2*c]) + VERY_SMALL;
397          /* Second stage */
398          y = tmp - hp_mem[2*c+1];
399          hp_mem[2*c+1] = hp_mem[2*c+1] + coef*(tmp - hp_mem[2*c+1]) + VERY_SMALL;
400          out[channels*i+c] = y;
401       }
402    }
403 }
404 #endif
405
406 static void stereo_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2,
407         int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
408 {
409     int i;
410     int overlap;
411     int inc;
412     inc = 48000/Fs;
413     overlap=overlap48/inc;
414     g1 = Q15ONE-g1;
415     g2 = Q15ONE-g2;
416     for (i=0;i<overlap;i++)
417     {
418        opus_val32 diff;
419        opus_val16 g, w;
420        w = MULT16_16_Q15(window[i*inc], window[i*inc]);
421        g = SHR32(MAC16_16(MULT16_16(w,g2),
422              Q15ONE-w, g1), 15);
423        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
424        diff = MULT16_16_Q15(g, diff);
425        out[i*channels] = out[i*channels] - diff;
426        out[i*channels+1] = out[i*channels+1] + diff;
427     }
428     for (;i<frame_size;i++)
429     {
430        opus_val32 diff;
431        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
432        diff = MULT16_16_Q15(g2, diff);
433        out[i*channels] = out[i*channels] - diff;
434        out[i*channels+1] = out[i*channels+1] + diff;
435     }
436 }
437
438 static void gain_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2,
439         int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
440 {
441     int i;
442     int inc;
443     int overlap;
444     int c;
445     inc = 48000/Fs;
446     overlap=overlap48/inc;
447     if (channels==1)
448     {
449        for (i=0;i<overlap;i++)
450        {
451           opus_val16 g, w;
452           w = MULT16_16_Q15(window[i*inc], window[i*inc]);
453           g = SHR32(MAC16_16(MULT16_16(w,g2),
454                 Q15ONE-w, g1), 15);
455           out[i] = MULT16_16_Q15(g, in[i]);
456        }
457     } else {
458        for (i=0;i<overlap;i++)
459        {
460           opus_val16 g, w;
461           w = MULT16_16_Q15(window[i*inc], window[i*inc]);
462           g = SHR32(MAC16_16(MULT16_16(w,g2),
463                 Q15ONE-w, g1), 15);
464           out[i*2] = MULT16_16_Q15(g, in[i*2]);
465           out[i*2+1] = MULT16_16_Q15(g, in[i*2+1]);
466        }
467     }
468     c=0;do {
469        for (i=overlap;i<frame_size;i++)
470        {
471           out[i*channels+c] = MULT16_16_Q15(g2, in[i*channels+c]);
472        }
473     }
474     while (++c<channels);
475 }
476
477 OpusEncoder *opus_encoder_create(opus_int32 Fs, int channels, int application, int *error)
478 {
479    int ret;
480    OpusEncoder *st;
481    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
482        (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
483        && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
484    {
485       if (error)
486          *error = OPUS_BAD_ARG;
487       return NULL;
488    }
489    st = (OpusEncoder *)opus_alloc(opus_encoder_get_size(channels));
490    if (st == NULL)
491    {
492       if (error)
493          *error = OPUS_ALLOC_FAIL;
494       return NULL;
495    }
496    ret = opus_encoder_init(st, Fs, channels, application);
497    if (error)
498       *error = ret;
499    if (ret != OPUS_OK)
500    {
501       opus_free(st);
502       st = NULL;
503    }
504    return st;
505 }
506
507 static opus_int32 user_bitrate_to_bitrate(OpusEncoder *st, int frame_size, int max_data_bytes)
508 {
509   if(!frame_size)frame_size=st->Fs/400;
510   if (st->user_bitrate_bps==OPUS_AUTO)
511     return 60*st->Fs/frame_size + st->Fs*st->channels;
512   else if (st->user_bitrate_bps==OPUS_BITRATE_MAX)
513     return max_data_bytes*8*st->Fs/frame_size;
514   else
515     return st->user_bitrate_bps;
516 }
517
518 #ifndef DISABLE_FLOAT_API
519 /* Don't use more than 60 ms for the frame size analysis */
520 #define MAX_DYNAMIC_FRAMESIZE 24
521 /* Estimates how much the bitrate will be boosted based on the sub-frame energy */
522 static float transient_boost(const float *E, const float *E_1, int LM, int maxM)
523 {
524    int i;
525    int M;
526    float sumE=0, sumE_1=0;
527    float metric;
528
529    M = IMIN(maxM, (1<<LM)+1);
530    for (i=0;i<M;i++)
531    {
532       sumE += E[i];
533       sumE_1 += E_1[i];
534    }
535    metric = sumE*sumE_1/(M*M);
536    /*if (LM==3)
537       printf("%f\n", metric);*/
538    /*return metric>10 ? 1 : 0;*/
539    /*return MAX16(0,1-exp(-.25*(metric-2.)));*/
540    return MIN16(1,(float)sqrt(MAX16(0,.05f*(metric-2))));
541 }
542
543 /* Viterbi decoding trying to find the best frame size combination using look-ahead
544
545    State numbering:
546     0: unused
547     1:  2.5 ms
548     2:  5 ms (#1)
549     3:  5 ms (#2)
550     4: 10 ms (#1)
551     5: 10 ms (#2)
552     6: 10 ms (#3)
553     7: 10 ms (#4)
554     8: 20 ms (#1)
555     9: 20 ms (#2)
556    10: 20 ms (#3)
557    11: 20 ms (#4)
558    12: 20 ms (#5)
559    13: 20 ms (#6)
560    14: 20 ms (#7)
561    15: 20 ms (#8)
562 */
563 static int transient_viterbi(const float *E, const float *E_1, int N, int frame_cost, int rate)
564 {
565    int i;
566    float cost[MAX_DYNAMIC_FRAMESIZE][16];
567    int states[MAX_DYNAMIC_FRAMESIZE][16];
568    float best_cost;
569    int best_state;
570    float factor;
571    /* Take into account that we damp VBR in the 32 kb/s to 64 kb/s range. */
572    if (rate<80)
573       factor=0;
574    else if (rate>160)
575       factor=1;
576    else
577       factor = (rate-80.f)/80.f;
578    /* Makes variable framesize less aggressive at lower bitrates, but I can't
579       find any valid theoretical justification for this (other than it seems
580       to help) */
581    for (i=0;i<16;i++)
582    {
583       /* Impossible state */
584       states[0][i] = -1;
585       cost[0][i] = 1e10;
586    }
587    for (i=0;i<4;i++)
588    {
589       cost[0][1<<i] = (frame_cost + rate*(1<<i))*(1+factor*transient_boost(E, E_1, i, N+1));
590       states[0][1<<i] = i;
591    }
592    for (i=1;i<N;i++)
593    {
594       int j;
595
596       /* Follow continuations */
597       for (j=2;j<16;j++)
598       {
599          cost[i][j] = cost[i-1][j-1];
600          states[i][j] = j-1;
601       }
602
603       /* New frames */
604       for(j=0;j<4;j++)
605       {
606          int k;
607          float min_cost;
608          float curr_cost;
609          states[i][1<<j] = 1;
610          min_cost = cost[i-1][1];
611          for(k=1;k<4;k++)
612          {
613             float tmp = cost[i-1][(1<<(k+1))-1];
614             if (tmp < min_cost)
615             {
616                states[i][1<<j] = (1<<(k+1))-1;
617                min_cost = tmp;
618             }
619          }
620          curr_cost = (frame_cost + rate*(1<<j))*(1+factor*transient_boost(E+i, E_1+i, j, N-i+1));
621          cost[i][1<<j] = min_cost;
622          /* If part of the frame is outside the analysis window, only count part of the cost */
623          if (N-i < (1<<j))
624             cost[i][1<<j] += curr_cost*(float)(N-i)/(1<<j);
625          else
626             cost[i][1<<j] += curr_cost;
627       }
628    }
629
630    best_state=1;
631    best_cost = cost[N-1][1];
632    /* Find best end state (doesn't force a frame to end at N-1) */
633    for (i=2;i<16;i++)
634    {
635       if (cost[N-1][i]<best_cost)
636       {
637          best_cost = cost[N-1][i];
638          best_state = i;
639       }
640    }
641
642    /* Follow transitions back */
643    for (i=N-1;i>=0;i--)
644    {
645       /*printf("%d ", best_state);*/
646       best_state = states[i][best_state];
647    }
648    /*printf("%d\n", best_state);*/
649    return best_state;
650 }
651
652 static int optimize_framesize(const void *x, int len, int C, opus_int32 Fs,
653                 int bitrate, opus_val16 tonality, float *mem, int buffering,
654                 downmix_func downmix)
655 {
656    int N;
657    int i;
658    float e[MAX_DYNAMIC_FRAMESIZE+4];
659    float e_1[MAX_DYNAMIC_FRAMESIZE+3];
660    opus_val32 memx;
661    int bestLM=0;
662    int subframe;
663    int pos;
664    int offset;
665    VARDECL(opus_val32, sub);
666
667    subframe = Fs/400;
668    ALLOC(sub, subframe, opus_val32);
669    e[0]=mem[0];
670    e_1[0]=1.f/(EPSILON+mem[0]);
671    if (buffering)
672    {
673       /* Consider the CELT delay when not in restricted-lowdelay */
674       /* We assume the buffering is between 2.5 and 5 ms */
675       offset = 2*subframe - buffering;
676       celt_assert(offset>=0 && offset <= subframe);
677       len -= offset;
678       e[1]=mem[1];
679       e_1[1]=1.f/(EPSILON+mem[1]);
680       e[2]=mem[2];
681       e_1[2]=1.f/(EPSILON+mem[2]);
682       pos = 3;
683    } else {
684       pos=1;
685       offset=0;
686    }
687    N=IMIN(len/subframe, MAX_DYNAMIC_FRAMESIZE);
688    /* Just silencing a warning, it's really initialized later */
689    memx = 0;
690    for (i=0;i<N;i++)
691    {
692       float tmp;
693       opus_val32 tmpx;
694       int j;
695       tmp=EPSILON;
696
697       downmix(x, sub, subframe, i*subframe+offset, 0, -2, C);
698       if (i==0)
699          memx = sub[0];
700       for (j=0;j<subframe;j++)
701       {
702          tmpx = sub[j];
703          tmp += (tmpx-memx)*(float)(tmpx-memx);
704          memx = tmpx;
705       }
706       e[i+pos] = tmp;
707       e_1[i+pos] = 1.f/tmp;
708    }
709    /* Hack to get 20 ms working with APPLICATION_AUDIO
710       The real problem is that the corresponding memory needs to use 1.5 ms
711       from this frame and 1 ms from the next frame */
712    e[i+pos] = e[i+pos-1];
713    if (buffering)
714       N=IMIN(MAX_DYNAMIC_FRAMESIZE, N+2);
715    bestLM = transient_viterbi(e, e_1, N, (int)((1.f+.5f*tonality)*(60*C+40)), bitrate/400);
716    mem[0] = e[1<<bestLM];
717    if (buffering)
718    {
719       mem[1] = e[(1<<bestLM)+1];
720       mem[2] = e[(1<<bestLM)+2];
721    }
722    return bestLM;
723 }
724
725 #endif
726
727 #ifndef DISABLE_FLOAT_API
728 #ifdef FIXED_POINT
729 #define PCM2VAL(x) FLOAT2INT16(x)
730 #else
731 #define PCM2VAL(x) SCALEIN(x)
732 #endif
733 void downmix_float(const void *_x, opus_val32 *sub, int subframe, int offset, int c1, int c2, int C)
734 {
735    const float *x;
736    opus_val32 scale;
737    int j;
738    x = (const float *)_x;
739    for (j=0;j<subframe;j++)
740       sub[j] = PCM2VAL(x[(j+offset)*C+c1]);
741    if (c2>-1)
742    {
743       for (j=0;j<subframe;j++)
744          sub[j] += PCM2VAL(x[(j+offset)*C+c2]);
745    } else if (c2==-2)
746    {
747       int c;
748       for (c=1;c<C;c++)
749       {
750          for (j=0;j<subframe;j++)
751             sub[j] += PCM2VAL(x[(j+offset)*C+c]);
752       }
753    }
754 #ifdef FIXED_POINT
755    scale = (1<<SIG_SHIFT);
756 #else
757    scale = 1.f;
758 #endif
759    if (C==-2)
760       scale /= C;
761    else
762       scale /= 2;
763    for (j=0;j<subframe;j++)
764       sub[j] *= scale;
765 }
766 #endif
767
768 void downmix_int(const void *_x, opus_val32 *sub, int subframe, int offset, int c1, int c2, int C)
769 {
770    const opus_int16 *x;
771    opus_val32 scale;
772    int j;
773    x = (const opus_int16 *)_x;
774    for (j=0;j<subframe;j++)
775       sub[j] = x[(j+offset)*C+c1];
776    if (c2>-1)
777    {
778       for (j=0;j<subframe;j++)
779          sub[j] += x[(j+offset)*C+c2];
780    } else if (c2==-2)
781    {
782       int c;
783       for (c=1;c<C;c++)
784       {
785          for (j=0;j<subframe;j++)
786             sub[j] += x[(j+offset)*C+c];
787       }
788    }
789 #ifdef FIXED_POINT
790    scale = (1<<SIG_SHIFT);
791 #else
792    scale = 1.f/32768;
793 #endif
794    if (C==-2)
795       scale /= C;
796    else
797       scale /= 2;
798    for (j=0;j<subframe;j++)
799       sub[j] *= scale;
800 }
801
802 opus_int32 frame_size_select(opus_int32 frame_size, int variable_duration, opus_int32 Fs)
803 {
804    int new_size;
805    if (frame_size<Fs/400)
806       return -1;
807    if (variable_duration == OPUS_FRAMESIZE_ARG)
808       new_size = frame_size;
809    else if (variable_duration == OPUS_FRAMESIZE_VARIABLE)
810       new_size = Fs/50;
811    else if (variable_duration >= OPUS_FRAMESIZE_2_5_MS && variable_duration <= OPUS_FRAMESIZE_60_MS)
812       new_size = IMIN(3*Fs/50, (Fs/400)<<(variable_duration-OPUS_FRAMESIZE_2_5_MS));
813    else
814       return -1;
815    if (new_size>frame_size)
816       return -1;
817    if (400*new_size!=Fs && 200*new_size!=Fs && 100*new_size!=Fs &&
818             50*new_size!=Fs && 25*new_size!=Fs && 50*new_size!=3*Fs)
819       return -1;
820    return new_size;
821 }
822
823 opus_int32 compute_frame_size(const void *analysis_pcm, int frame_size,
824       int variable_duration, int C, opus_int32 Fs, int bitrate_bps,
825       int delay_compensation, downmix_func downmix
826 #ifndef DISABLE_FLOAT_API
827       , float *subframe_mem
828 #endif
829       )
830 {
831 #ifndef DISABLE_FLOAT_API
832    if (variable_duration == OPUS_FRAMESIZE_VARIABLE && frame_size >= Fs/200)
833    {
834       int LM = 3;
835       LM = optimize_framesize(analysis_pcm, frame_size, C, Fs, bitrate_bps,
836             0, subframe_mem, delay_compensation, downmix);
837       while ((Fs/400<<LM)>frame_size)
838          LM--;
839       frame_size = (Fs/400<<LM);
840    } else
841 #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);
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           OPUS_CLEAR(&pcm_buf[total_buffer*st->channels], frame_size*st->channels);
1469     }
1470 #endif
1471
1472
1473     /* SILK processing */
1474     HB_gain = Q15ONE;
1475     if (st->mode != MODE_CELT_ONLY)
1476     {
1477         opus_int32 total_bitRate, celt_rate;
1478 #ifdef FIXED_POINT
1479        const opus_int16 *pcm_silk;
1480 #else
1481        VARDECL(opus_int16, pcm_silk);
1482        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
1483 #endif
1484
1485         /* Distribute bits between SILK and CELT */
1486         total_bitRate = 8 * bytes_target * frame_rate;
1487         if( st->mode == MODE_HYBRID ) {
1488             int HB_gain_ref;
1489             /* Base rate for SILK */
1490             st->silk_mode.bitRate = st->stream_channels * ( 5000 + 1000 * ( st->Fs == 100 * frame_size ) );
1491             if( curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
1492                 /* SILK gets 2/3 of the remaining bits */
1493                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 2 / 3;
1494             } else { /* FULLBAND */
1495                 /* SILK gets 3/5 of the remaining bits */
1496                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 3 / 5;
1497             }
1498             /* Don't let SILK use more than 80% */
1499             if( st->silk_mode.bitRate > total_bitRate * 4/5 ) {
1500                 st->silk_mode.bitRate = total_bitRate * 4/5;
1501             }
1502             if (!st->energy_masking)
1503             {
1504                /* Increasingly attenuate high band when it gets allocated fewer bits */
1505                celt_rate = total_bitRate - st->silk_mode.bitRate;
1506                HB_gain_ref = (curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND) ? 3000 : 3600;
1507                HB_gain = SHL32((opus_val32)celt_rate, 9) / SHR32((opus_val32)celt_rate + st->stream_channels * HB_gain_ref, 6);
1508                HB_gain = HB_gain < Q15ONE*6/7 ? HB_gain + Q15ONE/7 : Q15ONE;
1509             }
1510         } else {
1511             /* SILK gets all bits */
1512             st->silk_mode.bitRate = total_bitRate;
1513         }
1514
1515         /* Surround masking for SILK */
1516         if (st->energy_masking && st->use_vbr && !st->lfe)
1517         {
1518            opus_val32 mask_sum=0;
1519            opus_val16 masking_depth;
1520            opus_int32 rate_offset;
1521            int c;
1522            int end = 17;
1523            opus_int16 srate = 16000;
1524            if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND)
1525            {
1526               end = 13;
1527               srate = 8000;
1528            } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1529            {
1530               end = 15;
1531               srate = 12000;
1532            }
1533            for (c=0;c<st->channels;c++)
1534            {
1535               for(i=0;i<end;i++)
1536               {
1537                  opus_val16 mask;
1538                  mask = MAX16(MIN16(st->energy_masking[21*c+i],
1539                         QCONST16(.5f, DB_SHIFT)), -QCONST16(2.0f, DB_SHIFT));
1540                  if (mask > 0)
1541                     mask = HALF16(mask);
1542                  mask_sum += mask;
1543               }
1544            }
1545            /* Conservative rate reduction, we cut the masking in half */
1546            masking_depth = mask_sum / end*st->channels;
1547            masking_depth += QCONST16(.2f, DB_SHIFT);
1548            rate_offset = (opus_int32)PSHR32(MULT16_16(srate, masking_depth), DB_SHIFT);
1549            rate_offset = MAX32(rate_offset, -2*st->silk_mode.bitRate/3);
1550            /* Split the rate change between the SILK and CELT part for hybrid. */
1551            if (st->bandwidth==OPUS_BANDWIDTH_SUPERWIDEBAND || st->bandwidth==OPUS_BANDWIDTH_FULLBAND)
1552               st->silk_mode.bitRate += 3*rate_offset/5;
1553            else
1554               st->silk_mode.bitRate += rate_offset;
1555            bytes_target += rate_offset * frame_size / (8 * st->Fs);
1556         }
1557
1558         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
1559         st->silk_mode.nChannelsAPI = st->channels;
1560         st->silk_mode.nChannelsInternal = st->stream_channels;
1561         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1562             st->silk_mode.desiredInternalSampleRate = 8000;
1563         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1564             st->silk_mode.desiredInternalSampleRate = 12000;
1565         } else {
1566             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
1567             st->silk_mode.desiredInternalSampleRate = 16000;
1568         }
1569         if( st->mode == MODE_HYBRID ) {
1570             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
1571             st->silk_mode.minInternalSampleRate = 16000;
1572         } else {
1573             st->silk_mode.minInternalSampleRate = 8000;
1574         }
1575
1576         if (st->mode == MODE_SILK_ONLY)
1577         {
1578            opus_int32 effective_max_rate = max_rate;
1579            st->silk_mode.maxInternalSampleRate = 16000;
1580            if (frame_rate > 50)
1581               effective_max_rate = effective_max_rate*2/3;
1582            if (effective_max_rate < 13000)
1583            {
1584               st->silk_mode.maxInternalSampleRate = 12000;
1585               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
1586            }
1587            if (effective_max_rate < 9600)
1588            {
1589               st->silk_mode.maxInternalSampleRate = 8000;
1590               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
1591            }
1592         } else {
1593            st->silk_mode.maxInternalSampleRate = 16000;
1594         }
1595
1596         st->silk_mode.useCBR = !st->use_vbr;
1597
1598         /* Call SILK encoder for the low band */
1599         nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes);
1600
1601         st->silk_mode.maxBits = nBytes*8;
1602         /* Only allow up to 90% of the bits for hybrid mode*/
1603         if (st->mode == MODE_HYBRID)
1604            st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
1605         if (st->silk_mode.useCBR)
1606         {
1607            st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
1608            /* Reduce the initial target to make it easier to reach the CBR rate */
1609            st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000);
1610         }
1611
1612         if (prefill)
1613         {
1614             opus_int32 zero=0;
1615             int prefill_offset;
1616             /* Use a smooth onset for the SILK prefill to avoid the encoder trying to encode
1617                a discontinuity. The exact location is what we need to avoid leaving any "gap"
1618                in the audio when mixing with the redundant CELT frame. Here we can afford to
1619                overwrite st->delay_buffer because the only thing that uses it before it gets
1620                rewritten is tmp_prefill[] and even then only the part after the ramp really
1621                gets used (rather than sent to the encoder and discarded) */
1622             prefill_offset = st->channels*(st->encoder_buffer-st->delay_compensation-st->Fs/400);
1623             gain_fade(st->delay_buffer+prefill_offset, st->delay_buffer+prefill_offset,
1624                   0, Q15ONE, celt_mode->overlap, st->Fs/400, st->channels, celt_mode->window, st->Fs);
1625             OPUS_CLEAR(st->delay_buffer, prefill_offset);
1626 #ifdef FIXED_POINT
1627             pcm_silk = st->delay_buffer;
1628 #else
1629             for (i=0;i<st->encoder_buffer*st->channels;i++)
1630                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
1631 #endif
1632             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
1633         }
1634
1635 #ifdef FIXED_POINT
1636         pcm_silk = pcm_buf+total_buffer*st->channels;
1637 #else
1638         for (i=0;i<frame_size*st->channels;i++)
1639             pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
1640 #endif
1641         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
1642         if( ret ) {
1643             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
1644             /* Handle error */
1645            RESTORE_STACK;
1646            return OPUS_INTERNAL_ERROR;
1647         }
1648         if (nBytes==0)
1649         {
1650            st->rangeFinal = 0;
1651            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1652            RESTORE_STACK;
1653            return 1;
1654         }
1655         /* Extract SILK internal bandwidth for signaling in first byte */
1656         if( st->mode == MODE_SILK_ONLY ) {
1657             if( st->silk_mode.internalSampleRate == 8000 ) {
1658                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1659             } else if( st->silk_mode.internalSampleRate == 12000 ) {
1660                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1661             } else if( st->silk_mode.internalSampleRate == 16000 ) {
1662                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1663             }
1664         } else {
1665             silk_assert( st->silk_mode.internalSampleRate == 16000 );
1666         }
1667
1668         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
1669         /* FIXME: How do we allocate the redundancy for CBR? */
1670         if (st->silk_mode.opusCanSwitch)
1671         {
1672            redundancy = 1;
1673            celt_to_silk = 0;
1674            st->silk_bw_switch = 1;
1675         }
1676     }
1677
1678     /* CELT processing */
1679     {
1680         int endband=21;
1681
1682         switch(curr_bandwidth)
1683         {
1684             case OPUS_BANDWIDTH_NARROWBAND:
1685                 endband = 13;
1686                 break;
1687             case OPUS_BANDWIDTH_MEDIUMBAND:
1688             case OPUS_BANDWIDTH_WIDEBAND:
1689                 endband = 17;
1690                 break;
1691             case OPUS_BANDWIDTH_SUPERWIDEBAND:
1692                 endband = 19;
1693                 break;
1694             case OPUS_BANDWIDTH_FULLBAND:
1695                 endband = 21;
1696                 break;
1697         }
1698         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
1699         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
1700     }
1701     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1702     if (st->mode != MODE_SILK_ONLY)
1703     {
1704         opus_val32 celt_pred=2;
1705         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1706         /* We may still decide to disable prediction later */
1707         if (st->silk_mode.reducedDependency)
1708            celt_pred = 0;
1709         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(celt_pred));
1710
1711         if (st->mode == MODE_HYBRID)
1712         {
1713             int len;
1714
1715             len = (ec_tell(&enc)+7)>>3;
1716             if (redundancy)
1717                len += st->mode == MODE_HYBRID ? 3 : 1;
1718             if( st->use_vbr ) {
1719                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
1720             } else {
1721                 /* check if SILK used up too much */
1722                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
1723             }
1724         } else {
1725             if (st->use_vbr)
1726             {
1727                 opus_int32 bonus=0;
1728 #ifndef DISABLE_FLOAT_API
1729                 if (st->variable_duration==OPUS_FRAMESIZE_VARIABLE && frame_size != st->Fs/50)
1730                 {
1731                    bonus = (60*st->stream_channels+40)*(st->Fs/frame_size-50);
1732                    if (analysis_info.valid)
1733                       bonus = (opus_int32)(bonus*(1.f+.5f*analysis_info.tonality));
1734                 }
1735 #endif
1736                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
1737                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
1738                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps+bonus));
1739                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
1740             } else {
1741                 nb_compr_bytes = bytes_target;
1742             }
1743         }
1744
1745     } else {
1746         nb_compr_bytes = 0;
1747     }
1748
1749     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
1750     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
1751     {
1752        OPUS_COPY(tmp_prefill, &st->delay_buffer[(st->encoder_buffer-total_buffer-st->Fs/400)*st->channels], st->channels*st->Fs/400);
1753     }
1754
1755     if (st->channels*(st->encoder_buffer-(frame_size+total_buffer)) > 0)
1756     {
1757        OPUS_MOVE(st->delay_buffer, &st->delay_buffer[st->channels*frame_size], st->channels*(st->encoder_buffer-frame_size-total_buffer));
1758        OPUS_COPY(&st->delay_buffer[st->channels*(st->encoder_buffer-frame_size-total_buffer)],
1759              &pcm_buf[0],
1760              (frame_size+total_buffer)*st->channels);
1761     } else {
1762        OPUS_COPY(st->delay_buffer, &pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels], st->encoder_buffer*st->channels);
1763     }
1764     /* gain_fade() and stereo_fade() need to be after the buffer copying
1765        because we don't want any of this to affect the SILK part */
1766     if( st->prev_HB_gain < Q15ONE || HB_gain < Q15ONE ) {
1767        gain_fade(pcm_buf, pcm_buf,
1768              st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs);
1769     }
1770     st->prev_HB_gain = HB_gain;
1771     if (st->mode != MODE_HYBRID || st->stream_channels==1)
1772        st->silk_mode.stereoWidth_Q14 = IMIN((1<<14),2*IMAX(0,equiv_rate-30000));
1773     if( !st->energy_masking && st->channels == 2 ) {
1774         /* Apply stereo width reduction (at low bitrates) */
1775         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1776             opus_val16 g1, g2;
1777             g1 = st->hybrid_stereo_width_Q14;
1778             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1779 #ifdef FIXED_POINT
1780             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
1781             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
1782 #else
1783             g1 *= (1.f/16384);
1784             g2 *= (1.f/16384);
1785 #endif
1786             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
1787                   frame_size, st->channels, celt_mode->window, st->Fs);
1788             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1789         }
1790     }
1791
1792     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
1793     {
1794         /* For SILK mode, the redundancy is inferred from the length */
1795         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
1796            ec_enc_bit_logp(&enc, redundancy, 12);
1797         if (redundancy)
1798         {
1799             int max_redundancy;
1800             ec_enc_bit_logp(&enc, celt_to_silk, 1);
1801             if (st->mode == MODE_HYBRID)
1802                max_redundancy = (max_data_bytes-1)-nb_compr_bytes;
1803             else
1804                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1805             /* Target the same bit-rate for redundancy as for the rest,
1806                up to a max of 257 bytes */
1807             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
1808             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
1809             if (st->mode == MODE_HYBRID)
1810                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
1811         }
1812     } else {
1813         redundancy = 0;
1814     }
1815
1816     if (!redundancy)
1817     {
1818        st->silk_bw_switch = 0;
1819        redundancy_bytes = 0;
1820     }
1821     if (st->mode != MODE_CELT_ONLY)start_band=17;
1822
1823     if (st->mode == MODE_SILK_ONLY)
1824     {
1825         ret = (ec_tell(&enc)+7)>>3;
1826         ec_enc_done(&enc);
1827         nb_compr_bytes = ret;
1828     } else {
1829        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
1830        ec_enc_shrink(&enc, nb_compr_bytes);
1831     }
1832
1833 #ifndef DISABLE_FLOAT_API
1834     if (redundancy || st->mode != MODE_SILK_ONLY)
1835        celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(&analysis_info));
1836 #endif
1837
1838     /* 5 ms redundant frame for CELT->SILK */
1839     if (redundancy && celt_to_silk)
1840     {
1841         int err;
1842         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1843         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1844         err = celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
1845         if (err < 0)
1846         {
1847            RESTORE_STACK;
1848            return OPUS_INTERNAL_ERROR;
1849         }
1850         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1851         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1852     }
1853
1854     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
1855
1856     if (st->mode != MODE_SILK_ONLY)
1857     {
1858         if (st->mode != st->prev_mode && st->prev_mode > 0)
1859         {
1860            unsigned char dummy[2];
1861            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1862
1863            /* Prefilling */
1864            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
1865            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1866         }
1867         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
1868         if (ec_tell(&enc) <= 8*nb_compr_bytes)
1869         {
1870            ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
1871            if (ret < 0)
1872            {
1873               RESTORE_STACK;
1874               return OPUS_INTERNAL_ERROR;
1875            }
1876         }
1877     }
1878
1879     /* 5 ms redundant frame for SILK->CELT */
1880     if (redundancy && !celt_to_silk)
1881     {
1882         int err;
1883         unsigned char dummy[2];
1884         int N2, N4;
1885         N2 = st->Fs/200;
1886         N4 = st->Fs/400;
1887
1888         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1889         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1890         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1891
1892         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1893         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL);
1894
1895         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1896         if (err < 0)
1897         {
1898            RESTORE_STACK;
1899            return OPUS_INTERNAL_ERROR;
1900         }
1901         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1902     }
1903
1904
1905
1906     /* Signalling the mode in the first byte */
1907     data--;
1908     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1909
1910     st->rangeFinal = enc.rng ^ redundant_rng;
1911
1912     if (to_celt)
1913         st->prev_mode = MODE_CELT_ONLY;
1914     else
1915         st->prev_mode = st->mode;
1916     st->prev_channels = st->stream_channels;
1917     st->prev_framesize = frame_size;
1918
1919     st->first = 0;
1920
1921     /* In the unlikely case that the SILK encoder busted its target, tell
1922        the decoder to call the PLC */
1923     if (ec_tell(&enc) > (max_data_bytes-1)*8)
1924     {
1925        if (max_data_bytes < 2)
1926        {
1927           RESTORE_STACK;
1928           return OPUS_BUFFER_TOO_SMALL;
1929        }
1930        data[1] = 0;
1931        ret = 1;
1932        st->rangeFinal = 0;
1933     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
1934     {
1935        /*When in LPC only mode it's perfectly
1936          reasonable to strip off trailing zero bytes as
1937          the required range decoder behavior is to
1938          fill these in. This can't be done when the MDCT
1939          modes are used because the decoder needs to know
1940          the actual length for allocation purposes.*/
1941        while(ret>2&&data[ret]==0)ret--;
1942     }
1943     /* Count ToC and redundancy */
1944     ret += 1+redundancy_bytes;
1945     if (!st->use_vbr)
1946     {
1947        if (opus_packet_pad(data, ret, max_data_bytes) != OPUS_OK)
1948
1949        {
1950           RESTORE_STACK;
1951           return OPUS_INTERNAL_ERROR;
1952        }
1953        ret = max_data_bytes;
1954     }
1955     RESTORE_STACK;
1956     return ret;
1957 }
1958
1959 #ifdef FIXED_POINT
1960
1961 #ifndef DISABLE_FLOAT_API
1962 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int analysis_frame_size,
1963       unsigned char *data, opus_int32 max_data_bytes)
1964 {
1965    int i, ret;
1966    int frame_size;
1967    int delay_compensation;
1968    VARDECL(opus_int16, in);
1969    ALLOC_STACK;
1970
1971    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1972       delay_compensation = 0;
1973    else
1974       delay_compensation = st->delay_compensation;
1975    frame_size = compute_frame_size(pcm, analysis_frame_size,
1976          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
1977          delay_compensation, downmix_float, st->analysis.subframe_mem);
1978
1979    ALLOC(in, frame_size*st->channels, opus_int16);
1980
1981    for (i=0;i<frame_size*st->channels;i++)
1982       in[i] = FLOAT2INT16(pcm[i]);
1983    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16,
1984                             pcm, analysis_frame_size, 0, -2, st->channels, downmix_float, 1);
1985    RESTORE_STACK;
1986    return ret;
1987 }
1988 #endif
1989
1990 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int analysis_frame_size,
1991                 unsigned char *data, opus_int32 out_data_bytes)
1992 {
1993    int frame_size;
1994    int delay_compensation;
1995    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1996       delay_compensation = 0;
1997    else
1998       delay_compensation = st->delay_compensation;
1999    frame_size = compute_frame_size(pcm, analysis_frame_size,
2000          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2001          delay_compensation, downmix_int
2002 #ifndef DISABLE_FLOAT_API
2003          , st->analysis.subframe_mem
2004 #endif
2005          );
2006    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 16,
2007                              pcm, analysis_frame_size, 0, -2, st->channels, downmix_int, 0);
2008 }
2009
2010 #else
2011 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int analysis_frame_size,
2012       unsigned char *data, opus_int32 max_data_bytes)
2013 {
2014    int i, ret;
2015    int frame_size;
2016    int delay_compensation;
2017    VARDECL(float, in);
2018    ALLOC_STACK;
2019
2020    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2021       delay_compensation = 0;
2022    else
2023       delay_compensation = st->delay_compensation;
2024    frame_size = compute_frame_size(pcm, analysis_frame_size,
2025          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2026          delay_compensation, downmix_int, st->analysis.subframe_mem);
2027
2028    ALLOC(in, frame_size*st->channels, float);
2029
2030    for (i=0;i<frame_size*st->channels;i++)
2031       in[i] = (1.0f/32768)*pcm[i];
2032    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16,
2033                             pcm, analysis_frame_size, 0, -2, st->channels, downmix_int, 0);
2034    RESTORE_STACK;
2035    return ret;
2036 }
2037 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int analysis_frame_size,
2038                       unsigned char *data, opus_int32 out_data_bytes)
2039 {
2040    int frame_size;
2041    int delay_compensation;
2042    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2043       delay_compensation = 0;
2044    else
2045       delay_compensation = st->delay_compensation;
2046    frame_size = compute_frame_size(pcm, analysis_frame_size,
2047          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2048          delay_compensation, downmix_float, st->analysis.subframe_mem);
2049    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 24,
2050                              pcm, analysis_frame_size, 0, -2, st->channels, downmix_float, 1);
2051 }
2052 #endif
2053
2054
2055 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
2056 {
2057     int ret;
2058     CELTEncoder *celt_enc;
2059     va_list ap;
2060
2061     ret = OPUS_OK;
2062     va_start(ap, request);
2063
2064     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
2065
2066     switch (request)
2067     {
2068         case OPUS_SET_APPLICATION_REQUEST:
2069         {
2070             opus_int32 value = va_arg(ap, opus_int32);
2071             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
2072                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2073                || (!st->first && st->application != value))
2074             {
2075                ret = OPUS_BAD_ARG;
2076                break;
2077             }
2078             st->application = value;
2079         }
2080         break;
2081         case OPUS_GET_APPLICATION_REQUEST:
2082         {
2083             opus_int32 *value = va_arg(ap, opus_int32*);
2084             if (!value)
2085             {
2086                goto bad_arg;
2087             }
2088             *value = st->application;
2089         }
2090         break;
2091         case OPUS_SET_BITRATE_REQUEST:
2092         {
2093             opus_int32 value = va_arg(ap, opus_int32);
2094             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
2095             {
2096                 if (value <= 0)
2097                     goto bad_arg;
2098                 else if (value <= 500)
2099                     value = 500;
2100                 else if (value > (opus_int32)300000*st->channels)
2101                     value = (opus_int32)300000*st->channels;
2102             }
2103             st->user_bitrate_bps = value;
2104         }
2105         break;
2106         case OPUS_GET_BITRATE_REQUEST:
2107         {
2108             opus_int32 *value = va_arg(ap, opus_int32*);
2109             if (!value)
2110             {
2111                goto bad_arg;
2112             }
2113             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
2114         }
2115         break;
2116         case OPUS_SET_FORCE_CHANNELS_REQUEST:
2117         {
2118             opus_int32 value = va_arg(ap, opus_int32);
2119             if((value<1 || value>st->channels) && value != OPUS_AUTO)
2120             {
2121                goto bad_arg;
2122             }
2123             st->force_channels = value;
2124         }
2125         break;
2126         case OPUS_GET_FORCE_CHANNELS_REQUEST:
2127         {
2128             opus_int32 *value = va_arg(ap, opus_int32*);
2129             if (!value)
2130             {
2131                goto bad_arg;
2132             }
2133             *value = st->force_channels;
2134         }
2135         break;
2136         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
2137         {
2138             opus_int32 value = va_arg(ap, opus_int32);
2139             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND)
2140             {
2141                goto bad_arg;
2142             }
2143             st->max_bandwidth = value;
2144             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2145                 st->silk_mode.maxInternalSampleRate = 8000;
2146             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2147                 st->silk_mode.maxInternalSampleRate = 12000;
2148             } else {
2149                 st->silk_mode.maxInternalSampleRate = 16000;
2150             }
2151         }
2152         break;
2153         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
2154         {
2155             opus_int32 *value = va_arg(ap, opus_int32*);
2156             if (!value)
2157             {
2158                goto bad_arg;
2159             }
2160             *value = st->max_bandwidth;
2161         }
2162         break;
2163         case OPUS_SET_BANDWIDTH_REQUEST:
2164         {
2165             opus_int32 value = va_arg(ap, opus_int32);
2166             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
2167             {
2168                goto bad_arg;
2169             }
2170             st->user_bandwidth = value;
2171             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2172                 st->silk_mode.maxInternalSampleRate = 8000;
2173             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2174                 st->silk_mode.maxInternalSampleRate = 12000;
2175             } else {
2176                 st->silk_mode.maxInternalSampleRate = 16000;
2177             }
2178         }
2179         break;
2180         case OPUS_GET_BANDWIDTH_REQUEST:
2181         {
2182             opus_int32 *value = va_arg(ap, opus_int32*);
2183             if (!value)
2184             {
2185                goto bad_arg;
2186             }
2187             *value = st->bandwidth;
2188         }
2189         break;
2190         case OPUS_SET_DTX_REQUEST:
2191         {
2192             opus_int32 value = va_arg(ap, opus_int32);
2193             if(value<0 || value>1)
2194             {
2195                goto bad_arg;
2196             }
2197             st->silk_mode.useDTX = value;
2198         }
2199         break;
2200         case OPUS_GET_DTX_REQUEST:
2201         {
2202             opus_int32 *value = va_arg(ap, opus_int32*);
2203             if (!value)
2204             {
2205                goto bad_arg;
2206             }
2207             *value = st->silk_mode.useDTX;
2208         }
2209         break;
2210         case OPUS_SET_COMPLEXITY_REQUEST:
2211         {
2212             opus_int32 value = va_arg(ap, opus_int32);
2213             if(value<0 || value>10)
2214             {
2215                goto bad_arg;
2216             }
2217             st->silk_mode.complexity = value;
2218             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
2219         }
2220         break;
2221         case OPUS_GET_COMPLEXITY_REQUEST:
2222         {
2223             opus_int32 *value = va_arg(ap, opus_int32*);
2224             if (!value)
2225             {
2226                goto bad_arg;
2227             }
2228             *value = st->silk_mode.complexity;
2229         }
2230         break;
2231         case OPUS_SET_INBAND_FEC_REQUEST:
2232         {
2233             opus_int32 value = va_arg(ap, opus_int32);
2234             if(value<0 || value>1)
2235             {
2236                goto bad_arg;
2237             }
2238             st->silk_mode.useInBandFEC = value;
2239         }
2240         break;
2241         case OPUS_GET_INBAND_FEC_REQUEST:
2242         {
2243             opus_int32 *value = va_arg(ap, opus_int32*);
2244             if (!value)
2245             {
2246                goto bad_arg;
2247             }
2248             *value = st->silk_mode.useInBandFEC;
2249         }
2250         break;
2251         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
2252         {
2253             opus_int32 value = va_arg(ap, opus_int32);
2254             if (value < 0 || value > 100)
2255             {
2256                goto bad_arg;
2257             }
2258             st->silk_mode.packetLossPercentage = value;
2259             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
2260         }
2261         break;
2262         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
2263         {
2264             opus_int32 *value = va_arg(ap, opus_int32*);
2265             if (!value)
2266             {
2267                goto bad_arg;
2268             }
2269             *value = st->silk_mode.packetLossPercentage;
2270         }
2271         break;
2272         case OPUS_SET_VBR_REQUEST:
2273         {
2274             opus_int32 value = va_arg(ap, opus_int32);
2275             if(value<0 || value>1)
2276             {
2277                goto bad_arg;
2278             }
2279             st->use_vbr = value;
2280             st->silk_mode.useCBR = 1-value;
2281         }
2282         break;
2283         case OPUS_GET_VBR_REQUEST:
2284         {
2285             opus_int32 *value = va_arg(ap, opus_int32*);
2286             if (!value)
2287             {
2288                goto bad_arg;
2289             }
2290             *value = st->use_vbr;
2291         }
2292         break;
2293         case OPUS_SET_VOICE_RATIO_REQUEST:
2294         {
2295             opus_int32 value = va_arg(ap, opus_int32);
2296             if (value<-1 || value>100)
2297             {
2298                goto bad_arg;
2299             }
2300             st->voice_ratio = value;
2301         }
2302         break;
2303         case OPUS_GET_VOICE_RATIO_REQUEST:
2304         {
2305             opus_int32 *value = va_arg(ap, opus_int32*);
2306             if (!value)
2307             {
2308                goto bad_arg;
2309             }
2310             *value = st->voice_ratio;
2311         }
2312         break;
2313         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
2314         {
2315             opus_int32 value = va_arg(ap, opus_int32);
2316             if(value<0 || value>1)
2317             {
2318                goto bad_arg;
2319             }
2320             st->vbr_constraint = value;
2321         }
2322         break;
2323         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
2324         {
2325             opus_int32 *value = va_arg(ap, opus_int32*);
2326             if (!value)
2327             {
2328                goto bad_arg;
2329             }
2330             *value = st->vbr_constraint;
2331         }
2332         break;
2333         case OPUS_SET_SIGNAL_REQUEST:
2334         {
2335             opus_int32 value = va_arg(ap, opus_int32);
2336             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
2337             {
2338                goto bad_arg;
2339             }
2340             st->signal_type = value;
2341         }
2342         break;
2343         case OPUS_GET_SIGNAL_REQUEST:
2344         {
2345             opus_int32 *value = va_arg(ap, opus_int32*);
2346             if (!value)
2347             {
2348                goto bad_arg;
2349             }
2350             *value = st->signal_type;
2351         }
2352         break;
2353         case OPUS_GET_LOOKAHEAD_REQUEST:
2354         {
2355             opus_int32 *value = va_arg(ap, opus_int32*);
2356             if (!value)
2357             {
2358                goto bad_arg;
2359             }
2360             *value = st->Fs/400;
2361             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2362                 *value += st->delay_compensation;
2363         }
2364         break;
2365         case OPUS_GET_SAMPLE_RATE_REQUEST:
2366         {
2367             opus_int32 *value = va_arg(ap, opus_int32*);
2368             if (!value)
2369             {
2370                goto bad_arg;
2371             }
2372             *value = st->Fs;
2373         }
2374         break;
2375         case OPUS_GET_FINAL_RANGE_REQUEST:
2376         {
2377             opus_uint32 *value = va_arg(ap, opus_uint32*);
2378             if (!value)
2379             {
2380                goto bad_arg;
2381             }
2382             *value = st->rangeFinal;
2383         }
2384         break;
2385         case OPUS_SET_LSB_DEPTH_REQUEST:
2386         {
2387             opus_int32 value = va_arg(ap, opus_int32);
2388             if (value<8 || value>24)
2389             {
2390                goto bad_arg;
2391             }
2392             st->lsb_depth=value;
2393         }
2394         break;
2395         case OPUS_GET_LSB_DEPTH_REQUEST:
2396         {
2397             opus_int32 *value = va_arg(ap, opus_int32*);
2398             if (!value)
2399             {
2400                goto bad_arg;
2401             }
2402             *value = st->lsb_depth;
2403         }
2404         break;
2405         case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
2406         {
2407             opus_int32 value = va_arg(ap, opus_int32);
2408             if (value != OPUS_FRAMESIZE_ARG   && value != OPUS_FRAMESIZE_2_5_MS &&
2409                 value != OPUS_FRAMESIZE_5_MS  && value != OPUS_FRAMESIZE_10_MS  &&
2410                 value != OPUS_FRAMESIZE_20_MS && value != OPUS_FRAMESIZE_40_MS  &&
2411                 value != OPUS_FRAMESIZE_60_MS && value != OPUS_FRAMESIZE_VARIABLE)
2412             {
2413                goto bad_arg;
2414             }
2415             st->variable_duration = value;
2416             celt_encoder_ctl(celt_enc, OPUS_SET_EXPERT_FRAME_DURATION(value));
2417         }
2418         break;
2419         case OPUS_GET_EXPERT_FRAME_DURATION_REQUEST:
2420         {
2421             opus_int32 *value = va_arg(ap, opus_int32*);
2422             if (!value)
2423             {
2424                goto bad_arg;
2425             }
2426             *value = st->variable_duration;
2427         }
2428         break;
2429         case OPUS_SET_PREDICTION_DISABLED_REQUEST:
2430         {
2431            opus_int32 value = va_arg(ap, opus_int32);
2432            if (value > 1 || value < 0)
2433               goto bad_arg;
2434            st->silk_mode.reducedDependency = value;
2435         }
2436         break;
2437         case OPUS_GET_PREDICTION_DISABLED_REQUEST:
2438         {
2439            opus_int32 *value = va_arg(ap, opus_int32*);
2440            if (!value)
2441               goto bad_arg;
2442            *value = st->silk_mode.reducedDependency;
2443         }
2444         break;
2445         case OPUS_RESET_STATE:
2446         {
2447            void *silk_enc;
2448            silk_EncControlStruct dummy;
2449            silk_enc = (char*)st+st->silk_enc_offset;
2450
2451            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
2452                  sizeof(OpusEncoder)-
2453                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
2454
2455            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2456            silk_InitEncoder( silk_enc, st->arch, &dummy );
2457            st->stream_channels = st->channels;
2458            st->hybrid_stereo_width_Q14 = 1 << 14;
2459            st->prev_HB_gain = Q15ONE;
2460            st->first = 1;
2461            st->mode = MODE_HYBRID;
2462            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
2463            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
2464         }
2465         break;
2466         case OPUS_SET_FORCE_MODE_REQUEST:
2467         {
2468             opus_int32 value = va_arg(ap, opus_int32);
2469             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
2470             {
2471                goto bad_arg;
2472             }
2473             st->user_forced_mode = value;
2474         }
2475         break;
2476         case OPUS_SET_LFE_REQUEST:
2477         {
2478             opus_int32 value = va_arg(ap, opus_int32);
2479             st->lfe = value;
2480             ret = celt_encoder_ctl(celt_enc, OPUS_SET_LFE(value));
2481         }
2482         break;
2483         case OPUS_SET_ENERGY_MASK_REQUEST:
2484         {
2485             opus_val16 *value = va_arg(ap, opus_val16*);
2486             st->energy_masking = value;
2487             ret = celt_encoder_ctl(celt_enc, OPUS_SET_ENERGY_MASK(value));
2488         }
2489         break;
2490
2491         case CELT_GET_MODE_REQUEST:
2492         {
2493            const CELTMode ** value = va_arg(ap, const CELTMode**);
2494            if (!value)
2495            {
2496               goto bad_arg;
2497            }
2498            ret = celt_encoder_ctl(celt_enc, CELT_GET_MODE(value));
2499         }
2500         break;
2501         default:
2502             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
2503             ret = OPUS_UNIMPLEMENTED;
2504             break;
2505     }
2506     va_end(ap);
2507     return ret;
2508 bad_arg:
2509     va_end(ap);
2510     return OPUS_BAD_ARG;
2511 }
2512
2513 void opus_encoder_destroy(OpusEncoder *st)
2514 {
2515     opus_free(st);
2516 }