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