Variable framesize improvements
[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        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        opus_repacketizer_init(&rp);
1254
1255        bak_mode = st->user_forced_mode;
1256        bak_bandwidth = st->user_bandwidth;
1257        bak_channels = st->force_channels;
1258
1259        st->user_forced_mode = st->mode;
1260        st->user_bandwidth = st->bandwidth;
1261        st->force_channels = st->stream_channels;
1262        bak_to_mono = st->silk_mode.toMono;
1263
1264        if (bak_to_mono)
1265           st->force_channels = 1;
1266        else
1267           st->prev_channels = st->stream_channels;
1268        for (i=0;i<nb_frames;i++)
1269        {
1270           int tmp_len;
1271           st->silk_mode.toMono = 0;
1272           /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
1273           if (to_celt && i==nb_frames-1)
1274              st->user_forced_mode = MODE_CELT_ONLY;
1275           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
1276 #ifndef FIXED_POINT
1277                 , analysis_info
1278 #endif
1279                 );
1280           if (tmp_len<0)
1281           {
1282              RESTORE_STACK;
1283              return OPUS_INTERNAL_ERROR;
1284           }
1285           ret = opus_repacketizer_cat(&rp, tmp_data+i*bytes_per_frame, tmp_len);
1286           if (ret<0)
1287           {
1288              RESTORE_STACK;
1289              return OPUS_INTERNAL_ERROR;
1290           }
1291        }
1292        ret = opus_repacketizer_out(&rp, data, out_data_bytes);
1293        if (ret<0)
1294        {
1295           RESTORE_STACK;
1296           return OPUS_INTERNAL_ERROR;
1297        }
1298        st->user_forced_mode = bak_mode;
1299        st->user_bandwidth = bak_bandwidth;
1300        st->force_channels = bak_channels;
1301        st->silk_mode.toMono = bak_to_mono;
1302        RESTORE_STACK;
1303        return ret;
1304     }
1305     curr_bandwidth = st->bandwidth;
1306
1307     /* Chooses the appropriate mode for speech
1308        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
1309     if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1310         st->mode = MODE_HYBRID;
1311     if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
1312         st->mode = MODE_SILK_ONLY;
1313
1314     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
1315     bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
1316
1317     data += 1;
1318
1319     ec_enc_init(&enc, data, max_data_bytes-1);
1320
1321     ALLOC(pcm_buf, (total_buffer+frame_size)*st->channels, opus_val16);
1322     for (i=0;i<total_buffer*st->channels;i++)
1323        pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-total_buffer)*st->channels+i];
1324
1325     if (st->mode == MODE_CELT_ONLY)
1326        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1327     else
1328        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
1329
1330     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
1331           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
1332
1333     /* convert from log scale to Hertz */
1334     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
1335
1336     if (st->application == OPUS_APPLICATION_VOIP)
1337     {
1338        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1339     } else {
1340        dc_reject(pcm, 3, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1341     }
1342
1343
1344
1345     /* SILK processing */
1346     HB_gain = Q15ONE;
1347     if (st->mode != MODE_CELT_ONLY)
1348     {
1349         opus_int32 total_bitRate, celt_rate;
1350 #ifdef FIXED_POINT
1351        const opus_int16 *pcm_silk;
1352 #else
1353        VARDECL(opus_int16, pcm_silk);
1354        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
1355 #endif
1356
1357         /* Distribute bits between SILK and CELT */
1358         total_bitRate = 8 * bytes_target * frame_rate;
1359         if( st->mode == MODE_HYBRID ) {
1360             int HB_gain_ref;
1361             /* Base rate for SILK */
1362             st->silk_mode.bitRate = st->stream_channels * ( 5000 + 1000 * ( st->Fs == 100 * frame_size ) );
1363             if( curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
1364                 /* SILK gets 2/3 of the remaining bits */
1365                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 2 / 3;
1366             } else { /* FULLBAND */
1367                 /* SILK gets 3/5 of the remaining bits */
1368                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 3 / 5;
1369             }
1370             /* Don't let SILK use more than 80% */
1371             if( st->silk_mode.bitRate > total_bitRate * 4/5 ) {
1372                 st->silk_mode.bitRate = total_bitRate * 4/5;
1373             }
1374             /* Increasingly attenuate high band when it gets allocated fewer bits */
1375             celt_rate = total_bitRate - st->silk_mode.bitRate;
1376             HB_gain_ref = (curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND) ? 3000 : 3600;
1377             HB_gain = SHL32((opus_val32)celt_rate, 9) / SHR32((opus_val32)celt_rate + st->stream_channels * HB_gain_ref, 6);
1378             HB_gain = HB_gain < Q15ONE*6/7 ? HB_gain + Q15ONE/7 : Q15ONE;
1379         } else {
1380             /* SILK gets all bits */
1381             st->silk_mode.bitRate = total_bitRate;
1382         }
1383
1384         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
1385         st->silk_mode.nChannelsAPI = st->channels;
1386         st->silk_mode.nChannelsInternal = st->stream_channels;
1387         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1388             st->silk_mode.desiredInternalSampleRate = 8000;
1389         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1390             st->silk_mode.desiredInternalSampleRate = 12000;
1391         } else {
1392             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
1393             st->silk_mode.desiredInternalSampleRate = 16000;
1394         }
1395         if( st->mode == MODE_HYBRID ) {
1396             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
1397             st->silk_mode.minInternalSampleRate = 16000;
1398         } else {
1399             st->silk_mode.minInternalSampleRate = 8000;
1400         }
1401
1402         if (st->mode == MODE_SILK_ONLY)
1403         {
1404            opus_int32 effective_max_rate = max_rate;
1405            st->silk_mode.maxInternalSampleRate = 16000;
1406            if (frame_rate > 50)
1407               effective_max_rate = effective_max_rate*2/3;
1408            if (effective_max_rate < 13000)
1409            {
1410               st->silk_mode.maxInternalSampleRate = 12000;
1411               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
1412            }
1413            if (effective_max_rate < 9600)
1414            {
1415               st->silk_mode.maxInternalSampleRate = 8000;
1416               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
1417            }
1418         } else {
1419            st->silk_mode.maxInternalSampleRate = 16000;
1420         }
1421
1422         st->silk_mode.useCBR = !st->use_vbr;
1423
1424         /* Call SILK encoder for the low band */
1425         nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes);
1426
1427         st->silk_mode.maxBits = nBytes*8;
1428         /* Only allow up to 90% of the bits for hybrid mode*/
1429         if (st->mode == MODE_HYBRID)
1430            st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
1431         if (st->silk_mode.useCBR)
1432         {
1433            st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
1434            /* Reduce the initial target to make it easier to reach the CBR rate */
1435            st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000);
1436         }
1437
1438         if (prefill)
1439         {
1440             opus_int32 zero=0;
1441             const CELTMode *celt_mode;
1442             int prefill_offset;
1443             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1444             /* Use a smooth onset for the SILK prefill to avoid the encoder trying to encode
1445                a discontinuity. The exact location is what we need to avoid leaving any "gap"
1446                in the audio when mixing with the redundant CELT frame. Here we can afford to
1447                overwrite st->delay_buffer because the only thing that uses it before it gets
1448                rewritten is tmp_prefill[] and even then only the part after the ramp really
1449                gets used (rather than sent to the encoder and discarded) */
1450             prefill_offset = st->channels*(st->encoder_buffer-st->delay_compensation-st->Fs/400);
1451             gain_fade(st->delay_buffer+prefill_offset, st->delay_buffer+prefill_offset,
1452                   0, Q15ONE, celt_mode->overlap, st->Fs/400, st->channels, celt_mode->window, st->Fs);
1453             for(i=0;i<prefill_offset;i++)
1454                st->delay_buffer[i]=0;
1455 #ifdef FIXED_POINT
1456             pcm_silk = st->delay_buffer;
1457 #else
1458             for (i=0;i<st->encoder_buffer*st->channels;i++)
1459                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
1460 #endif
1461             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
1462         }
1463
1464 #ifdef FIXED_POINT
1465         pcm_silk = pcm_buf+total_buffer*st->channels;
1466 #else
1467         for (i=0;i<frame_size*st->channels;i++)
1468             pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
1469 #endif
1470         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
1471         if( ret ) {
1472             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
1473             /* Handle error */
1474            RESTORE_STACK;
1475            return OPUS_INTERNAL_ERROR;
1476         }
1477         if (nBytes==0)
1478         {
1479            st->rangeFinal = 0;
1480            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1481            RESTORE_STACK;
1482            return 1;
1483         }
1484         /* Extract SILK internal bandwidth for signaling in first byte */
1485         if( st->mode == MODE_SILK_ONLY ) {
1486             if( st->silk_mode.internalSampleRate == 8000 ) {
1487                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1488             } else if( st->silk_mode.internalSampleRate == 12000 ) {
1489                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1490             } else if( st->silk_mode.internalSampleRate == 16000 ) {
1491                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1492             }
1493         } else {
1494             silk_assert( st->silk_mode.internalSampleRate == 16000 );
1495         }
1496
1497         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
1498         /* FIXME: How do we allocate the redundancy for CBR? */
1499         if (st->silk_mode.opusCanSwitch)
1500         {
1501            redundancy = 1;
1502            celt_to_silk = 0;
1503            st->silk_bw_switch = 1;
1504         }
1505     }
1506
1507     /* CELT processing */
1508     {
1509         int endband=21;
1510
1511         switch(curr_bandwidth)
1512         {
1513             case OPUS_BANDWIDTH_NARROWBAND:
1514                 endband = 13;
1515                 break;
1516             case OPUS_BANDWIDTH_MEDIUMBAND:
1517             case OPUS_BANDWIDTH_WIDEBAND:
1518                 endband = 17;
1519                 break;
1520             case OPUS_BANDWIDTH_SUPERWIDEBAND:
1521                 endband = 19;
1522                 break;
1523             case OPUS_BANDWIDTH_FULLBAND:
1524                 endband = 21;
1525                 break;
1526         }
1527         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
1528         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
1529     }
1530     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1531     if (st->mode != MODE_SILK_ONLY)
1532     {
1533         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1534         /* Allow prediction unless we decide to disable it later */
1535         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
1536
1537         if (st->mode == MODE_HYBRID)
1538         {
1539             int len;
1540
1541             len = (ec_tell(&enc)+7)>>3;
1542             if (redundancy)
1543                len += st->mode == MODE_HYBRID ? 3 : 1;
1544             if( st->use_vbr ) {
1545                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
1546             } else {
1547                 /* check if SILK used up too much */
1548                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
1549             }
1550         } else {
1551             if (st->use_vbr)
1552             {
1553                 opus_int32 bonus=0;
1554 #ifndef FIXED_POINT
1555                 if (st->variable_duration==OPUS_FRAMESIZE_VARIABLE && frame_size != st->Fs/50)
1556                 {
1557                    bonus = (60*st->stream_channels+40)*(st->Fs/frame_size-50);
1558                    if (analysis_info->valid)
1559                       bonus = bonus*(1.f+.5*analysis_info->tonality);
1560                 }
1561 #endif
1562                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
1563                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
1564                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps+bonus));
1565                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
1566             } else {
1567                 nb_compr_bytes = bytes_target;
1568             }
1569         }
1570
1571     } else {
1572         nb_compr_bytes = 0;
1573     }
1574
1575     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
1576     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
1577     {
1578        for (i=0;i<st->channels*st->Fs/400;i++)
1579           tmp_prefill[i] = st->delay_buffer[(st->encoder_buffer-total_buffer-st->Fs/400)*st->channels + i];
1580     }
1581
1582     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+total_buffer));i++)
1583         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
1584     for (;i<st->encoder_buffer*st->channels;i++)
1585         st->delay_buffer[i] = pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels+i];
1586
1587     /* gain_fade() and stereo_fade() need to be after the buffer copying
1588        because we don't want any of this to affect the SILK part */
1589     if( st->prev_HB_gain < Q15ONE || HB_gain < Q15ONE ) {
1590        const CELTMode *celt_mode;
1591
1592        celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1593        gain_fade(pcm_buf, pcm_buf,
1594              st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs);
1595     }
1596     st->prev_HB_gain = HB_gain;
1597     if (st->mode != MODE_HYBRID || st->stream_channels==1)
1598        st->silk_mode.stereoWidth_Q14 = IMIN((1<<14),IMAX(0,st->bitrate_bps-32000));
1599     if( st->channels == 2 ) {
1600         /* Apply stereo width reduction (at low bitrates) */
1601         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1602             opus_val16 g1, g2;
1603             const CELTMode *celt_mode;
1604
1605             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1606             g1 = st->hybrid_stereo_width_Q14;
1607             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1608 #ifdef FIXED_POINT
1609             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
1610             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
1611 #else
1612             g1 *= (1.f/16384);
1613             g2 *= (1.f/16384);
1614 #endif
1615             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
1616                   frame_size, st->channels, celt_mode->window, st->Fs);
1617             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1618         }
1619     }
1620
1621     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
1622     {
1623         /* For SILK mode, the redundancy is inferred from the length */
1624         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
1625            ec_enc_bit_logp(&enc, redundancy, 12);
1626         if (redundancy)
1627         {
1628             int max_redundancy;
1629             ec_enc_bit_logp(&enc, celt_to_silk, 1);
1630             if (st->mode == MODE_HYBRID)
1631                max_redundancy = (max_data_bytes-1)-nb_compr_bytes-1;
1632             else
1633                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1634             /* Target the same bit-rate for redundancy as for the rest,
1635                up to a max of 257 bytes */
1636             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
1637             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
1638             if (st->mode == MODE_HYBRID)
1639                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
1640         }
1641     } else {
1642         redundancy = 0;
1643     }
1644
1645     if (!redundancy)
1646     {
1647        st->silk_bw_switch = 0;
1648        redundancy_bytes = 0;
1649     }
1650     if (st->mode != MODE_CELT_ONLY)start_band=17;
1651
1652     if (st->mode == MODE_SILK_ONLY)
1653     {
1654         ret = (ec_tell(&enc)+7)>>3;
1655         ec_enc_done(&enc);
1656         nb_compr_bytes = ret;
1657     } else {
1658        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
1659        ec_enc_shrink(&enc, nb_compr_bytes);
1660     }
1661
1662
1663     /* 5 ms redundant frame for CELT->SILK */
1664     if (redundancy && celt_to_silk)
1665     {
1666         int err;
1667         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1668         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1669         err = celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
1670         if (err < 0)
1671         {
1672            RESTORE_STACK;
1673            return OPUS_INTERNAL_ERROR;
1674         }
1675         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1676         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1677     }
1678
1679     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
1680
1681     if (st->mode != MODE_SILK_ONLY)
1682     {
1683         if (st->mode != st->prev_mode && st->prev_mode > 0)
1684         {
1685            unsigned char dummy[2];
1686            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1687
1688            /* Prefilling */
1689            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
1690            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1691         }
1692         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
1693         if (ec_tell(&enc) <= 8*nb_compr_bytes)
1694         {
1695 #ifndef FIXED_POINT
1696            celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(analysis_info));
1697 #endif
1698            ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
1699            if (ret < 0)
1700            {
1701               RESTORE_STACK;
1702               return OPUS_INTERNAL_ERROR;
1703            }
1704         }
1705     }
1706
1707     /* 5 ms redundant frame for SILK->CELT */
1708     if (redundancy && !celt_to_silk)
1709     {
1710         int err;
1711         unsigned char dummy[2];
1712         int N2, N4;
1713         N2 = st->Fs/200;
1714         N4 = st->Fs/400;
1715
1716         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1717         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1718         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1719
1720         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1721         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL);
1722
1723         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1724         if (err < 0)
1725         {
1726            RESTORE_STACK;
1727            return OPUS_INTERNAL_ERROR;
1728         }
1729         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1730     }
1731
1732
1733
1734     /* Signalling the mode in the first byte */
1735     data--;
1736     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1737
1738     st->rangeFinal = enc.rng ^ redundant_rng;
1739
1740     if (to_celt)
1741         st->prev_mode = MODE_CELT_ONLY;
1742     else
1743         st->prev_mode = st->mode;
1744     st->prev_channels = st->stream_channels;
1745     st->prev_framesize = frame_size;
1746
1747     st->first = 0;
1748
1749     /* In the unlikely case that the SILK encoder busted its target, tell
1750        the decoder to call the PLC */
1751     if (ec_tell(&enc) > (max_data_bytes-1)*8)
1752     {
1753        if (max_data_bytes < 2)
1754        {
1755           RESTORE_STACK;
1756           return OPUS_BUFFER_TOO_SMALL;
1757        }
1758        data[1] = 0;
1759        ret = 1;
1760        st->rangeFinal = 0;
1761     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
1762     {
1763        /*When in LPC only mode it's perfectly
1764          reasonable to strip off trailing zero bytes as
1765          the required range decoder behavior is to
1766          fill these in. This can't be done when the MDCT
1767          modes are used because the decoder needs to know
1768          the actual length for allocation purposes.*/
1769        while(ret>2&&data[ret]==0)ret--;
1770     }
1771     /* Count ToC and redundancy */
1772     ret += 1+redundancy_bytes;
1773     if (!st->use_vbr && ret >= 3)
1774     {
1775        if (pad_frame(data, ret, max_data_bytes))
1776        {
1777           RESTORE_STACK;
1778           return OPUS_INTERNAL_ERROR;
1779        }
1780        ret = max_data_bytes;
1781     }
1782     RESTORE_STACK;
1783     return ret;
1784 }
1785
1786 #ifdef FIXED_POINT
1787
1788 #ifndef DISABLE_FLOAT_API
1789 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1790       unsigned char *data, opus_int32 max_data_bytes)
1791 {
1792    int i, ret;
1793    VARDECL(opus_int16, in);
1794    ALLOC_STACK;
1795
1796    frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1797    if(frame_size<0)
1798    {
1799       RESTORE_STACK;
1800       return OPUS_BAD_ARG;
1801    }
1802
1803    ALLOC(in, frame_size*st->channels, opus_int16);
1804
1805    for (i=0;i<frame_size*st->channels;i++)
1806       in[i] = FLOAT2INT16(pcm[i]);
1807    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16);
1808    RESTORE_STACK;
1809    return ret;
1810 }
1811 #endif
1812
1813 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1814                 unsigned char *data, opus_int32 out_data_bytes)
1815 {
1816    frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1817    if(frame_size<0)
1818    {
1819       return OPUS_BAD_ARG;
1820    }
1821    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 16);
1822 }
1823
1824 #else
1825 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1826       unsigned char *data, opus_int32 max_data_bytes)
1827 {
1828    int i, ret;
1829    const CELTMode *celt_mode;
1830    int delay_compensation;
1831    int lsb_depth;
1832    VARDECL(float, in);
1833    AnalysisInfo analysis_info;
1834    ALLOC_STACK;
1835
1836    opus_encoder_ctl(st, CELT_GET_MODE(&celt_mode));
1837    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1838       delay_compensation = 0;
1839    else
1840       delay_compensation = st->delay_compensation;
1841
1842    lsb_depth = IMIN(16, st->lsb_depth);
1843
1844    analysis_info.valid = 0;
1845    if (st->silk_mode.complexity >= 7 && st->Fs==48000)
1846    {
1847       frame_size = run_analysis(&st->analysis, celt_mode, pcm, pcm+st->channels*st->analysis.analysis_offset,
1848             frame_size, st->variable_duration, st->channels, st->Fs, st->bitrate_bps, delay_compensation, lsb_depth, downmix_int, &analysis_info);
1849    } else {
1850       frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1851    }
1852    if(frame_size<0)
1853    {
1854       RESTORE_STACK;
1855       return OPUS_BAD_ARG;
1856    }
1857
1858    ALLOC(in, frame_size*st->channels, float);
1859
1860    for (i=0;i<frame_size*st->channels;i++)
1861       in[i] = (1.0f/32768)*pcm[i];
1862    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16, &analysis_info);
1863    RESTORE_STACK;
1864    return ret;
1865 }
1866 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1867                       unsigned char *data, opus_int32 out_data_bytes)
1868 {
1869    const CELTMode *celt_mode;
1870    int delay_compensation;
1871    int lsb_depth;
1872    AnalysisInfo analysis_info;
1873
1874    opus_encoder_ctl(st, CELT_GET_MODE(&celt_mode));
1875    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1876       delay_compensation = 0;
1877    else
1878       delay_compensation = st->delay_compensation;
1879
1880    lsb_depth = IMIN(24, st->lsb_depth);
1881
1882    analysis_info.valid = 0;
1883    if (st->silk_mode.complexity >= 7 && st->Fs==48000)
1884    {
1885       frame_size = run_analysis(&st->analysis, celt_mode, pcm, pcm+st->channels*st->analysis.analysis_offset,
1886             frame_size, st->variable_duration, st->channels, st->Fs, st->bitrate_bps, delay_compensation, lsb_depth, downmix_float, &analysis_info);
1887    } else {
1888       frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1889    }
1890    if(frame_size<0)
1891    {
1892       return OPUS_BAD_ARG;
1893    }
1894
1895    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 24, &analysis_info);
1896
1897 }
1898 #endif
1899
1900
1901 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
1902 {
1903     int ret;
1904     CELTEncoder *celt_enc;
1905     va_list ap;
1906
1907     ret = OPUS_OK;
1908     va_start(ap, request);
1909
1910     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1911
1912     switch (request)
1913     {
1914         case OPUS_SET_APPLICATION_REQUEST:
1915         {
1916             opus_int32 value = va_arg(ap, opus_int32);
1917             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
1918                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1919                || (!st->first && st->application != value))
1920             {
1921                ret = OPUS_BAD_ARG;
1922                break;
1923             }
1924             st->application = value;
1925         }
1926         break;
1927         case OPUS_GET_APPLICATION_REQUEST:
1928         {
1929             opus_int32 *value = va_arg(ap, opus_int32*);
1930             *value = st->application;
1931         }
1932         break;
1933         case OPUS_SET_BITRATE_REQUEST:
1934         {
1935             opus_int32 value = va_arg(ap, opus_int32);
1936             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1937             {
1938                 if (value <= 0)
1939                     goto bad_arg;
1940                 else if (value <= 500)
1941                     value = 500;
1942                 else if (value > (opus_int32)300000*st->channels)
1943                     value = (opus_int32)300000*st->channels;
1944             }
1945             st->user_bitrate_bps = value;
1946         }
1947         break;
1948         case OPUS_GET_BITRATE_REQUEST:
1949         {
1950             opus_int32 *value = va_arg(ap, opus_int32*);
1951             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
1952         }
1953         break;
1954         case OPUS_SET_FORCE_CHANNELS_REQUEST:
1955         {
1956             opus_int32 value = va_arg(ap, opus_int32);
1957             if((value<1 || value>st->channels) && value != OPUS_AUTO)
1958                 return OPUS_BAD_ARG;
1959             st->force_channels = value;
1960         }
1961         break;
1962         case OPUS_GET_FORCE_CHANNELS_REQUEST:
1963         {
1964             opus_int32 *value = va_arg(ap, opus_int32*);
1965             *value = st->force_channels;
1966         }
1967         break;
1968         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
1969         {
1970             opus_int32 value = va_arg(ap, opus_int32);
1971             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND)
1972                 return OPUS_BAD_ARG;
1973             st->max_bandwidth = value;
1974             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1975                 st->silk_mode.maxInternalSampleRate = 8000;
1976             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1977                 st->silk_mode.maxInternalSampleRate = 12000;
1978             } else {
1979                 st->silk_mode.maxInternalSampleRate = 16000;
1980             }
1981         }
1982         break;
1983         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
1984         {
1985             opus_int32 *value = va_arg(ap, opus_int32*);
1986             *value = st->max_bandwidth;
1987         }
1988         break;
1989         case OPUS_SET_BANDWIDTH_REQUEST:
1990         {
1991             opus_int32 value = va_arg(ap, opus_int32);
1992             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
1993                 return OPUS_BAD_ARG;
1994             st->user_bandwidth = value;
1995             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1996                 st->silk_mode.maxInternalSampleRate = 8000;
1997             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1998                 st->silk_mode.maxInternalSampleRate = 12000;
1999             } else {
2000                 st->silk_mode.maxInternalSampleRate = 16000;
2001             }
2002         }
2003         break;
2004         case OPUS_GET_BANDWIDTH_REQUEST:
2005         {
2006             opus_int32 *value = va_arg(ap, opus_int32*);
2007             *value = st->bandwidth;
2008         }
2009         break;
2010         case OPUS_SET_DTX_REQUEST:
2011         {
2012             opus_int32 value = va_arg(ap, opus_int32);
2013             if(value<0 || value>1)
2014                 return OPUS_BAD_ARG;
2015             st->silk_mode.useDTX = value;
2016         }
2017         break;
2018         case OPUS_GET_DTX_REQUEST:
2019         {
2020             opus_int32 *value = va_arg(ap, opus_int32*);
2021             *value = st->silk_mode.useDTX;
2022         }
2023         break;
2024         case OPUS_SET_COMPLEXITY_REQUEST:
2025         {
2026             opus_int32 value = va_arg(ap, opus_int32);
2027             if(value<0 || value>10)
2028                 return OPUS_BAD_ARG;
2029             st->silk_mode.complexity = value;
2030             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
2031         }
2032         break;
2033         case OPUS_GET_COMPLEXITY_REQUEST:
2034         {
2035             opus_int32 *value = va_arg(ap, opus_int32*);
2036             *value = st->silk_mode.complexity;
2037         }
2038         break;
2039         case OPUS_SET_INBAND_FEC_REQUEST:
2040         {
2041             opus_int32 value = va_arg(ap, opus_int32);
2042             if(value<0 || value>1)
2043                 return OPUS_BAD_ARG;
2044             st->silk_mode.useInBandFEC = value;
2045         }
2046         break;
2047         case OPUS_GET_INBAND_FEC_REQUEST:
2048         {
2049             opus_int32 *value = va_arg(ap, opus_int32*);
2050             *value = st->silk_mode.useInBandFEC;
2051         }
2052         break;
2053         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
2054         {
2055             opus_int32 value = va_arg(ap, opus_int32);
2056             if (value < 0 || value > 100)
2057                 return OPUS_BAD_ARG;
2058             st->silk_mode.packetLossPercentage = value;
2059             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
2060         }
2061         break;
2062         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
2063         {
2064             opus_int32 *value = va_arg(ap, opus_int32*);
2065             *value = st->silk_mode.packetLossPercentage;
2066         }
2067         break;
2068         case OPUS_SET_VBR_REQUEST:
2069         {
2070             opus_int32 value = va_arg(ap, opus_int32);
2071             if(value<0 || value>1)
2072                 return OPUS_BAD_ARG;
2073             st->use_vbr = value;
2074             st->silk_mode.useCBR = 1-value;
2075         }
2076         break;
2077         case OPUS_GET_VBR_REQUEST:
2078         {
2079             opus_int32 *value = va_arg(ap, opus_int32*);
2080             *value = st->use_vbr;
2081         }
2082         break;
2083         case OPUS_SET_VOICE_RATIO_REQUEST:
2084         {
2085             opus_int32 value = va_arg(ap, opus_int32);
2086             if (value>100 || value<-1)
2087                 goto bad_arg;
2088             st->voice_ratio = value;
2089         }
2090         break;
2091         case OPUS_GET_VOICE_RATIO_REQUEST:
2092         {
2093             opus_int32 *value = va_arg(ap, opus_int32*);
2094             *value = st->voice_ratio;
2095         }
2096         break;
2097         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
2098         {
2099             opus_int32 value = va_arg(ap, opus_int32);
2100             if(value<0 || value>1)
2101                 return OPUS_BAD_ARG;
2102             st->vbr_constraint = value;
2103         }
2104         break;
2105         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
2106         {
2107             opus_int32 *value = va_arg(ap, opus_int32*);
2108             *value = st->vbr_constraint;
2109         }
2110         break;
2111         case OPUS_SET_SIGNAL_REQUEST:
2112         {
2113             opus_int32 value = va_arg(ap, opus_int32);
2114             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
2115                 return OPUS_BAD_ARG;
2116             st->signal_type = value;
2117         }
2118         break;
2119         case OPUS_GET_SIGNAL_REQUEST:
2120         {
2121             opus_int32 *value = va_arg(ap, opus_int32*);
2122             *value = st->signal_type;
2123         }
2124         break;
2125         case OPUS_GET_LOOKAHEAD_REQUEST:
2126         {
2127             opus_int32 *value = va_arg(ap, opus_int32*);
2128             *value = st->Fs/400;
2129             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2130                 *value += st->delay_compensation;
2131         }
2132         break;
2133         case OPUS_GET_SAMPLE_RATE_REQUEST:
2134         {
2135             opus_int32 *value = va_arg(ap, opus_int32*);
2136             if (value==NULL)
2137             {
2138                 ret = OPUS_BAD_ARG;
2139                 break;
2140             }
2141             *value = st->Fs;
2142         }
2143         break;
2144         case OPUS_GET_FINAL_RANGE_REQUEST:
2145         {
2146             opus_uint32 *value = va_arg(ap, opus_uint32*);
2147             *value = st->rangeFinal;
2148         }
2149         break;
2150         case OPUS_SET_LSB_DEPTH_REQUEST:
2151         {
2152             opus_int32 value = va_arg(ap, opus_int32);
2153             if (value<8 || value>24)
2154                goto bad_arg;
2155             st->lsb_depth=value;
2156         }
2157         break;
2158         case OPUS_GET_LSB_DEPTH_REQUEST:
2159         {
2160             opus_int32 *value = va_arg(ap, opus_int32*);
2161             *value = st->lsb_depth;
2162         }
2163         break;
2164         case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
2165         {
2166             opus_int32 value = va_arg(ap, opus_int32);
2167             st->variable_duration = value;
2168             celt_encoder_ctl(celt_enc, OPUS_SET_EXPERT_FRAME_DURATION(value));
2169         }
2170         break;
2171         case OPUS_GET_EXPERT_FRAME_DURATION_REQUEST:
2172         {
2173             opus_int32 *value = va_arg(ap, opus_int32*);
2174             *value = st->variable_duration;
2175         }
2176         break;
2177         case OPUS_RESET_STATE:
2178         {
2179            void *silk_enc;
2180            silk_EncControlStruct dummy;
2181            silk_enc = (char*)st+st->silk_enc_offset;
2182
2183            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
2184                  sizeof(OpusEncoder)-
2185                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
2186
2187            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2188            silk_InitEncoder( silk_enc, &dummy );
2189            st->stream_channels = st->channels;
2190            st->hybrid_stereo_width_Q14 = 1 << 14;
2191            st->prev_HB_gain = Q15ONE;
2192            st->first = 1;
2193            st->mode = MODE_HYBRID;
2194            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
2195            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
2196         }
2197         break;
2198         case OPUS_SET_FORCE_MODE_REQUEST:
2199         {
2200             opus_int32 value = va_arg(ap, opus_int32);
2201             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
2202                goto bad_arg;
2203             st->user_forced_mode = value;
2204         }
2205         break;
2206
2207         case CELT_GET_MODE_REQUEST:
2208         {
2209            const CELTMode ** value = va_arg(ap, const CELTMode**);
2210            if (value==0)
2211               goto bad_arg;
2212            celt_encoder_ctl(celt_enc, CELT_GET_MODE(value));
2213         }
2214         break;
2215         default:
2216             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
2217             ret = OPUS_UNIMPLEMENTED;
2218             break;
2219     }
2220     va_end(ap);
2221     return ret;
2222 bad_arg:
2223     va_end(ap);
2224     return OPUS_BAD_ARG;
2225 }
2226
2227 void opus_encoder_destroy(OpusEncoder *st)
2228 {
2229     opus_free(st);
2230 }