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