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