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