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