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