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