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