Analysis scaling fixes
[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     int          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         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
1482         st->silk_mode.nChannelsAPI = st->channels;
1483         st->silk_mode.nChannelsInternal = st->stream_channels;
1484         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1485             st->silk_mode.desiredInternalSampleRate = 8000;
1486         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1487             st->silk_mode.desiredInternalSampleRate = 12000;
1488         } else {
1489             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
1490             st->silk_mode.desiredInternalSampleRate = 16000;
1491         }
1492         if( st->mode == MODE_HYBRID ) {
1493             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
1494             st->silk_mode.minInternalSampleRate = 16000;
1495         } else {
1496             st->silk_mode.minInternalSampleRate = 8000;
1497         }
1498
1499         if (st->mode == MODE_SILK_ONLY)
1500         {
1501            opus_int32 effective_max_rate = max_rate;
1502            st->silk_mode.maxInternalSampleRate = 16000;
1503            if (frame_rate > 50)
1504               effective_max_rate = effective_max_rate*2/3;
1505            if (effective_max_rate < 13000)
1506            {
1507               st->silk_mode.maxInternalSampleRate = 12000;
1508               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
1509            }
1510            if (effective_max_rate < 9600)
1511            {
1512               st->silk_mode.maxInternalSampleRate = 8000;
1513               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
1514            }
1515         } else {
1516            st->silk_mode.maxInternalSampleRate = 16000;
1517         }
1518
1519         st->silk_mode.useCBR = !st->use_vbr;
1520
1521         /* Call SILK encoder for the low band */
1522         nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes);
1523
1524         st->silk_mode.maxBits = nBytes*8;
1525         /* Only allow up to 90% of the bits for hybrid mode*/
1526         if (st->mode == MODE_HYBRID)
1527            st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
1528         if (st->silk_mode.useCBR)
1529         {
1530            st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
1531            /* Reduce the initial target to make it easier to reach the CBR rate */
1532            st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000);
1533         }
1534
1535         if (prefill)
1536         {
1537             opus_int32 zero=0;
1538             int prefill_offset;
1539             /* Use a smooth onset for the SILK prefill to avoid the encoder trying to encode
1540                a discontinuity. The exact location is what we need to avoid leaving any "gap"
1541                in the audio when mixing with the redundant CELT frame. Here we can afford to
1542                overwrite st->delay_buffer because the only thing that uses it before it gets
1543                rewritten is tmp_prefill[] and even then only the part after the ramp really
1544                gets used (rather than sent to the encoder and discarded) */
1545             prefill_offset = st->channels*(st->encoder_buffer-st->delay_compensation-st->Fs/400);
1546             gain_fade(st->delay_buffer+prefill_offset, st->delay_buffer+prefill_offset,
1547                   0, Q15ONE, celt_mode->overlap, st->Fs/400, st->channels, celt_mode->window, st->Fs);
1548             for(i=0;i<prefill_offset;i++)
1549                st->delay_buffer[i]=0;
1550 #ifdef FIXED_POINT
1551             pcm_silk = st->delay_buffer;
1552 #else
1553             for (i=0;i<st->encoder_buffer*st->channels;i++)
1554                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
1555 #endif
1556             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
1557         }
1558
1559 #ifdef FIXED_POINT
1560         pcm_silk = pcm_buf+total_buffer*st->channels;
1561 #else
1562         for (i=0;i<frame_size*st->channels;i++)
1563             pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
1564 #endif
1565         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
1566         if( ret ) {
1567             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
1568             /* Handle error */
1569            RESTORE_STACK;
1570            return OPUS_INTERNAL_ERROR;
1571         }
1572         if (nBytes==0)
1573         {
1574            st->rangeFinal = 0;
1575            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1576            RESTORE_STACK;
1577            return 1;
1578         }
1579         /* Extract SILK internal bandwidth for signaling in first byte */
1580         if( st->mode == MODE_SILK_ONLY ) {
1581             if( st->silk_mode.internalSampleRate == 8000 ) {
1582                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1583             } else if( st->silk_mode.internalSampleRate == 12000 ) {
1584                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1585             } else if( st->silk_mode.internalSampleRate == 16000 ) {
1586                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1587             }
1588         } else {
1589             silk_assert( st->silk_mode.internalSampleRate == 16000 );
1590         }
1591
1592         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
1593         /* FIXME: How do we allocate the redundancy for CBR? */
1594         if (st->silk_mode.opusCanSwitch)
1595         {
1596            redundancy = 1;
1597            celt_to_silk = 0;
1598            st->silk_bw_switch = 1;
1599         }
1600     }
1601
1602     /* CELT processing */
1603     {
1604         int endband=21;
1605
1606         switch(curr_bandwidth)
1607         {
1608             case OPUS_BANDWIDTH_NARROWBAND:
1609                 endband = 13;
1610                 break;
1611             case OPUS_BANDWIDTH_MEDIUMBAND:
1612             case OPUS_BANDWIDTH_WIDEBAND:
1613                 endband = 17;
1614                 break;
1615             case OPUS_BANDWIDTH_SUPERWIDEBAND:
1616                 endband = 19;
1617                 break;
1618             case OPUS_BANDWIDTH_FULLBAND:
1619                 endband = 21;
1620                 break;
1621         }
1622         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
1623         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
1624     }
1625     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1626     if (st->mode != MODE_SILK_ONLY)
1627     {
1628         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1629         /* Allow prediction unless we decide to disable it later */
1630         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
1631
1632         if (st->mode == MODE_HYBRID)
1633         {
1634             int len;
1635
1636             len = (ec_tell(&enc)+7)>>3;
1637             if (redundancy)
1638                len += st->mode == MODE_HYBRID ? 3 : 1;
1639             if( st->use_vbr ) {
1640                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
1641             } else {
1642                 /* check if SILK used up too much */
1643                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
1644             }
1645         } else {
1646             if (st->use_vbr)
1647             {
1648                 opus_int32 bonus=0;
1649 #ifndef DISABLE_FLOAT_API
1650                 if (st->variable_duration==OPUS_FRAMESIZE_VARIABLE && frame_size != st->Fs/50)
1651                 {
1652                    bonus = (60*st->stream_channels+40)*(st->Fs/frame_size-50);
1653                    if (analysis_info.valid)
1654                       bonus = (opus_int32)(bonus*(1.f+.5f*analysis_info.tonality));
1655                 }
1656 #endif
1657                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
1658                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
1659                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps+bonus));
1660                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
1661             } else {
1662                 nb_compr_bytes = bytes_target;
1663             }
1664         }
1665
1666     } else {
1667         nb_compr_bytes = 0;
1668     }
1669
1670     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
1671     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
1672     {
1673        for (i=0;i<st->channels*st->Fs/400;i++)
1674           tmp_prefill[i] = st->delay_buffer[(st->encoder_buffer-total_buffer-st->Fs/400)*st->channels + i];
1675     }
1676
1677     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+total_buffer));i++)
1678         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
1679     for (;i<st->encoder_buffer*st->channels;i++)
1680         st->delay_buffer[i] = pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels+i];
1681
1682     /* gain_fade() and stereo_fade() need to be after the buffer copying
1683        because we don't want any of this to affect the SILK part */
1684     if( st->prev_HB_gain < Q15ONE || HB_gain < Q15ONE ) {
1685        gain_fade(pcm_buf, pcm_buf,
1686              st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs);
1687     }
1688     st->prev_HB_gain = HB_gain;
1689     if (st->mode != MODE_HYBRID || st->stream_channels==1)
1690        st->silk_mode.stereoWidth_Q14 = IMIN((1<<14),IMAX(0,st->bitrate_bps-32000));
1691     if( !st->energy_masking && st->channels == 2 ) {
1692         /* Apply stereo width reduction (at low bitrates) */
1693         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1694             opus_val16 g1, g2;
1695             g1 = st->hybrid_stereo_width_Q14;
1696             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1697 #ifdef FIXED_POINT
1698             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
1699             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
1700 #else
1701             g1 *= (1.f/16384);
1702             g2 *= (1.f/16384);
1703 #endif
1704             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
1705                   frame_size, st->channels, celt_mode->window, st->Fs);
1706             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1707         }
1708     }
1709
1710     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
1711     {
1712         /* For SILK mode, the redundancy is inferred from the length */
1713         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
1714            ec_enc_bit_logp(&enc, redundancy, 12);
1715         if (redundancy)
1716         {
1717             int max_redundancy;
1718             ec_enc_bit_logp(&enc, celt_to_silk, 1);
1719             if (st->mode == MODE_HYBRID)
1720                max_redundancy = (max_data_bytes-1)-nb_compr_bytes-1;
1721             else
1722                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1723             /* Target the same bit-rate for redundancy as for the rest,
1724                up to a max of 257 bytes */
1725             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
1726             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
1727             if (st->mode == MODE_HYBRID)
1728                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
1729         }
1730     } else {
1731         redundancy = 0;
1732     }
1733
1734     if (!redundancy)
1735     {
1736        st->silk_bw_switch = 0;
1737        redundancy_bytes = 0;
1738     }
1739     if (st->mode != MODE_CELT_ONLY)start_band=17;
1740
1741     if (st->mode == MODE_SILK_ONLY)
1742     {
1743         ret = (ec_tell(&enc)+7)>>3;
1744         ec_enc_done(&enc);
1745         nb_compr_bytes = ret;
1746     } else {
1747        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
1748        ec_enc_shrink(&enc, nb_compr_bytes);
1749     }
1750
1751 #ifndef DISABLE_FLOAT_API
1752     if (redundancy || st->mode != MODE_SILK_ONLY)
1753        celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(&analysis_info));
1754 #endif
1755
1756     /* 5 ms redundant frame for CELT->SILK */
1757     if (redundancy && celt_to_silk)
1758     {
1759         int err;
1760         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1761         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1762         err = celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
1763         if (err < 0)
1764         {
1765            RESTORE_STACK;
1766            return OPUS_INTERNAL_ERROR;
1767         }
1768         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1769         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1770     }
1771
1772     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
1773
1774     if (st->mode != MODE_SILK_ONLY)
1775     {
1776         if (st->mode != st->prev_mode && st->prev_mode > 0)
1777         {
1778            unsigned char dummy[2];
1779            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1780
1781            /* Prefilling */
1782            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
1783            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1784         }
1785         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
1786         if (ec_tell(&enc) <= 8*nb_compr_bytes)
1787         {
1788            ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
1789            if (ret < 0)
1790            {
1791               RESTORE_STACK;
1792               return OPUS_INTERNAL_ERROR;
1793            }
1794         }
1795     }
1796
1797     /* 5 ms redundant frame for SILK->CELT */
1798     if (redundancy && !celt_to_silk)
1799     {
1800         int err;
1801         unsigned char dummy[2];
1802         int N2, N4;
1803         N2 = st->Fs/200;
1804         N4 = st->Fs/400;
1805
1806         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1807         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1808         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1809
1810         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1811         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL);
1812
1813         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1814         if (err < 0)
1815         {
1816            RESTORE_STACK;
1817            return OPUS_INTERNAL_ERROR;
1818         }
1819         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1820     }
1821
1822
1823
1824     /* Signalling the mode in the first byte */
1825     data--;
1826     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1827
1828     st->rangeFinal = enc.rng ^ redundant_rng;
1829
1830     if (to_celt)
1831         st->prev_mode = MODE_CELT_ONLY;
1832     else
1833         st->prev_mode = st->mode;
1834     st->prev_channels = st->stream_channels;
1835     st->prev_framesize = frame_size;
1836
1837     st->first = 0;
1838
1839     /* In the unlikely case that the SILK encoder busted its target, tell
1840        the decoder to call the PLC */
1841     if (ec_tell(&enc) > (max_data_bytes-1)*8)
1842     {
1843        if (max_data_bytes < 2)
1844        {
1845           RESTORE_STACK;
1846           return OPUS_BUFFER_TOO_SMALL;
1847        }
1848        data[1] = 0;
1849        ret = 1;
1850        st->rangeFinal = 0;
1851     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
1852     {
1853        /*When in LPC only mode it's perfectly
1854          reasonable to strip off trailing zero bytes as
1855          the required range decoder behavior is to
1856          fill these in. This can't be done when the MDCT
1857          modes are used because the decoder needs to know
1858          the actual length for allocation purposes.*/
1859        while(ret>2&&data[ret]==0)ret--;
1860     }
1861     /* Count ToC and redundancy */
1862     ret += 1+redundancy_bytes;
1863     if (!st->use_vbr && ret >= 3)
1864     {
1865        if (pad_frame(data, ret, max_data_bytes))
1866        {
1867           RESTORE_STACK;
1868           return OPUS_INTERNAL_ERROR;
1869        }
1870        ret = max_data_bytes;
1871     }
1872     RESTORE_STACK;
1873     return ret;
1874 }
1875
1876 #ifdef FIXED_POINT
1877
1878 #ifndef DISABLE_FLOAT_API
1879 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1880       unsigned char *data, opus_int32 max_data_bytes)
1881 {
1882    int i, ret;
1883    VARDECL(opus_int16, in);
1884    ALLOC_STACK;
1885
1886    frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1887    if(frame_size<0)
1888    {
1889       RESTORE_STACK;
1890       return OPUS_BAD_ARG;
1891    }
1892
1893    ALLOC(in, frame_size*st->channels, opus_int16);
1894
1895    for (i=0;i<frame_size*st->channels;i++)
1896       in[i] = FLOAT2INT16(pcm[i]);
1897    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16, pcm, 0, -2, st->channels, downmix_float);
1898    RESTORE_STACK;
1899    return ret;
1900 }
1901 #endif
1902
1903 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1904                 unsigned char *data, opus_int32 out_data_bytes)
1905 {
1906    frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1907    if(frame_size<0)
1908    {
1909       return OPUS_BAD_ARG;
1910    }
1911    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 16, pcm, 0, -2, st->channels, downmix_int);
1912 }
1913
1914 #else
1915 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1916       unsigned char *data, opus_int32 max_data_bytes)
1917 {
1918    int i, ret;
1919    VARDECL(float, in);
1920    ALLOC_STACK;
1921
1922    ALLOC(in, frame_size*st->channels, float);
1923
1924    for (i=0;i<frame_size*st->channels;i++)
1925       in[i] = (1.0f/32768)*pcm[i];
1926    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16, pcm, 0, -2, st->channels, downmix_int);
1927    RESTORE_STACK;
1928    return ret;
1929 }
1930 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1931                       unsigned char *data, opus_int32 out_data_bytes)
1932 {
1933    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 24, pcm, 0, -2, st->channels, downmix_float);
1934 }
1935 #endif
1936
1937
1938 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
1939 {
1940     int ret;
1941     CELTEncoder *celt_enc;
1942     va_list ap;
1943
1944     ret = OPUS_OK;
1945     va_start(ap, request);
1946
1947     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1948
1949     switch (request)
1950     {
1951         case OPUS_SET_APPLICATION_REQUEST:
1952         {
1953             opus_int32 value = va_arg(ap, opus_int32);
1954             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
1955                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1956                || (!st->first && st->application != value))
1957             {
1958                ret = OPUS_BAD_ARG;
1959                break;
1960             }
1961             st->application = value;
1962         }
1963         break;
1964         case OPUS_GET_APPLICATION_REQUEST:
1965         {
1966             opus_int32 *value = va_arg(ap, opus_int32*);
1967             if (!value)
1968             {
1969                goto bad_arg;
1970             }
1971             *value = st->application;
1972         }
1973         break;
1974         case OPUS_SET_BITRATE_REQUEST:
1975         {
1976             opus_int32 value = va_arg(ap, opus_int32);
1977             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1978             {
1979                 if (value <= 0)
1980                     goto bad_arg;
1981                 else if (value <= 500)
1982                     value = 500;
1983                 else if (value > (opus_int32)300000*st->channels)
1984                     value = (opus_int32)300000*st->channels;
1985             }
1986             st->user_bitrate_bps = value;
1987         }
1988         break;
1989         case OPUS_GET_BITRATE_REQUEST:
1990         {
1991             opus_int32 *value = va_arg(ap, opus_int32*);
1992             if (!value)
1993             {
1994                goto bad_arg;
1995             }
1996             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
1997         }
1998         break;
1999         case OPUS_SET_FORCE_CHANNELS_REQUEST:
2000         {
2001             opus_int32 value = va_arg(ap, opus_int32);
2002             if((value<1 || value>st->channels) && value != OPUS_AUTO)
2003             {
2004                goto bad_arg;
2005             }
2006             st->force_channels = value;
2007         }
2008         break;
2009         case OPUS_GET_FORCE_CHANNELS_REQUEST:
2010         {
2011             opus_int32 *value = va_arg(ap, opus_int32*);
2012             if (!value)
2013             {
2014                goto bad_arg;
2015             }
2016             *value = st->force_channels;
2017         }
2018         break;
2019         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
2020         {
2021             opus_int32 value = va_arg(ap, opus_int32);
2022             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) 
2023             {
2024                goto bad_arg;
2025             }
2026             st->max_bandwidth = value;
2027             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2028                 st->silk_mode.maxInternalSampleRate = 8000;
2029             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2030                 st->silk_mode.maxInternalSampleRate = 12000;
2031             } else {
2032                 st->silk_mode.maxInternalSampleRate = 16000;
2033             }
2034         }
2035         break;
2036         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
2037         {
2038             opus_int32 *value = va_arg(ap, opus_int32*);
2039             if (!value)
2040             {
2041                goto bad_arg;
2042             }
2043             *value = st->max_bandwidth;
2044         }
2045         break;
2046         case OPUS_SET_BANDWIDTH_REQUEST:
2047         {
2048             opus_int32 value = va_arg(ap, opus_int32);
2049             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
2050             {
2051                goto bad_arg;
2052             }
2053             st->user_bandwidth = value;
2054             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2055                 st->silk_mode.maxInternalSampleRate = 8000;
2056             } else if (st->user_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_BANDWIDTH_REQUEST:
2064         {
2065             opus_int32 *value = va_arg(ap, opus_int32*);
2066             if (!value)
2067             {
2068                goto bad_arg;
2069             }
2070             *value = st->bandwidth;
2071         }
2072         break;
2073         case OPUS_SET_DTX_REQUEST:
2074         {
2075             opus_int32 value = va_arg(ap, opus_int32);
2076             if(value<0 || value>1)
2077             {
2078                goto bad_arg;
2079             }
2080             st->silk_mode.useDTX = value;
2081         }
2082         break;
2083         case OPUS_GET_DTX_REQUEST:
2084         {
2085             opus_int32 *value = va_arg(ap, opus_int32*);
2086             if (!value)
2087             {
2088                goto bad_arg;
2089             }
2090             *value = st->silk_mode.useDTX;
2091         }
2092         break;
2093         case OPUS_SET_COMPLEXITY_REQUEST:
2094         {
2095             opus_int32 value = va_arg(ap, opus_int32);
2096             if(value<0 || value>10)
2097             {
2098                goto bad_arg;
2099             }
2100             st->silk_mode.complexity = value;
2101             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
2102         }
2103         break;
2104         case OPUS_GET_COMPLEXITY_REQUEST:
2105         {
2106             opus_int32 *value = va_arg(ap, opus_int32*);
2107             if (!value)
2108             {
2109                goto bad_arg;
2110             }
2111             *value = st->silk_mode.complexity;
2112         }
2113         break;
2114         case OPUS_SET_INBAND_FEC_REQUEST:
2115         {
2116             opus_int32 value = va_arg(ap, opus_int32);
2117             if(value<0 || value>1)
2118             {
2119                goto bad_arg;
2120             }
2121             st->silk_mode.useInBandFEC = value;
2122         }
2123         break;
2124         case OPUS_GET_INBAND_FEC_REQUEST:
2125         {
2126             opus_int32 *value = va_arg(ap, opus_int32*);
2127             if (!value)
2128             {
2129                goto bad_arg;
2130             }
2131             *value = st->silk_mode.useInBandFEC;
2132         }
2133         break;
2134         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
2135         {
2136             opus_int32 value = va_arg(ap, opus_int32);
2137             if (value < 0 || value > 100)
2138             {
2139                goto bad_arg;
2140             }
2141             st->silk_mode.packetLossPercentage = value;
2142             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
2143         }
2144         break;
2145         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
2146         {
2147             opus_int32 *value = va_arg(ap, opus_int32*);
2148             if (!value)
2149             {
2150                goto bad_arg;
2151             }
2152             *value = st->silk_mode.packetLossPercentage;
2153         }
2154         break;
2155         case OPUS_SET_VBR_REQUEST:
2156         {
2157             opus_int32 value = va_arg(ap, opus_int32);
2158             if(value<0 || value>1)
2159             {
2160                goto bad_arg;
2161             }
2162             st->use_vbr = value;
2163             st->silk_mode.useCBR = 1-value;
2164         }
2165         break;
2166         case OPUS_GET_VBR_REQUEST:
2167         {
2168             opus_int32 *value = va_arg(ap, opus_int32*);
2169             if (!value)
2170             {
2171                goto bad_arg;
2172             }
2173             *value = st->use_vbr;
2174         }
2175         break;
2176         case OPUS_SET_VOICE_RATIO_REQUEST:
2177         {
2178             opus_int32 value = va_arg(ap, opus_int32);
2179             if (value<-1 || value>100)
2180             {
2181                goto bad_arg;
2182             }
2183             st->voice_ratio = value;
2184         }
2185         break;
2186         case OPUS_GET_VOICE_RATIO_REQUEST:
2187         {
2188             opus_int32 *value = va_arg(ap, opus_int32*);
2189             if (!value)
2190             {
2191                goto bad_arg;
2192             }
2193             *value = st->voice_ratio;
2194         }
2195         break;
2196         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
2197         {
2198             opus_int32 value = va_arg(ap, opus_int32);
2199             if(value<0 || value>1)
2200             {
2201                goto bad_arg;
2202             }
2203             st->vbr_constraint = value;
2204         }
2205         break;
2206         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
2207         {
2208             opus_int32 *value = va_arg(ap, opus_int32*);
2209             if (!value)
2210             {
2211                goto bad_arg;
2212             }
2213             *value = st->vbr_constraint;
2214         }
2215         break;
2216         case OPUS_SET_SIGNAL_REQUEST:
2217         {
2218             opus_int32 value = va_arg(ap, opus_int32);
2219             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
2220             {
2221                goto bad_arg;
2222             }
2223             st->signal_type = value;
2224         }
2225         break;
2226         case OPUS_GET_SIGNAL_REQUEST:
2227         {
2228             opus_int32 *value = va_arg(ap, opus_int32*);
2229             if (!value)
2230             {
2231                goto bad_arg;
2232             }
2233             *value = st->signal_type;
2234         }
2235         break;
2236         case OPUS_GET_LOOKAHEAD_REQUEST:
2237         {
2238             opus_int32 *value = va_arg(ap, opus_int32*);
2239             if (!value)
2240             {
2241                goto bad_arg;
2242             }
2243             *value = st->Fs/400;
2244             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2245                 *value += st->delay_compensation;
2246         }
2247         break;
2248         case OPUS_GET_SAMPLE_RATE_REQUEST:
2249         {
2250             opus_int32 *value = va_arg(ap, opus_int32*);
2251             if (!value)
2252             {
2253                goto bad_arg;
2254             }
2255             *value = st->Fs;
2256         }
2257         break;
2258         case OPUS_GET_FINAL_RANGE_REQUEST:
2259         {
2260             opus_uint32 *value = va_arg(ap, opus_uint32*);
2261             if (!value)
2262             {
2263                goto bad_arg;
2264             }
2265             *value = st->rangeFinal;
2266         }
2267         break;
2268         case OPUS_SET_LSB_DEPTH_REQUEST:
2269         {
2270             opus_int32 value = va_arg(ap, opus_int32);
2271             if (value<8 || value>24)
2272             {
2273                goto bad_arg;
2274             }
2275             st->lsb_depth=value;
2276         }
2277         break;
2278         case OPUS_GET_LSB_DEPTH_REQUEST:
2279         {
2280             opus_int32 *value = va_arg(ap, opus_int32*);
2281             if (!value)
2282             {
2283                goto bad_arg;
2284             }
2285             *value = st->lsb_depth;
2286         }
2287         break;
2288         case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
2289         {
2290             opus_int32 value = va_arg(ap, opus_int32);
2291             if (value != OPUS_FRAMESIZE_ARG   && value != OPUS_FRAMESIZE_2_5_MS &&
2292                 value != OPUS_FRAMESIZE_5_MS  && value != OPUS_FRAMESIZE_10_MS  &&
2293                 value != OPUS_FRAMESIZE_20_MS && value != OPUS_FRAMESIZE_40_MS  &&
2294                 value != OPUS_FRAMESIZE_60_MS && value != OPUS_FRAMESIZE_VARIABLE)
2295             {
2296                goto bad_arg;
2297             }
2298             st->variable_duration = value;
2299             celt_encoder_ctl(celt_enc, OPUS_SET_EXPERT_FRAME_DURATION(value));
2300         }
2301         break;
2302         case OPUS_GET_EXPERT_FRAME_DURATION_REQUEST:
2303         {
2304             opus_int32 *value = va_arg(ap, opus_int32*);
2305             if (!value)
2306             {
2307                goto bad_arg;
2308             }
2309             *value = st->variable_duration;
2310         }
2311         break;
2312         case OPUS_RESET_STATE:
2313         {
2314            void *silk_enc;
2315            silk_EncControlStruct dummy;
2316            silk_enc = (char*)st+st->silk_enc_offset;
2317
2318            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
2319                  sizeof(OpusEncoder)-
2320                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
2321
2322            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2323            silk_InitEncoder( silk_enc, &dummy );
2324            st->stream_channels = st->channels;
2325            st->hybrid_stereo_width_Q14 = 1 << 14;
2326            st->prev_HB_gain = Q15ONE;
2327            st->first = 1;
2328            st->mode = MODE_HYBRID;
2329            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
2330            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
2331         }
2332         break;
2333         case OPUS_SET_FORCE_MODE_REQUEST:
2334         {
2335             opus_int32 value = va_arg(ap, opus_int32);
2336             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
2337             {
2338                goto bad_arg;
2339             }
2340             st->user_forced_mode = value;
2341         }
2342         break;
2343         case OPUS_SET_LFE_REQUEST:
2344         {
2345             opus_int32 value = va_arg(ap, opus_int32);
2346             st->lfe = value;
2347             ret = celt_encoder_ctl(celt_enc, OPUS_SET_LFE(value));
2348         }
2349         break;
2350         case OPUS_SET_ENERGY_MASK_REQUEST:
2351         {
2352             opus_val16 *value = va_arg(ap, opus_val16*);
2353             st->energy_masking = (value!=NULL);
2354             ret = celt_encoder_ctl(celt_enc, OPUS_SET_ENERGY_MASK(value));
2355         }
2356         break;
2357
2358         case CELT_GET_MODE_REQUEST:
2359         {
2360            const CELTMode ** value = va_arg(ap, const CELTMode**);
2361            if (!value)
2362            {
2363               goto bad_arg;
2364            }
2365            ret = celt_encoder_ctl(celt_enc, CELT_GET_MODE(value));
2366         }
2367         break;
2368         default:
2369             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
2370             ret = OPUS_UNIMPLEMENTED;
2371             break;
2372     }
2373     va_end(ap);
2374     return ret;
2375 bad_arg:
2376     va_end(ap);
2377     return OPUS_BAD_ARG;
2378 }
2379
2380 void opus_encoder_destroy(OpusEncoder *st)
2381 {
2382     opus_free(st);
2383 }