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