Makes bandwidth detection less aggressive.
[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
601    /* Makes variable framesize less aggressive at lower bitrates, but I can't
602       find any valid theretical justification for this (other than it seems
603       to help) */
604    frame_cost *= 720/rate;
605    for (i=0;i<16;i++)
606    {
607       /* Impossible state */
608       states[0][i] = -1;
609       cost[0][i] = 1e10;
610    }
611    for (i=0;i<4;i++)
612    {
613       cost[0][1<<i] = frame_cost + rate*(1<<i)*transient_boost(E, E_1, i, N+1);
614       states[0][1<<i] = i;
615    }
616    for (i=1;i<N;i++)
617    {
618       int j;
619
620       /* Follow continuations */
621       for (j=2;j<16;j++)
622       {
623          cost[i][j] = cost[i-1][j-1];
624          states[i][j] = j-1;
625       }
626
627       /* New frames */
628       for(j=0;j<4;j++)
629       {
630          int k;
631          float min_cost;
632          float curr_cost;
633          states[i][1<<j] = 1;
634          min_cost = cost[i-1][1];
635          for(k=1;k<4;k++)
636          {
637             float tmp = cost[i-1][(1<<(k+1))-1];
638             if (tmp < min_cost)
639             {
640                states[i][1<<j] = (1<<(k+1))-1;
641                min_cost = tmp;
642             }
643          }
644          curr_cost = frame_cost+rate*(1<<j)*transient_boost(E+i, E_1+i, j, N-i+1);
645          cost[i][1<<j] = min_cost;
646          /* If part of the frame is outside the analysis window, only count part of the cost */
647          if (N-i < (1<<j))
648             cost[i][1<<j] += curr_cost*(float)(N-i)/(1<<j);
649          else
650             cost[i][1<<j] += curr_cost;
651       }
652    }
653
654    best_state=1;
655    best_cost = cost[N-1][1];
656    /* Find best end state (doesn't force a frame to end at N-1) */
657    for (i=2;i<16;i++)
658    {
659       if (cost[N-1][i]<best_cost)
660       {
661          best_cost = cost[N-1][i];
662          best_state = i;
663       }
664    }
665
666    /* Follow transitions back */
667    for (i=N-1;i>=0;i--)
668    {
669       /*printf("%d ", best_state);*/
670       best_state = states[i][best_state];
671    }
672    /*printf("%d\n", best_state);*/
673    return best_state;
674 }
675
676 void downmix_float(const void *_x, float *sub, int subframe, int offset, int C)
677 {
678    const float *x;
679    int c, j;
680    x = (const float *)_x;
681    for (j=0;j<subframe;j++)
682       sub[j] = x[(j+offset)*C];
683    for (c=1;c<C;c++)
684       for (j=0;j<subframe;j++)
685          sub[j] += x[(j+offset)*C+c];
686 }
687
688 void downmix_int(const void *_x, float *sub, int subframe, int offset, int C)
689 {
690    const opus_int16 *x;
691    int c, j;
692    x = (const opus_int16 *)_x;
693    for (j=0;j<subframe;j++)
694       sub[j] = x[(j+offset)*C];
695    for (c=1;c<C;c++)
696       for (j=0;j<subframe;j++)
697          sub[j] += x[(j+offset)*C+c];
698    for (j=0;j<subframe;j++)
699       sub[j] *= (1.f/32768);
700 }
701
702 int optimize_framesize(const opus_val16 *x, int len, int C, opus_int32 Fs,
703                 int bitrate, opus_val16 tonality, opus_val32 *mem, int buffering,
704                 downmix_func downmix)
705 {
706    int N;
707    int i;
708    float e[MAX_DYNAMIC_FRAMESIZE+4];
709    float e_1[MAX_DYNAMIC_FRAMESIZE+3];
710    float memx;
711    int bestLM=0;
712    int subframe;
713    int pos;
714    VARDECL(opus_val16, sub);
715
716    subframe = Fs/400;
717    ALLOC(sub, subframe, opus_val16);
718    e[0]=mem[0];
719    e_1[0]=1./(EPSILON+mem[0]);
720    if (buffering)
721    {
722       /* Consider the CELT delay when not in restricted-lowdelay */
723       /* We assume the buffering is between 2.5 and 5 ms */
724       int offset = 2*subframe - buffering;
725       celt_assert(offset>=0 && offset <= subframe);
726       x += C*offset;
727       len -= offset;
728       e[1]=mem[1];
729       e_1[1]=1./(EPSILON+mem[1]);
730       e[2]=mem[2];
731       e_1[2]=1./(EPSILON+mem[2]);
732       pos = 3;
733    } else {
734       pos=1;
735    }
736    N=IMIN(len/subframe, MAX_DYNAMIC_FRAMESIZE);
737    memx = x[0];
738    for (i=0;i<N;i++)
739    {
740       float tmp;
741       float tmpx;
742       int j;
743       tmp=EPSILON;
744
745       downmix(x, sub, subframe, i*subframe, C);
746       if (i==0)
747          memx = sub[0];
748       for (j=0;j<subframe;j++)
749       {
750          tmpx = sub[j];
751          tmp += (tmpx-memx)*(tmpx-memx);
752          memx = tmpx;
753       }
754       e[i+pos] = tmp;
755       e_1[i+pos] = 1.f/tmp;
756    }
757    /* Hack to get 20 ms working with APPLICATION_AUDIO
758       The real problem is that the corresponding memory needs to use 1.5 ms
759       from this frame and 1 ms from the next frame */
760    e[i+pos] = e[i+pos-1];
761    if (buffering)
762       N=IMIN(MAX_DYNAMIC_FRAMESIZE, N+2);
763    bestLM = transient_viterbi(e, e_1, N, (1.f+.5*tonality)*(40*C+40), bitrate/400);
764    mem[0] = e[1<<bestLM];
765    if (buffering)
766    {
767       mem[1] = e[(1<<bestLM)+1];
768       mem[2] = e[(1<<bestLM)+2];
769    }
770    return bestLM;
771 }
772
773 #endif
774
775 opus_int32 frame_size_select(opus_int32 frame_size, int variable_duration, opus_int32 Fs)
776 {
777    int new_size;
778    if (frame_size<Fs/400)
779       return -1;
780    if (variable_duration == OPUS_FRAMESIZE_ARG)
781       new_size = frame_size;
782    else if (variable_duration == OPUS_FRAMESIZE_VARIABLE)
783       new_size = Fs/50;
784    else if (variable_duration >= OPUS_FRAMESIZE_2_5_MS && variable_duration <= OPUS_FRAMESIZE_60_MS)
785       new_size = IMIN(3*Fs/50, (Fs/400)<<(variable_duration-OPUS_FRAMESIZE_2_5_MS));
786    else
787       return -1;
788    if (new_size>frame_size)
789       return -1;
790    if (400*new_size!=Fs && 200*new_size!=Fs && 100*new_size!=Fs &&
791             50*new_size!=Fs && 25*new_size!=Fs && 50*new_size!=3*Fs)
792       return -1;
793    return new_size;
794 }
795
796 opus_val16 compute_stereo_width(const opus_val16 *pcm, int frame_size, opus_int32 Fs, StereoWidthState *mem)
797 {
798    opus_val16 corr;
799    opus_val16 ldiff;
800    opus_val16 width;
801    opus_val32 xx, xy, yy;
802    opus_val16 sqrt_xx, sqrt_yy;
803    opus_val16 qrrt_xx, qrrt_yy;
804    int frame_rate;
805    int i;
806    opus_val16 short_alpha;
807
808    frame_rate = Fs/frame_size;
809    short_alpha = Q15ONE - 25*Q15ONE/IMAX(50,frame_rate);
810    xx=xy=yy=0;
811    for (i=0;i<frame_size;i+=4)
812    {
813       opus_val32 pxx=0;
814       opus_val32 pxy=0;
815       opus_val32 pyy=0;
816       opus_val16 x, y;
817       x = pcm[2*i];
818       y = pcm[2*i+1];
819       pxx = SHR32(MULT16_16(x,x),2);
820       pxy = SHR32(MULT16_16(x,y),2);
821       pyy = SHR32(MULT16_16(y,y),2);
822       x = pcm[2*i+2];
823       y = pcm[2*i+3];
824       pxx += SHR32(MULT16_16(x,x),2);
825       pxy += SHR32(MULT16_16(x,y),2);
826       pyy += SHR32(MULT16_16(y,y),2);
827       x = pcm[2*i+4];
828       y = pcm[2*i+5];
829       pxx += SHR32(MULT16_16(x,x),2);
830       pxy += SHR32(MULT16_16(x,y),2);
831       pyy += SHR32(MULT16_16(y,y),2);
832       x = pcm[2*i+6];
833       y = pcm[2*i+7];
834       pxx += SHR32(MULT16_16(x,x),2);
835       pxy += SHR32(MULT16_16(x,y),2);
836       pyy += SHR32(MULT16_16(y,y),2);
837
838       xx += SHR32(pxx, 10);
839       xy += SHR32(pxy, 10);
840       yy += SHR32(pyy, 10);
841    }
842    mem->XX += MULT16_32_Q15(short_alpha, xx-mem->XX);
843    mem->XY += MULT16_32_Q15(short_alpha, xy-mem->XY);
844    mem->YY += MULT16_32_Q15(short_alpha, yy-mem->YY);
845    mem->XX = MAX32(0, mem->XX);
846    mem->XY = MAX32(0, mem->XY);
847    mem->YY = MAX32(0, mem->YY);
848    if (MAX32(mem->XX, mem->YY)>QCONST16(8e-4f, 18))
849    {
850       sqrt_xx = celt_sqrt(mem->XX);
851       sqrt_yy = celt_sqrt(mem->YY);
852       qrrt_xx = celt_sqrt(sqrt_xx);
853       qrrt_yy = celt_sqrt(sqrt_yy);
854       /* Inter-channel correlation */
855       mem->XY = MIN32(mem->XY, sqrt_xx*sqrt_yy);
856       corr = SHR32(frac_div32(mem->XY,EPSILON+MULT16_16(sqrt_xx,sqrt_yy)),16);
857       /* Approximate loudness difference */
858       ldiff = Q15ONE*ABS16(qrrt_xx-qrrt_yy)/(EPSILON+qrrt_xx+qrrt_yy);
859       width = MULT16_16_Q15(celt_sqrt(QCONST32(1.f,30)-MULT16_16(corr,corr)), ldiff);
860       /* Smoothing over one second */
861       mem->smoothed_width += (width-mem->smoothed_width)/frame_rate;
862       /* Peak follower */
863       mem->max_follower = MAX16(mem->max_follower-QCONST16(.02f,15)/frame_rate, mem->smoothed_width);
864    } else {
865       width = 0;
866       corr=Q15ONE;
867       ldiff=0;
868    }
869    /*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);*/
870    return EXTRACT16(MIN32(Q15ONE,20*mem->max_follower));
871 }
872
873 opus_int32 opus_encode_native(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
874                 unsigned char *data, opus_int32 out_data_bytes, int lsb_depth
875 #ifndef FIXED_POINT
876                 , AnalysisInfo *analysis_info
877 #endif
878                 )
879 {
880     void *silk_enc;
881     CELTEncoder *celt_enc;
882     int i;
883     int ret=0;
884     opus_int32 nBytes;
885     ec_enc enc;
886     int bytes_target;
887     int prefill=0;
888     int start_band = 0;
889     int redundancy = 0;
890     int redundancy_bytes = 0; /* Number of bytes to use for redundancy frame */
891     int celt_to_silk = 0;
892     VARDECL(opus_val16, pcm_buf);
893     int nb_compr_bytes;
894     int to_celt = 0;
895     opus_uint32 redundant_rng = 0;
896     int cutoff_Hz, hp_freq_smth1;
897     int voice_est; /* Probability of voice in Q7 */
898     opus_int32 equiv_rate;
899     int delay_compensation;
900     int frame_rate;
901     opus_int32 max_rate; /* Max bitrate we're allowed to use */
902     int curr_bandwidth;
903     opus_val16 HB_gain;
904     opus_int32 max_data_bytes; /* Max number of bytes we're allowed to use */
905     int total_buffer;
906     opus_val16 stereo_width;
907     VARDECL(opus_val16, tmp_prefill);
908
909     ALLOC_STACK;
910
911     max_data_bytes = IMIN(1276, out_data_bytes);
912
913     st->rangeFinal = 0;
914     if ((!st->variable_duration && 400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
915          50*frame_size != st->Fs &&  25*frame_size != st->Fs &&  50*frame_size != 3*st->Fs)
916          || (400*frame_size < st->Fs)
917          || max_data_bytes<=0
918          )
919     {
920        RESTORE_STACK;
921        return OPUS_BAD_ARG;
922     }
923     silk_enc = (char*)st+st->silk_enc_offset;
924     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
925     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
926        delay_compensation = 0;
927     else
928        delay_compensation = st->delay_compensation;
929
930     lsb_depth = IMIN(lsb_depth, st->lsb_depth);
931
932     st->voice_ratio = -1;
933
934 #ifndef FIXED_POINT
935     st->detected_bandwidth = 0;
936     if (analysis_info->valid)
937     {
938        if (st->signal_type == OPUS_AUTO)
939           st->voice_ratio = (int)floor(.5+100*(1-analysis_info->music_prob));
940        st->detected_bandwidth = analysis_info->opus_bandwidth;
941     }
942 #endif
943
944     if (st->channels==2 && st->force_channels!=1)
945        stereo_width = compute_stereo_width(pcm, frame_size, st->Fs, &st->width_mem);
946     else
947        stereo_width = 0;
948     total_buffer = delay_compensation;
949     st->bitrate_bps = user_bitrate_to_bitrate(st, frame_size, max_data_bytes);
950
951     frame_rate = st->Fs/frame_size;
952     if (max_data_bytes<3 || st->bitrate_bps < 3*frame_rate*8
953        || (frame_rate<50 && (max_data_bytes*frame_rate<300 || st->bitrate_bps < 2400)))
954     {
955        /*If the space is too low to do something useful, emit 'PLC' frames.*/
956        int tocmode = st->mode;
957        int bw = st->bandwidth == 0 ? OPUS_BANDWIDTH_NARROWBAND : st->bandwidth;
958        if (tocmode==0)
959           tocmode = MODE_SILK_ONLY;
960        if (frame_rate>100)
961           tocmode = MODE_CELT_ONLY;
962        if (frame_rate < 50)
963           tocmode = MODE_SILK_ONLY;
964        if(tocmode==MODE_SILK_ONLY&&bw>OPUS_BANDWIDTH_WIDEBAND)
965           bw=OPUS_BANDWIDTH_WIDEBAND;
966        else if (tocmode==MODE_CELT_ONLY&&bw==OPUS_BANDWIDTH_MEDIUMBAND)
967           bw=OPUS_BANDWIDTH_NARROWBAND;
968        else if (bw<=OPUS_BANDWIDTH_SUPERWIDEBAND)
969           bw=OPUS_BANDWIDTH_SUPERWIDEBAND;
970        data[0] = gen_toc(tocmode, frame_rate, bw, st->stream_channels);
971        RESTORE_STACK;
972        return 1;
973     }
974     if (!st->use_vbr)
975     {
976        int cbrBytes;
977        cbrBytes = IMIN( (st->bitrate_bps + 4*frame_rate)/(8*frame_rate) , max_data_bytes);
978        st->bitrate_bps = cbrBytes * (8*frame_rate);
979        max_data_bytes = cbrBytes;
980     }
981     max_rate = frame_rate*max_data_bytes*8;
982
983     /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */
984     equiv_rate = st->bitrate_bps - 60*(st->Fs/frame_size - 50);
985
986     if (st->signal_type == OPUS_SIGNAL_VOICE)
987        voice_est = 127;
988     else if (st->signal_type == OPUS_SIGNAL_MUSIC)
989        voice_est = 0;
990     else if (st->voice_ratio >= 0)
991     {
992        voice_est = st->voice_ratio*327>>8;
993        /* For AUDIO, never be more than 90% confident of having speech */
994        if (st->application == OPUS_APPLICATION_AUDIO)
995           voice_est = IMIN(voice_est, 115);
996     } else if (st->application == OPUS_APPLICATION_VOIP)
997        voice_est = 115;
998     else
999        voice_est = 48;
1000
1001     if (st->force_channels!=OPUS_AUTO && st->channels == 2)
1002     {
1003         st->stream_channels = st->force_channels;
1004     } else {
1005 #ifdef FUZZING
1006        /* Random mono/stereo decision */
1007        if (st->channels == 2 && (rand()&0x1F)==0)
1008           st->stream_channels = 3-st->stream_channels;
1009 #else
1010        /* Rate-dependent mono-stereo decision */
1011        if (st->channels == 2)
1012        {
1013           opus_int32 stereo_threshold;
1014           stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14);
1015           if (st->stream_channels == 2)
1016              stereo_threshold -= 1000;
1017           else
1018              stereo_threshold += 1000;
1019           st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1;
1020        } else {
1021           st->stream_channels = st->channels;
1022        }
1023 #endif
1024     }
1025
1026     /* Mode selection depending on application and signal type */
1027     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1028     {
1029        st->mode = MODE_CELT_ONLY;
1030     } else if (st->user_forced_mode == OPUS_AUTO)
1031     {
1032 #ifdef FUZZING
1033        /* Random mode switching */
1034        if ((rand()&0xF)==0)
1035        {
1036           if ((rand()&0x1)==0)
1037              st->mode = MODE_CELT_ONLY;
1038           else
1039              st->mode = MODE_SILK_ONLY;
1040        } else {
1041           if (st->prev_mode==MODE_CELT_ONLY)
1042              st->mode = MODE_CELT_ONLY;
1043           else
1044              st->mode = MODE_SILK_ONLY;
1045        }
1046 #else
1047        opus_int32 mode_voice, mode_music;
1048        opus_int32 threshold;
1049
1050        /* Interpolate based on stereo width */
1051        mode_voice = MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[0][0]) + MULT16_32_Q15(stereo_width,mode_thresholds[1][0]);
1052        mode_music = MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[1][1]) + MULT16_32_Q15(stereo_width,mode_thresholds[1][1]);
1053        /* Interpolate based on speech/music probability */
1054        threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14);
1055        /* Bias towards SILK for VoIP because of some useful features */
1056        if (st->application == OPUS_APPLICATION_VOIP)
1057           threshold += 8000;
1058
1059        /*printf("%f %d\n", stereo_width/(float)Q15ONE, threshold);*/
1060        /* Hysteresis */
1061        if (st->prev_mode == MODE_CELT_ONLY)
1062            threshold -= 4000;
1063        else if (st->prev_mode>0)
1064            threshold += 4000;
1065
1066        st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY;
1067
1068        /* When FEC is enabled and there's enough packet loss, use SILK */
1069        if (st->silk_mode.useInBandFEC && st->silk_mode.packetLossPercentage > (128-voice_est)>>4)
1070           st->mode = MODE_SILK_ONLY;
1071        /* When encoding voice and DTX is enabled, set the encoder to SILK mode (at least for now) */
1072        if (st->silk_mode.useDTX && voice_est > 100)
1073           st->mode = MODE_SILK_ONLY;
1074 #endif
1075     } else {
1076        st->mode = st->user_forced_mode;
1077     }
1078
1079     /* Override the chosen mode to make sure we meet the requested frame size */
1080     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
1081        st->mode = MODE_CELT_ONLY;
1082
1083     if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0
1084           && st->mode != MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)
1085     {
1086        /* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */
1087        st->silk_mode.toMono = 1;
1088        st->stream_channels = 2;
1089     } else {
1090        st->silk_mode.toMono = 0;
1091     }
1092
1093     if (st->prev_mode > 0 &&
1094         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
1095     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
1096     {
1097         redundancy = 1;
1098         celt_to_silk = (st->mode != MODE_CELT_ONLY);
1099         if (!celt_to_silk)
1100         {
1101             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
1102             if (frame_size >= st->Fs/100)
1103             {
1104                 st->mode = st->prev_mode;
1105                 to_celt = 1;
1106             } else {
1107                 redundancy=0;
1108             }
1109         }
1110     }
1111     /* For the first frame at a new SILK bandwidth */
1112     if (st->silk_bw_switch)
1113     {
1114        redundancy = 1;
1115        celt_to_silk = 1;
1116        st->silk_bw_switch = 0;
1117        prefill=1;
1118     }
1119
1120     if (redundancy)
1121     {
1122        /* Fair share of the max size allowed */
1123        redundancy_bytes = IMIN(257, max_data_bytes*(opus_int32)(st->Fs/200)/(frame_size+st->Fs/200));
1124        /* For VBR, target the actual bitrate (subject to the limit above) */
1125        if (st->use_vbr)
1126           redundancy_bytes = IMIN(redundancy_bytes, st->bitrate_bps/1600);
1127     }
1128
1129     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
1130     {
1131         silk_EncControlStruct dummy;
1132         silk_InitEncoder( silk_enc, &dummy);
1133         prefill=1;
1134     }
1135
1136     /* Automatic (rate-dependent) bandwidth selection */
1137     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
1138     {
1139         const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds;
1140         opus_int32 bandwidth_thresholds[8];
1141         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
1142         opus_int32 equiv_rate2;
1143
1144         equiv_rate2 = equiv_rate;
1145         if (st->mode != MODE_CELT_ONLY)
1146         {
1147            /* Adjust the threshold +/- 10% depending on complexity */
1148            equiv_rate2 = equiv_rate2 * (45+st->silk_mode.complexity)/50;
1149            /* CBR is less efficient by ~1 kb/s */
1150            if (!st->use_vbr)
1151               equiv_rate2 -= 1000;
1152         }
1153         if (st->channels==2 && st->force_channels!=1)
1154         {
1155            voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds;
1156            music_bandwidth_thresholds = stereo_music_bandwidth_thresholds;
1157         } else {
1158            voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds;
1159            music_bandwidth_thresholds = mono_music_bandwidth_thresholds;
1160         }
1161         /* Interpolate bandwidth thresholds depending on voice estimation */
1162         for (i=0;i<8;i++)
1163         {
1164            bandwidth_thresholds[i] = music_bandwidth_thresholds[i]
1165                     + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14);
1166         }
1167         do {
1168             int threshold, hysteresis;
1169             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
1170             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
1171             if (!st->first)
1172             {
1173                 if (st->bandwidth >= bandwidth)
1174                     threshold -= hysteresis;
1175                 else
1176                     threshold += hysteresis;
1177             }
1178             if (equiv_rate2 >= threshold)
1179                 break;
1180         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
1181         st->bandwidth = bandwidth;
1182         /* Prevents any transition to SWB/FB until the SILK layer has fully
1183            switched to WB mode and turned the variable LP filter off */
1184         if (!st->first && st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1185             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1186     }
1187
1188     if (st->bandwidth>st->max_bandwidth)
1189        st->bandwidth = st->max_bandwidth;
1190
1191     if (st->user_bandwidth != OPUS_AUTO)
1192         st->bandwidth = st->user_bandwidth;
1193
1194     /* This prevents us from using hybrid at unsafe CBR/max rates */
1195     if (st->mode != MODE_CELT_ONLY && max_rate < 15000)
1196     {
1197        st->bandwidth = IMIN(st->bandwidth, OPUS_BANDWIDTH_WIDEBAND);
1198     }
1199
1200     /* Prevents Opus from wasting bits on frequencies that are above
1201        the Nyquist rate of the input signal */
1202     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
1203         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1204     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1205         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1206     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
1207         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1208     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
1209         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1210 #ifndef FIXED_POINT
1211     /* Use detected bandwidth to reduce the encoded bandwidth. */
1212     if (st->detected_bandwidth && st->user_bandwidth == OPUS_AUTO)
1213     {
1214        /* When operating in SILK/hybrid mode, we don't go below wideband to avoid
1215           more complicated switches that require redundancy */
1216        if (st->mode == MODE_CELT_ONLY)
1217           st->bandwidth = IMIN(st->bandwidth, st->detected_bandwidth);
1218        else
1219           st->bandwidth = IMIN(st->bandwidth, IMAX(OPUS_BANDWIDTH_WIDEBAND, st->detected_bandwidth));
1220     }
1221 #endif
1222     celt_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(lsb_depth));
1223
1224     /* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */
1225     if (max_data_bytes < (frame_rate > 50 ? 12000 : 8000)*frame_size / (st->Fs * 8))
1226        st->mode = MODE_CELT_ONLY;
1227
1228     /* CELT mode doesn't support mediumband, use wideband instead */
1229     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1230         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1231
1232     /* Can't support higher than wideband for >20 ms frames */
1233     if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND))
1234     {
1235        VARDECL(unsigned char, tmp_data);
1236        int nb_frames;
1237        int bak_mode, bak_bandwidth, bak_channels, bak_to_mono;
1238        OpusRepacketizer rp;
1239        opus_int32 bytes_per_frame;
1240
1241
1242        nb_frames = frame_size > st->Fs/25 ? 3 : 2;
1243        bytes_per_frame = IMIN(1276,(out_data_bytes-3)/nb_frames);
1244
1245        ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char);
1246
1247        opus_repacketizer_init(&rp);
1248
1249        bak_mode = st->user_forced_mode;
1250        bak_bandwidth = st->user_bandwidth;
1251        bak_channels = st->force_channels;
1252
1253        st->user_forced_mode = st->mode;
1254        st->user_bandwidth = st->bandwidth;
1255        st->force_channels = st->stream_channels;
1256        bak_to_mono = st->silk_mode.toMono;
1257
1258        if (bak_to_mono)
1259           st->force_channels = 1;
1260        else
1261           st->prev_channels = st->stream_channels;
1262        for (i=0;i<nb_frames;i++)
1263        {
1264           int tmp_len;
1265           st->silk_mode.toMono = 0;
1266           /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
1267           if (to_celt && i==nb_frames-1)
1268              st->user_forced_mode = MODE_CELT_ONLY;
1269           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
1270 #ifndef FIXED_POINT
1271                 , analysis_info
1272 #endif
1273                 );
1274           if (tmp_len<0)
1275           {
1276              RESTORE_STACK;
1277              return OPUS_INTERNAL_ERROR;
1278           }
1279           ret = opus_repacketizer_cat(&rp, tmp_data+i*bytes_per_frame, tmp_len);
1280           if (ret<0)
1281           {
1282              RESTORE_STACK;
1283              return OPUS_INTERNAL_ERROR;
1284           }
1285        }
1286        ret = opus_repacketizer_out(&rp, data, out_data_bytes);
1287        if (ret<0)
1288        {
1289           RESTORE_STACK;
1290           return OPUS_INTERNAL_ERROR;
1291        }
1292        st->user_forced_mode = bak_mode;
1293        st->user_bandwidth = bak_bandwidth;
1294        st->force_channels = bak_channels;
1295        st->silk_mode.toMono = bak_to_mono;
1296        RESTORE_STACK;
1297        return ret;
1298     }
1299     curr_bandwidth = st->bandwidth;
1300
1301     /* Chooses the appropriate mode for speech
1302        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
1303     if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1304         st->mode = MODE_HYBRID;
1305     if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
1306         st->mode = MODE_SILK_ONLY;
1307
1308     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
1309     bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
1310
1311     data += 1;
1312
1313     ec_enc_init(&enc, data, max_data_bytes-1);
1314
1315     ALLOC(pcm_buf, (total_buffer+frame_size)*st->channels, opus_val16);
1316     for (i=0;i<total_buffer*st->channels;i++)
1317        pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-total_buffer)*st->channels+i];
1318
1319     if (st->mode == MODE_CELT_ONLY)
1320        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1321     else
1322        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
1323
1324     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
1325           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
1326
1327     /* convert from log scale to Hertz */
1328     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
1329
1330     if (st->application == OPUS_APPLICATION_VOIP)
1331     {
1332        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1333     } else {
1334        dc_reject(pcm, 3, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1335     }
1336
1337
1338
1339     /* SILK processing */
1340     HB_gain = Q15ONE;
1341     if (st->mode != MODE_CELT_ONLY)
1342     {
1343         opus_int32 total_bitRate, celt_rate;
1344 #ifdef FIXED_POINT
1345        const opus_int16 *pcm_silk;
1346 #else
1347        VARDECL(opus_int16, pcm_silk);
1348        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
1349 #endif
1350
1351         /* Distribute bits between SILK and CELT */
1352         total_bitRate = 8 * bytes_target * frame_rate;
1353         if( st->mode == MODE_HYBRID ) {
1354             int HB_gain_ref;
1355             /* Base rate for SILK */
1356             st->silk_mode.bitRate = st->stream_channels * ( 5000 + 1000 * ( st->Fs == 100 * frame_size ) );
1357             if( curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
1358                 /* SILK gets 2/3 of the remaining bits */
1359                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 2 / 3;
1360             } else { /* FULLBAND */
1361                 /* SILK gets 3/5 of the remaining bits */
1362                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 3 / 5;
1363             }
1364             /* Don't let SILK use more than 80% */
1365             if( st->silk_mode.bitRate > total_bitRate * 4/5 ) {
1366                 st->silk_mode.bitRate = total_bitRate * 4/5;
1367             }
1368             /* Increasingly attenuate high band when it gets allocated fewer bits */
1369             celt_rate = total_bitRate - st->silk_mode.bitRate;
1370             HB_gain_ref = (curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND) ? 3000 : 3600;
1371             HB_gain = SHL32((opus_val32)celt_rate, 9) / SHR32((opus_val32)celt_rate + st->stream_channels * HB_gain_ref, 6);
1372             HB_gain = HB_gain < Q15ONE*6/7 ? HB_gain + Q15ONE/7 : Q15ONE;
1373         } else {
1374             /* SILK gets all bits */
1375             st->silk_mode.bitRate = total_bitRate;
1376         }
1377
1378         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
1379         st->silk_mode.nChannelsAPI = st->channels;
1380         st->silk_mode.nChannelsInternal = st->stream_channels;
1381         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1382             st->silk_mode.desiredInternalSampleRate = 8000;
1383         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1384             st->silk_mode.desiredInternalSampleRate = 12000;
1385         } else {
1386             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
1387             st->silk_mode.desiredInternalSampleRate = 16000;
1388         }
1389         if( st->mode == MODE_HYBRID ) {
1390             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
1391             st->silk_mode.minInternalSampleRate = 16000;
1392         } else {
1393             st->silk_mode.minInternalSampleRate = 8000;
1394         }
1395
1396         if (st->mode == MODE_SILK_ONLY)
1397         {
1398            opus_int32 effective_max_rate = max_rate;
1399            st->silk_mode.maxInternalSampleRate = 16000;
1400            if (frame_rate > 50)
1401               effective_max_rate = effective_max_rate*2/3;
1402            if (effective_max_rate < 13000)
1403            {
1404               st->silk_mode.maxInternalSampleRate = 12000;
1405               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
1406            }
1407            if (effective_max_rate < 9600)
1408            {
1409               st->silk_mode.maxInternalSampleRate = 8000;
1410               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
1411            }
1412         } else {
1413            st->silk_mode.maxInternalSampleRate = 16000;
1414         }
1415
1416         st->silk_mode.useCBR = !st->use_vbr;
1417
1418         /* Call SILK encoder for the low band */
1419         nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes);
1420
1421         st->silk_mode.maxBits = nBytes*8;
1422         /* Only allow up to 90% of the bits for hybrid mode*/
1423         if (st->mode == MODE_HYBRID)
1424            st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
1425         if (st->silk_mode.useCBR)
1426         {
1427            st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
1428            /* Reduce the initial target to make it easier to reach the CBR rate */
1429            st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000);
1430         }
1431
1432         if (prefill)
1433         {
1434             opus_int32 zero=0;
1435             const CELTMode *celt_mode;
1436             int prefill_offset;
1437             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1438             /* Use a smooth onset for the SILK prefill to avoid the encoder trying to encode
1439                a discontinuity. The exact location is what we need to avoid leaving any "gap"
1440                in the audio when mixing with the redundant CELT frame. Here we can afford to
1441                overwrite st->delay_buffer because the only thing that uses it before it gets
1442                rewritten is tmp_prefill[] and even then only the part after the ramp really
1443                gets used (rather than sent to the encoder and discarded) */
1444             prefill_offset = st->channels*(st->encoder_buffer-st->delay_compensation-st->Fs/400);
1445             gain_fade(st->delay_buffer+prefill_offset, st->delay_buffer+prefill_offset,
1446                   0, Q15ONE, celt_mode->overlap, st->Fs/400, st->channels, celt_mode->window, st->Fs);
1447             for(i=0;i<prefill_offset;i++)
1448                st->delay_buffer[i]=0;
1449 #ifdef FIXED_POINT
1450             pcm_silk = st->delay_buffer;
1451 #else
1452             for (i=0;i<st->encoder_buffer*st->channels;i++)
1453                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
1454 #endif
1455             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
1456         }
1457
1458 #ifdef FIXED_POINT
1459         pcm_silk = pcm_buf+total_buffer*st->channels;
1460 #else
1461         for (i=0;i<frame_size*st->channels;i++)
1462             pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
1463 #endif
1464         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
1465         if( ret ) {
1466             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
1467             /* Handle error */
1468            RESTORE_STACK;
1469            return OPUS_INTERNAL_ERROR;
1470         }
1471         if (nBytes==0)
1472         {
1473            st->rangeFinal = 0;
1474            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1475            RESTORE_STACK;
1476            return 1;
1477         }
1478         /* Extract SILK internal bandwidth for signaling in first byte */
1479         if( st->mode == MODE_SILK_ONLY ) {
1480             if( st->silk_mode.internalSampleRate == 8000 ) {
1481                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1482             } else if( st->silk_mode.internalSampleRate == 12000 ) {
1483                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1484             } else if( st->silk_mode.internalSampleRate == 16000 ) {
1485                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1486             }
1487         } else {
1488             silk_assert( st->silk_mode.internalSampleRate == 16000 );
1489         }
1490
1491         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
1492         /* FIXME: How do we allocate the redundancy for CBR? */
1493         if (st->silk_mode.opusCanSwitch)
1494         {
1495            redundancy = 1;
1496            celt_to_silk = 0;
1497            st->silk_bw_switch = 1;
1498         }
1499     }
1500
1501     /* CELT processing */
1502     {
1503         int endband=21;
1504
1505         switch(curr_bandwidth)
1506         {
1507             case OPUS_BANDWIDTH_NARROWBAND:
1508                 endband = 13;
1509                 break;
1510             case OPUS_BANDWIDTH_MEDIUMBAND:
1511             case OPUS_BANDWIDTH_WIDEBAND:
1512                 endband = 17;
1513                 break;
1514             case OPUS_BANDWIDTH_SUPERWIDEBAND:
1515                 endband = 19;
1516                 break;
1517             case OPUS_BANDWIDTH_FULLBAND:
1518                 endband = 21;
1519                 break;
1520         }
1521         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
1522         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
1523     }
1524     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1525     if (st->mode != MODE_SILK_ONLY)
1526     {
1527         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1528         /* Allow prediction unless we decide to disable it later */
1529         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
1530
1531         if (st->mode == MODE_HYBRID)
1532         {
1533             int len;
1534
1535             len = (ec_tell(&enc)+7)>>3;
1536             if (redundancy)
1537                len += st->mode == MODE_HYBRID ? 3 : 1;
1538             if( st->use_vbr ) {
1539                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
1540             } else {
1541                 /* check if SILK used up too much */
1542                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
1543             }
1544         } else {
1545             if (st->use_vbr)
1546             {
1547                 opus_int32 bonus=0;
1548 #ifndef FIXED_POINT
1549                 if (st->variable_duration==OPUS_FRAMESIZE_VARIABLE && frame_size != st->Fs/50)
1550                 {
1551                    bonus = (40*st->stream_channels+40)*(st->Fs/frame_size-50);
1552                    if (analysis_info->valid)
1553                       bonus = bonus*(1.f+.5*analysis_info->tonality);
1554                 }
1555 #endif
1556                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
1557                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
1558                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps+bonus));
1559                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
1560             } else {
1561                 nb_compr_bytes = bytes_target;
1562             }
1563         }
1564
1565     } else {
1566         nb_compr_bytes = 0;
1567     }
1568
1569     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
1570     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
1571     {
1572        for (i=0;i<st->channels*st->Fs/400;i++)
1573           tmp_prefill[i] = st->delay_buffer[(st->encoder_buffer-total_buffer-st->Fs/400)*st->channels + i];
1574     }
1575
1576     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+total_buffer));i++)
1577         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
1578     for (;i<st->encoder_buffer*st->channels;i++)
1579         st->delay_buffer[i] = pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels+i];
1580
1581     /* gain_fade() and stereo_fade() need to be after the buffer copying
1582        because we don't want any of this to affect the SILK part */
1583     if( st->prev_HB_gain < Q15ONE || HB_gain < Q15ONE ) {
1584        const CELTMode *celt_mode;
1585
1586        celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1587        gain_fade(pcm_buf, pcm_buf,
1588              st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs);
1589     }
1590     st->prev_HB_gain = HB_gain;
1591     if (st->mode != MODE_HYBRID || st->stream_channels==1)
1592        st->silk_mode.stereoWidth_Q14 = IMIN((1<<14),IMAX(0,st->bitrate_bps-32000));
1593     if( st->channels == 2 ) {
1594         /* Apply stereo width reduction (at low bitrates) */
1595         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1596             opus_val16 g1, g2;
1597             const CELTMode *celt_mode;
1598
1599             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1600             g1 = st->hybrid_stereo_width_Q14;
1601             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1602 #ifdef FIXED_POINT
1603             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
1604             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
1605 #else
1606             g1 *= (1.f/16384);
1607             g2 *= (1.f/16384);
1608 #endif
1609             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
1610                   frame_size, st->channels, celt_mode->window, st->Fs);
1611             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1612         }
1613     }
1614
1615     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
1616     {
1617         /* For SILK mode, the redundancy is inferred from the length */
1618         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
1619            ec_enc_bit_logp(&enc, redundancy, 12);
1620         if (redundancy)
1621         {
1622             int max_redundancy;
1623             ec_enc_bit_logp(&enc, celt_to_silk, 1);
1624             if (st->mode == MODE_HYBRID)
1625                max_redundancy = (max_data_bytes-1)-nb_compr_bytes-1;
1626             else
1627                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1628             /* Target the same bit-rate for redundancy as for the rest,
1629                up to a max of 257 bytes */
1630             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
1631             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
1632             if (st->mode == MODE_HYBRID)
1633                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
1634         }
1635     } else {
1636         redundancy = 0;
1637     }
1638
1639     if (!redundancy)
1640     {
1641        st->silk_bw_switch = 0;
1642        redundancy_bytes = 0;
1643     }
1644     if (st->mode != MODE_CELT_ONLY)start_band=17;
1645
1646     if (st->mode == MODE_SILK_ONLY)
1647     {
1648         ret = (ec_tell(&enc)+7)>>3;
1649         ec_enc_done(&enc);
1650         nb_compr_bytes = ret;
1651     } else {
1652        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
1653        ec_enc_shrink(&enc, nb_compr_bytes);
1654     }
1655
1656
1657     /* 5 ms redundant frame for CELT->SILK */
1658     if (redundancy && celt_to_silk)
1659     {
1660         int err;
1661         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1662         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1663         err = celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
1664         if (err < 0)
1665         {
1666            RESTORE_STACK;
1667            return OPUS_INTERNAL_ERROR;
1668         }
1669         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1670         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1671     }
1672
1673     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
1674
1675     if (st->mode != MODE_SILK_ONLY)
1676     {
1677         if (st->mode != st->prev_mode && st->prev_mode > 0)
1678         {
1679            unsigned char dummy[2];
1680            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1681
1682            /* Prefilling */
1683            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
1684            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1685         }
1686         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
1687         if (ec_tell(&enc) <= 8*nb_compr_bytes)
1688         {
1689 #ifndef FIXED_POINT
1690            celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(analysis_info));
1691 #endif
1692            ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
1693            if (ret < 0)
1694            {
1695               RESTORE_STACK;
1696               return OPUS_INTERNAL_ERROR;
1697            }
1698         }
1699     }
1700
1701     /* 5 ms redundant frame for SILK->CELT */
1702     if (redundancy && !celt_to_silk)
1703     {
1704         int err;
1705         unsigned char dummy[2];
1706         int N2, N4;
1707         N2 = st->Fs/200;
1708         N4 = st->Fs/400;
1709
1710         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1711         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1712         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1713
1714         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1715         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL);
1716
1717         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1718         if (err < 0)
1719         {
1720            RESTORE_STACK;
1721            return OPUS_INTERNAL_ERROR;
1722         }
1723         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1724     }
1725
1726
1727
1728     /* Signalling the mode in the first byte */
1729     data--;
1730     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1731
1732     st->rangeFinal = enc.rng ^ redundant_rng;
1733
1734     if (to_celt)
1735         st->prev_mode = MODE_CELT_ONLY;
1736     else
1737         st->prev_mode = st->mode;
1738     st->prev_channels = st->stream_channels;
1739     st->prev_framesize = frame_size;
1740
1741     st->first = 0;
1742
1743     /* In the unlikely case that the SILK encoder busted its target, tell
1744        the decoder to call the PLC */
1745     if (ec_tell(&enc) > (max_data_bytes-1)*8)
1746     {
1747        if (max_data_bytes < 2)
1748        {
1749           RESTORE_STACK;
1750           return OPUS_BUFFER_TOO_SMALL;
1751        }
1752        data[1] = 0;
1753        ret = 1;
1754        st->rangeFinal = 0;
1755     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
1756     {
1757        /*When in LPC only mode it's perfectly
1758          reasonable to strip off trailing zero bytes as
1759          the required range decoder behavior is to
1760          fill these in. This can't be done when the MDCT
1761          modes are used because the decoder needs to know
1762          the actual length for allocation purposes.*/
1763        while(ret>2&&data[ret]==0)ret--;
1764     }
1765     /* Count ToC and redundancy */
1766     ret += 1+redundancy_bytes;
1767     if (!st->use_vbr && ret >= 3)
1768     {
1769        if (pad_frame(data, ret, max_data_bytes))
1770        {
1771           RESTORE_STACK;
1772           return OPUS_INTERNAL_ERROR;
1773        }
1774        ret = max_data_bytes;
1775     }
1776     RESTORE_STACK;
1777     return ret;
1778 }
1779
1780 #ifdef FIXED_POINT
1781
1782 #ifndef DISABLE_FLOAT_API
1783 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1784       unsigned char *data, opus_int32 max_data_bytes)
1785 {
1786    int i, ret;
1787    VARDECL(opus_int16, in);
1788    ALLOC_STACK;
1789
1790    frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1791    if(frame_size<0)
1792    {
1793       RESTORE_STACK;
1794       return OPUS_BAD_ARG;
1795    }
1796
1797    ALLOC(in, frame_size*st->channels, opus_int16);
1798
1799    for (i=0;i<frame_size*st->channels;i++)
1800       in[i] = FLOAT2INT16(pcm[i]);
1801    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16);
1802    RESTORE_STACK;
1803    return ret;
1804 }
1805 #endif
1806
1807 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1808                 unsigned char *data, opus_int32 out_data_bytes)
1809 {
1810    frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1811    if(frame_size<0)
1812    {
1813       return OPUS_BAD_ARG;
1814    }
1815    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 16);
1816 }
1817
1818 #else
1819 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1820       unsigned char *data, opus_int32 max_data_bytes)
1821 {
1822    int i, ret;
1823    const CELTMode *celt_mode;
1824    int delay_compensation;
1825    int lsb_depth;
1826    VARDECL(float, in);
1827    AnalysisInfo analysis_info;
1828    ALLOC_STACK;
1829
1830    opus_encoder_ctl(st, CELT_GET_MODE(&celt_mode));
1831    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1832       delay_compensation = 0;
1833    else
1834       delay_compensation = st->delay_compensation;
1835
1836    lsb_depth = IMIN(16, st->lsb_depth);
1837
1838    analysis_info.valid = 0;
1839    if (st->silk_mode.complexity >= 7 && st->Fs==48000)
1840    {
1841       frame_size = run_analysis(&st->analysis, celt_mode, pcm, pcm+st->channels*st->analysis.analysis_offset,
1842             frame_size, st->variable_duration, st->channels, st->Fs, st->bitrate_bps, delay_compensation, lsb_depth, downmix_int, &analysis_info);
1843    } else {
1844       frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1845    }
1846    if(frame_size<0)
1847    {
1848       RESTORE_STACK;
1849       return OPUS_BAD_ARG;
1850    }
1851
1852    ALLOC(in, frame_size*st->channels, float);
1853
1854    for (i=0;i<frame_size*st->channels;i++)
1855       in[i] = (1.0f/32768)*pcm[i];
1856    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16, &analysis_info);
1857    RESTORE_STACK;
1858    return ret;
1859 }
1860 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1861                       unsigned char *data, opus_int32 out_data_bytes)
1862 {
1863    const CELTMode *celt_mode;
1864    int delay_compensation;
1865    int lsb_depth;
1866    AnalysisInfo analysis_info;
1867
1868    opus_encoder_ctl(st, CELT_GET_MODE(&celt_mode));
1869    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1870       delay_compensation = 0;
1871    else
1872       delay_compensation = st->delay_compensation;
1873
1874    lsb_depth = IMIN(24, st->lsb_depth);
1875
1876    analysis_info.valid = 0;
1877    if (st->silk_mode.complexity >= 7 && st->Fs==48000)
1878    {
1879       frame_size = run_analysis(&st->analysis, celt_mode, pcm, pcm+st->channels*st->analysis.analysis_offset,
1880             frame_size, st->variable_duration, st->channels, st->Fs, st->bitrate_bps, delay_compensation, lsb_depth, downmix_float, &analysis_info);
1881    } else {
1882       frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1883    }
1884    if(frame_size<0)
1885    {
1886       return OPUS_BAD_ARG;
1887    }
1888
1889    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 24, &analysis_info);
1890
1891 }
1892 #endif
1893
1894
1895 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
1896 {
1897     int ret;
1898     CELTEncoder *celt_enc;
1899     va_list ap;
1900
1901     ret = OPUS_OK;
1902     va_start(ap, request);
1903
1904     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1905
1906     switch (request)
1907     {
1908         case OPUS_SET_APPLICATION_REQUEST:
1909         {
1910             opus_int32 value = va_arg(ap, opus_int32);
1911             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
1912                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1913                || (!st->first && st->application != value))
1914             {
1915                ret = OPUS_BAD_ARG;
1916                break;
1917             }
1918             st->application = value;
1919         }
1920         break;
1921         case OPUS_GET_APPLICATION_REQUEST:
1922         {
1923             opus_int32 *value = va_arg(ap, opus_int32*);
1924             *value = st->application;
1925         }
1926         break;
1927         case OPUS_SET_BITRATE_REQUEST:
1928         {
1929             opus_int32 value = va_arg(ap, opus_int32);
1930             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1931             {
1932                 if (value <= 0)
1933                     goto bad_arg;
1934                 else if (value <= 500)
1935                     value = 500;
1936                 else if (value > (opus_int32)300000*st->channels)
1937                     value = (opus_int32)300000*st->channels;
1938             }
1939             st->user_bitrate_bps = value;
1940         }
1941         break;
1942         case OPUS_GET_BITRATE_REQUEST:
1943         {
1944             opus_int32 *value = va_arg(ap, opus_int32*);
1945             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
1946         }
1947         break;
1948         case OPUS_SET_FORCE_CHANNELS_REQUEST:
1949         {
1950             opus_int32 value = va_arg(ap, opus_int32);
1951             if((value<1 || value>st->channels) && value != OPUS_AUTO)
1952                 return OPUS_BAD_ARG;
1953             st->force_channels = value;
1954         }
1955         break;
1956         case OPUS_GET_FORCE_CHANNELS_REQUEST:
1957         {
1958             opus_int32 *value = va_arg(ap, opus_int32*);
1959             *value = st->force_channels;
1960         }
1961         break;
1962         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
1963         {
1964             opus_int32 value = va_arg(ap, opus_int32);
1965             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND)
1966                 return OPUS_BAD_ARG;
1967             st->max_bandwidth = value;
1968             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1969                 st->silk_mode.maxInternalSampleRate = 8000;
1970             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1971                 st->silk_mode.maxInternalSampleRate = 12000;
1972             } else {
1973                 st->silk_mode.maxInternalSampleRate = 16000;
1974             }
1975         }
1976         break;
1977         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
1978         {
1979             opus_int32 *value = va_arg(ap, opus_int32*);
1980             *value = st->max_bandwidth;
1981         }
1982         break;
1983         case OPUS_SET_BANDWIDTH_REQUEST:
1984         {
1985             opus_int32 value = va_arg(ap, opus_int32);
1986             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
1987                 return OPUS_BAD_ARG;
1988             st->user_bandwidth = value;
1989             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1990                 st->silk_mode.maxInternalSampleRate = 8000;
1991             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1992                 st->silk_mode.maxInternalSampleRate = 12000;
1993             } else {
1994                 st->silk_mode.maxInternalSampleRate = 16000;
1995             }
1996         }
1997         break;
1998         case OPUS_GET_BANDWIDTH_REQUEST:
1999         {
2000             opus_int32 *value = va_arg(ap, opus_int32*);
2001             *value = st->bandwidth;
2002         }
2003         break;
2004         case OPUS_SET_DTX_REQUEST:
2005         {
2006             opus_int32 value = va_arg(ap, opus_int32);
2007             if(value<0 || value>1)
2008                 return OPUS_BAD_ARG;
2009             st->silk_mode.useDTX = value;
2010         }
2011         break;
2012         case OPUS_GET_DTX_REQUEST:
2013         {
2014             opus_int32 *value = va_arg(ap, opus_int32*);
2015             *value = st->silk_mode.useDTX;
2016         }
2017         break;
2018         case OPUS_SET_COMPLEXITY_REQUEST:
2019         {
2020             opus_int32 value = va_arg(ap, opus_int32);
2021             if(value<0 || value>10)
2022                 return OPUS_BAD_ARG;
2023             st->silk_mode.complexity = value;
2024             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
2025         }
2026         break;
2027         case OPUS_GET_COMPLEXITY_REQUEST:
2028         {
2029             opus_int32 *value = va_arg(ap, opus_int32*);
2030             *value = st->silk_mode.complexity;
2031         }
2032         break;
2033         case OPUS_SET_INBAND_FEC_REQUEST:
2034         {
2035             opus_int32 value = va_arg(ap, opus_int32);
2036             if(value<0 || value>1)
2037                 return OPUS_BAD_ARG;
2038             st->silk_mode.useInBandFEC = value;
2039         }
2040         break;
2041         case OPUS_GET_INBAND_FEC_REQUEST:
2042         {
2043             opus_int32 *value = va_arg(ap, opus_int32*);
2044             *value = st->silk_mode.useInBandFEC;
2045         }
2046         break;
2047         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
2048         {
2049             opus_int32 value = va_arg(ap, opus_int32);
2050             if (value < 0 || value > 100)
2051                 return OPUS_BAD_ARG;
2052             st->silk_mode.packetLossPercentage = value;
2053             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
2054         }
2055         break;
2056         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
2057         {
2058             opus_int32 *value = va_arg(ap, opus_int32*);
2059             *value = st->silk_mode.packetLossPercentage;
2060         }
2061         break;
2062         case OPUS_SET_VBR_REQUEST:
2063         {
2064             opus_int32 value = va_arg(ap, opus_int32);
2065             if(value<0 || value>1)
2066                 return OPUS_BAD_ARG;
2067             st->use_vbr = value;
2068             st->silk_mode.useCBR = 1-value;
2069         }
2070         break;
2071         case OPUS_GET_VBR_REQUEST:
2072         {
2073             opus_int32 *value = va_arg(ap, opus_int32*);
2074             *value = st->use_vbr;
2075         }
2076         break;
2077         case OPUS_SET_VOICE_RATIO_REQUEST:
2078         {
2079             opus_int32 value = va_arg(ap, opus_int32);
2080             if (value>100 || value<-1)
2081                 goto bad_arg;
2082             st->voice_ratio = value;
2083         }
2084         break;
2085         case OPUS_GET_VOICE_RATIO_REQUEST:
2086         {
2087             opus_int32 *value = va_arg(ap, opus_int32*);
2088             *value = st->voice_ratio;
2089         }
2090         break;
2091         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
2092         {
2093             opus_int32 value = va_arg(ap, opus_int32);
2094             if(value<0 || value>1)
2095                 return OPUS_BAD_ARG;
2096             st->vbr_constraint = value;
2097         }
2098         break;
2099         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
2100         {
2101             opus_int32 *value = va_arg(ap, opus_int32*);
2102             *value = st->vbr_constraint;
2103         }
2104         break;
2105         case OPUS_SET_SIGNAL_REQUEST:
2106         {
2107             opus_int32 value = va_arg(ap, opus_int32);
2108             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
2109                 return OPUS_BAD_ARG;
2110             st->signal_type = value;
2111         }
2112         break;
2113         case OPUS_GET_SIGNAL_REQUEST:
2114         {
2115             opus_int32 *value = va_arg(ap, opus_int32*);
2116             *value = st->signal_type;
2117         }
2118         break;
2119         case OPUS_GET_LOOKAHEAD_REQUEST:
2120         {
2121             opus_int32 *value = va_arg(ap, opus_int32*);
2122             *value = st->Fs/400;
2123             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2124                 *value += st->delay_compensation;
2125         }
2126         break;
2127         case OPUS_GET_SAMPLE_RATE_REQUEST:
2128         {
2129             opus_int32 *value = va_arg(ap, opus_int32*);
2130             if (value==NULL)
2131             {
2132                 ret = OPUS_BAD_ARG;
2133                 break;
2134             }
2135             *value = st->Fs;
2136         }
2137         break;
2138         case OPUS_GET_FINAL_RANGE_REQUEST:
2139         {
2140             opus_uint32 *value = va_arg(ap, opus_uint32*);
2141             *value = st->rangeFinal;
2142         }
2143         break;
2144         case OPUS_SET_LSB_DEPTH_REQUEST:
2145         {
2146             opus_int32 value = va_arg(ap, opus_int32);
2147             if (value<8 || value>24)
2148                goto bad_arg;
2149             st->lsb_depth=value;
2150         }
2151         break;
2152         case OPUS_GET_LSB_DEPTH_REQUEST:
2153         {
2154             opus_int32 *value = va_arg(ap, opus_int32*);
2155             *value = st->lsb_depth;
2156         }
2157         break;
2158         case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
2159         {
2160             opus_int32 value = va_arg(ap, opus_int32);
2161             st->variable_duration = value;
2162         }
2163         break;
2164         case OPUS_GET_EXPERT_FRAME_DURATION_REQUEST:
2165         {
2166             opus_int32 *value = va_arg(ap, opus_int32*);
2167             *value = st->variable_duration;
2168         }
2169         break;
2170         case OPUS_RESET_STATE:
2171         {
2172            void *silk_enc;
2173            silk_EncControlStruct dummy;
2174            silk_enc = (char*)st+st->silk_enc_offset;
2175
2176            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
2177                  sizeof(OpusEncoder)-
2178                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
2179
2180            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2181            silk_InitEncoder( silk_enc, &dummy );
2182            st->stream_channels = st->channels;
2183            st->hybrid_stereo_width_Q14 = 1 << 14;
2184            st->prev_HB_gain = Q15ONE;
2185            st->first = 1;
2186            st->mode = MODE_HYBRID;
2187            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
2188            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
2189         }
2190         break;
2191         case OPUS_SET_FORCE_MODE_REQUEST:
2192         {
2193             opus_int32 value = va_arg(ap, opus_int32);
2194             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
2195                goto bad_arg;
2196             st->user_forced_mode = value;
2197         }
2198         break;
2199
2200         case CELT_GET_MODE_REQUEST:
2201         {
2202            const CELTMode ** value = va_arg(ap, const CELTMode**);
2203            if (value==0)
2204               goto bad_arg;
2205            celt_encoder_ctl(celt_enc, CELT_GET_MODE(value));
2206         }
2207         break;
2208         default:
2209             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
2210             ret = OPUS_UNIMPLEMENTED;
2211             break;
2212     }
2213     va_end(ap);
2214     return ret;
2215 bad_arg:
2216     va_end(ap);
2217     return OPUS_BAD_ARG;
2218 }
2219
2220 void opus_encoder_destroy(OpusEncoder *st)
2221 {
2222     opus_free(st);
2223 }