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