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