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