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