5e75d853354a2325b18486211cb0de3cb6ad1332
[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     }
1116
1117     if (redundancy)
1118     {
1119        /* Fair share of the max size allowed */
1120        redundancy_bytes = IMIN(257, max_data_bytes*(opus_int32)(st->Fs/200)/(frame_size+st->Fs/200));
1121        /* For VBR, target the actual bitrate (subject to the limit above) */
1122        if (st->use_vbr)
1123           redundancy_bytes = IMIN(redundancy_bytes, st->bitrate_bps/1600);
1124     }
1125
1126     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
1127     {
1128         silk_EncControlStruct dummy;
1129         silk_InitEncoder( silk_enc, &dummy);
1130         prefill=1;
1131     }
1132
1133     /* Automatic (rate-dependent) bandwidth selection */
1134     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
1135     {
1136         const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds;
1137         opus_int32 bandwidth_thresholds[8];
1138         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
1139         opus_int32 equiv_rate2;
1140
1141         equiv_rate2 = equiv_rate;
1142         if (st->mode != MODE_CELT_ONLY)
1143         {
1144            /* Adjust the threshold +/- 10% depending on complexity */
1145            equiv_rate2 = equiv_rate2 * (45+st->silk_mode.complexity)/50;
1146            /* CBR is less efficient by ~1 kb/s */
1147            if (!st->use_vbr)
1148               equiv_rate2 -= 1000;
1149         }
1150         if (st->channels==2 && st->force_channels!=1)
1151         {
1152            voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds;
1153            music_bandwidth_thresholds = stereo_music_bandwidth_thresholds;
1154         } else {
1155            voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds;
1156            music_bandwidth_thresholds = mono_music_bandwidth_thresholds;
1157         }
1158         /* Interpolate bandwidth thresholds depending on voice estimation */
1159         for (i=0;i<8;i++)
1160         {
1161            bandwidth_thresholds[i] = music_bandwidth_thresholds[i]
1162                     + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14);
1163         }
1164         do {
1165             int threshold, hysteresis;
1166             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
1167             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
1168             if (!st->first)
1169             {
1170                 if (st->bandwidth >= bandwidth)
1171                     threshold -= hysteresis;
1172                 else
1173                     threshold += hysteresis;
1174             }
1175             if (equiv_rate2 >= threshold)
1176                 break;
1177         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
1178         st->bandwidth = bandwidth;
1179         /* Prevents any transition to SWB/FB until the SILK layer has fully
1180            switched to WB mode and turned the variable LP filter off */
1181         if (!st->first && st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1182             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1183     }
1184
1185     if (st->bandwidth>st->max_bandwidth)
1186        st->bandwidth = st->max_bandwidth;
1187
1188     if (st->user_bandwidth != OPUS_AUTO)
1189         st->bandwidth = st->user_bandwidth;
1190
1191     /* This prevents us from using hybrid at unsafe CBR/max rates */
1192     if (st->mode != MODE_CELT_ONLY && max_rate < 15000)
1193     {
1194        st->bandwidth = IMIN(st->bandwidth, OPUS_BANDWIDTH_WIDEBAND);
1195     }
1196
1197     /* Prevents Opus from wasting bits on frequencies that are above
1198        the Nyquist rate of the input signal */
1199     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
1200         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1201     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1202         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1203     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
1204         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1205     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
1206         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1207 #ifndef FIXED_POINT
1208     /* Use detected bandwidth to reduce the encoded bandwidth. */
1209     if (st->detected_bandwidth && st->user_bandwidth == OPUS_AUTO)
1210     {
1211        /* When operating in SILK/hybrid mode, we don't go below wideband to avoid
1212           more complicated switches that require redundancy */
1213        if (st->mode == MODE_CELT_ONLY)
1214           st->bandwidth = IMIN(st->bandwidth, st->detected_bandwidth);
1215        else
1216           st->bandwidth = IMIN(st->bandwidth, IMAX(OPUS_BANDWIDTH_WIDEBAND, st->detected_bandwidth));
1217     }
1218 #endif
1219     celt_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(lsb_depth));
1220
1221     /* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */
1222     if (max_data_bytes < (frame_rate > 50 ? 12000 : 8000)*frame_size / (st->Fs * 8))
1223        st->mode = MODE_CELT_ONLY;
1224
1225     /* CELT mode doesn't support mediumband, use wideband instead */
1226     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1227         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1228
1229     /* Can't support higher than wideband for >20 ms frames */
1230     if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND))
1231     {
1232        VARDECL(unsigned char, tmp_data);
1233        int nb_frames;
1234        int bak_mode, bak_bandwidth, bak_channels, bak_to_mono;
1235        OpusRepacketizer rp;
1236        opus_int32 bytes_per_frame;
1237
1238
1239        nb_frames = frame_size > st->Fs/25 ? 3 : 2;
1240        bytes_per_frame = IMIN(1276,(out_data_bytes-3)/nb_frames);
1241
1242        ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char);
1243
1244        opus_repacketizer_init(&rp);
1245
1246        bak_mode = st->user_forced_mode;
1247        bak_bandwidth = st->user_bandwidth;
1248        bak_channels = st->force_channels;
1249
1250        st->user_forced_mode = st->mode;
1251        st->user_bandwidth = st->bandwidth;
1252        st->force_channels = st->stream_channels;
1253        bak_to_mono = st->silk_mode.toMono;
1254
1255        if (bak_to_mono)
1256           st->force_channels = 1;
1257        else
1258           st->prev_channels = st->stream_channels;
1259        for (i=0;i<nb_frames;i++)
1260        {
1261           int tmp_len;
1262           st->silk_mode.toMono = 0;
1263           /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
1264           if (to_celt && i==nb_frames-1)
1265              st->user_forced_mode = MODE_CELT_ONLY;
1266           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
1267 #ifndef FIXED_POINT
1268                 , analysis_info
1269 #endif
1270                 );
1271           if (tmp_len<0)
1272           {
1273              RESTORE_STACK;
1274              return OPUS_INTERNAL_ERROR;
1275           }
1276           ret = opus_repacketizer_cat(&rp, tmp_data+i*bytes_per_frame, tmp_len);
1277           if (ret<0)
1278           {
1279              RESTORE_STACK;
1280              return OPUS_INTERNAL_ERROR;
1281           }
1282        }
1283        ret = opus_repacketizer_out(&rp, data, out_data_bytes);
1284        if (ret<0)
1285        {
1286           RESTORE_STACK;
1287           return OPUS_INTERNAL_ERROR;
1288        }
1289        st->user_forced_mode = bak_mode;
1290        st->user_bandwidth = bak_bandwidth;
1291        st->force_channels = bak_channels;
1292        st->silk_mode.toMono = bak_to_mono;
1293        RESTORE_STACK;
1294        return ret;
1295     }
1296     curr_bandwidth = st->bandwidth;
1297
1298     /* Chooses the appropriate mode for speech
1299        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
1300     if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1301         st->mode = MODE_HYBRID;
1302     if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
1303         st->mode = MODE_SILK_ONLY;
1304
1305     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
1306     bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
1307
1308     data += 1;
1309
1310     ec_enc_init(&enc, data, max_data_bytes-1);
1311
1312     ALLOC(pcm_buf, (total_buffer+frame_size)*st->channels, opus_val16);
1313     for (i=0;i<total_buffer*st->channels;i++)
1314        pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-total_buffer)*st->channels+i];
1315
1316     if (st->mode == MODE_CELT_ONLY)
1317        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1318     else
1319        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
1320
1321     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
1322           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
1323
1324     /* convert from log scale to Hertz */
1325     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
1326
1327     if (st->application == OPUS_APPLICATION_VOIP)
1328     {
1329        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1330     } else {
1331        dc_reject(pcm, 3, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1332     }
1333
1334
1335
1336     /* SILK processing */
1337     HB_gain = Q15ONE;
1338     if (st->mode != MODE_CELT_ONLY)
1339     {
1340         opus_int32 total_bitRate, celt_rate;
1341 #ifdef FIXED_POINT
1342        const opus_int16 *pcm_silk;
1343 #else
1344        VARDECL(opus_int16, pcm_silk);
1345        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
1346 #endif
1347
1348         /* Distribute bits between SILK and CELT */
1349         total_bitRate = 8 * bytes_target * frame_rate;
1350         if( st->mode == MODE_HYBRID ) {
1351             int HB_gain_ref;
1352             /* Base rate for SILK */
1353             st->silk_mode.bitRate = st->stream_channels * ( 5000 + 1000 * ( st->Fs == 100 * frame_size ) );
1354             if( curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
1355                 /* SILK gets 2/3 of the remaining bits */
1356                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 2 / 3;
1357             } else { /* FULLBAND */
1358                 /* SILK gets 3/5 of the remaining bits */
1359                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 3 / 5;
1360             }
1361             /* Don't let SILK use more than 80% */
1362             if( st->silk_mode.bitRate > total_bitRate * 4/5 ) {
1363                 st->silk_mode.bitRate = total_bitRate * 4/5;
1364             }
1365             /* Increasingly attenuate high band when it gets allocated fewer bits */
1366             celt_rate = total_bitRate - st->silk_mode.bitRate;
1367             HB_gain_ref = (curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND) ? 2000 : 2400;
1368             HB_gain = SHL32((opus_val32)celt_rate, 9) / SHR32((opus_val32)celt_rate + st->stream_channels*HB_gain_ref, 6);
1369         } else {
1370             /* SILK gets all bits */
1371             st->silk_mode.bitRate = total_bitRate;
1372         }
1373
1374         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
1375         st->silk_mode.nChannelsAPI = st->channels;
1376         st->silk_mode.nChannelsInternal = st->stream_channels;
1377         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1378             st->silk_mode.desiredInternalSampleRate = 8000;
1379         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1380             st->silk_mode.desiredInternalSampleRate = 12000;
1381         } else {
1382             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
1383             st->silk_mode.desiredInternalSampleRate = 16000;
1384         }
1385         if( st->mode == MODE_HYBRID ) {
1386             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
1387             st->silk_mode.minInternalSampleRate = 16000;
1388         } else {
1389             st->silk_mode.minInternalSampleRate = 8000;
1390         }
1391
1392         if (st->mode == MODE_SILK_ONLY)
1393         {
1394            opus_int32 effective_max_rate = max_rate;
1395            st->silk_mode.maxInternalSampleRate = 16000;
1396            if (frame_rate > 50)
1397               effective_max_rate = effective_max_rate*2/3;
1398            if (effective_max_rate < 13000)
1399            {
1400               st->silk_mode.maxInternalSampleRate = 12000;
1401               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
1402            }
1403            if (effective_max_rate < 9600)
1404            {
1405               st->silk_mode.maxInternalSampleRate = 8000;
1406               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
1407            }
1408         } else {
1409            st->silk_mode.maxInternalSampleRate = 16000;
1410         }
1411
1412         st->silk_mode.useCBR = !st->use_vbr;
1413
1414         /* Call SILK encoder for the low band */
1415         nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes);
1416
1417         st->silk_mode.maxBits = nBytes*8;
1418         /* Only allow up to 90% of the bits for hybrid mode*/
1419         if (st->mode == MODE_HYBRID)
1420            st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
1421         if (st->silk_mode.useCBR)
1422         {
1423            st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
1424            /* Reduce the initial target to make it easier to reach the CBR rate */
1425            st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000);
1426         }
1427
1428         if (prefill)
1429         {
1430             opus_int32 zero=0;
1431             const CELTMode *celt_mode;
1432             int prefill_offset;
1433             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1434             /* Use a smooth onset for the SILK prefill to avoid the encoder trying to encode
1435                a discontinuity. The exact location is what we need to avoid leaving any "gap"
1436                in the audio when mixing with the redundant CELT frame. Here we can afford to
1437                overwrite st->delay_buffer because the only thing that uses it before it gets
1438                rewritten is tmp_prefill[] and even then only the part after the ramp really
1439                gets used (rather than sent to the encoder and discarded) */
1440             prefill_offset = st->channels*(st->encoder_buffer-st->delay_compensation-st->Fs/400);
1441             gain_fade(st->delay_buffer+prefill_offset, st->delay_buffer+prefill_offset,
1442                   0, Q15ONE, celt_mode->overlap, st->Fs/400, st->channels, celt_mode->window, st->Fs);
1443             for(i=0;i<prefill_offset;i++)
1444                st->delay_buffer[i]=0;
1445 #ifdef FIXED_POINT
1446             pcm_silk = st->delay_buffer;
1447 #else
1448             for (i=0;i<st->encoder_buffer*st->channels;i++)
1449                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
1450 #endif
1451             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
1452         }
1453
1454 #ifdef FIXED_POINT
1455         pcm_silk = pcm_buf+total_buffer*st->channels;
1456 #else
1457         for (i=0;i<frame_size*st->channels;i++)
1458             pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
1459 #endif
1460         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
1461         if( ret ) {
1462             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
1463             /* Handle error */
1464            RESTORE_STACK;
1465            return OPUS_INTERNAL_ERROR;
1466         }
1467         if (nBytes==0)
1468         {
1469            st->rangeFinal = 0;
1470            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1471            RESTORE_STACK;
1472            return 1;
1473         }
1474         /* Extract SILK internal bandwidth for signaling in first byte */
1475         if( st->mode == MODE_SILK_ONLY ) {
1476             if( st->silk_mode.internalSampleRate == 8000 ) {
1477                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1478             } else if( st->silk_mode.internalSampleRate == 12000 ) {
1479                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1480             } else if( st->silk_mode.internalSampleRate == 16000 ) {
1481                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1482             }
1483         } else {
1484             silk_assert( st->silk_mode.internalSampleRate == 16000 );
1485         }
1486
1487         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
1488         /* FIXME: How do we allocate the redundancy for CBR? */
1489         if (st->silk_mode.opusCanSwitch)
1490         {
1491            redundancy = 1;
1492            celt_to_silk = 0;
1493            st->silk_bw_switch = 1;
1494         }
1495     }
1496
1497     /* CELT processing */
1498     {
1499         int endband=21;
1500
1501         switch(curr_bandwidth)
1502         {
1503             case OPUS_BANDWIDTH_NARROWBAND:
1504                 endband = 13;
1505                 break;
1506             case OPUS_BANDWIDTH_MEDIUMBAND:
1507             case OPUS_BANDWIDTH_WIDEBAND:
1508                 endband = 17;
1509                 break;
1510             case OPUS_BANDWIDTH_SUPERWIDEBAND:
1511                 endband = 19;
1512                 break;
1513             case OPUS_BANDWIDTH_FULLBAND:
1514                 endband = 21;
1515                 break;
1516         }
1517         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
1518         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
1519     }
1520     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1521     if (st->mode != MODE_SILK_ONLY)
1522     {
1523         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1524         /* Allow prediction unless we decide to disable it later */
1525         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
1526
1527         if (st->mode == MODE_HYBRID)
1528         {
1529             int len;
1530
1531             len = (ec_tell(&enc)+7)>>3;
1532             if (redundancy)
1533                len += st->mode == MODE_HYBRID ? 3 : 1;
1534             if( st->use_vbr ) {
1535                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
1536             } else {
1537                 /* check if SILK used up too much */
1538                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
1539             }
1540         } else {
1541             if (st->use_vbr)
1542             {
1543                 opus_int32 bonus=0;
1544 #ifndef FIXED_POINT
1545                 if (st->variable_duration==OPUS_FRAMESIZE_VARIABLE && frame_size != st->Fs/50)
1546                 {
1547                    bonus = (40*st->stream_channels+40)*(st->Fs/frame_size-50);
1548                    if (analysis_info->valid)
1549                       bonus = bonus*(1.f+.5*analysis_info->tonality);
1550                 }
1551 #endif
1552                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
1553                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
1554                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps+bonus));
1555                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
1556             } else {
1557                 nb_compr_bytes = bytes_target;
1558             }
1559         }
1560
1561     } else {
1562         nb_compr_bytes = 0;
1563     }
1564
1565     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
1566     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
1567     {
1568        for (i=0;i<st->channels*st->Fs/400;i++)
1569           tmp_prefill[i] = st->delay_buffer[(st->encoder_buffer-total_buffer-st->Fs/400)*st->channels + i];
1570     }
1571
1572     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+total_buffer));i++)
1573         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
1574     for (;i<st->encoder_buffer*st->channels;i++)
1575         st->delay_buffer[i] = pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels+i];
1576
1577     /* gain_fade() and stereo_fade() need to be after the buffer copying
1578        because we don't want any of this to affect the SILK part */
1579     if( st->prev_HB_gain < Q15ONE || HB_gain < Q15ONE ) {
1580        const CELTMode *celt_mode;
1581
1582        celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1583        gain_fade(pcm_buf, pcm_buf,
1584              st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs);
1585     }
1586     st->prev_HB_gain = HB_gain;
1587     if (st->mode != MODE_HYBRID || st->stream_channels==1)
1588        st->silk_mode.stereoWidth_Q14 = IMIN((1<<14),IMAX(0,st->bitrate_bps-32000));
1589     if( st->channels == 2 ) {
1590         /* Apply stereo width reduction (at low bitrates) */
1591         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1592             opus_val16 g1, g2;
1593             const CELTMode *celt_mode;
1594
1595             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1596             g1 = st->hybrid_stereo_width_Q14;
1597             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1598 #ifdef FIXED_POINT
1599             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
1600             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
1601 #else
1602             g1 *= (1.f/16384);
1603             g2 *= (1.f/16384);
1604 #endif
1605             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
1606                   frame_size, st->channels, celt_mode->window, st->Fs);
1607             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1608         }
1609     }
1610
1611     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
1612     {
1613         /* For SILK mode, the redundancy is inferred from the length */
1614         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
1615            ec_enc_bit_logp(&enc, redundancy, 12);
1616         if (redundancy)
1617         {
1618             int max_redundancy;
1619             ec_enc_bit_logp(&enc, celt_to_silk, 1);
1620             if (st->mode == MODE_HYBRID)
1621                max_redundancy = (max_data_bytes-1)-nb_compr_bytes-1;
1622             else
1623                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1624             /* Target the same bit-rate for redundancy as for the rest,
1625                up to a max of 257 bytes */
1626             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
1627             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
1628             if (st->mode == MODE_HYBRID)
1629                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
1630         }
1631     } else {
1632         redundancy = 0;
1633     }
1634
1635     if (!redundancy)
1636     {
1637        st->silk_bw_switch = 0;
1638        redundancy_bytes = 0;
1639     }
1640     if (st->mode != MODE_CELT_ONLY)start_band=17;
1641
1642     if (st->mode == MODE_SILK_ONLY)
1643     {
1644         ret = (ec_tell(&enc)+7)>>3;
1645         ec_enc_done(&enc);
1646         nb_compr_bytes = ret;
1647     } else {
1648        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
1649        ec_enc_shrink(&enc, nb_compr_bytes);
1650     }
1651
1652
1653     /* 5 ms redundant frame for CELT->SILK */
1654     if (redundancy && celt_to_silk)
1655     {
1656         int err;
1657         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1658         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1659         err = celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
1660         if (err < 0)
1661         {
1662            RESTORE_STACK;
1663            return OPUS_INTERNAL_ERROR;
1664         }
1665         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1666         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1667     }
1668
1669     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
1670
1671     if (st->mode != MODE_SILK_ONLY)
1672     {
1673         if (st->mode != st->prev_mode && st->prev_mode > 0)
1674         {
1675            unsigned char dummy[2];
1676            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1677
1678            /* Prefilling */
1679            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
1680            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1681         }
1682         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
1683         if (ec_tell(&enc) <= 8*nb_compr_bytes)
1684         {
1685 #ifndef FIXED_POINT
1686            celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(analysis_info));
1687 #endif
1688            ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
1689            if (ret < 0)
1690            {
1691               RESTORE_STACK;
1692               return OPUS_INTERNAL_ERROR;
1693            }
1694         }
1695     }
1696
1697     /* 5 ms redundant frame for SILK->CELT */
1698     if (redundancy && !celt_to_silk)
1699     {
1700         int err;
1701         unsigned char dummy[2];
1702         int N2, N4;
1703         N2 = st->Fs/200;
1704         N4 = st->Fs/400;
1705
1706         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1707         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1708         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1709
1710         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1711         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL);
1712
1713         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1714         if (err < 0)
1715         {
1716            RESTORE_STACK;
1717            return OPUS_INTERNAL_ERROR;
1718         }
1719         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1720     }
1721
1722
1723
1724     /* Signalling the mode in the first byte */
1725     data--;
1726     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1727
1728     st->rangeFinal = enc.rng ^ redundant_rng;
1729
1730     if (to_celt)
1731         st->prev_mode = MODE_CELT_ONLY;
1732     else
1733         st->prev_mode = st->mode;
1734     st->prev_channels = st->stream_channels;
1735     st->prev_framesize = frame_size;
1736
1737     st->first = 0;
1738
1739     /* In the unlikely case that the SILK encoder busted its target, tell
1740        the decoder to call the PLC */
1741     if (ec_tell(&enc) > (max_data_bytes-1)*8)
1742     {
1743        if (max_data_bytes < 2)
1744        {
1745           RESTORE_STACK;
1746           return OPUS_BUFFER_TOO_SMALL;
1747        }
1748        data[1] = 0;
1749        ret = 1;
1750        st->rangeFinal = 0;
1751     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
1752     {
1753        /*When in LPC only mode it's perfectly
1754          reasonable to strip off trailing zero bytes as
1755          the required range decoder behavior is to
1756          fill these in. This can't be done when the MDCT
1757          modes are used because the decoder needs to know
1758          the actual length for allocation purposes.*/
1759        while(ret>2&&data[ret]==0)ret--;
1760     }
1761     /* Count ToC and redundancy */
1762     ret += 1+redundancy_bytes;
1763     if (!st->use_vbr && ret >= 3)
1764     {
1765        if (pad_frame(data, ret, max_data_bytes))
1766        {
1767           RESTORE_STACK;
1768           return OPUS_INTERNAL_ERROR;
1769        }
1770        ret = max_data_bytes;
1771     }
1772     RESTORE_STACK;
1773     return ret;
1774 }
1775
1776 #ifdef FIXED_POINT
1777
1778 #ifndef DISABLE_FLOAT_API
1779 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1780       unsigned char *data, opus_int32 max_data_bytes)
1781 {
1782    int i, ret;
1783    VARDECL(opus_int16, in);
1784    ALLOC_STACK;
1785
1786    frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1787    if(frame_size<0)
1788    {
1789       RESTORE_STACK;
1790       return OPUS_BAD_ARG;
1791    }
1792
1793    ALLOC(in, frame_size*st->channels, opus_int16);
1794
1795    for (i=0;i<frame_size*st->channels;i++)
1796       in[i] = FLOAT2INT16(pcm[i]);
1797    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16);
1798    RESTORE_STACK;
1799    return ret;
1800 }
1801 #endif
1802
1803 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1804                 unsigned char *data, opus_int32 out_data_bytes)
1805 {
1806    frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1807    if(frame_size<0)
1808    {
1809       RESTORE_STACK;
1810       return OPUS_BAD_ARG;
1811    }
1812    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 16);
1813 }
1814
1815 #else
1816 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1817       unsigned char *data, opus_int32 max_data_bytes)
1818 {
1819    int i, ret;
1820    const CELTMode *celt_mode;
1821    int delay_compensation;
1822    int lsb_depth;
1823    VARDECL(float, in);
1824    AnalysisInfo analysis_info;
1825    ALLOC_STACK;
1826
1827    opus_encoder_ctl(st, CELT_GET_MODE(&celt_mode));
1828    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1829       delay_compensation = 0;
1830    else
1831       delay_compensation = st->delay_compensation;
1832
1833    lsb_depth = IMIN(16, st->lsb_depth);
1834
1835    analysis_info.valid = 0;
1836    if (st->silk_mode.complexity >= 7 && st->Fs==48000)
1837    {
1838       frame_size = run_analysis(&st->analysis, celt_mode, pcm, pcm+st->channels*st->analysis.analysis_offset,
1839             frame_size, st->variable_duration, st->channels, st->Fs, st->bitrate_bps, delay_compensation, lsb_depth, downmix_int, &analysis_info);
1840    } else {
1841       frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1842    }
1843    if(frame_size<0)
1844    {
1845       RESTORE_STACK;
1846       return OPUS_BAD_ARG;
1847    }
1848
1849    ALLOC(in, frame_size*st->channels, float);
1850
1851    for (i=0;i<frame_size*st->channels;i++)
1852       in[i] = (1.0f/32768)*pcm[i];
1853    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16, &analysis_info);
1854    RESTORE_STACK;
1855    return ret;
1856 }
1857 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1858                       unsigned char *data, opus_int32 out_data_bytes)
1859 {
1860    const CELTMode *celt_mode;
1861    int delay_compensation;
1862    int lsb_depth;
1863    AnalysisInfo analysis_info;
1864
1865    opus_encoder_ctl(st, CELT_GET_MODE(&celt_mode));
1866    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1867       delay_compensation = 0;
1868    else
1869       delay_compensation = st->delay_compensation;
1870
1871    lsb_depth = IMIN(24, st->lsb_depth);
1872
1873    analysis_info.valid = 0;
1874    if (st->silk_mode.complexity >= 7 && st->Fs==48000)
1875    {
1876       frame_size = run_analysis(&st->analysis, celt_mode, pcm, pcm+st->channels*st->analysis.analysis_offset,
1877             frame_size, st->variable_duration, st->channels, st->Fs, st->bitrate_bps, delay_compensation, lsb_depth, downmix_float, &analysis_info);
1878    } else {
1879       frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1880    }
1881    if(frame_size<0)
1882    {
1883       RESTORE_STACK;
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 }