Use dynamic stack allocation in the SILK encoder.
[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 "opus_private.h"
42 #include "os_support.h"
43 #include "analysis.h"
44 #include "mathops.h"
45 #include "tuning_parameters.h"
46 #ifdef FIXED_POINT
47 #include "fixed/structs_FIX.h"
48 #else
49 #include "float/structs_FLP.h"
50 #endif
51
52 #define MAX_ENCODER_BUFFER 480
53
54 typedef struct {
55    opus_val32 XX, XY, YY;
56    opus_val16 smoothed_width;
57    opus_val16 max_follower;
58 } StereoWidthState;
59
60 struct OpusEncoder {
61     int          celt_enc_offset;
62     int          silk_enc_offset;
63     silk_EncControlStruct silk_mode;
64     int          application;
65     int          channels;
66     int          delay_compensation;
67     int          force_channels;
68     int          signal_type;
69     int          user_bandwidth;
70     int          max_bandwidth;
71     int          user_forced_mode;
72     int          voice_ratio;
73     opus_int32   Fs;
74     int          use_vbr;
75     int          vbr_constraint;
76     int          variable_duration;
77     opus_int32   bitrate_bps;
78     opus_int32   user_bitrate_bps;
79     int          lsb_depth;
80     int          encoder_buffer;
81
82 #define OPUS_ENCODER_RESET_START stream_channels
83     int          stream_channels;
84     opus_int16   hybrid_stereo_width_Q14;
85     opus_int32   variable_HP_smth2_Q15;
86     opus_val16   prev_HB_gain;
87     opus_val32   hp_mem[4];
88     int          mode;
89     int          prev_mode;
90     int          prev_channels;
91     int          prev_framesize;
92     int          bandwidth;
93     int          silk_bw_switch;
94     /* Sampling rate (at the API level) */
95     int          first;
96     StereoWidthState width_mem;
97     opus_val16   delay_buffer[MAX_ENCODER_BUFFER*2];
98 #ifndef FIXED_POINT
99     TonalityAnalysisState analysis;
100     int          detected_bandwidth;
101     int          analysis_offset;
102 #endif
103     opus_uint32  rangeFinal;
104 };
105
106 /* Transition tables for the voice and music. First column is the
107    middle (memoriless) threshold. The second column is the hysteresis
108    (difference with the middle) */
109 static const opus_int32 mono_voice_bandwidth_thresholds[8] = {
110         11000, 1000, /* NB<->MB */
111         14000, 1000, /* MB<->WB */
112         17000, 1000, /* WB<->SWB */
113         20000, 1000, /* SWB<->FB */
114 };
115 static const opus_int32 mono_music_bandwidth_thresholds[8] = {
116         14000, 1000, /* MB not allowed */
117         18000, 2000, /* MB<->WB */
118         24000, 2000, /* WB<->SWB */
119         33000, 2000, /* SWB<->FB */
120 };
121 static const opus_int32 stereo_voice_bandwidth_thresholds[8] = {
122         11000, 1000, /* NB<->MB */
123         14000, 1000, /* MB<->WB */
124         21000, 2000, /* WB<->SWB */
125         32000, 2000, /* SWB<->FB */
126 };
127 static const opus_int32 stereo_music_bandwidth_thresholds[8] = {
128         14000, 1000, /* MB not allowed */
129         18000, 2000, /* MB<->WB */
130         24000, 2000, /* WB<->SWB */
131         48000, 2000, /* SWB<->FB */
132 };
133 /* Threshold bit-rates for switching between mono and stereo */
134 static const opus_int32 stereo_voice_threshold = 31000;
135 static const opus_int32 stereo_music_threshold = 31000;
136
137 /* Threshold bit-rate for switching between SILK/hybrid and CELT-only */
138 static const opus_int32 mode_thresholds[2][2] = {
139       /* voice */ /* music */
140       {  64000,      20000}, /* mono */
141       {  36000,      20000}, /* stereo */
142 };
143
144 int opus_encoder_get_size(int channels)
145 {
146     int silkEncSizeBytes, celtEncSizeBytes;
147     int ret;
148     if (channels<1 || channels > 2)
149         return 0;
150     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
151     if (ret)
152         return 0;
153     silkEncSizeBytes = align(silkEncSizeBytes);
154     celtEncSizeBytes = celt_encoder_get_size(channels);
155     return align(sizeof(OpusEncoder))+silkEncSizeBytes+celtEncSizeBytes;
156 }
157
158 int opus_encoder_init(OpusEncoder* st, opus_int32 Fs, int channels, int application)
159 {
160     void *silk_enc;
161     CELTEncoder *celt_enc;
162     int err;
163     int ret, silkEncSizeBytes;
164
165    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
166         (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
167         && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
168         return OPUS_BAD_ARG;
169
170     OPUS_CLEAR((char*)st, opus_encoder_get_size(channels));
171     /* Create SILK encoder */
172     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
173     if (ret)
174         return OPUS_BAD_ARG;
175     silkEncSizeBytes = align(silkEncSizeBytes);
176     st->silk_enc_offset = align(sizeof(OpusEncoder));
177     st->celt_enc_offset = st->silk_enc_offset+silkEncSizeBytes;
178     silk_enc = (char*)st+st->silk_enc_offset;
179     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
180
181     st->stream_channels = st->channels = channels;
182
183     st->Fs = Fs;
184
185     ret = silk_InitEncoder( silk_enc, &st->silk_mode );
186     if(ret)return OPUS_INTERNAL_ERROR;
187
188     /* default SILK parameters */
189     st->silk_mode.nChannelsAPI              = channels;
190     st->silk_mode.nChannelsInternal         = channels;
191     st->silk_mode.API_sampleRate            = st->Fs;
192     st->silk_mode.maxInternalSampleRate     = 16000;
193     st->silk_mode.minInternalSampleRate     = 8000;
194     st->silk_mode.desiredInternalSampleRate = 16000;
195     st->silk_mode.payloadSize_ms            = 20;
196     st->silk_mode.bitRate                   = 25000;
197     st->silk_mode.packetLossPercentage      = 0;
198     st->silk_mode.complexity                = 10;
199     st->silk_mode.useInBandFEC              = 0;
200     st->silk_mode.useDTX                    = 0;
201     st->silk_mode.useCBR                    = 0;
202
203     /* Create CELT encoder */
204     /* Initialize CELT encoder */
205     err = celt_encoder_init(celt_enc, Fs, channels);
206     if(err!=OPUS_OK)return OPUS_INTERNAL_ERROR;
207
208     celt_encoder_ctl(celt_enc, CELT_SET_SIGNALLING(0));
209     celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(10));
210
211     st->use_vbr = 1;
212     /* Makes constrained VBR the default (safer for real-time use) */
213     st->vbr_constraint = 1;
214     st->user_bitrate_bps = OPUS_AUTO;
215     st->bitrate_bps = 3000+Fs*channels;
216     st->application = application;
217     st->signal_type = OPUS_AUTO;
218     st->user_bandwidth = OPUS_AUTO;
219     st->max_bandwidth = OPUS_BANDWIDTH_FULLBAND;
220     st->force_channels = OPUS_AUTO;
221     st->user_forced_mode = OPUS_AUTO;
222     st->voice_ratio = -1;
223     st->encoder_buffer = st->Fs/100;
224     st->lsb_depth = 24;
225     st->variable_duration = OPUS_FRAMESIZE_ARG;
226
227     /* Delay compensation of 4 ms (2.5 ms for SILK's extra look-ahead 
228        + 1.5 ms for SILK resamplers and stereo prediction) */
229     st->delay_compensation = st->Fs/250;
230
231     st->hybrid_stereo_width_Q14 = 1 << 14;
232     st->prev_HB_gain = Q15ONE;
233     st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
234     st->first = 1;
235     st->mode = MODE_HYBRID;
236     st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
237
238     return OPUS_OK;
239 }
240
241 static int pad_frame(unsigned char *data, opus_int32 len, opus_int32 new_len)
242 {
243    if (len == new_len)
244       return 0;
245    if (len > new_len)
246       return 1;
247
248    if ((data[0]&0x3)==0)
249    {
250       int i;
251       int padding, nb_255s;
252
253       padding = new_len - len;
254       if (padding >= 2)
255       {
256          nb_255s = (padding-2)/255;
257
258          for (i=len-1;i>=1;i--)
259             data[i+nb_255s+2] = data[i];
260          data[0] |= 0x3;
261          data[1] = 0x41;
262          for (i=0;i<nb_255s;i++)
263             data[i+2] = 255;
264          data[nb_255s+2] = padding-255*nb_255s-2;
265          for (i=len+3+nb_255s;i<new_len;i++)
266             data[i] = 0;
267       } else {
268          for (i=len-1;i>=1;i--)
269             data[i+1] = data[i];
270          data[0] |= 0x3;
271          data[1] = 1;
272       }
273       return 0;
274    } else {
275       return 1;
276    }
277 }
278
279 static unsigned char gen_toc(int mode, int framerate, int bandwidth, int channels)
280 {
281    int period;
282    unsigned char toc;
283    period = 0;
284    while (framerate < 400)
285    {
286        framerate <<= 1;
287        period++;
288    }
289    if (mode == MODE_SILK_ONLY)
290    {
291        toc = (bandwidth-OPUS_BANDWIDTH_NARROWBAND)<<5;
292        toc |= (period-2)<<3;
293    } else if (mode == MODE_CELT_ONLY)
294    {
295        int tmp = bandwidth-OPUS_BANDWIDTH_MEDIUMBAND;
296        if (tmp < 0)
297            tmp = 0;
298        toc = 0x80;
299        toc |= tmp << 5;
300        toc |= period<<3;
301    } else /* Hybrid */
302    {
303        toc = 0x60;
304        toc |= (bandwidth-OPUS_BANDWIDTH_SUPERWIDEBAND)<<4;
305        toc |= (period-2)<<3;
306    }
307    toc |= (channels==2)<<2;
308    return toc;
309 }
310
311 #ifndef FIXED_POINT
312 static void silk_biquad_float(
313     const opus_val16      *in,            /* I:    Input signal                   */
314     const opus_int32      *B_Q28,         /* I:    MA coefficients [3]            */
315     const opus_int32      *A_Q28,         /* I:    AR coefficients [2]            */
316     opus_val32            *S,             /* I/O:  State vector [2]               */
317     opus_val16            *out,           /* O:    Output signal                  */
318     const opus_int32      len,            /* I:    Signal length (must be even)   */
319     int stride
320 )
321 {
322     /* DIRECT FORM II TRANSPOSED (uses 2 element state vector) */
323     opus_int   k;
324     opus_val32 vout;
325     opus_val32 inval;
326     opus_val32 A[2], B[3];
327
328     A[0] = (opus_val32)(A_Q28[0] * (1.f/((opus_int32)1<<28)));
329     A[1] = (opus_val32)(A_Q28[1] * (1.f/((opus_int32)1<<28)));
330     B[0] = (opus_val32)(B_Q28[0] * (1.f/((opus_int32)1<<28)));
331     B[1] = (opus_val32)(B_Q28[1] * (1.f/((opus_int32)1<<28)));
332     B[2] = (opus_val32)(B_Q28[2] * (1.f/((opus_int32)1<<28)));
333
334     /* Negate A_Q28 values and split in two parts */
335
336     for( k = 0; k < len; k++ ) {
337         /* S[ 0 ], S[ 1 ]: Q12 */
338         inval = in[ k*stride ];
339         vout = S[ 0 ] + B[0]*inval;
340
341         S[ 0 ] = S[1] - vout*A[0] + B[1]*inval;
342
343         S[ 1 ] = - vout*A[1] + B[2]*inval;
344
345         /* Scale back to Q0 and saturate */
346         out[ k*stride ] = vout;
347     }
348 }
349 #endif
350
351 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)
352 {
353    opus_int32 B_Q28[ 3 ], A_Q28[ 2 ];
354    opus_int32 Fc_Q19, r_Q28, r_Q22;
355
356    silk_assert( cutoff_Hz <= silk_int32_MAX / SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ) );
357    Fc_Q19 = silk_DIV32_16( silk_SMULBB( SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ), cutoff_Hz ), Fs/1000 );
358    silk_assert( Fc_Q19 > 0 && Fc_Q19 < 32768 );
359
360    r_Q28 = SILK_FIX_CONST( 1.0, 28 ) - silk_MUL( SILK_FIX_CONST( 0.92, 9 ), Fc_Q19 );
361
362    /* b = r * [ 1; -2; 1 ]; */
363    /* a = [ 1; -2 * r * ( 1 - 0.5 * Fc^2 ); r^2 ]; */
364    B_Q28[ 0 ] = r_Q28;
365    B_Q28[ 1 ] = silk_LSHIFT( -r_Q28, 1 );
366    B_Q28[ 2 ] = r_Q28;
367
368    /* -r * ( 2 - Fc * Fc ); */
369    r_Q22  = silk_RSHIFT( r_Q28, 6 );
370    A_Q28[ 0 ] = silk_SMULWW( r_Q22, silk_SMULWW( Fc_Q19, Fc_Q19 ) - SILK_FIX_CONST( 2.0,  22 ) );
371    A_Q28[ 1 ] = silk_SMULWW( r_Q22, r_Q22 );
372
373 #ifdef FIXED_POINT
374    silk_biquad_alt( in, B_Q28, A_Q28, hp_mem, out, len, channels );
375    if( channels == 2 ) {
376        silk_biquad_alt( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
377    }
378 #else
379    silk_biquad_float( in, B_Q28, A_Q28, hp_mem, out, len, channels );
380    if( channels == 2 ) {
381        silk_biquad_float( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
382    }
383 #endif
384 }
385
386 #ifdef FIXED_POINT
387 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)
388 {
389    int c, i;
390    int shift;
391
392    /* Approximates -round(log2(4.*cutoff_Hz/Fs)) */
393    shift=celt_ilog2(Fs/(cutoff_Hz*3));
394    for (c=0;c<channels;c++)
395    {
396       for (i=0;i<len;i++)
397       {
398          opus_val32 x, tmp, y;
399          x = SHL32(EXTEND32(in[channels*i+c]), 15);
400          /* First stage */
401          tmp = x-hp_mem[2*c];
402          hp_mem[2*c] = hp_mem[2*c] + PSHR32(x - hp_mem[2*c], shift);
403          /* Second stage */
404          y = tmp - hp_mem[2*c+1];
405          hp_mem[2*c+1] = hp_mem[2*c+1] + PSHR32(tmp - hp_mem[2*c+1], shift);
406          out[channels*i+c] = EXTRACT16(SATURATE(PSHR32(y, 15), 32767));
407       }
408    }
409 }
410
411 #else
412 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)
413 {
414    int c, i;
415    float coef;
416
417    coef = 4.0f*cutoff_Hz/Fs;
418    for (c=0;c<channels;c++)
419    {
420       for (i=0;i<len;i++)
421       {
422          opus_val32 x, tmp, y;
423          x = in[channels*i+c];
424          /* First stage */
425          tmp = x-hp_mem[2*c];
426          hp_mem[2*c] = hp_mem[2*c] + coef*(x - hp_mem[2*c]);
427          /* Second stage */
428          y = tmp - hp_mem[2*c+1];
429          hp_mem[2*c+1] = hp_mem[2*c+1] + coef*(tmp - hp_mem[2*c+1]);
430          out[channels*i+c] = y;
431       }
432    }
433 }
434 #endif
435
436 static void stereo_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2,
437         int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
438 {
439     int i;
440     int overlap;
441     int inc;
442     inc = 48000/Fs;
443     overlap=overlap48/inc;
444     g1 = Q15ONE-g1;
445     g2 = Q15ONE-g2;
446     for (i=0;i<overlap;i++)
447     {
448        opus_val32 diff;
449        opus_val16 g, w;
450        w = MULT16_16_Q15(window[i*inc], window[i*inc]);
451        g = SHR32(MAC16_16(MULT16_16(w,g2),
452              Q15ONE-w, g1), 15);
453        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
454        diff = MULT16_16_Q15(g, diff);
455        out[i*channels] = out[i*channels] - diff;
456        out[i*channels+1] = out[i*channels+1] + diff;
457     }
458     for (;i<frame_size;i++)
459     {
460        opus_val32 diff;
461        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
462        diff = MULT16_16_Q15(g2, diff);
463        out[i*channels] = out[i*channels] - diff;
464        out[i*channels+1] = out[i*channels+1] + diff;
465     }
466 }
467
468 static void gain_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2,
469         int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
470 {
471     int i;
472     int inc;
473     int overlap;
474     int c;
475     inc = 48000/Fs;
476     overlap=overlap48/inc;
477     if (channels==1)
478     {
479        for (i=0;i<overlap;i++)
480        {
481           opus_val16 g, w;
482           w = MULT16_16_Q15(window[i*inc], window[i*inc]);
483           g = SHR32(MAC16_16(MULT16_16(w,g2),
484                 Q15ONE-w, g1), 15);
485           out[i] = MULT16_16_Q15(g, in[i]);
486        }
487     } else {
488        for (i=0;i<overlap;i++)
489        {
490           opus_val16 g, w;
491           w = MULT16_16_Q15(window[i*inc], window[i*inc]);
492           g = SHR32(MAC16_16(MULT16_16(w,g2),
493                 Q15ONE-w, g1), 15);
494           out[i*2] = MULT16_16_Q15(g, in[i*2]);
495           out[i*2+1] = MULT16_16_Q15(g, in[i*2+1]);
496        }
497     }
498     c=0;do {
499        for (i=overlap;i<frame_size;i++)
500        {
501           out[i*channels+c] = MULT16_16_Q15(g2, in[i*channels+c]);
502        }
503     }
504     while (++c<channels);
505 }
506
507 OpusEncoder *opus_encoder_create(opus_int32 Fs, int channels, int application, int *error)
508 {
509    int ret;
510    OpusEncoder *st;
511    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
512        (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
513        && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
514    {
515       if (error)
516          *error = OPUS_BAD_ARG;
517       return NULL;
518    }
519    st = (OpusEncoder *)opus_alloc(opus_encoder_get_size(channels));
520    if (st == NULL)
521    {
522       if (error)
523          *error = OPUS_ALLOC_FAIL;
524       return NULL;
525    }
526    ret = opus_encoder_init(st, Fs, channels, application);
527    if (error)
528       *error = ret;
529    if (ret != OPUS_OK)
530    {
531       opus_free(st);
532       st = NULL;
533    }
534    return st;
535 }
536
537 static opus_int32 user_bitrate_to_bitrate(OpusEncoder *st, int frame_size, int max_data_bytes)
538 {
539   if(!frame_size)frame_size=st->Fs/400;
540   if (st->user_bitrate_bps==OPUS_AUTO)
541     return 60*st->Fs/frame_size + st->Fs*st->channels;
542   else if (st->user_bitrate_bps==OPUS_BITRATE_MAX)
543     return max_data_bytes*8*st->Fs/frame_size;
544   else
545     return st->user_bitrate_bps;
546 }
547
548 #ifndef FIXED_POINT
549 /* Don't use more than 60 ms for the frame size analysis */
550 #define MAX_DYNAMIC_FRAMESIZE 24
551 /* Estimates how much the bitrate will be boosted based on the sub-frame energy */
552 static float transient_boost(const float *E, const float *E_1, int LM, int maxM)
553 {
554    int i;
555    int M;
556    float sumE=0, sumE_1=0;
557    float metric;
558
559    M = IMIN(maxM, (1<<LM)+1);
560    for (i=0;i<M;i++)
561    {
562       sumE += E[i];
563       sumE_1 += E_1[i];
564    }
565    metric = sumE*sumE_1/(M*M);
566    /*if (LM==3)
567       printf("%f\n", metric);*/
568    /*return metric>10 ? 1 : 0;*/
569    /*return MAX16(0,1-exp(-.25*(metric-2.)));*/
570    return MIN16(1,sqrt(MAX16(0,.05*(metric-2))));
571 }
572
573 /* Viterbi decoding trying to find the best frame size combination using look-ahead
574
575    State numbering:
576     0: unused
577     1:  2.5 ms
578     2:  5 ms (#1)
579     3:  5 ms (#2)
580     4: 10 ms (#1)
581     5: 10 ms (#2)
582     6: 10 ms (#3)
583     7: 10 ms (#4)
584     8: 20 ms (#1)
585     9: 20 ms (#2)
586    10: 20 ms (#3)
587    11: 20 ms (#4)
588    12: 20 ms (#5)
589    13: 20 ms (#6)
590    14: 20 ms (#7)
591    15: 20 ms (#8)
592 */
593 static int transient_viterbi(const float *E, const float *E_1, int N, int frame_cost, int rate)
594 {
595    int i;
596    float cost[MAX_DYNAMIC_FRAMESIZE][16];
597    int states[MAX_DYNAMIC_FRAMESIZE][16];
598    float best_cost;
599    int best_state;
600    float factor;
601    /* Take into account that we damp VBR in the 32 kb/s to 64 kb/s range. */
602    if (rate<80)
603       factor=0;
604    else if (rate>160)
605       factor=1;
606    else
607       factor = (rate-80.f)/80.f;
608    /* Makes variable framesize less aggressive at lower bitrates, but I can't
609       find any valid theoretical justification for this (other than it seems
610       to help) */
611    for (i=0;i<16;i++)
612    {
613       /* Impossible state */
614       states[0][i] = -1;
615       cost[0][i] = 1e10;
616    }
617    for (i=0;i<4;i++)
618    {
619       cost[0][1<<i] = (frame_cost + rate*(1<<i))*(1+factor*transient_boost(E, E_1, i, N+1));
620       states[0][1<<i] = i;
621    }
622    for (i=1;i<N;i++)
623    {
624       int j;
625
626       /* Follow continuations */
627       for (j=2;j<16;j++)
628       {
629          cost[i][j] = cost[i-1][j-1];
630          states[i][j] = j-1;
631       }
632
633       /* New frames */
634       for(j=0;j<4;j++)
635       {
636          int k;
637          float min_cost;
638          float curr_cost;
639          states[i][1<<j] = 1;
640          min_cost = cost[i-1][1];
641          for(k=1;k<4;k++)
642          {
643             float tmp = cost[i-1][(1<<(k+1))-1];
644             if (tmp < min_cost)
645             {
646                states[i][1<<j] = (1<<(k+1))-1;
647                min_cost = tmp;
648             }
649          }
650          curr_cost = (frame_cost + rate*(1<<j))*(1+factor*transient_boost(E+i, E_1+i, j, N-i+1));
651          cost[i][1<<j] = min_cost;
652          /* If part of the frame is outside the analysis window, only count part of the cost */
653          if (N-i < (1<<j))
654             cost[i][1<<j] += curr_cost*(float)(N-i)/(1<<j);
655          else
656             cost[i][1<<j] += curr_cost;
657       }
658    }
659
660    best_state=1;
661    best_cost = cost[N-1][1];
662    /* Find best end state (doesn't force a frame to end at N-1) */
663    for (i=2;i<16;i++)
664    {
665       if (cost[N-1][i]<best_cost)
666       {
667          best_cost = cost[N-1][i];
668          best_state = i;
669       }
670    }
671
672    /* Follow transitions back */
673    for (i=N-1;i>=0;i--)
674    {
675       /*printf("%d ", best_state);*/
676       best_state = states[i][best_state];
677    }
678    /*printf("%d\n", best_state);*/
679    return best_state;
680 }
681
682 void downmix_float(const void *_x, float *sub, int subframe, int offset, int C)
683 {
684    const float *x;
685    int c, j;
686    x = (const float *)_x;
687    for (j=0;j<subframe;j++)
688       sub[j] = x[(j+offset)*C];
689    for (c=1;c<C;c++)
690       for (j=0;j<subframe;j++)
691          sub[j] += x[(j+offset)*C+c];
692 }
693
694 void downmix_int(const void *_x, float *sub, int subframe, int offset, int C)
695 {
696    const opus_int16 *x;
697    int c, j;
698    x = (const opus_int16 *)_x;
699    for (j=0;j<subframe;j++)
700       sub[j] = x[(j+offset)*C];
701    for (c=1;c<C;c++)
702       for (j=0;j<subframe;j++)
703          sub[j] += x[(j+offset)*C+c];
704    for (j=0;j<subframe;j++)
705       sub[j] *= (1.f/32768);
706 }
707
708 int optimize_framesize(const opus_val16 *x, int len, int C, opus_int32 Fs,
709                 int bitrate, opus_val16 tonality, opus_val32 *mem, int buffering,
710                 downmix_func downmix)
711 {
712    int N;
713    int i;
714    float e[MAX_DYNAMIC_FRAMESIZE+4];
715    float e_1[MAX_DYNAMIC_FRAMESIZE+3];
716    float memx;
717    int bestLM=0;
718    int subframe;
719    int pos;
720    VARDECL(opus_val16, sub);
721
722    subframe = Fs/400;
723    ALLOC(sub, subframe, opus_val16);
724    e[0]=mem[0];
725    e_1[0]=1./(EPSILON+mem[0]);
726    if (buffering)
727    {
728       /* Consider the CELT delay when not in restricted-lowdelay */
729       /* We assume the buffering is between 2.5 and 5 ms */
730       int offset = 2*subframe - buffering;
731       celt_assert(offset>=0 && offset <= subframe);
732       x += C*offset;
733       len -= offset;
734       e[1]=mem[1];
735       e_1[1]=1./(EPSILON+mem[1]);
736       e[2]=mem[2];
737       e_1[2]=1./(EPSILON+mem[2]);
738       pos = 3;
739    } else {
740       pos=1;
741    }
742    N=IMIN(len/subframe, MAX_DYNAMIC_FRAMESIZE);
743    memx = x[0];
744    for (i=0;i<N;i++)
745    {
746       float tmp;
747       float tmpx;
748       int j;
749       tmp=EPSILON;
750
751       downmix(x, sub, subframe, i*subframe, C);
752       if (i==0)
753          memx = sub[0];
754       for (j=0;j<subframe;j++)
755       {
756          tmpx = sub[j];
757          tmp += (tmpx-memx)*(tmpx-memx);
758          memx = tmpx;
759       }
760       e[i+pos] = tmp;
761       e_1[i+pos] = 1.f/tmp;
762    }
763    /* Hack to get 20 ms working with APPLICATION_AUDIO
764       The real problem is that the corresponding memory needs to use 1.5 ms
765       from this frame and 1 ms from the next frame */
766    e[i+pos] = e[i+pos-1];
767    if (buffering)
768       N=IMIN(MAX_DYNAMIC_FRAMESIZE, N+2);
769    bestLM = transient_viterbi(e, e_1, N, (1.f+.5*tonality)*(60*C+40), bitrate/400);
770    mem[0] = e[1<<bestLM];
771    if (buffering)
772    {
773       mem[1] = e[(1<<bestLM)+1];
774       mem[2] = e[(1<<bestLM)+2];
775    }
776    return bestLM;
777 }
778
779 #endif
780
781 opus_int32 frame_size_select(opus_int32 frame_size, int variable_duration, opus_int32 Fs)
782 {
783    int new_size;
784    if (frame_size<Fs/400)
785       return -1;
786    if (variable_duration == OPUS_FRAMESIZE_ARG)
787       new_size = frame_size;
788    else if (variable_duration == OPUS_FRAMESIZE_VARIABLE)
789       new_size = Fs/50;
790    else if (variable_duration >= OPUS_FRAMESIZE_2_5_MS && variable_duration <= OPUS_FRAMESIZE_60_MS)
791       new_size = IMIN(3*Fs/50, (Fs/400)<<(variable_duration-OPUS_FRAMESIZE_2_5_MS));
792    else
793       return -1;
794    if (new_size>frame_size)
795       return -1;
796    if (400*new_size!=Fs && 200*new_size!=Fs && 100*new_size!=Fs &&
797             50*new_size!=Fs && 25*new_size!=Fs && 50*new_size!=3*Fs)
798       return -1;
799    return new_size;
800 }
801
802 opus_val16 compute_stereo_width(const opus_val16 *pcm, int frame_size, opus_int32 Fs, StereoWidthState *mem)
803 {
804    opus_val16 corr;
805    opus_val16 ldiff;
806    opus_val16 width;
807    opus_val32 xx, xy, yy;
808    opus_val16 sqrt_xx, sqrt_yy;
809    opus_val16 qrrt_xx, qrrt_yy;
810    int frame_rate;
811    int i;
812    opus_val16 short_alpha;
813
814    frame_rate = Fs/frame_size;
815    short_alpha = Q15ONE - 25*Q15ONE/IMAX(50,frame_rate);
816    xx=xy=yy=0;
817    for (i=0;i<frame_size;i+=4)
818    {
819       opus_val32 pxx=0;
820       opus_val32 pxy=0;
821       opus_val32 pyy=0;
822       opus_val16 x, y;
823       x = pcm[2*i];
824       y = pcm[2*i+1];
825       pxx = SHR32(MULT16_16(x,x),2);
826       pxy = SHR32(MULT16_16(x,y),2);
827       pyy = SHR32(MULT16_16(y,y),2);
828       x = pcm[2*i+2];
829       y = pcm[2*i+3];
830       pxx += SHR32(MULT16_16(x,x),2);
831       pxy += SHR32(MULT16_16(x,y),2);
832       pyy += SHR32(MULT16_16(y,y),2);
833       x = pcm[2*i+4];
834       y = pcm[2*i+5];
835       pxx += SHR32(MULT16_16(x,x),2);
836       pxy += SHR32(MULT16_16(x,y),2);
837       pyy += SHR32(MULT16_16(y,y),2);
838       x = pcm[2*i+6];
839       y = pcm[2*i+7];
840       pxx += SHR32(MULT16_16(x,x),2);
841       pxy += SHR32(MULT16_16(x,y),2);
842       pyy += SHR32(MULT16_16(y,y),2);
843
844       xx += SHR32(pxx, 10);
845       xy += SHR32(pxy, 10);
846       yy += SHR32(pyy, 10);
847    }
848    mem->XX += MULT16_32_Q15(short_alpha, xx-mem->XX);
849    mem->XY += MULT16_32_Q15(short_alpha, xy-mem->XY);
850    mem->YY += MULT16_32_Q15(short_alpha, yy-mem->YY);
851    mem->XX = MAX32(0, mem->XX);
852    mem->XY = MAX32(0, mem->XY);
853    mem->YY = MAX32(0, mem->YY);
854    if (MAX32(mem->XX, mem->YY)>QCONST16(8e-4f, 18))
855    {
856       sqrt_xx = celt_sqrt(mem->XX);
857       sqrt_yy = celt_sqrt(mem->YY);
858       qrrt_xx = celt_sqrt(sqrt_xx);
859       qrrt_yy = celt_sqrt(sqrt_yy);
860       /* Inter-channel correlation */
861       mem->XY = MIN32(mem->XY, sqrt_xx*sqrt_yy);
862       corr = SHR32(frac_div32(mem->XY,EPSILON+MULT16_16(sqrt_xx,sqrt_yy)),16);
863       /* Approximate loudness difference */
864       ldiff = Q15ONE*ABS16(qrrt_xx-qrrt_yy)/(EPSILON+qrrt_xx+qrrt_yy);
865       width = MULT16_16_Q15(celt_sqrt(QCONST32(1.f,30)-MULT16_16(corr,corr)), ldiff);
866       /* Smoothing over one second */
867       mem->smoothed_width += (width-mem->smoothed_width)/frame_rate;
868       /* Peak follower */
869       mem->max_follower = MAX16(mem->max_follower-QCONST16(.02f,15)/frame_rate, mem->smoothed_width);
870    } else {
871       width = 0;
872       corr=Q15ONE;
873       ldiff=0;
874    }
875    /*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);*/
876    return EXTRACT16(MIN32(Q15ONE,20*mem->max_follower));
877 }
878
879 opus_int32 opus_encode_native(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
880                 unsigned char *data, opus_int32 out_data_bytes, int lsb_depth
881 #ifndef FIXED_POINT
882                 , AnalysisInfo *analysis_info
883 #endif
884                 )
885 {
886     void *silk_enc;
887     CELTEncoder *celt_enc;
888     int i;
889     int ret=0;
890     opus_int32 nBytes;
891     ec_enc enc;
892     int bytes_target;
893     int prefill=0;
894     int start_band = 0;
895     int redundancy = 0;
896     int redundancy_bytes = 0; /* Number of bytes to use for redundancy frame */
897     int celt_to_silk = 0;
898     VARDECL(opus_val16, pcm_buf);
899     int nb_compr_bytes;
900     int to_celt = 0;
901     opus_uint32 redundant_rng = 0;
902     int cutoff_Hz, hp_freq_smth1;
903     int voice_est; /* Probability of voice in Q7 */
904     opus_int32 equiv_rate;
905     int delay_compensation;
906     int frame_rate;
907     opus_int32 max_rate; /* Max bitrate we're allowed to use */
908     int curr_bandwidth;
909     opus_val16 HB_gain;
910     opus_int32 max_data_bytes; /* Max number of bytes we're allowed to use */
911     int total_buffer;
912     opus_val16 stereo_width;
913     VARDECL(opus_val16, tmp_prefill);
914
915     ALLOC_STACK;
916
917     max_data_bytes = IMIN(1276, out_data_bytes);
918
919     st->rangeFinal = 0;
920     if ((!st->variable_duration && 400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
921          50*frame_size != st->Fs &&  25*frame_size != st->Fs &&  50*frame_size != 3*st->Fs)
922          || (400*frame_size < st->Fs)
923          || max_data_bytes<=0
924          )
925     {
926        RESTORE_STACK;
927        return OPUS_BAD_ARG;
928     }
929     silk_enc = (char*)st+st->silk_enc_offset;
930     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
931     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
932        delay_compensation = 0;
933     else
934        delay_compensation = st->delay_compensation;
935
936     lsb_depth = IMIN(lsb_depth, st->lsb_depth);
937
938     st->voice_ratio = -1;
939
940 #ifndef FIXED_POINT
941     st->detected_bandwidth = 0;
942     if (analysis_info->valid)
943     {
944        if (st->signal_type == OPUS_AUTO)
945           st->voice_ratio = (int)floor(.5+100*(1-analysis_info->music_prob));
946        st->detected_bandwidth = analysis_info->opus_bandwidth;
947     }
948 #endif
949
950     if (st->channels==2 && st->force_channels!=1)
951        stereo_width = compute_stereo_width(pcm, frame_size, st->Fs, &st->width_mem);
952     else
953        stereo_width = 0;
954     total_buffer = delay_compensation;
955     st->bitrate_bps = user_bitrate_to_bitrate(st, frame_size, max_data_bytes);
956
957     frame_rate = st->Fs/frame_size;
958     if (max_data_bytes<3 || st->bitrate_bps < 3*frame_rate*8
959        || (frame_rate<50 && (max_data_bytes*frame_rate<300 || st->bitrate_bps < 2400)))
960     {
961        /*If the space is too low to do something useful, emit 'PLC' frames.*/
962        int tocmode = st->mode;
963        int bw = st->bandwidth == 0 ? OPUS_BANDWIDTH_NARROWBAND : st->bandwidth;
964        if (tocmode==0)
965           tocmode = MODE_SILK_ONLY;
966        if (frame_rate>100)
967           tocmode = MODE_CELT_ONLY;
968        if (frame_rate < 50)
969           tocmode = MODE_SILK_ONLY;
970        if(tocmode==MODE_SILK_ONLY&&bw>OPUS_BANDWIDTH_WIDEBAND)
971           bw=OPUS_BANDWIDTH_WIDEBAND;
972        else if (tocmode==MODE_CELT_ONLY&&bw==OPUS_BANDWIDTH_MEDIUMBAND)
973           bw=OPUS_BANDWIDTH_NARROWBAND;
974        else if (bw<=OPUS_BANDWIDTH_SUPERWIDEBAND)
975           bw=OPUS_BANDWIDTH_SUPERWIDEBAND;
976        data[0] = gen_toc(tocmode, frame_rate, bw, st->stream_channels);
977        RESTORE_STACK;
978        return 1;
979     }
980     if (!st->use_vbr)
981     {
982        int cbrBytes;
983        cbrBytes = IMIN( (st->bitrate_bps + 4*frame_rate)/(8*frame_rate) , max_data_bytes);
984        st->bitrate_bps = cbrBytes * (8*frame_rate);
985        max_data_bytes = cbrBytes;
986     }
987     max_rate = frame_rate*max_data_bytes*8;
988
989     /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */
990     equiv_rate = st->bitrate_bps - 60*(st->Fs/frame_size - 50);
991
992     if (st->signal_type == OPUS_SIGNAL_VOICE)
993        voice_est = 127;
994     else if (st->signal_type == OPUS_SIGNAL_MUSIC)
995        voice_est = 0;
996     else if (st->voice_ratio >= 0)
997     {
998        voice_est = st->voice_ratio*327>>8;
999        /* For AUDIO, never be more than 90% confident of having speech */
1000        if (st->application == OPUS_APPLICATION_AUDIO)
1001           voice_est = IMIN(voice_est, 115);
1002     } else if (st->application == OPUS_APPLICATION_VOIP)
1003        voice_est = 115;
1004     else
1005        voice_est = 48;
1006
1007     if (st->force_channels!=OPUS_AUTO && st->channels == 2)
1008     {
1009         st->stream_channels = st->force_channels;
1010     } else {
1011 #ifdef FUZZING
1012        /* Random mono/stereo decision */
1013        if (st->channels == 2 && (rand()&0x1F)==0)
1014           st->stream_channels = 3-st->stream_channels;
1015 #else
1016        /* Rate-dependent mono-stereo decision */
1017        if (st->channels == 2)
1018        {
1019           opus_int32 stereo_threshold;
1020           stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14);
1021           if (st->stream_channels == 2)
1022              stereo_threshold -= 1000;
1023           else
1024              stereo_threshold += 1000;
1025           st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1;
1026        } else {
1027           st->stream_channels = st->channels;
1028        }
1029 #endif
1030     }
1031
1032     /* Mode selection depending on application and signal type */
1033     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1034     {
1035        st->mode = MODE_CELT_ONLY;
1036     } else if (st->user_forced_mode == OPUS_AUTO)
1037     {
1038 #ifdef FUZZING
1039        /* Random mode switching */
1040        if ((rand()&0xF)==0)
1041        {
1042           if ((rand()&0x1)==0)
1043              st->mode = MODE_CELT_ONLY;
1044           else
1045              st->mode = MODE_SILK_ONLY;
1046        } else {
1047           if (st->prev_mode==MODE_CELT_ONLY)
1048              st->mode = MODE_CELT_ONLY;
1049           else
1050              st->mode = MODE_SILK_ONLY;
1051        }
1052 #else
1053        opus_int32 mode_voice, mode_music;
1054        opus_int32 threshold;
1055
1056        /* Interpolate based on stereo width */
1057        mode_voice = MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[0][0]) + MULT16_32_Q15(stereo_width,mode_thresholds[1][0]);
1058        mode_music = MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[1][1]) + MULT16_32_Q15(stereo_width,mode_thresholds[1][1]);
1059        /* Interpolate based on speech/music probability */
1060        threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14);
1061        /* Bias towards SILK for VoIP because of some useful features */
1062        if (st->application == OPUS_APPLICATION_VOIP)
1063           threshold += 8000;
1064
1065        /*printf("%f %d\n", stereo_width/(float)Q15ONE, threshold);*/
1066        /* Hysteresis */
1067        if (st->prev_mode == MODE_CELT_ONLY)
1068            threshold -= 4000;
1069        else if (st->prev_mode>0)
1070            threshold += 4000;
1071
1072        st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY;
1073
1074        /* When FEC is enabled and there's enough packet loss, use SILK */
1075        if (st->silk_mode.useInBandFEC && st->silk_mode.packetLossPercentage > (128-voice_est)>>4)
1076           st->mode = MODE_SILK_ONLY;
1077        /* When encoding voice and DTX is enabled, set the encoder to SILK mode (at least for now) */
1078        if (st->silk_mode.useDTX && voice_est > 100)
1079           st->mode = MODE_SILK_ONLY;
1080 #endif
1081     } else {
1082        st->mode = st->user_forced_mode;
1083     }
1084
1085     /* Override the chosen mode to make sure we meet the requested frame size */
1086     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
1087        st->mode = MODE_CELT_ONLY;
1088
1089     if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0
1090           && st->mode != MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)
1091     {
1092        /* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */
1093        st->silk_mode.toMono = 1;
1094        st->stream_channels = 2;
1095     } else {
1096        st->silk_mode.toMono = 0;
1097     }
1098
1099     if (st->prev_mode > 0 &&
1100         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
1101     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
1102     {
1103         redundancy = 1;
1104         celt_to_silk = (st->mode != MODE_CELT_ONLY);
1105         if (!celt_to_silk)
1106         {
1107             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
1108             if (frame_size >= st->Fs/100)
1109             {
1110                 st->mode = st->prev_mode;
1111                 to_celt = 1;
1112             } else {
1113                 redundancy=0;
1114             }
1115         }
1116     }
1117     /* For the first frame at a new SILK bandwidth */
1118     if (st->silk_bw_switch)
1119     {
1120        redundancy = 1;
1121        celt_to_silk = 1;
1122        st->silk_bw_switch = 0;
1123        prefill=1;
1124     }
1125
1126     if (redundancy)
1127     {
1128        /* Fair share of the max size allowed */
1129        redundancy_bytes = IMIN(257, max_data_bytes*(opus_int32)(st->Fs/200)/(frame_size+st->Fs/200));
1130        /* For VBR, target the actual bitrate (subject to the limit above) */
1131        if (st->use_vbr)
1132           redundancy_bytes = IMIN(redundancy_bytes, st->bitrate_bps/1600);
1133     }
1134
1135     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
1136     {
1137         silk_EncControlStruct dummy;
1138         silk_InitEncoder( silk_enc, &dummy);
1139         prefill=1;
1140     }
1141
1142     /* Automatic (rate-dependent) bandwidth selection */
1143     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
1144     {
1145         const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds;
1146         opus_int32 bandwidth_thresholds[8];
1147         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
1148         opus_int32 equiv_rate2;
1149
1150         equiv_rate2 = equiv_rate;
1151         if (st->mode != MODE_CELT_ONLY)
1152         {
1153            /* Adjust the threshold +/- 10% depending on complexity */
1154            equiv_rate2 = equiv_rate2 * (45+st->silk_mode.complexity)/50;
1155            /* CBR is less efficient by ~1 kb/s */
1156            if (!st->use_vbr)
1157               equiv_rate2 -= 1000;
1158         }
1159         if (st->channels==2 && st->force_channels!=1)
1160         {
1161            voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds;
1162            music_bandwidth_thresholds = stereo_music_bandwidth_thresholds;
1163         } else {
1164            voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds;
1165            music_bandwidth_thresholds = mono_music_bandwidth_thresholds;
1166         }
1167         /* Interpolate bandwidth thresholds depending on voice estimation */
1168         for (i=0;i<8;i++)
1169         {
1170            bandwidth_thresholds[i] = music_bandwidth_thresholds[i]
1171                     + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14);
1172         }
1173         do {
1174             int threshold, hysteresis;
1175             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
1176             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
1177             if (!st->first)
1178             {
1179                 if (st->bandwidth >= bandwidth)
1180                     threshold -= hysteresis;
1181                 else
1182                     threshold += hysteresis;
1183             }
1184             if (equiv_rate2 >= threshold)
1185                 break;
1186         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
1187         st->bandwidth = bandwidth;
1188         /* Prevents any transition to SWB/FB until the SILK layer has fully
1189            switched to WB mode and turned the variable LP filter off */
1190         if (!st->first && st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1191             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1192     }
1193
1194     if (st->bandwidth>st->max_bandwidth)
1195        st->bandwidth = st->max_bandwidth;
1196
1197     if (st->user_bandwidth != OPUS_AUTO)
1198         st->bandwidth = st->user_bandwidth;
1199
1200     /* This prevents us from using hybrid at unsafe CBR/max rates */
1201     if (st->mode != MODE_CELT_ONLY && max_rate < 15000)
1202     {
1203        st->bandwidth = IMIN(st->bandwidth, OPUS_BANDWIDTH_WIDEBAND);
1204     }
1205
1206     /* Prevents Opus from wasting bits on frequencies that are above
1207        the Nyquist rate of the input signal */
1208     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
1209         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1210     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1211         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1212     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
1213         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1214     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
1215         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1216 #ifndef FIXED_POINT
1217     /* Use detected bandwidth to reduce the encoded bandwidth. */
1218     if (st->detected_bandwidth && st->user_bandwidth == OPUS_AUTO)
1219     {
1220        /* When operating in SILK/hybrid mode, we don't go below wideband to avoid
1221           more complicated switches that require redundancy */
1222        if (st->mode == MODE_CELT_ONLY)
1223           st->bandwidth = IMIN(st->bandwidth, st->detected_bandwidth);
1224        else
1225           st->bandwidth = IMIN(st->bandwidth, IMAX(OPUS_BANDWIDTH_WIDEBAND, st->detected_bandwidth));
1226     }
1227 #endif
1228     celt_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(lsb_depth));
1229
1230     /* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */
1231     if (max_data_bytes < (frame_rate > 50 ? 12000 : 8000)*frame_size / (st->Fs * 8))
1232        st->mode = MODE_CELT_ONLY;
1233
1234     /* CELT mode doesn't support mediumband, use wideband instead */
1235     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1236         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1237
1238     /* Can't support higher than wideband for >20 ms frames */
1239     if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND))
1240     {
1241        VARDECL(unsigned char, tmp_data);
1242        int nb_frames;
1243        int bak_mode, bak_bandwidth, bak_channels, bak_to_mono;
1244        VARDECL(OpusRepacketizer, rp);
1245        opus_int32 bytes_per_frame;
1246
1247
1248        nb_frames = frame_size > st->Fs/25 ? 3 : 2;
1249        bytes_per_frame = IMIN(1276,(out_data_bytes-3)/nb_frames);
1250
1251        ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char);
1252
1253        ALLOC(rp, 1, OpusRepacketizer);
1254        opus_repacketizer_init(rp);
1255
1256        bak_mode = st->user_forced_mode;
1257        bak_bandwidth = st->user_bandwidth;
1258        bak_channels = st->force_channels;
1259
1260        st->user_forced_mode = st->mode;
1261        st->user_bandwidth = st->bandwidth;
1262        st->force_channels = st->stream_channels;
1263        bak_to_mono = st->silk_mode.toMono;
1264
1265        if (bak_to_mono)
1266           st->force_channels = 1;
1267        else
1268           st->prev_channels = st->stream_channels;
1269        for (i=0;i<nb_frames;i++)
1270        {
1271           int tmp_len;
1272           st->silk_mode.toMono = 0;
1273           /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
1274           if (to_celt && i==nb_frames-1)
1275              st->user_forced_mode = MODE_CELT_ONLY;
1276           tmp_len = opus_encode_native(st, pcm+i*(st->channels*st->Fs/50), st->Fs/50, tmp_data+i*bytes_per_frame, bytes_per_frame, lsb_depth
1277 #ifndef FIXED_POINT
1278                 , analysis_info
1279 #endif
1280                 );
1281           if (tmp_len<0)
1282           {
1283              RESTORE_STACK;
1284              return OPUS_INTERNAL_ERROR;
1285           }
1286           ret = opus_repacketizer_cat(rp, tmp_data+i*bytes_per_frame, tmp_len);
1287           if (ret<0)
1288           {
1289              RESTORE_STACK;
1290              return OPUS_INTERNAL_ERROR;
1291           }
1292        }
1293        ret = opus_repacketizer_out(rp, data, out_data_bytes);
1294        if (ret<0)
1295        {
1296           RESTORE_STACK;
1297           return OPUS_INTERNAL_ERROR;
1298        }
1299        st->user_forced_mode = bak_mode;
1300        st->user_bandwidth = bak_bandwidth;
1301        st->force_channels = bak_channels;
1302        st->silk_mode.toMono = bak_to_mono;
1303        RESTORE_STACK;
1304        return ret;
1305     }
1306     curr_bandwidth = st->bandwidth;
1307
1308     /* Chooses the appropriate mode for speech
1309        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
1310     if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1311         st->mode = MODE_HYBRID;
1312     if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
1313         st->mode = MODE_SILK_ONLY;
1314
1315     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
1316     bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
1317
1318     data += 1;
1319
1320     ec_enc_init(&enc, data, max_data_bytes-1);
1321
1322     ALLOC(pcm_buf, (total_buffer+frame_size)*st->channels, opus_val16);
1323     for (i=0;i<total_buffer*st->channels;i++)
1324        pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-total_buffer)*st->channels+i];
1325
1326     if (st->mode == MODE_CELT_ONLY)
1327        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1328     else
1329        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
1330
1331     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
1332           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
1333
1334     /* convert from log scale to Hertz */
1335     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
1336
1337     if (st->application == OPUS_APPLICATION_VOIP)
1338     {
1339        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1340     } else {
1341        dc_reject(pcm, 3, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1342     }
1343
1344
1345
1346     /* SILK processing */
1347     HB_gain = Q15ONE;
1348     if (st->mode != MODE_CELT_ONLY)
1349     {
1350         opus_int32 total_bitRate, celt_rate;
1351 #ifdef FIXED_POINT
1352        const opus_int16 *pcm_silk;
1353 #else
1354        VARDECL(opus_int16, pcm_silk);
1355        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
1356 #endif
1357
1358         /* Distribute bits between SILK and CELT */
1359         total_bitRate = 8 * bytes_target * frame_rate;
1360         if( st->mode == MODE_HYBRID ) {
1361             int HB_gain_ref;
1362             /* Base rate for SILK */
1363             st->silk_mode.bitRate = st->stream_channels * ( 5000 + 1000 * ( st->Fs == 100 * frame_size ) );
1364             if( curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
1365                 /* SILK gets 2/3 of the remaining bits */
1366                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 2 / 3;
1367             } else { /* FULLBAND */
1368                 /* SILK gets 3/5 of the remaining bits */
1369                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 3 / 5;
1370             }
1371             /* Don't let SILK use more than 80% */
1372             if( st->silk_mode.bitRate > total_bitRate * 4/5 ) {
1373                 st->silk_mode.bitRate = total_bitRate * 4/5;
1374             }
1375             /* Increasingly attenuate high band when it gets allocated fewer bits */
1376             celt_rate = total_bitRate - st->silk_mode.bitRate;
1377             HB_gain_ref = (curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND) ? 3000 : 3600;
1378             HB_gain = SHL32((opus_val32)celt_rate, 9) / SHR32((opus_val32)celt_rate + st->stream_channels * HB_gain_ref, 6);
1379             HB_gain = HB_gain < Q15ONE*6/7 ? HB_gain + Q15ONE/7 : Q15ONE;
1380         } else {
1381             /* SILK gets all bits */
1382             st->silk_mode.bitRate = total_bitRate;
1383         }
1384
1385         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
1386         st->silk_mode.nChannelsAPI = st->channels;
1387         st->silk_mode.nChannelsInternal = st->stream_channels;
1388         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1389             st->silk_mode.desiredInternalSampleRate = 8000;
1390         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1391             st->silk_mode.desiredInternalSampleRate = 12000;
1392         } else {
1393             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
1394             st->silk_mode.desiredInternalSampleRate = 16000;
1395         }
1396         if( st->mode == MODE_HYBRID ) {
1397             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
1398             st->silk_mode.minInternalSampleRate = 16000;
1399         } else {
1400             st->silk_mode.minInternalSampleRate = 8000;
1401         }
1402
1403         if (st->mode == MODE_SILK_ONLY)
1404         {
1405            opus_int32 effective_max_rate = max_rate;
1406            st->silk_mode.maxInternalSampleRate = 16000;
1407            if (frame_rate > 50)
1408               effective_max_rate = effective_max_rate*2/3;
1409            if (effective_max_rate < 13000)
1410            {
1411               st->silk_mode.maxInternalSampleRate = 12000;
1412               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
1413            }
1414            if (effective_max_rate < 9600)
1415            {
1416               st->silk_mode.maxInternalSampleRate = 8000;
1417               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
1418            }
1419         } else {
1420            st->silk_mode.maxInternalSampleRate = 16000;
1421         }
1422
1423         st->silk_mode.useCBR = !st->use_vbr;
1424
1425         /* Call SILK encoder for the low band */
1426         nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes);
1427
1428         st->silk_mode.maxBits = nBytes*8;
1429         /* Only allow up to 90% of the bits for hybrid mode*/
1430         if (st->mode == MODE_HYBRID)
1431            st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
1432         if (st->silk_mode.useCBR)
1433         {
1434            st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
1435            /* Reduce the initial target to make it easier to reach the CBR rate */
1436            st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000);
1437         }
1438
1439         if (prefill)
1440         {
1441             opus_int32 zero=0;
1442             const CELTMode *celt_mode;
1443             int prefill_offset;
1444             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1445             /* Use a smooth onset for the SILK prefill to avoid the encoder trying to encode
1446                a discontinuity. The exact location is what we need to avoid leaving any "gap"
1447                in the audio when mixing with the redundant CELT frame. Here we can afford to
1448                overwrite st->delay_buffer because the only thing that uses it before it gets
1449                rewritten is tmp_prefill[] and even then only the part after the ramp really
1450                gets used (rather than sent to the encoder and discarded) */
1451             prefill_offset = st->channels*(st->encoder_buffer-st->delay_compensation-st->Fs/400);
1452             gain_fade(st->delay_buffer+prefill_offset, st->delay_buffer+prefill_offset,
1453                   0, Q15ONE, celt_mode->overlap, st->Fs/400, st->channels, celt_mode->window, st->Fs);
1454             for(i=0;i<prefill_offset;i++)
1455                st->delay_buffer[i]=0;
1456 #ifdef FIXED_POINT
1457             pcm_silk = st->delay_buffer;
1458 #else
1459             for (i=0;i<st->encoder_buffer*st->channels;i++)
1460                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
1461 #endif
1462             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
1463         }
1464
1465 #ifdef FIXED_POINT
1466         pcm_silk = pcm_buf+total_buffer*st->channels;
1467 #else
1468         for (i=0;i<frame_size*st->channels;i++)
1469             pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
1470 #endif
1471         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
1472         if( ret ) {
1473             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
1474             /* Handle error */
1475            RESTORE_STACK;
1476            return OPUS_INTERNAL_ERROR;
1477         }
1478         if (nBytes==0)
1479         {
1480            st->rangeFinal = 0;
1481            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1482            RESTORE_STACK;
1483            return 1;
1484         }
1485         /* Extract SILK internal bandwidth for signaling in first byte */
1486         if( st->mode == MODE_SILK_ONLY ) {
1487             if( st->silk_mode.internalSampleRate == 8000 ) {
1488                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1489             } else if( st->silk_mode.internalSampleRate == 12000 ) {
1490                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1491             } else if( st->silk_mode.internalSampleRate == 16000 ) {
1492                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1493             }
1494         } else {
1495             silk_assert( st->silk_mode.internalSampleRate == 16000 );
1496         }
1497
1498         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
1499         /* FIXME: How do we allocate the redundancy for CBR? */
1500         if (st->silk_mode.opusCanSwitch)
1501         {
1502            redundancy = 1;
1503            celt_to_silk = 0;
1504            st->silk_bw_switch = 1;
1505         }
1506     }
1507
1508     /* CELT processing */
1509     {
1510         int endband=21;
1511
1512         switch(curr_bandwidth)
1513         {
1514             case OPUS_BANDWIDTH_NARROWBAND:
1515                 endband = 13;
1516                 break;
1517             case OPUS_BANDWIDTH_MEDIUMBAND:
1518             case OPUS_BANDWIDTH_WIDEBAND:
1519                 endband = 17;
1520                 break;
1521             case OPUS_BANDWIDTH_SUPERWIDEBAND:
1522                 endband = 19;
1523                 break;
1524             case OPUS_BANDWIDTH_FULLBAND:
1525                 endband = 21;
1526                 break;
1527         }
1528         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
1529         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
1530     }
1531     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1532     if (st->mode != MODE_SILK_ONLY)
1533     {
1534         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1535         /* Allow prediction unless we decide to disable it later */
1536         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
1537
1538         if (st->mode == MODE_HYBRID)
1539         {
1540             int len;
1541
1542             len = (ec_tell(&enc)+7)>>3;
1543             if (redundancy)
1544                len += st->mode == MODE_HYBRID ? 3 : 1;
1545             if( st->use_vbr ) {
1546                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
1547             } else {
1548                 /* check if SILK used up too much */
1549                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
1550             }
1551         } else {
1552             if (st->use_vbr)
1553             {
1554                 opus_int32 bonus=0;
1555 #ifndef FIXED_POINT
1556                 if (st->variable_duration==OPUS_FRAMESIZE_VARIABLE && frame_size != st->Fs/50)
1557                 {
1558                    bonus = (60*st->stream_channels+40)*(st->Fs/frame_size-50);
1559                    if (analysis_info->valid)
1560                       bonus = bonus*(1.f+.5*analysis_info->tonality);
1561                 }
1562 #endif
1563                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
1564                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
1565                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps+bonus));
1566                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
1567             } else {
1568                 nb_compr_bytes = bytes_target;
1569             }
1570         }
1571
1572     } else {
1573         nb_compr_bytes = 0;
1574     }
1575
1576     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
1577     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
1578     {
1579        for (i=0;i<st->channels*st->Fs/400;i++)
1580           tmp_prefill[i] = st->delay_buffer[(st->encoder_buffer-total_buffer-st->Fs/400)*st->channels + i];
1581     }
1582
1583     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+total_buffer));i++)
1584         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
1585     for (;i<st->encoder_buffer*st->channels;i++)
1586         st->delay_buffer[i] = pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels+i];
1587
1588     /* gain_fade() and stereo_fade() need to be after the buffer copying
1589        because we don't want any of this to affect the SILK part */
1590     if( st->prev_HB_gain < Q15ONE || HB_gain < Q15ONE ) {
1591        const CELTMode *celt_mode;
1592
1593        celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1594        gain_fade(pcm_buf, pcm_buf,
1595              st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs);
1596     }
1597     st->prev_HB_gain = HB_gain;
1598     if (st->mode != MODE_HYBRID || st->stream_channels==1)
1599        st->silk_mode.stereoWidth_Q14 = IMIN((1<<14),IMAX(0,st->bitrate_bps-32000));
1600     if( st->channels == 2 ) {
1601         /* Apply stereo width reduction (at low bitrates) */
1602         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1603             opus_val16 g1, g2;
1604             const CELTMode *celt_mode;
1605
1606             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1607             g1 = st->hybrid_stereo_width_Q14;
1608             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1609 #ifdef FIXED_POINT
1610             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
1611             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
1612 #else
1613             g1 *= (1.f/16384);
1614             g2 *= (1.f/16384);
1615 #endif
1616             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
1617                   frame_size, st->channels, celt_mode->window, st->Fs);
1618             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1619         }
1620     }
1621
1622     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
1623     {
1624         /* For SILK mode, the redundancy is inferred from the length */
1625         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
1626            ec_enc_bit_logp(&enc, redundancy, 12);
1627         if (redundancy)
1628         {
1629             int max_redundancy;
1630             ec_enc_bit_logp(&enc, celt_to_silk, 1);
1631             if (st->mode == MODE_HYBRID)
1632                max_redundancy = (max_data_bytes-1)-nb_compr_bytes-1;
1633             else
1634                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1635             /* Target the same bit-rate for redundancy as for the rest,
1636                up to a max of 257 bytes */
1637             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
1638             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
1639             if (st->mode == MODE_HYBRID)
1640                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
1641         }
1642     } else {
1643         redundancy = 0;
1644     }
1645
1646     if (!redundancy)
1647     {
1648        st->silk_bw_switch = 0;
1649        redundancy_bytes = 0;
1650     }
1651     if (st->mode != MODE_CELT_ONLY)start_band=17;
1652
1653     if (st->mode == MODE_SILK_ONLY)
1654     {
1655         ret = (ec_tell(&enc)+7)>>3;
1656         ec_enc_done(&enc);
1657         nb_compr_bytes = ret;
1658     } else {
1659        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
1660        ec_enc_shrink(&enc, nb_compr_bytes);
1661     }
1662
1663
1664     /* 5 ms redundant frame for CELT->SILK */
1665     if (redundancy && celt_to_silk)
1666     {
1667         int err;
1668         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1669         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1670         err = celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
1671         if (err < 0)
1672         {
1673            RESTORE_STACK;
1674            return OPUS_INTERNAL_ERROR;
1675         }
1676         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1677         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1678     }
1679
1680     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
1681
1682     if (st->mode != MODE_SILK_ONLY)
1683     {
1684         if (st->mode != st->prev_mode && st->prev_mode > 0)
1685         {
1686            unsigned char dummy[2];
1687            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1688
1689            /* Prefilling */
1690            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
1691            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1692         }
1693         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
1694         if (ec_tell(&enc) <= 8*nb_compr_bytes)
1695         {
1696 #ifndef FIXED_POINT
1697            celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(analysis_info));
1698 #endif
1699            ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
1700            if (ret < 0)
1701            {
1702               RESTORE_STACK;
1703               return OPUS_INTERNAL_ERROR;
1704            }
1705         }
1706     }
1707
1708     /* 5 ms redundant frame for SILK->CELT */
1709     if (redundancy && !celt_to_silk)
1710     {
1711         int err;
1712         unsigned char dummy[2];
1713         int N2, N4;
1714         N2 = st->Fs/200;
1715         N4 = st->Fs/400;
1716
1717         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1718         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1719         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1720
1721         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1722         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL);
1723
1724         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1725         if (err < 0)
1726         {
1727            RESTORE_STACK;
1728            return OPUS_INTERNAL_ERROR;
1729         }
1730         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1731     }
1732
1733
1734
1735     /* Signalling the mode in the first byte */
1736     data--;
1737     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1738
1739     st->rangeFinal = enc.rng ^ redundant_rng;
1740
1741     if (to_celt)
1742         st->prev_mode = MODE_CELT_ONLY;
1743     else
1744         st->prev_mode = st->mode;
1745     st->prev_channels = st->stream_channels;
1746     st->prev_framesize = frame_size;
1747
1748     st->first = 0;
1749
1750     /* In the unlikely case that the SILK encoder busted its target, tell
1751        the decoder to call the PLC */
1752     if (ec_tell(&enc) > (max_data_bytes-1)*8)
1753     {
1754        if (max_data_bytes < 2)
1755        {
1756           RESTORE_STACK;
1757           return OPUS_BUFFER_TOO_SMALL;
1758        }
1759        data[1] = 0;
1760        ret = 1;
1761        st->rangeFinal = 0;
1762     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
1763     {
1764        /*When in LPC only mode it's perfectly
1765          reasonable to strip off trailing zero bytes as
1766          the required range decoder behavior is to
1767          fill these in. This can't be done when the MDCT
1768          modes are used because the decoder needs to know
1769          the actual length for allocation purposes.*/
1770        while(ret>2&&data[ret]==0)ret--;
1771     }
1772     /* Count ToC and redundancy */
1773     ret += 1+redundancy_bytes;
1774     if (!st->use_vbr && ret >= 3)
1775     {
1776        if (pad_frame(data, ret, max_data_bytes))
1777        {
1778           RESTORE_STACK;
1779           return OPUS_INTERNAL_ERROR;
1780        }
1781        ret = max_data_bytes;
1782     }
1783     RESTORE_STACK;
1784     return ret;
1785 }
1786
1787 #ifdef FIXED_POINT
1788
1789 #ifndef DISABLE_FLOAT_API
1790 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1791       unsigned char *data, opus_int32 max_data_bytes)
1792 {
1793    int i, ret;
1794    VARDECL(opus_int16, in);
1795    ALLOC_STACK;
1796
1797    frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1798    if(frame_size<0)
1799    {
1800       RESTORE_STACK;
1801       return OPUS_BAD_ARG;
1802    }
1803
1804    ALLOC(in, frame_size*st->channels, opus_int16);
1805
1806    for (i=0;i<frame_size*st->channels;i++)
1807       in[i] = FLOAT2INT16(pcm[i]);
1808    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16);
1809    RESTORE_STACK;
1810    return ret;
1811 }
1812 #endif
1813
1814 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1815                 unsigned char *data, opus_int32 out_data_bytes)
1816 {
1817    frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1818    if(frame_size<0)
1819    {
1820       return OPUS_BAD_ARG;
1821    }
1822    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 16);
1823 }
1824
1825 #else
1826 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1827       unsigned char *data, opus_int32 max_data_bytes)
1828 {
1829    int i, ret;
1830    const CELTMode *celt_mode;
1831    int delay_compensation;
1832    int lsb_depth;
1833    VARDECL(float, in);
1834    AnalysisInfo analysis_info;
1835    ALLOC_STACK;
1836
1837    opus_encoder_ctl(st, CELT_GET_MODE(&celt_mode));
1838    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1839       delay_compensation = 0;
1840    else
1841       delay_compensation = st->delay_compensation;
1842
1843    lsb_depth = IMIN(16, st->lsb_depth);
1844
1845    analysis_info.valid = 0;
1846    if (st->silk_mode.complexity >= 7 && st->Fs==48000)
1847    {
1848       frame_size = run_analysis(&st->analysis, celt_mode, pcm, pcm+st->channels*st->analysis.analysis_offset,
1849             frame_size, st->variable_duration, st->channels, st->Fs, st->bitrate_bps, delay_compensation, lsb_depth, downmix_int, &analysis_info);
1850    } else {
1851       frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1852    }
1853    if(frame_size<0)
1854    {
1855       RESTORE_STACK;
1856       return OPUS_BAD_ARG;
1857    }
1858
1859    ALLOC(in, frame_size*st->channels, float);
1860
1861    for (i=0;i<frame_size*st->channels;i++)
1862       in[i] = (1.0f/32768)*pcm[i];
1863    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16, &analysis_info);
1864    RESTORE_STACK;
1865    return ret;
1866 }
1867 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1868                       unsigned char *data, opus_int32 out_data_bytes)
1869 {
1870    const CELTMode *celt_mode;
1871    int delay_compensation;
1872    int lsb_depth;
1873    AnalysisInfo analysis_info;
1874
1875    opus_encoder_ctl(st, CELT_GET_MODE(&celt_mode));
1876    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1877       delay_compensation = 0;
1878    else
1879       delay_compensation = st->delay_compensation;
1880
1881    lsb_depth = IMIN(24, st->lsb_depth);
1882
1883    analysis_info.valid = 0;
1884    if (st->silk_mode.complexity >= 7 && st->Fs==48000)
1885    {
1886       frame_size = run_analysis(&st->analysis, celt_mode, pcm, pcm+st->channels*st->analysis.analysis_offset,
1887             frame_size, st->variable_duration, st->channels, st->Fs, st->bitrate_bps, delay_compensation, lsb_depth, downmix_float, &analysis_info);
1888    } else {
1889       frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1890    }
1891    if(frame_size<0)
1892    {
1893       return OPUS_BAD_ARG;
1894    }
1895
1896    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 24, &analysis_info);
1897
1898 }
1899 #endif
1900
1901
1902 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
1903 {
1904     int ret;
1905     CELTEncoder *celt_enc;
1906     va_list ap;
1907
1908     ret = OPUS_OK;
1909     va_start(ap, request);
1910
1911     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1912
1913     switch (request)
1914     {
1915         case OPUS_SET_APPLICATION_REQUEST:
1916         {
1917             opus_int32 value = va_arg(ap, opus_int32);
1918             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
1919                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1920                || (!st->first && st->application != value))
1921             {
1922                ret = OPUS_BAD_ARG;
1923                break;
1924             }
1925             st->application = value;
1926         }
1927         break;
1928         case OPUS_GET_APPLICATION_REQUEST:
1929         {
1930             opus_int32 *value = va_arg(ap, opus_int32*);
1931             *value = st->application;
1932         }
1933         break;
1934         case OPUS_SET_BITRATE_REQUEST:
1935         {
1936             opus_int32 value = va_arg(ap, opus_int32);
1937             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1938             {
1939                 if (value <= 0)
1940                     goto bad_arg;
1941                 else if (value <= 500)
1942                     value = 500;
1943                 else if (value > (opus_int32)300000*st->channels)
1944                     value = (opus_int32)300000*st->channels;
1945             }
1946             st->user_bitrate_bps = value;
1947         }
1948         break;
1949         case OPUS_GET_BITRATE_REQUEST:
1950         {
1951             opus_int32 *value = va_arg(ap, opus_int32*);
1952             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
1953         }
1954         break;
1955         case OPUS_SET_FORCE_CHANNELS_REQUEST:
1956         {
1957             opus_int32 value = va_arg(ap, opus_int32);
1958             if((value<1 || value>st->channels) && value != OPUS_AUTO)
1959                 return OPUS_BAD_ARG;
1960             st->force_channels = value;
1961         }
1962         break;
1963         case OPUS_GET_FORCE_CHANNELS_REQUEST:
1964         {
1965             opus_int32 *value = va_arg(ap, opus_int32*);
1966             *value = st->force_channels;
1967         }
1968         break;
1969         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
1970         {
1971             opus_int32 value = va_arg(ap, opus_int32);
1972             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND)
1973                 return OPUS_BAD_ARG;
1974             st->max_bandwidth = value;
1975             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1976                 st->silk_mode.maxInternalSampleRate = 8000;
1977             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1978                 st->silk_mode.maxInternalSampleRate = 12000;
1979             } else {
1980                 st->silk_mode.maxInternalSampleRate = 16000;
1981             }
1982         }
1983         break;
1984         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
1985         {
1986             opus_int32 *value = va_arg(ap, opus_int32*);
1987             *value = st->max_bandwidth;
1988         }
1989         break;
1990         case OPUS_SET_BANDWIDTH_REQUEST:
1991         {
1992             opus_int32 value = va_arg(ap, opus_int32);
1993             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
1994                 return OPUS_BAD_ARG;
1995             st->user_bandwidth = value;
1996             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1997                 st->silk_mode.maxInternalSampleRate = 8000;
1998             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1999                 st->silk_mode.maxInternalSampleRate = 12000;
2000             } else {
2001                 st->silk_mode.maxInternalSampleRate = 16000;
2002             }
2003         }
2004         break;
2005         case OPUS_GET_BANDWIDTH_REQUEST:
2006         {
2007             opus_int32 *value = va_arg(ap, opus_int32*);
2008             *value = st->bandwidth;
2009         }
2010         break;
2011         case OPUS_SET_DTX_REQUEST:
2012         {
2013             opus_int32 value = va_arg(ap, opus_int32);
2014             if(value<0 || value>1)
2015                 return OPUS_BAD_ARG;
2016             st->silk_mode.useDTX = value;
2017         }
2018         break;
2019         case OPUS_GET_DTX_REQUEST:
2020         {
2021             opus_int32 *value = va_arg(ap, opus_int32*);
2022             *value = st->silk_mode.useDTX;
2023         }
2024         break;
2025         case OPUS_SET_COMPLEXITY_REQUEST:
2026         {
2027             opus_int32 value = va_arg(ap, opus_int32);
2028             if(value<0 || value>10)
2029                 return OPUS_BAD_ARG;
2030             st->silk_mode.complexity = value;
2031             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
2032         }
2033         break;
2034         case OPUS_GET_COMPLEXITY_REQUEST:
2035         {
2036             opus_int32 *value = va_arg(ap, opus_int32*);
2037             *value = st->silk_mode.complexity;
2038         }
2039         break;
2040         case OPUS_SET_INBAND_FEC_REQUEST:
2041         {
2042             opus_int32 value = va_arg(ap, opus_int32);
2043             if(value<0 || value>1)
2044                 return OPUS_BAD_ARG;
2045             st->silk_mode.useInBandFEC = value;
2046         }
2047         break;
2048         case OPUS_GET_INBAND_FEC_REQUEST:
2049         {
2050             opus_int32 *value = va_arg(ap, opus_int32*);
2051             *value = st->silk_mode.useInBandFEC;
2052         }
2053         break;
2054         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
2055         {
2056             opus_int32 value = va_arg(ap, opus_int32);
2057             if (value < 0 || value > 100)
2058                 return OPUS_BAD_ARG;
2059             st->silk_mode.packetLossPercentage = value;
2060             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
2061         }
2062         break;
2063         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
2064         {
2065             opus_int32 *value = va_arg(ap, opus_int32*);
2066             *value = st->silk_mode.packetLossPercentage;
2067         }
2068         break;
2069         case OPUS_SET_VBR_REQUEST:
2070         {
2071             opus_int32 value = va_arg(ap, opus_int32);
2072             if(value<0 || value>1)
2073                 return OPUS_BAD_ARG;
2074             st->use_vbr = value;
2075             st->silk_mode.useCBR = 1-value;
2076         }
2077         break;
2078         case OPUS_GET_VBR_REQUEST:
2079         {
2080             opus_int32 *value = va_arg(ap, opus_int32*);
2081             *value = st->use_vbr;
2082         }
2083         break;
2084         case OPUS_SET_VOICE_RATIO_REQUEST:
2085         {
2086             opus_int32 value = va_arg(ap, opus_int32);
2087             if (value>100 || value<-1)
2088                 goto bad_arg;
2089             st->voice_ratio = value;
2090         }
2091         break;
2092         case OPUS_GET_VOICE_RATIO_REQUEST:
2093         {
2094             opus_int32 *value = va_arg(ap, opus_int32*);
2095             *value = st->voice_ratio;
2096         }
2097         break;
2098         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
2099         {
2100             opus_int32 value = va_arg(ap, opus_int32);
2101             if(value<0 || value>1)
2102                 return OPUS_BAD_ARG;
2103             st->vbr_constraint = value;
2104         }
2105         break;
2106         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
2107         {
2108             opus_int32 *value = va_arg(ap, opus_int32*);
2109             *value = st->vbr_constraint;
2110         }
2111         break;
2112         case OPUS_SET_SIGNAL_REQUEST:
2113         {
2114             opus_int32 value = va_arg(ap, opus_int32);
2115             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
2116                 return OPUS_BAD_ARG;
2117             st->signal_type = value;
2118         }
2119         break;
2120         case OPUS_GET_SIGNAL_REQUEST:
2121         {
2122             opus_int32 *value = va_arg(ap, opus_int32*);
2123             *value = st->signal_type;
2124         }
2125         break;
2126         case OPUS_GET_LOOKAHEAD_REQUEST:
2127         {
2128             opus_int32 *value = va_arg(ap, opus_int32*);
2129             *value = st->Fs/400;
2130             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2131                 *value += st->delay_compensation;
2132         }
2133         break;
2134         case OPUS_GET_SAMPLE_RATE_REQUEST:
2135         {
2136             opus_int32 *value = va_arg(ap, opus_int32*);
2137             if (value==NULL)
2138             {
2139                 ret = OPUS_BAD_ARG;
2140                 break;
2141             }
2142             *value = st->Fs;
2143         }
2144         break;
2145         case OPUS_GET_FINAL_RANGE_REQUEST:
2146         {
2147             opus_uint32 *value = va_arg(ap, opus_uint32*);
2148             *value = st->rangeFinal;
2149         }
2150         break;
2151         case OPUS_SET_LSB_DEPTH_REQUEST:
2152         {
2153             opus_int32 value = va_arg(ap, opus_int32);
2154             if (value<8 || value>24)
2155                goto bad_arg;
2156             st->lsb_depth=value;
2157         }
2158         break;
2159         case OPUS_GET_LSB_DEPTH_REQUEST:
2160         {
2161             opus_int32 *value = va_arg(ap, opus_int32*);
2162             *value = st->lsb_depth;
2163         }
2164         break;
2165         case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
2166         {
2167             opus_int32 value = va_arg(ap, opus_int32);
2168             st->variable_duration = value;
2169             celt_encoder_ctl(celt_enc, OPUS_SET_EXPERT_FRAME_DURATION(value));
2170         }
2171         break;
2172         case OPUS_GET_EXPERT_FRAME_DURATION_REQUEST:
2173         {
2174             opus_int32 *value = va_arg(ap, opus_int32*);
2175             *value = st->variable_duration;
2176         }
2177         break;
2178         case OPUS_RESET_STATE:
2179         {
2180            void *silk_enc;
2181            silk_EncControlStruct dummy;
2182            silk_enc = (char*)st+st->silk_enc_offset;
2183
2184            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
2185                  sizeof(OpusEncoder)-
2186                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
2187
2188            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2189            silk_InitEncoder( silk_enc, &dummy );
2190            st->stream_channels = st->channels;
2191            st->hybrid_stereo_width_Q14 = 1 << 14;
2192            st->prev_HB_gain = Q15ONE;
2193            st->first = 1;
2194            st->mode = MODE_HYBRID;
2195            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
2196            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
2197         }
2198         break;
2199         case OPUS_SET_FORCE_MODE_REQUEST:
2200         {
2201             opus_int32 value = va_arg(ap, opus_int32);
2202             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
2203                goto bad_arg;
2204             st->user_forced_mode = value;
2205         }
2206         break;
2207
2208         case CELT_GET_MODE_REQUEST:
2209         {
2210            const CELTMode ** value = va_arg(ap, const CELTMode**);
2211            if (value==0)
2212               goto bad_arg;
2213            celt_encoder_ctl(celt_enc, CELT_GET_MODE(value));
2214         }
2215         break;
2216         default:
2217             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
2218             ret = OPUS_UNIMPLEMENTED;
2219             break;
2220     }
2221     va_end(ap);
2222     return ret;
2223 bad_arg:
2224     va_end(ap);
2225     return OPUS_BAD_ARG;
2226 }
2227
2228 void opus_encoder_destroy(OpusEncoder *st)
2229 {
2230     opus_free(st);
2231 }