19778a401250ebd8154865564aac36dc4415d450
[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 struct OpusEncoder {
55     int          celt_enc_offset;
56     int          silk_enc_offset;
57     silk_EncControlStruct silk_mode;
58     int          application;
59     int          channels;
60     int          delay_compensation;
61     int          force_channels;
62     int          signal_type;
63     int          user_bandwidth;
64     int          max_bandwidth;
65     int          user_forced_mode;
66     int          voice_ratio;
67     opus_int32   Fs;
68     int          use_vbr;
69     int          vbr_constraint;
70     int          variable_duration;
71     opus_int32   bitrate_bps;
72     opus_int32   user_bitrate_bps;
73     int          lsb_depth;
74     int          encoder_buffer;
75
76 #define OPUS_ENCODER_RESET_START stream_channels
77     int          stream_channels;
78     opus_int16   hybrid_stereo_width_Q14;
79     opus_int32   variable_HP_smth2_Q15;
80     opus_val16   prev_HB_gain;
81     opus_val32   hp_mem[4];
82     int          mode;
83     int          prev_mode;
84     int          prev_channels;
85     int          prev_framesize;
86     int          bandwidth;
87     int          silk_bw_switch;
88     /* Sampling rate (at the API level) */
89     int          first;
90     opus_val16   delay_buffer[MAX_ENCODER_BUFFER*2];
91 #ifndef FIXED_POINT
92     opus_val32   subframe_mem[3];
93     TonalityAnalysisState analysis;
94     int                   detected_bandwidth;
95 #endif
96     opus_uint32  rangeFinal;
97 };
98
99 /* Transition tables for the voice and music. First column is the
100    middle (memoriless) threshold. The second column is the hysteresis
101    (difference with the middle) */
102 static const opus_int32 mono_voice_bandwidth_thresholds[8] = {
103         11000, 1000, /* NB<->MB */
104         14000, 1000, /* MB<->WB */
105         17000, 1000, /* WB<->SWB */
106         20000, 1000, /* SWB<->FB */
107 };
108 static const opus_int32 mono_music_bandwidth_thresholds[8] = {
109         14000, 1000, /* MB not allowed */
110         18000, 2000, /* MB<->WB */
111         24000, 2000, /* WB<->SWB */
112         33000, 2000, /* SWB<->FB */
113 };
114 static const opus_int32 stereo_voice_bandwidth_thresholds[8] = {
115         11000, 1000, /* NB<->MB */
116         14000, 1000, /* MB<->WB */
117         21000, 2000, /* WB<->SWB */
118         32000, 2000, /* SWB<->FB */
119 };
120 static const opus_int32 stereo_music_bandwidth_thresholds[8] = {
121         14000, 1000, /* MB not allowed */
122         18000, 2000, /* MB<->WB */
123         24000, 2000, /* WB<->SWB */
124         48000, 2000, /* SWB<->FB */
125 };
126 /* Threshold bit-rates for switching between mono and stereo */
127 static const opus_int32 stereo_voice_threshold = 26000;
128 static const opus_int32 stereo_music_threshold = 36000;
129
130 /* Threshold bit-rate for switching between SILK/hybrid and CELT-only */
131 static const opus_int32 mode_thresholds[2][2] = {
132       /* voice */ /* music */
133       {  48000,      24000}, /* mono */
134       {  48000,      24000}, /* stereo */
135 };
136
137 int opus_encoder_get_size(int channels)
138 {
139     int silkEncSizeBytes, celtEncSizeBytes;
140     int ret;
141     if (channels<1 || channels > 2)
142         return 0;
143     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
144     if (ret)
145         return 0;
146     silkEncSizeBytes = align(silkEncSizeBytes);
147     celtEncSizeBytes = celt_encoder_get_size(channels);
148     return align(sizeof(OpusEncoder))+silkEncSizeBytes+celtEncSizeBytes;
149 }
150
151 int opus_encoder_init(OpusEncoder* st, opus_int32 Fs, int channels, int application)
152 {
153     void *silk_enc;
154     CELTEncoder *celt_enc;
155     int err;
156     int ret, silkEncSizeBytes;
157
158    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
159         (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
160         && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
161         return OPUS_BAD_ARG;
162
163     OPUS_CLEAR((char*)st, opus_encoder_get_size(channels));
164     /* Create SILK encoder */
165     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
166     if (ret)
167         return OPUS_BAD_ARG;
168     silkEncSizeBytes = align(silkEncSizeBytes);
169     st->silk_enc_offset = align(sizeof(OpusEncoder));
170     st->celt_enc_offset = st->silk_enc_offset+silkEncSizeBytes;
171     silk_enc = (char*)st+st->silk_enc_offset;
172     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
173
174     st->stream_channels = st->channels = channels;
175
176     st->Fs = Fs;
177
178     ret = silk_InitEncoder( silk_enc, &st->silk_mode );
179     if(ret)return OPUS_INTERNAL_ERROR;
180
181     /* default SILK parameters */
182     st->silk_mode.nChannelsAPI              = channels;
183     st->silk_mode.nChannelsInternal         = channels;
184     st->silk_mode.API_sampleRate            = st->Fs;
185     st->silk_mode.maxInternalSampleRate     = 16000;
186     st->silk_mode.minInternalSampleRate     = 8000;
187     st->silk_mode.desiredInternalSampleRate = 16000;
188     st->silk_mode.payloadSize_ms            = 20;
189     st->silk_mode.bitRate                   = 25000;
190     st->silk_mode.packetLossPercentage      = 0;
191     st->silk_mode.complexity                = 10;
192     st->silk_mode.useInBandFEC              = 0;
193     st->silk_mode.useDTX                    = 0;
194     st->silk_mode.useCBR                    = 0;
195
196     /* Create CELT encoder */
197     /* Initialize CELT encoder */
198     err = celt_encoder_init(celt_enc, Fs, channels);
199     if(err!=OPUS_OK)return OPUS_INTERNAL_ERROR;
200
201     celt_encoder_ctl(celt_enc, CELT_SET_SIGNALLING(0));
202     celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(10));
203
204     st->use_vbr = 1;
205     /* Makes constrained VBR the default (safer for real-time use) */
206     st->vbr_constraint = 1;
207     st->user_bitrate_bps = OPUS_AUTO;
208     st->bitrate_bps = 3000+Fs*channels;
209     st->application = application;
210     st->signal_type = OPUS_AUTO;
211     st->user_bandwidth = OPUS_AUTO;
212     st->max_bandwidth = OPUS_BANDWIDTH_FULLBAND;
213     st->force_channels = OPUS_AUTO;
214     st->user_forced_mode = OPUS_AUTO;
215     st->voice_ratio = -1;
216     st->encoder_buffer = st->Fs/100;
217     st->lsb_depth = 24;
218
219     /* Delay compensation of 4 ms (2.5 ms for SILK's extra look-ahead 
220        + 1.5 ms for SILK resamplers and stereo prediction) */
221     st->delay_compensation = st->Fs/250;
222
223     st->hybrid_stereo_width_Q14 = 1 << 14;
224     st->prev_HB_gain = Q15ONE;
225     st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
226     st->first = 1;
227     st->mode = MODE_HYBRID;
228     st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
229
230     return OPUS_OK;
231 }
232
233 static int pad_frame(unsigned char *data, opus_int32 len, opus_int32 new_len)
234 {
235    if (len == new_len)
236       return 0;
237    if (len > new_len)
238       return 1;
239
240    if ((data[0]&0x3)==0)
241    {
242       int i;
243       int padding, nb_255s;
244
245       padding = new_len - len;
246       if (padding >= 2)
247       {
248          nb_255s = (padding-2)/255;
249
250          for (i=len-1;i>=1;i--)
251             data[i+nb_255s+2] = data[i];
252          data[0] |= 0x3;
253          data[1] = 0x41;
254          for (i=0;i<nb_255s;i++)
255             data[i+2] = 255;
256          data[nb_255s+2] = padding-255*nb_255s-2;
257          for (i=len+3+nb_255s;i<new_len;i++)
258             data[i] = 0;
259       } else {
260          for (i=len-1;i>=1;i--)
261             data[i+1] = data[i];
262          data[0] |= 0x3;
263          data[1] = 1;
264       }
265       return 0;
266    } else {
267       return 1;
268    }
269 }
270
271 static unsigned char gen_toc(int mode, int framerate, int bandwidth, int channels)
272 {
273    int period;
274    unsigned char toc;
275    period = 0;
276    while (framerate < 400)
277    {
278        framerate <<= 1;
279        period++;
280    }
281    if (mode == MODE_SILK_ONLY)
282    {
283        toc = (bandwidth-OPUS_BANDWIDTH_NARROWBAND)<<5;
284        toc |= (period-2)<<3;
285    } else if (mode == MODE_CELT_ONLY)
286    {
287        int tmp = bandwidth-OPUS_BANDWIDTH_MEDIUMBAND;
288        if (tmp < 0)
289            tmp = 0;
290        toc = 0x80;
291        toc |= tmp << 5;
292        toc |= period<<3;
293    } else /* Hybrid */
294    {
295        toc = 0x60;
296        toc |= (bandwidth-OPUS_BANDWIDTH_SUPERWIDEBAND)<<4;
297        toc |= (period-2)<<3;
298    }
299    toc |= (channels==2)<<2;
300    return toc;
301 }
302
303 #ifndef FIXED_POINT
304 static void silk_biquad_float(
305     const opus_val16      *in,            /* I:    Input signal                   */
306     const opus_int32      *B_Q28,         /* I:    MA coefficients [3]            */
307     const opus_int32      *A_Q28,         /* I:    AR coefficients [2]            */
308     opus_val32            *S,             /* I/O:  State vector [2]               */
309     opus_val16            *out,           /* O:    Output signal                  */
310     const opus_int32      len,            /* I:    Signal length (must be even)   */
311     int stride
312 )
313 {
314     /* DIRECT FORM II TRANSPOSED (uses 2 element state vector) */
315     opus_int   k;
316     opus_val32 vout;
317     opus_val32 inval;
318     opus_val32 A[2], B[3];
319
320     A[0] = (opus_val32)(A_Q28[0] * (1.f/((opus_int32)1<<28)));
321     A[1] = (opus_val32)(A_Q28[1] * (1.f/((opus_int32)1<<28)));
322     B[0] = (opus_val32)(B_Q28[0] * (1.f/((opus_int32)1<<28)));
323     B[1] = (opus_val32)(B_Q28[1] * (1.f/((opus_int32)1<<28)));
324     B[2] = (opus_val32)(B_Q28[2] * (1.f/((opus_int32)1<<28)));
325
326     /* Negate A_Q28 values and split in two parts */
327
328     for( k = 0; k < len; k++ ) {
329         /* S[ 0 ], S[ 1 ]: Q12 */
330         inval = in[ k*stride ];
331         vout = S[ 0 ] + B[0]*inval;
332
333         S[ 0 ] = S[1] - vout*A[0] + B[1]*inval;
334
335         S[ 1 ] = - vout*A[1] + B[2]*inval;
336
337         /* Scale back to Q0 and saturate */
338         out[ k*stride ] = vout;
339     }
340 }
341 #endif
342
343 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)
344 {
345    opus_int32 B_Q28[ 3 ], A_Q28[ 2 ];
346    opus_int32 Fc_Q19, r_Q28, r_Q22;
347
348    silk_assert( cutoff_Hz <= silk_int32_MAX / SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ) );
349    Fc_Q19 = silk_DIV32_16( silk_SMULBB( SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ), cutoff_Hz ), Fs/1000 );
350    silk_assert( Fc_Q19 > 0 && Fc_Q19 < 32768 );
351
352    r_Q28 = SILK_FIX_CONST( 1.0, 28 ) - silk_MUL( SILK_FIX_CONST( 0.92, 9 ), Fc_Q19 );
353
354    /* b = r * [ 1; -2; 1 ]; */
355    /* a = [ 1; -2 * r * ( 1 - 0.5 * Fc^2 ); r^2 ]; */
356    B_Q28[ 0 ] = r_Q28;
357    B_Q28[ 1 ] = silk_LSHIFT( -r_Q28, 1 );
358    B_Q28[ 2 ] = r_Q28;
359
360    /* -r * ( 2 - Fc * Fc ); */
361    r_Q22  = silk_RSHIFT( r_Q28, 6 );
362    A_Q28[ 0 ] = silk_SMULWW( r_Q22, silk_SMULWW( Fc_Q19, Fc_Q19 ) - SILK_FIX_CONST( 2.0,  22 ) );
363    A_Q28[ 1 ] = silk_SMULWW( r_Q22, r_Q22 );
364
365 #ifdef FIXED_POINT
366    silk_biquad_alt( in, B_Q28, A_Q28, hp_mem, out, len, channels );
367    if( channels == 2 ) {
368        silk_biquad_alt( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
369    }
370 #else
371    silk_biquad_float( in, B_Q28, A_Q28, hp_mem, out, len, channels );
372    if( channels == 2 ) {
373        silk_biquad_float( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
374    }
375 #endif
376 }
377
378 #ifdef FIXED_POINT
379 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)
380 {
381    int c, i;
382    int shift;
383
384    /* Approximates -round(log2(4.*cutoff_Hz/Fs)) */
385    shift=celt_ilog2(Fs/(cutoff_Hz*3));
386    for (c=0;c<channels;c++)
387    {
388       for (i=0;i<len;i++)
389       {
390          opus_val32 x, tmp, y;
391          x = SHL32(EXTEND32(in[channels*i+c]), 15);
392          /* First stage */
393          tmp = x-hp_mem[2*c];
394          hp_mem[2*c] = hp_mem[2*c] + PSHR32(x - hp_mem[2*c], shift);
395          /* Second stage */
396          y = tmp - hp_mem[2*c+1];
397          hp_mem[2*c+1] = hp_mem[2*c+1] + PSHR32(tmp - hp_mem[2*c+1], shift);
398          out[channels*i+c] = EXTRACT16(SATURATE(PSHR32(y, 15), 32767));
399       }
400    }
401 }
402
403 #else
404 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)
405 {
406    int c, i;
407    float coef;
408
409    coef = 4.0f*cutoff_Hz/Fs;
410    for (c=0;c<channels;c++)
411    {
412       for (i=0;i<len;i++)
413       {
414          opus_val32 x, tmp, y;
415          x = in[channels*i+c];
416          /* First stage */
417          tmp = x-hp_mem[2*c];
418          hp_mem[2*c] = hp_mem[2*c] + coef*(x - hp_mem[2*c]);
419          /* Second stage */
420          y = tmp - hp_mem[2*c+1];
421          hp_mem[2*c+1] = hp_mem[2*c+1] + coef*(tmp - hp_mem[2*c+1]);
422          out[channels*i+c] = y;
423       }
424    }
425 }
426 #endif
427
428 static void stereo_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2,
429         int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
430 {
431     int i;
432     int overlap;
433     int inc;
434     inc = 48000/Fs;
435     overlap=overlap48/inc;
436     g1 = Q15ONE-g1;
437     g2 = Q15ONE-g2;
438     for (i=0;i<overlap;i++)
439     {
440        opus_val32 diff;
441        opus_val16 g, w;
442        w = MULT16_16_Q15(window[i*inc], window[i*inc]);
443        g = SHR32(MAC16_16(MULT16_16(w,g2),
444              Q15ONE-w, g1), 15);
445        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
446        diff = MULT16_16_Q15(g, diff);
447        out[i*channels] = out[i*channels] - diff;
448        out[i*channels+1] = out[i*channels+1] + diff;
449     }
450     for (;i<frame_size;i++)
451     {
452        opus_val32 diff;
453        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
454        diff = MULT16_16_Q15(g2, diff);
455        out[i*channels] = out[i*channels] - diff;
456        out[i*channels+1] = out[i*channels+1] + diff;
457     }
458 }
459
460 static void gain_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2,
461         int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
462 {
463     int i;
464     int inc;
465     int overlap;
466     int c;
467     inc = 48000/Fs;
468     overlap=overlap48/inc;
469     if (channels==1)
470     {
471        for (i=0;i<overlap;i++)
472        {
473           opus_val16 g, w;
474           w = MULT16_16_Q15(window[i*inc], window[i*inc]);
475           g = SHR32(MAC16_16(MULT16_16(w,g2),
476                 Q15ONE-w, g1), 15);
477           out[i] = MULT16_16_Q15(g, in[i]);
478        }
479     } else {
480        for (i=0;i<overlap;i++)
481        {
482           opus_val16 g, w;
483           w = MULT16_16_Q15(window[i*inc], window[i*inc]);
484           g = SHR32(MAC16_16(MULT16_16(w,g2),
485                 Q15ONE-w, g1), 15);
486           out[i*2] = MULT16_16_Q15(g, in[i*2]);
487           out[i*2+1] = MULT16_16_Q15(g, in[i*2+1]);
488        }
489     }
490     c=0;do {
491        for (i=overlap;i<frame_size;i++)
492        {
493           out[i*channels+c] = MULT16_16_Q15(g2, in[i*channels+c]);
494        }
495     }
496     while (++c<channels);
497 }
498
499 OpusEncoder *opus_encoder_create(opus_int32 Fs, int channels, int application, int *error)
500 {
501    int ret;
502    OpusEncoder *st;
503    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
504        (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
505        && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
506    {
507       if (error)
508          *error = OPUS_BAD_ARG;
509       return NULL;
510    }
511    st = (OpusEncoder *)opus_alloc(opus_encoder_get_size(channels));
512    if (st == NULL)
513    {
514       if (error)
515          *error = OPUS_ALLOC_FAIL;
516       return NULL;
517    }
518    ret = opus_encoder_init(st, Fs, channels, application);
519    if (error)
520       *error = ret;
521    if (ret != OPUS_OK)
522    {
523       opus_free(st);
524       st = NULL;
525    }
526    return st;
527 }
528
529 static opus_int32 user_bitrate_to_bitrate(OpusEncoder *st, int frame_size, int max_data_bytes)
530 {
531   if(!frame_size)frame_size=st->Fs/400;
532   if (st->user_bitrate_bps==OPUS_AUTO)
533     return 60*st->Fs/frame_size + st->Fs*st->channels;
534   else if (st->user_bitrate_bps==OPUS_BITRATE_MAX)
535     return max_data_bytes*8*st->Fs/frame_size;
536   else
537     return st->user_bitrate_bps;
538 }
539
540 #ifndef FIXED_POINT
541 /* Don't use more than 60 ms for the frame size analysis */
542 #define MAX_DYNAMIC_FRAMESIZE 24
543 /* Estimates how much the bitrate will be boosted based on the sub-frame energy */
544 static float transient_boost(const float *E, const float *E_1, int LM, int maxM)
545 {
546    int i;
547    int M;
548    float sumE=0, sumE_1=0;
549    float metric;
550
551    M = IMIN(maxM, (1<<LM)+1);
552    for (i=0;i<M;i++)
553    {
554       sumE += E[i];
555       sumE_1 += E_1[i];
556    }
557    metric = sumE*sumE_1/(M*M);
558    /*if (LM==3)
559       printf("%f\n", metric);*/
560    /*return metric>10 ? 1 : 0;*/
561    /*return MAX16(0,1-exp(-.25*(metric-2.)));*/
562    return MIN16(1,sqrt(MAX16(0,.05*(metric-2))));
563 }
564
565 /* Viterbi decoding trying to find the best frame size combination using look-ahead
566
567    State numbering:
568     0: unused
569     1:  2.5 ms
570     2:  5 ms (#1)
571     3:  5 ms (#2)
572     4: 10 ms (#1)
573     5: 10 ms (#2)
574     6: 10 ms (#3)
575     7: 10 ms (#4)
576     8: 20 ms (#1)
577     9: 20 ms (#2)
578    10: 20 ms (#3)
579    11: 20 ms (#4)
580    12: 20 ms (#5)
581    13: 20 ms (#6)
582    14: 20 ms (#7)
583    15: 20 ms (#8)
584 */
585 static int transient_viterbi(const float *E, const float *E_1, int N, int frame_cost, int rate)
586 {
587    int i;
588    float cost[MAX_DYNAMIC_FRAMESIZE][16];
589    int states[MAX_DYNAMIC_FRAMESIZE][16];
590    float best_cost;
591    int best_state;
592
593    /* Makes variable framesize less aggressive at lower bitrates, but I can't
594       find any valid theretical justification for this (other than it seems
595       to help) */
596    frame_cost *= 720/rate;
597    for (i=0;i<16;i++)
598    {
599       /* Impossible state */
600       states[0][i] = -1;
601       cost[0][i] = 1e10;
602    }
603    for (i=0;i<4;i++)
604    {
605       cost[0][1<<i] = frame_cost + rate*(1<<i)*transient_boost(E, E_1, i, N+1);
606       states[0][1<<i] = i;
607    }
608    for (i=1;i<N;i++)
609    {
610       int j;
611
612       /* Follow continuations */
613       for (j=2;j<16;j++)
614       {
615          cost[i][j] = cost[i-1][j-1];
616          states[i][j] = j-1;
617       }
618
619       /* New frames */
620       for(j=0;j<4;j++)
621       {
622          int k;
623          float min_cost;
624          float curr_cost;
625          states[i][1<<j] = 1;
626          min_cost = cost[i-1][1];
627          for(k=1;k<4;k++)
628          {
629             float tmp = cost[i-1][(1<<(k+1))-1];
630             if (tmp < min_cost)
631             {
632                states[i][1<<j] = (1<<(k+1))-1;
633                min_cost = tmp;
634             }
635          }
636          curr_cost = frame_cost+rate*(1<<j)*transient_boost(E+i, E_1+i, j, N-i+1);
637          cost[i][1<<j] = min_cost;
638          /* If part of the frame is outside the analysis window, only count part of the cost */
639          if (N-i < (1<<j))
640             cost[i][1<<j] += curr_cost*(float)(N-i)/(1<<j);
641          else
642             cost[i][1<<j] += curr_cost;
643       }
644    }
645
646    best_state=1;
647    best_cost = cost[N-1][1];
648    /* Find best end state (doesn't force a frame to end at N-1) */
649    for (i=2;i<16;i++)
650    {
651       if (cost[N-1][i]<best_cost)
652       {
653          best_cost = cost[N-1][i];
654          best_state = i;
655       }
656    }
657
658    /* Follow transitions back */
659    for (i=N-1;i>=0;i--)
660    {
661       /*printf("%d ", best_state);*/
662       best_state = states[i][best_state];
663    }
664    /*printf("%d\n", best_state);*/
665    return best_state;
666 }
667
668 void downmix_float(const void *_x, float *sub, int subframe, int i, int C)
669 {
670    const float *x;
671    int c, j;
672    x = (const float *)_x;
673    for (j=0;j<subframe;j++)
674       sub[j] = x[(subframe*i+j)*C];
675    for (c=1;c<C;c++)
676       for (j=0;j<subframe;j++)
677          sub[j] += x[(subframe*i+j)*C+c];
678 }
679
680 void downmix_int(const void *_x, float *sub, int subframe, int i, int C)
681 {
682    const opus_int16 *x;
683    int c, j;
684    x = (const opus_int16 *)_x;
685    for (j=0;j<subframe;j++)
686       sub[j] = x[(subframe*i+j)*C];
687    for (c=1;c<C;c++)
688       for (j=0;j<subframe;j++)
689          sub[j] += x[(subframe*i+j)*C+c];
690 }
691
692 int optimize_framesize(const opus_val16 *x, int len, int C, opus_int32 Fs,
693                 int bitrate, opus_val16 tonality, opus_val32 *mem, int buffering,
694                 downmix_func downmix)
695 {
696    int N;
697    int i;
698    float e[MAX_DYNAMIC_FRAMESIZE+4];
699    float e_1[MAX_DYNAMIC_FRAMESIZE+3];
700    float memx;
701    int bestLM=0;
702    int subframe;
703    int pos;
704    VARDECL(opus_val16, sub);
705
706    subframe = Fs/400;
707    ALLOC(sub, subframe, opus_val16);
708    e[0]=mem[0];
709    e_1[0]=1./(EPSILON+mem[0]);
710    if (buffering)
711    {
712       /* Consider the CELT delay when not in restricted-lowdelay */
713       /* We assume the buffering is between 2.5 and 5 ms */
714       int offset = 2*subframe - buffering;
715       celt_assert(offset>=0 && offset <= subframe);
716       x += C*offset;
717       len -= offset;
718       e[1]=mem[1];
719       e_1[1]=1./(EPSILON+mem[1]);
720       e[2]=mem[2];
721       e_1[2]=1./(EPSILON+mem[2]);
722       pos = 3;
723    } else {
724       pos=1;
725    }
726    N=IMIN(len/subframe, MAX_DYNAMIC_FRAMESIZE);
727    memx = x[0];
728    for (i=0;i<N;i++)
729    {
730       float tmp;
731       float tmpx;
732       int j;
733       tmp=EPSILON;
734
735       downmix(x, sub, subframe, i, C);
736       if (i==0)
737          memx = sub[0];
738       for (j=0;j<subframe;j++)
739       {
740          tmpx = sub[j];
741          tmp += (tmpx-memx)*(tmpx-memx);
742          memx = tmpx;
743       }
744       e[i+pos] = tmp;
745       e_1[i+pos] = 1.f/tmp;
746    }
747    /* Hack to get 20 ms working with APPLICATION_AUDIO
748       The real problem is that the corresponding memory needs to use 1.5 ms
749       from this frame and 1 ms from the next frame */
750    e[i+pos] = e[i+pos-1];
751    if (buffering)
752       N=IMIN(MAX_DYNAMIC_FRAMESIZE, N+2);
753    bestLM = transient_viterbi(e, e_1, N, (1.f+.5*tonality)*(40*C+40), bitrate/400);
754    mem[0] = e[1<<bestLM];
755    if (buffering)
756    {
757       mem[1] = e[(1<<bestLM)+1];
758       mem[2] = e[(1<<bestLM)+2];
759    }
760    return bestLM;
761 }
762 #endif
763
764 opus_int32 opus_encode_native(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
765                 unsigned char *data, opus_int32 out_data_bytes, int lsb_depth)
766 {
767     void *silk_enc;
768     CELTEncoder *celt_enc;
769     int i;
770     int ret=0;
771     opus_int32 nBytes;
772     ec_enc enc;
773     int bytes_target;
774     int prefill=0;
775     int start_band = 0;
776     int redundancy = 0;
777     int redundancy_bytes = 0; /* Number of bytes to use for redundancy frame */
778     int celt_to_silk = 0;
779     VARDECL(opus_val16, pcm_buf);
780     int nb_compr_bytes;
781     int to_celt = 0;
782     opus_uint32 redundant_rng = 0;
783     int cutoff_Hz, hp_freq_smth1;
784     int voice_est; /* Probability of voice in Q7 */
785     opus_int32 equiv_rate;
786     int delay_compensation;
787     int frame_rate;
788     opus_int32 max_rate; /* Max bitrate we're allowed to use */
789     int curr_bandwidth;
790     opus_val16 HB_gain;
791     opus_int32 max_data_bytes; /* Max number of bytes we're allowed to use */
792     int total_buffer;
793     int perform_analysis=0;
794     int orig_frame_size;
795 #ifndef FIXED_POINT
796     AnalysisInfo analysis_info;
797 #endif
798     VARDECL(opus_val16, tmp_prefill);
799
800     ALLOC_STACK;
801
802     max_data_bytes = IMIN(1276, out_data_bytes);
803
804     st->rangeFinal = 0;
805     if ((!st->variable_duration && 400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
806          50*frame_size != st->Fs &&  25*frame_size != st->Fs &&  50*frame_size != 3*st->Fs)
807          || (400*frame_size < st->Fs)
808          || max_data_bytes<=0
809          )
810     {
811        RESTORE_STACK;
812        return OPUS_BAD_ARG;
813     }
814     silk_enc = (char*)st+st->silk_enc_offset;
815     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
816     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
817        delay_compensation = 0;
818     else
819        delay_compensation = st->delay_compensation;
820
821     lsb_depth = IMIN(lsb_depth, st->lsb_depth);
822
823     orig_frame_size = IMIN(frame_size,st->Fs/50);
824     if (st->variable_duration)
825     {
826        int LM = 3;
827 #ifndef FIXED_POINT
828        LM = optimize_framesize(pcm, frame_size, st->channels, st->Fs, st->bitrate_bps,
829              st->analysis.prev_tonality, st->subframe_mem, delay_compensation, downmix_float);
830 #endif
831        while ((st->Fs/400<<LM)>frame_size)
832           LM--;
833        frame_size = (st->Fs/400<<LM);
834     }
835 #ifndef FIXED_POINT
836     /* Only perform analysis up to 20-ms frames. Longer ones will be split if
837        they're in CELT-only mode. */
838     analysis_info.valid = 0;
839     perform_analysis = st->silk_mode.complexity >= 7 && st->Fs==48000;
840     if (!perform_analysis)
841     {
842        st->voice_ratio = -1;
843        st->detected_bandwidth = 0;
844     } else if (frame_size <= st->Fs/50)
845     {
846        tonality_analysis(&st->analysis, &analysis_info, celt_enc, pcm, IMIN(480, frame_size), st->channels, lsb_depth);
847        if (frame_size > st->Fs/100)
848           tonality_analysis(&st->analysis, &analysis_info, celt_enc, pcm+(st->Fs/100)*st->channels, 480, st->channels, lsb_depth);
849        if (analysis_info.valid)
850        {
851           if (st->signal_type == OPUS_AUTO)
852              st->voice_ratio = (int)floor(.5+100*(1-analysis_info.music_prob));
853           st->detected_bandwidth = analysis_info.opus_bandwidth;
854        }
855     }
856 #endif
857
858     total_buffer = delay_compensation;
859     st->bitrate_bps = user_bitrate_to_bitrate(st, frame_size, max_data_bytes);
860
861     frame_rate = st->Fs/frame_size;
862     if (max_data_bytes<3 || st->bitrate_bps < 3*frame_rate*8
863        || (frame_rate<50 && (max_data_bytes*frame_rate<300 || st->bitrate_bps < 2400)))
864     {
865        /*If the space is too low to do something useful, emit 'PLC' frames.*/
866        int tocmode = st->mode;
867        int bw = st->bandwidth == 0 ? OPUS_BANDWIDTH_NARROWBAND : st->bandwidth;
868        if (tocmode==0)
869           tocmode = MODE_SILK_ONLY;
870        if (frame_rate>100)
871           tocmode = MODE_CELT_ONLY;
872        if (frame_rate < 50)
873           tocmode = MODE_SILK_ONLY;
874        if(tocmode==MODE_SILK_ONLY&&bw>OPUS_BANDWIDTH_WIDEBAND)
875           bw=OPUS_BANDWIDTH_WIDEBAND;
876        else if (tocmode==MODE_CELT_ONLY&&bw==OPUS_BANDWIDTH_MEDIUMBAND)
877           bw=OPUS_BANDWIDTH_NARROWBAND;
878        else if (bw<=OPUS_BANDWIDTH_SUPERWIDEBAND)
879           bw=OPUS_BANDWIDTH_SUPERWIDEBAND;
880        data[0] = gen_toc(tocmode, frame_rate, bw, st->stream_channels);
881        RESTORE_STACK;
882        return 1;
883     }
884     if (!st->use_vbr)
885     {
886        int cbrBytes;
887        cbrBytes = IMIN( (st->bitrate_bps + 4*frame_rate)/(8*frame_rate) , max_data_bytes);
888        st->bitrate_bps = cbrBytes * (8*frame_rate);
889        max_data_bytes = cbrBytes;
890     }
891     max_rate = frame_rate*max_data_bytes*8;
892
893     /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */
894     equiv_rate = st->bitrate_bps - 60*(st->Fs/frame_size - 50);
895
896     if (st->signal_type == OPUS_SIGNAL_VOICE)
897        voice_est = 127;
898     else if (st->signal_type == OPUS_SIGNAL_MUSIC)
899        voice_est = 0;
900     else if (st->voice_ratio >= 0)
901        voice_est = st->voice_ratio*327>>8;
902     else if (st->application == OPUS_APPLICATION_VOIP)
903        voice_est = 115;
904     else
905        voice_est = 48;
906
907     if (st->force_channels!=OPUS_AUTO && st->channels == 2)
908     {
909         st->stream_channels = st->force_channels;
910     } else {
911 #ifdef FUZZING
912        /* Random mono/stereo decision */
913        if (st->channels == 2 && (rand()&0x1F)==0)
914           st->stream_channels = 3-st->stream_channels;
915 #else
916        /* Rate-dependent mono-stereo decision */
917        if (st->channels == 2)
918        {
919           opus_int32 stereo_threshold;
920           stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14);
921           if (st->stream_channels == 2)
922              stereo_threshold -= 4000;
923           else
924              stereo_threshold += 4000;
925           st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1;
926        } else {
927           st->stream_channels = st->channels;
928        }
929 #endif
930     }
931
932     /* Mode selection depending on application and signal type */
933     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
934     {
935        st->mode = MODE_CELT_ONLY;
936     } else if (st->user_forced_mode == OPUS_AUTO)
937     {
938 #ifdef FUZZING
939        /* Random mode switching */
940        if ((rand()&0xF)==0)
941        {
942           if ((rand()&0x1)==0)
943              st->mode = MODE_CELT_ONLY;
944           else
945              st->mode = MODE_SILK_ONLY;
946        } else {
947           if (st->prev_mode==MODE_CELT_ONLY)
948              st->mode = MODE_CELT_ONLY;
949           else
950              st->mode = MODE_SILK_ONLY;
951        }
952 #else
953        int chan;
954        opus_int32 mode_voice, mode_music;
955        opus_int32 threshold;
956
957        chan = (st->channels==2) && st->force_channels!=1;
958        mode_voice = mode_thresholds[chan][0];
959        mode_music = mode_thresholds[chan][1];
960        threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14);
961
962        /* Hysteresis */
963        if (st->prev_mode == MODE_CELT_ONLY)
964            threshold -= 4000;
965        else if (st->prev_mode>0)
966            threshold += 4000;
967
968        st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY;
969
970        /* When FEC is enabled and there's enough packet loss, use SILK */
971        if (st->silk_mode.useInBandFEC && st->silk_mode.packetLossPercentage > (128-voice_est)>>4)
972           st->mode = MODE_SILK_ONLY;
973        /* When encoding voice and DTX is enabled, set the encoder to SILK mode (at least for now) */
974        if (st->silk_mode.useDTX && voice_est > 100)
975           st->mode = MODE_SILK_ONLY;
976 #endif
977     } else {
978        st->mode = st->user_forced_mode;
979     }
980
981     /* Override the chosen mode to make sure we meet the requested frame size */
982     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
983        st->mode = MODE_CELT_ONLY;
984
985     if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0
986           && st->mode != MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)
987     {
988        /* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */
989        st->silk_mode.toMono = 1;
990        st->stream_channels = 2;
991     } else {
992        st->silk_mode.toMono = 0;
993     }
994
995     if (st->prev_mode > 0 &&
996         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
997     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
998     {
999         redundancy = 1;
1000         celt_to_silk = (st->mode != MODE_CELT_ONLY);
1001         if (!celt_to_silk)
1002         {
1003             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
1004             if (frame_size >= st->Fs/100)
1005             {
1006                 st->mode = st->prev_mode;
1007                 to_celt = 1;
1008             } else {
1009                 redundancy=0;
1010             }
1011         }
1012     }
1013     /* For the first frame at a new SILK bandwidth */
1014     if (st->silk_bw_switch)
1015     {
1016        redundancy = 1;
1017        celt_to_silk = 1;
1018        st->silk_bw_switch = 0;
1019     }
1020
1021     if (redundancy)
1022     {
1023        /* Fair share of the max size allowed */
1024        redundancy_bytes = IMIN(257, max_data_bytes*(opus_int32)(st->Fs/200)/(frame_size+st->Fs/200));
1025        /* For VBR, target the actual bitrate (subject to the limit above) */
1026        if (st->use_vbr)
1027           redundancy_bytes = IMIN(redundancy_bytes, st->bitrate_bps/1600);
1028     }
1029
1030     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
1031     {
1032         silk_EncControlStruct dummy;
1033         silk_InitEncoder( silk_enc, &dummy);
1034         prefill=1;
1035     }
1036
1037     /* Automatic (rate-dependent) bandwidth selection */
1038     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
1039     {
1040         const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds;
1041         opus_int32 bandwidth_thresholds[8];
1042         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
1043         opus_int32 equiv_rate2;
1044
1045         equiv_rate2 = equiv_rate;
1046         if (st->mode != MODE_CELT_ONLY)
1047         {
1048            /* Adjust the threshold +/- 10% depending on complexity */
1049            equiv_rate2 = equiv_rate2 * (45+st->silk_mode.complexity)/50;
1050            /* CBR is less efficient by ~1 kb/s */
1051            if (!st->use_vbr)
1052               equiv_rate2 -= 1000;
1053         }
1054         if (st->channels==2 && st->force_channels!=1)
1055         {
1056            voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds;
1057            music_bandwidth_thresholds = stereo_music_bandwidth_thresholds;
1058         } else {
1059            voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds;
1060            music_bandwidth_thresholds = mono_music_bandwidth_thresholds;
1061         }
1062         /* Interpolate bandwidth thresholds depending on voice estimation */
1063         for (i=0;i<8;i++)
1064         {
1065            bandwidth_thresholds[i] = music_bandwidth_thresholds[i]
1066                     + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14);
1067         }
1068         do {
1069             int threshold, hysteresis;
1070             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
1071             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
1072             if (!st->first)
1073             {
1074                 if (st->bandwidth >= bandwidth)
1075                     threshold -= hysteresis;
1076                 else
1077                     threshold += hysteresis;
1078             }
1079             if (equiv_rate2 >= threshold)
1080                 break;
1081         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
1082         st->bandwidth = bandwidth;
1083         /* Prevents any transition to SWB/FB until the SILK layer has fully
1084            switched to WB mode and turned the variable LP filter off */
1085         if (!st->first && st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1086             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1087     }
1088
1089     if (st->bandwidth>st->max_bandwidth)
1090        st->bandwidth = st->max_bandwidth;
1091
1092     if (st->user_bandwidth != OPUS_AUTO)
1093         st->bandwidth = st->user_bandwidth;
1094
1095     /* This prevents us from using hybrid at unsafe CBR/max rates */
1096     if (st->mode != MODE_CELT_ONLY && max_rate < 15000)
1097     {
1098        st->bandwidth = IMIN(st->bandwidth, OPUS_BANDWIDTH_WIDEBAND);
1099     }
1100
1101     /* Prevents Opus from wasting bits on frequencies that are above
1102        the Nyquist rate of the input signal */
1103     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
1104         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1105     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1106         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1107     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
1108         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1109     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
1110         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1111 #ifndef FIXED_POINT
1112     if (st->detected_bandwidth && st->user_bandwidth == OPUS_AUTO)
1113     {
1114        st->bandwidth = IMIN(st->bandwidth, st->detected_bandwidth);
1115     }
1116 #endif
1117     celt_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(lsb_depth));
1118
1119     /* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */
1120     if (max_data_bytes < (frame_rate > 50 ? 12000 : 8000)*frame_size / (st->Fs * 8))
1121        st->mode = MODE_CELT_ONLY;
1122
1123     /* CELT mode doesn't support mediumband, use wideband instead */
1124     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1125         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1126
1127     /* Can't support higher than wideband for >20 ms frames */
1128     if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND))
1129     {
1130        VARDECL(unsigned char, tmp_data);
1131        int nb_frames;
1132        int bak_mode, bak_bandwidth, bak_channels, bak_to_mono;
1133        OpusRepacketizer rp;
1134        opus_int32 bytes_per_frame;
1135
1136
1137        nb_frames = frame_size > st->Fs/25 ? 3 : 2;
1138        bytes_per_frame = IMIN(1276,(out_data_bytes-3)/nb_frames);
1139
1140        ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char);
1141
1142        opus_repacketizer_init(&rp);
1143
1144        bak_mode = st->user_forced_mode;
1145        bak_bandwidth = st->user_bandwidth;
1146        bak_channels = st->force_channels;
1147
1148        st->user_forced_mode = st->mode;
1149        st->user_bandwidth = st->bandwidth;
1150        st->force_channels = st->stream_channels;
1151        bak_to_mono = st->silk_mode.toMono;
1152
1153        if (bak_to_mono)
1154           st->force_channels = 1;
1155        else
1156           st->prev_channels = st->stream_channels;
1157        for (i=0;i<nb_frames;i++)
1158        {
1159           int tmp_len;
1160           st->silk_mode.toMono = 0;
1161           /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
1162           if (to_celt && i==nb_frames-1)
1163              st->user_forced_mode = MODE_CELT_ONLY;
1164           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);
1165           if (tmp_len<0)
1166           {
1167              RESTORE_STACK;
1168              return OPUS_INTERNAL_ERROR;
1169           }
1170           ret = opus_repacketizer_cat(&rp, tmp_data+i*bytes_per_frame, tmp_len);
1171           if (ret<0)
1172           {
1173              RESTORE_STACK;
1174              return OPUS_INTERNAL_ERROR;
1175           }
1176        }
1177        ret = opus_repacketizer_out(&rp, data, out_data_bytes);
1178        if (ret<0)
1179        {
1180           RESTORE_STACK;
1181           return OPUS_INTERNAL_ERROR;
1182        }
1183        st->user_forced_mode = bak_mode;
1184        st->user_bandwidth = bak_bandwidth;
1185        st->force_channels = bak_channels;
1186        st->silk_mode.toMono = bak_to_mono;
1187        RESTORE_STACK;
1188        return ret;
1189     }
1190 #ifndef FIXED_POINT
1191     /* Perform analysis for 40-60 ms frames */
1192     if (perform_analysis && frame_size > st->Fs/50)
1193     {
1194        int nb_analysis = frame_size/(st->Fs/100);
1195        for (i=0;i<nb_analysis;i++)
1196           tonality_analysis(&st->analysis, &analysis_info, celt_enc, pcm+i*(st->Fs/100)*st->channels, 480, st->channels, lsb_depth);
1197        st->voice_ratio = (int)floor(.5+100*(1-analysis_info.music_prob));
1198     }
1199 #endif
1200     curr_bandwidth = st->bandwidth;
1201
1202     /* Chooses the appropriate mode for speech
1203        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
1204     if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1205         st->mode = MODE_HYBRID;
1206     if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
1207         st->mode = MODE_SILK_ONLY;
1208
1209     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
1210     bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
1211
1212     data += 1;
1213
1214     ec_enc_init(&enc, data, max_data_bytes-1);
1215
1216     ALLOC(pcm_buf, (total_buffer+frame_size)*st->channels, opus_val16);
1217     for (i=0;i<total_buffer*st->channels;i++)
1218        pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-total_buffer)*st->channels+i];
1219
1220     if (st->mode == MODE_CELT_ONLY)
1221        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1222     else
1223        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
1224
1225     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
1226           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
1227
1228     /* convert from log scale to Hertz */
1229     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
1230
1231     if (st->application == OPUS_APPLICATION_VOIP)
1232     {
1233        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1234     } else {
1235        dc_reject(pcm, 3, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1236     }
1237
1238
1239
1240     /* SILK processing */
1241     HB_gain = Q15ONE;
1242     if (st->mode != MODE_CELT_ONLY)
1243     {
1244         opus_int32 total_bitRate, celt_rate;
1245 #ifdef FIXED_POINT
1246        const opus_int16 *pcm_silk;
1247 #else
1248        VARDECL(opus_int16, pcm_silk);
1249        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
1250 #endif
1251
1252         /* Distribute bits between SILK and CELT */
1253         total_bitRate = 8 * bytes_target * frame_rate;
1254         if( st->mode == MODE_HYBRID ) {
1255             int HB_gain_ref;
1256             /* Base rate for SILK */
1257             st->silk_mode.bitRate = st->stream_channels * ( 5000 + 1000 * ( st->Fs == 100 * frame_size ) );
1258             if( curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
1259                 /* SILK gets 2/3 of the remaining bits */
1260                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 2 / 3;
1261             } else { /* FULLBAND */
1262                 /* SILK gets 3/5 of the remaining bits */
1263                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 3 / 5;
1264             }
1265             /* Don't let SILK use more than 80% */
1266             if( st->silk_mode.bitRate > total_bitRate * 4/5 ) {
1267                 st->silk_mode.bitRate = total_bitRate * 4/5;
1268             }
1269             /* Increasingly attenuate high band when it gets allocated fewer bits */
1270             celt_rate = total_bitRate - st->silk_mode.bitRate;
1271             HB_gain_ref = (curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND) ? 2000 : 2400;
1272             HB_gain = SHL32((opus_val32)celt_rate, 9) / SHR32((opus_val32)celt_rate + st->stream_channels*HB_gain_ref, 6);
1273         } else {
1274             /* SILK gets all bits */
1275             st->silk_mode.bitRate = total_bitRate;
1276         }
1277
1278         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
1279         st->silk_mode.nChannelsAPI = st->channels;
1280         st->silk_mode.nChannelsInternal = st->stream_channels;
1281         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1282             st->silk_mode.desiredInternalSampleRate = 8000;
1283         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1284             st->silk_mode.desiredInternalSampleRate = 12000;
1285         } else {
1286             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
1287             st->silk_mode.desiredInternalSampleRate = 16000;
1288         }
1289         if( st->mode == MODE_HYBRID ) {
1290             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
1291             st->silk_mode.minInternalSampleRate = 16000;
1292         } else {
1293             st->silk_mode.minInternalSampleRate = 8000;
1294         }
1295
1296         if (st->mode == MODE_SILK_ONLY)
1297         {
1298            opus_int32 effective_max_rate = max_rate;
1299            st->silk_mode.maxInternalSampleRate = 16000;
1300            if (frame_rate > 50)
1301               effective_max_rate = effective_max_rate*2/3;
1302            if (effective_max_rate < 13000)
1303            {
1304               st->silk_mode.maxInternalSampleRate = 12000;
1305               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
1306            }
1307            if (effective_max_rate < 9600)
1308            {
1309               st->silk_mode.maxInternalSampleRate = 8000;
1310               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
1311            }
1312         } else {
1313            st->silk_mode.maxInternalSampleRate = 16000;
1314         }
1315
1316         st->silk_mode.useCBR = !st->use_vbr;
1317
1318         /* Call SILK encoder for the low band */
1319         nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes);
1320
1321         st->silk_mode.maxBits = nBytes*8;
1322         /* Only allow up to 90% of the bits for hybrid mode*/
1323         if (st->mode == MODE_HYBRID)
1324            st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
1325         if (st->silk_mode.useCBR)
1326         {
1327            st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
1328            /* Reduce the initial target to make it easier to reach the CBR rate */
1329            st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000);
1330         }
1331
1332         if (prefill)
1333         {
1334             opus_int32 zero=0;
1335             const CELTMode *celt_mode;
1336             int prefill_offset;
1337             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1338             /* Use a smooth onset for the SILK prefill to avoid the encoder trying to encode
1339                a discontinuity. The exact location is what we need to avoid leaving any "gap"
1340                in the audio when mixing with the redundant CELT frame. Here we can afford to
1341                overwrite st->delay_buffer because the only thing that uses it before it gets
1342                rewritten is tmp_prefill[] and even then only the part after the ramp really
1343                gets used (rather than sent to the encoder and discarded) */
1344             prefill_offset = st->channels*(st->encoder_buffer-st->delay_compensation-st->Fs/400);
1345             gain_fade(st->delay_buffer+prefill_offset, st->delay_buffer+prefill_offset,
1346                   0, Q15ONE, celt_mode->overlap, st->Fs/400, st->channels, celt_mode->window, st->Fs);
1347             for(i=0;i<prefill_offset;i++)
1348                st->delay_buffer[i]=0;
1349 #ifdef FIXED_POINT
1350             pcm_silk = st->delay_buffer;
1351 #else
1352             for (i=0;i<st->encoder_buffer*st->channels;i++)
1353                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
1354 #endif
1355             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
1356         }
1357
1358 #ifdef FIXED_POINT
1359         pcm_silk = pcm_buf+total_buffer*st->channels;
1360 #else
1361         for (i=0;i<frame_size*st->channels;i++)
1362             pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
1363 #endif
1364         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
1365         if( ret ) {
1366             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
1367             /* Handle error */
1368            RESTORE_STACK;
1369            return OPUS_INTERNAL_ERROR;
1370         }
1371         if (nBytes==0)
1372         {
1373            st->rangeFinal = 0;
1374            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1375            RESTORE_STACK;
1376            return 1;
1377         }
1378         /* Extract SILK internal bandwidth for signaling in first byte */
1379         if( st->mode == MODE_SILK_ONLY ) {
1380             if( st->silk_mode.internalSampleRate == 8000 ) {
1381                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1382             } else if( st->silk_mode.internalSampleRate == 12000 ) {
1383                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1384             } else if( st->silk_mode.internalSampleRate == 16000 ) {
1385                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1386             }
1387         } else {
1388             silk_assert( st->silk_mode.internalSampleRate == 16000 );
1389         }
1390
1391         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
1392         /* FIXME: How do we allocate the redundancy for CBR? */
1393         if (st->silk_mode.opusCanSwitch)
1394         {
1395            redundancy = 1;
1396            celt_to_silk = 0;
1397            st->silk_bw_switch = 1;
1398         }
1399     }
1400
1401     /* CELT processing */
1402     {
1403         int endband=21;
1404
1405         switch(curr_bandwidth)
1406         {
1407             case OPUS_BANDWIDTH_NARROWBAND:
1408                 endband = 13;
1409                 break;
1410             case OPUS_BANDWIDTH_MEDIUMBAND:
1411             case OPUS_BANDWIDTH_WIDEBAND:
1412                 endband = 17;
1413                 break;
1414             case OPUS_BANDWIDTH_SUPERWIDEBAND:
1415                 endband = 19;
1416                 break;
1417             case OPUS_BANDWIDTH_FULLBAND:
1418                 endband = 21;
1419                 break;
1420         }
1421         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
1422         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
1423     }
1424     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1425     if (st->mode != MODE_SILK_ONLY)
1426     {
1427         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1428         /* Allow prediction unless we decide to disable it later */
1429         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
1430
1431         if (st->mode == MODE_HYBRID)
1432         {
1433             int len;
1434
1435             len = (ec_tell(&enc)+7)>>3;
1436             if (redundancy)
1437                len += st->mode == MODE_HYBRID ? 3 : 1;
1438             if( st->use_vbr ) {
1439                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
1440             } else {
1441                 /* check if SILK used up too much */
1442                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
1443             }
1444         } else {
1445             if (st->use_vbr)
1446             {
1447                 opus_int32 bonus=0;
1448 #ifndef FIXED_POINT
1449                 if (st->variable_duration && orig_frame_size != frame_size)
1450                 {
1451                    bonus = (40*st->stream_channels+40)*(48000/frame_size-48000/orig_frame_size);
1452                    if (analysis_info.valid)
1453                       bonus = bonus*(1.f+.5*analysis_info.tonality);
1454                 }
1455 #endif
1456                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
1457                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
1458                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps+bonus));
1459                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
1460             } else {
1461                 nb_compr_bytes = bytes_target;
1462             }
1463         }
1464
1465     } else {
1466         nb_compr_bytes = 0;
1467     }
1468
1469     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
1470     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
1471     {
1472        for (i=0;i<st->channels*st->Fs/400;i++)
1473           tmp_prefill[i] = st->delay_buffer[(st->encoder_buffer-total_buffer-st->Fs/400)*st->channels + i];
1474     }
1475
1476     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+total_buffer));i++)
1477         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
1478     for (;i<st->encoder_buffer*st->channels;i++)
1479         st->delay_buffer[i] = pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels+i];
1480
1481     /* gain_fade() and stereo_fade() need to be after the buffer copying
1482        because we don't want any of this to affect the SILK part */
1483     if( st->prev_HB_gain < Q15ONE || HB_gain < Q15ONE ) {
1484        const CELTMode *celt_mode;
1485
1486        celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1487        gain_fade(pcm_buf, pcm_buf,
1488              st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs);
1489     }
1490     st->prev_HB_gain = HB_gain;
1491     if (st->mode != MODE_HYBRID || st->stream_channels==1)
1492        st->silk_mode.stereoWidth_Q14 = 1<<14;
1493     if( st->channels == 2 ) {
1494         /* Apply stereo width reduction (at low bitrates) */
1495         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1496             opus_val16 g1, g2;
1497             const CELTMode *celt_mode;
1498
1499             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1500             g1 = st->hybrid_stereo_width_Q14;
1501             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1502 #ifdef FIXED_POINT
1503             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
1504             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
1505 #else
1506             g1 *= (1.f/16384);
1507             g2 *= (1.f/16384);
1508 #endif
1509             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
1510                   frame_size, st->channels, celt_mode->window, st->Fs);
1511             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1512         }
1513     }
1514
1515     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
1516     {
1517         /* For SILK mode, the redundancy is inferred from the length */
1518         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
1519            ec_enc_bit_logp(&enc, redundancy, 12);
1520         if (redundancy)
1521         {
1522             int max_redundancy;
1523             ec_enc_bit_logp(&enc, celt_to_silk, 1);
1524             if (st->mode == MODE_HYBRID)
1525                max_redundancy = (max_data_bytes-1)-nb_compr_bytes-1;
1526             else
1527                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1528             /* Target the same bit-rate for redundancy as for the rest,
1529                up to a max of 257 bytes */
1530             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
1531             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
1532             if (st->mode == MODE_HYBRID)
1533                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
1534         }
1535     } else {
1536         redundancy = 0;
1537     }
1538
1539     if (!redundancy)
1540     {
1541        st->silk_bw_switch = 0;
1542        redundancy_bytes = 0;
1543     }
1544     if (st->mode != MODE_CELT_ONLY)start_band=17;
1545
1546     if (st->mode == MODE_SILK_ONLY)
1547     {
1548         ret = (ec_tell(&enc)+7)>>3;
1549         ec_enc_done(&enc);
1550         nb_compr_bytes = ret;
1551     } else {
1552        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
1553        ec_enc_shrink(&enc, nb_compr_bytes);
1554     }
1555
1556
1557     /* 5 ms redundant frame for CELT->SILK */
1558     if (redundancy && celt_to_silk)
1559     {
1560         int err;
1561         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1562         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1563         err = celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
1564         if (err < 0)
1565         {
1566            RESTORE_STACK;
1567            return OPUS_INTERNAL_ERROR;
1568         }
1569         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1570         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1571     }
1572
1573     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
1574
1575     if (st->mode != MODE_SILK_ONLY)
1576     {
1577         if (st->mode != st->prev_mode && st->prev_mode > 0)
1578         {
1579            unsigned char dummy[2];
1580            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1581
1582            /* Prefilling */
1583            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
1584            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1585         }
1586         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
1587         if (ec_tell(&enc) <= 8*nb_compr_bytes)
1588         {
1589 #ifndef FIXED_POINT
1590            if (perform_analysis)
1591               celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(&analysis_info));
1592 #endif
1593            ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
1594            if (ret < 0)
1595            {
1596               RESTORE_STACK;
1597               return OPUS_INTERNAL_ERROR;
1598            }
1599         }
1600     }
1601
1602     /* 5 ms redundant frame for SILK->CELT */
1603     if (redundancy && !celt_to_silk)
1604     {
1605         int err;
1606         unsigned char dummy[2];
1607         int N2, N4;
1608         N2 = st->Fs/200;
1609         N4 = st->Fs/400;
1610
1611         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1612         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1613         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1614
1615         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1616         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL);
1617
1618         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1619         if (err < 0)
1620         {
1621            RESTORE_STACK;
1622            return OPUS_INTERNAL_ERROR;
1623         }
1624         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1625     }
1626
1627
1628
1629     /* Signalling the mode in the first byte */
1630     data--;
1631     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1632
1633     st->rangeFinal = enc.rng ^ redundant_rng;
1634
1635     if (to_celt)
1636         st->prev_mode = MODE_CELT_ONLY;
1637     else
1638         st->prev_mode = st->mode;
1639     st->prev_channels = st->stream_channels;
1640     st->prev_framesize = frame_size;
1641
1642     st->first = 0;
1643
1644     /* In the unlikely case that the SILK encoder busted its target, tell
1645        the decoder to call the PLC */
1646     if (ec_tell(&enc) > (max_data_bytes-1)*8)
1647     {
1648        if (max_data_bytes < 2)
1649        {
1650           RESTORE_STACK;
1651           return OPUS_BUFFER_TOO_SMALL;
1652        }
1653        data[1] = 0;
1654        ret = 1;
1655        st->rangeFinal = 0;
1656     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
1657     {
1658        /*When in LPC only mode it's perfectly
1659          reasonable to strip off trailing zero bytes as
1660          the required range decoder behavior is to
1661          fill these in. This can't be done when the MDCT
1662          modes are used because the decoder needs to know
1663          the actual length for allocation purposes.*/
1664        while(ret>2&&data[ret]==0)ret--;
1665     }
1666     /* Count ToC and redundancy */
1667     ret += 1+redundancy_bytes;
1668     if (!st->use_vbr && ret >= 3)
1669     {
1670        if (pad_frame(data, ret, max_data_bytes))
1671        {
1672           RESTORE_STACK;
1673           return OPUS_INTERNAL_ERROR;
1674        }
1675        ret = max_data_bytes;
1676     }
1677     RESTORE_STACK;
1678     return ret;
1679 }
1680
1681 #ifdef FIXED_POINT
1682
1683 #ifndef DISABLE_FLOAT_API
1684 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1685       unsigned char *data, opus_int32 max_data_bytes)
1686 {
1687    int i, ret;
1688    VARDECL(opus_int16, in);
1689    ALLOC_STACK;
1690
1691    if(frame_size<0)
1692    {
1693       RESTORE_STACK;
1694       return OPUS_BAD_ARG;
1695    }
1696
1697    ALLOC(in, frame_size*st->channels, opus_int16);
1698
1699    for (i=0;i<frame_size*st->channels;i++)
1700       in[i] = FLOAT2INT16(pcm[i]);
1701    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16);
1702    RESTORE_STACK;
1703    return ret;
1704 }
1705 #endif
1706
1707 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1708                 unsigned char *data, opus_int32 out_data_bytes)
1709 {
1710    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 16);
1711 }
1712
1713 #else
1714 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1715       unsigned char *data, opus_int32 max_data_bytes)
1716 {
1717    int i, ret;
1718    VARDECL(float, in);
1719    ALLOC_STACK;
1720
1721    ALLOC(in, frame_size*st->channels, float);
1722
1723    for (i=0;i<frame_size*st->channels;i++)
1724       in[i] = (1.0f/32768)*pcm[i];
1725    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16);
1726    RESTORE_STACK;
1727    return ret;
1728 }
1729 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1730                       unsigned char *data, opus_int32 out_data_bytes)
1731 {
1732    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 24);
1733
1734 }
1735 #endif
1736
1737
1738 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
1739 {
1740     int ret;
1741     CELTEncoder *celt_enc;
1742     va_list ap;
1743
1744     ret = OPUS_OK;
1745     va_start(ap, request);
1746
1747     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1748
1749     switch (request)
1750     {
1751         case OPUS_SET_APPLICATION_REQUEST:
1752         {
1753             opus_int32 value = va_arg(ap, opus_int32);
1754             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
1755                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1756                || (!st->first && st->application != value))
1757             {
1758                ret = OPUS_BAD_ARG;
1759                break;
1760             }
1761             st->application = value;
1762         }
1763         break;
1764         case OPUS_GET_APPLICATION_REQUEST:
1765         {
1766             opus_int32 *value = va_arg(ap, opus_int32*);
1767             *value = st->application;
1768         }
1769         break;
1770         case OPUS_SET_BITRATE_REQUEST:
1771         {
1772             opus_int32 value = va_arg(ap, opus_int32);
1773             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1774             {
1775                 if (value <= 0)
1776                     goto bad_arg;
1777                 else if (value <= 500)
1778                     value = 500;
1779                 else if (value > (opus_int32)300000*st->channels)
1780                     value = (opus_int32)300000*st->channels;
1781             }
1782             st->user_bitrate_bps = value;
1783         }
1784         break;
1785         case OPUS_GET_BITRATE_REQUEST:
1786         {
1787             opus_int32 *value = va_arg(ap, opus_int32*);
1788             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
1789         }
1790         break;
1791         case OPUS_SET_FORCE_CHANNELS_REQUEST:
1792         {
1793             opus_int32 value = va_arg(ap, opus_int32);
1794             if((value<1 || value>st->channels) && value != OPUS_AUTO)
1795                 return OPUS_BAD_ARG;
1796             st->force_channels = value;
1797         }
1798         break;
1799         case OPUS_GET_FORCE_CHANNELS_REQUEST:
1800         {
1801             opus_int32 *value = va_arg(ap, opus_int32*);
1802             *value = st->force_channels;
1803         }
1804         break;
1805         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
1806         {
1807             opus_int32 value = va_arg(ap, opus_int32);
1808             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND)
1809                 return OPUS_BAD_ARG;
1810             st->max_bandwidth = value;
1811             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1812                 st->silk_mode.maxInternalSampleRate = 8000;
1813             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1814                 st->silk_mode.maxInternalSampleRate = 12000;
1815             } else {
1816                 st->silk_mode.maxInternalSampleRate = 16000;
1817             }
1818         }
1819         break;
1820         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
1821         {
1822             opus_int32 *value = va_arg(ap, opus_int32*);
1823             *value = st->max_bandwidth;
1824         }
1825         break;
1826         case OPUS_SET_BANDWIDTH_REQUEST:
1827         {
1828             opus_int32 value = va_arg(ap, opus_int32);
1829             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
1830                 return OPUS_BAD_ARG;
1831             st->user_bandwidth = value;
1832             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1833                 st->silk_mode.maxInternalSampleRate = 8000;
1834             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1835                 st->silk_mode.maxInternalSampleRate = 12000;
1836             } else {
1837                 st->silk_mode.maxInternalSampleRate = 16000;
1838             }
1839         }
1840         break;
1841         case OPUS_GET_BANDWIDTH_REQUEST:
1842         {
1843             opus_int32 *value = va_arg(ap, opus_int32*);
1844             *value = st->bandwidth;
1845         }
1846         break;
1847         case OPUS_SET_DTX_REQUEST:
1848         {
1849             opus_int32 value = va_arg(ap, opus_int32);
1850             if(value<0 || value>1)
1851                 return OPUS_BAD_ARG;
1852             st->silk_mode.useDTX = value;
1853         }
1854         break;
1855         case OPUS_GET_DTX_REQUEST:
1856         {
1857             opus_int32 *value = va_arg(ap, opus_int32*);
1858             *value = st->silk_mode.useDTX;
1859         }
1860         break;
1861         case OPUS_SET_COMPLEXITY_REQUEST:
1862         {
1863             opus_int32 value = va_arg(ap, opus_int32);
1864             if(value<0 || value>10)
1865                 return OPUS_BAD_ARG;
1866             st->silk_mode.complexity = value;
1867             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
1868         }
1869         break;
1870         case OPUS_GET_COMPLEXITY_REQUEST:
1871         {
1872             opus_int32 *value = va_arg(ap, opus_int32*);
1873             *value = st->silk_mode.complexity;
1874         }
1875         break;
1876         case OPUS_SET_INBAND_FEC_REQUEST:
1877         {
1878             opus_int32 value = va_arg(ap, opus_int32);
1879             if(value<0 || value>1)
1880                 return OPUS_BAD_ARG;
1881             st->silk_mode.useInBandFEC = value;
1882         }
1883         break;
1884         case OPUS_GET_INBAND_FEC_REQUEST:
1885         {
1886             opus_int32 *value = va_arg(ap, opus_int32*);
1887             *value = st->silk_mode.useInBandFEC;
1888         }
1889         break;
1890         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1891         {
1892             opus_int32 value = va_arg(ap, opus_int32);
1893             if (value < 0 || value > 100)
1894                 return OPUS_BAD_ARG;
1895             st->silk_mode.packetLossPercentage = value;
1896             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
1897         }
1898         break;
1899         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1900         {
1901             opus_int32 *value = va_arg(ap, opus_int32*);
1902             *value = st->silk_mode.packetLossPercentage;
1903         }
1904         break;
1905         case OPUS_SET_VBR_REQUEST:
1906         {
1907             opus_int32 value = va_arg(ap, opus_int32);
1908             if(value<0 || value>1)
1909                 return OPUS_BAD_ARG;
1910             st->use_vbr = value;
1911             st->silk_mode.useCBR = 1-value;
1912         }
1913         break;
1914         case OPUS_GET_VBR_REQUEST:
1915         {
1916             opus_int32 *value = va_arg(ap, opus_int32*);
1917             *value = st->use_vbr;
1918         }
1919         break;
1920         case OPUS_SET_VOICE_RATIO_REQUEST:
1921         {
1922             opus_int32 value = va_arg(ap, opus_int32);
1923             if (value>100 || value<-1)
1924                 goto bad_arg;
1925             st->voice_ratio = value;
1926         }
1927         break;
1928         case OPUS_GET_VOICE_RATIO_REQUEST:
1929         {
1930             opus_int32 *value = va_arg(ap, opus_int32*);
1931             *value = st->voice_ratio;
1932         }
1933         break;
1934         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1935         {
1936             opus_int32 value = va_arg(ap, opus_int32);
1937             if(value<0 || value>1)
1938                 return OPUS_BAD_ARG;
1939             st->vbr_constraint = value;
1940         }
1941         break;
1942         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1943         {
1944             opus_int32 *value = va_arg(ap, opus_int32*);
1945             *value = st->vbr_constraint;
1946         }
1947         break;
1948         case OPUS_SET_SIGNAL_REQUEST:
1949         {
1950             opus_int32 value = va_arg(ap, opus_int32);
1951             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
1952                 return OPUS_BAD_ARG;
1953             st->signal_type = value;
1954         }
1955         break;
1956         case OPUS_GET_SIGNAL_REQUEST:
1957         {
1958             opus_int32 *value = va_arg(ap, opus_int32*);
1959             *value = st->signal_type;
1960         }
1961         break;
1962         case OPUS_GET_LOOKAHEAD_REQUEST:
1963         {
1964             opus_int32 *value = va_arg(ap, opus_int32*);
1965             *value = st->Fs/400;
1966             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1967                 *value += st->delay_compensation;
1968         }
1969         break;
1970         case OPUS_GET_SAMPLE_RATE_REQUEST:
1971         {
1972             opus_int32 *value = va_arg(ap, opus_int32*);
1973             if (value==NULL)
1974             {
1975                 ret = OPUS_BAD_ARG;
1976                 break;
1977             }
1978             *value = st->Fs;
1979         }
1980         break;
1981         case OPUS_GET_FINAL_RANGE_REQUEST:
1982         {
1983             opus_uint32 *value = va_arg(ap, opus_uint32*);
1984             *value = st->rangeFinal;
1985         }
1986         break;
1987         case OPUS_SET_LSB_DEPTH_REQUEST:
1988         {
1989             opus_int32 value = va_arg(ap, opus_int32);
1990             if (value<8 || value>24)
1991                goto bad_arg;
1992             st->lsb_depth=value;
1993         }
1994         break;
1995         case OPUS_GET_LSB_DEPTH_REQUEST:
1996         {
1997             opus_int32 *value = va_arg(ap, opus_int32*);
1998             *value = st->lsb_depth;
1999         }
2000         break;
2001         case OPUS_SET_EXPERT_VARIABLE_DURATION_REQUEST:
2002         {
2003             opus_int32 value = va_arg(ap, opus_int32);
2004             if (value<0 || value>1)
2005                goto bad_arg;
2006             st->variable_duration = value;
2007         }
2008         break;
2009         case OPUS_GET_EXPERT_VARIABLE_DURATION_REQUEST:
2010         {
2011             opus_int32 *value = va_arg(ap, opus_int32*);
2012             *value = st->variable_duration;
2013         }
2014         break;
2015         case OPUS_RESET_STATE:
2016         {
2017            void *silk_enc;
2018            silk_EncControlStruct dummy;
2019            silk_enc = (char*)st+st->silk_enc_offset;
2020
2021            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
2022                  sizeof(OpusEncoder)-
2023                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
2024
2025            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2026            silk_InitEncoder( silk_enc, &dummy );
2027            st->stream_channels = st->channels;
2028            st->hybrid_stereo_width_Q14 = 1 << 14;
2029            st->prev_HB_gain = Q15ONE;
2030            st->first = 1;
2031            st->mode = MODE_HYBRID;
2032            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
2033            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
2034         }
2035         break;
2036         case OPUS_SET_FORCE_MODE_REQUEST:
2037         {
2038             opus_int32 value = va_arg(ap, opus_int32);
2039             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
2040                goto bad_arg;
2041             st->user_forced_mode = value;
2042         }
2043         break;
2044         default:
2045             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
2046             ret = OPUS_UNIMPLEMENTED;
2047             break;
2048     }
2049     va_end(ap);
2050     return ret;
2051 bad_arg:
2052     va_end(ap);
2053     return OPUS_BAD_ARG;
2054 }
2055
2056 void opus_encoder_destroy(OpusEncoder *st)
2057 {
2058     opus_free(st);
2059 }