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