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