Correct rare mismatch between the encoder and decoder introduced by e9b53212.
[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 FOUNDATION OR
19    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
44 #include "tuning_parameters.h"
45 #ifdef FIXED_POINT
46 #include "fixed/structs_FIX.h"
47 #else
48 #include "float/structs_FLP.h"
49 #endif
50
51 #define MAX_ENCODER_BUFFER 480
52
53 struct OpusEncoder {
54     int          celt_enc_offset;
55     int          silk_enc_offset;
56     silk_EncControlStruct silk_mode;
57     int          application;
58     int          channels;
59     int          delay_compensation;
60     int          force_channels;
61     int          signal_type;
62     int          user_bandwidth;
63     int          user_forced_mode;
64     int          voice_ratio;
65     opus_int32   Fs;
66     int          use_vbr;
67     int          vbr_constraint;
68     opus_int32   bitrate_bps;
69     opus_int32   user_bitrate_bps;
70     int          encoder_buffer;
71
72 #define OPUS_ENCODER_RESET_START stream_channels
73     int          stream_channels;
74     opus_int16   hybrid_stereo_width_Q14;
75     opus_int32   variable_HP_smth2_Q15;
76     opus_val32   hp_mem[4];
77     int          mode;
78     int          prev_mode;
79     int          prev_channels;
80     int          prev_framesize;
81     int          bandwidth;
82     /* Sampling rate (at the API level) */
83     int          first;
84     opus_val16   delay_buffer[MAX_ENCODER_BUFFER*2];
85
86     opus_uint32  rangeFinal;
87 };
88
89 /* Transition tables for the voice and music. First column is the
90    middle (memoriless) threshold. The second column is the hysteresis
91    (difference with the middle) */
92 static const opus_int32 mono_voice_bandwidth_thresholds[8] = {
93         11000, 1000, /* NB<->MB */
94         14000, 1000, /* MB<->WB */
95         21000, 2000, /* WB<->SWB */
96         29000, 2000, /* SWB<->FB */
97 };
98 static const opus_int32 mono_music_bandwidth_thresholds[8] = {
99         14000, 1000, /* MB not allowed */
100         18000, 2000, /* MB<->WB */
101         24000, 2000, /* WB<->SWB */
102         33000, 2000, /* SWB<->FB */
103 };
104 static const opus_int32 stereo_voice_bandwidth_thresholds[8] = {
105         11000, 1000, /* NB<->MB */
106         14000, 1000, /* MB<->WB */
107         21000, 2000, /* WB<->SWB */
108         32000, 2000, /* SWB<->FB */
109 };
110 static const opus_int32 stereo_music_bandwidth_thresholds[8] = {
111         14000, 1000, /* MB not allowed */
112         18000, 2000, /* MB<->WB */
113         24000, 2000, /* WB<->SWB */
114         48000, 2000, /* SWB<->FB */
115 };
116 /* Threshold bit-rates for switching between mono and stereo */
117 static const opus_int32 stereo_voice_threshold = 26000;
118 static const opus_int32 stereo_music_threshold = 36000;
119
120 /* Threshold bit-rate for switching between SILK/hybrid and CELT-only */
121 static const opus_int32 mode_thresholds[2][2] = {
122       /* voice */ /* music */
123       {  48000,      24000}, /* mono */
124       {  48000,      24000}, /* stereo */
125 };
126
127 static const int celt_delay_table[5] = {
128 /* API 8  12  16  24  48 */
129       10, 16, 21, 27, 55
130 };
131 int opus_encoder_get_size(int channels)
132 {
133     int silkEncSizeBytes, celtEncSizeBytes;
134     int ret;
135     if (channels<1 || channels > 2)
136         return 0;
137     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
138     if (ret)
139         return 0;
140     silkEncSizeBytes = align(silkEncSizeBytes);
141     celtEncSizeBytes = celt_encoder_get_size(channels);
142     return align(sizeof(OpusEncoder))+silkEncSizeBytes+celtEncSizeBytes;
143 }
144
145 int opus_encoder_init(OpusEncoder* st, opus_int32 Fs, int channels, int application)
146 {
147     void *silk_enc;
148     CELTEncoder *celt_enc;
149     int err;
150     int ret, silkEncSizeBytes;
151
152    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
153         (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
154         && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
155         return OPUS_BAD_ARG;
156
157     OPUS_CLEAR((char*)st, opus_encoder_get_size(channels));
158     /* Create SILK encoder */
159     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
160     if (ret)
161         return OPUS_BAD_ARG;
162     silkEncSizeBytes = align(silkEncSizeBytes);
163     st->silk_enc_offset = align(sizeof(OpusEncoder));
164     st->celt_enc_offset = st->silk_enc_offset+silkEncSizeBytes;
165     silk_enc = (char*)st+st->silk_enc_offset;
166     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
167
168     st->stream_channels = st->channels = channels;
169
170     st->Fs = Fs;
171
172     ret = silk_InitEncoder( silk_enc, &st->silk_mode );
173     if(ret)return OPUS_INTERNAL_ERROR;
174
175     /* default SILK parameters */
176     st->silk_mode.nChannelsAPI              = channels;
177     st->silk_mode.nChannelsInternal         = channels;
178     st->silk_mode.API_sampleRate            = st->Fs;
179     st->silk_mode.maxInternalSampleRate     = 16000;
180     st->silk_mode.minInternalSampleRate     = 8000;
181     st->silk_mode.desiredInternalSampleRate = 16000;
182     st->silk_mode.payloadSize_ms            = 20;
183     st->silk_mode.bitRate                   = 25000;
184     st->silk_mode.packetLossPercentage      = 0;
185     st->silk_mode.complexity                = 10;
186     st->silk_mode.useInBandFEC              = 0;
187     st->silk_mode.useDTX                    = 0;
188     st->silk_mode.useCBR                    = 0;
189
190     /* Create CELT encoder */
191     /* Initialize CELT encoder */
192     err = celt_encoder_init(celt_enc, Fs, channels);
193     if(err!=OPUS_OK)return OPUS_INTERNAL_ERROR;
194
195     celt_encoder_ctl(celt_enc, CELT_SET_SIGNALLING(0));
196     celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(10));
197
198     st->use_vbr = 1;
199     st->user_bitrate_bps = OPUS_AUTO;
200     st->bitrate_bps = 3000+Fs*channels;
201     st->application = application;
202     st->signal_type = OPUS_AUTO;
203     st->user_bandwidth = OPUS_AUTO;
204     st->force_channels = OPUS_AUTO;
205     st->user_forced_mode = OPUS_AUTO;
206     st->voice_ratio = -1;
207     st->encoder_buffer = st->Fs/100;
208
209     st->delay_compensation = st->Fs/400;
210
211     st->delay_compensation += celt_delay_table[rateID(st->Fs)];
212
213     st->hybrid_stereo_width_Q14             = 1 << 14;
214     st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
215     st->first = 1;
216     st->mode = MODE_HYBRID;
217     st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
218
219     return OPUS_OK;
220 }
221
222 static unsigned char gen_toc(int mode, int framerate, int bandwidth, int channels)
223 {
224    int period;
225    unsigned char toc;
226    period = 0;
227    while (framerate < 400)
228    {
229        framerate <<= 1;
230        period++;
231    }
232    if (mode == MODE_SILK_ONLY)
233    {
234        toc = (bandwidth-OPUS_BANDWIDTH_NARROWBAND)<<5;
235        toc |= (period-2)<<3;
236    } else if (mode == MODE_CELT_ONLY)
237    {
238        int tmp = bandwidth-OPUS_BANDWIDTH_MEDIUMBAND;
239        if (tmp < 0)
240            tmp = 0;
241        toc = 0x80;
242        toc |= tmp << 5;
243        toc |= period<<3;
244    } else /* Hybrid */
245    {
246        toc = 0x60;
247        toc |= (bandwidth-OPUS_BANDWIDTH_SUPERWIDEBAND)<<4;
248        toc |= (period-2)<<3;
249    }
250    toc |= (channels==2)<<2;
251    return toc;
252 }
253
254 #ifndef FIXED_POINT
255 void silk_biquad_float(
256     const opus_val16      *in,            /* I:    Input signal                   */
257     const opus_int32      *B_Q28,         /* I:    MA coefficients [3]            */
258     const opus_int32      *A_Q28,         /* I:    AR coefficients [2]            */
259     opus_val32            *S,             /* I/O:  State vector [2]               */
260     opus_val16            *out,           /* O:    Output signal                  */
261     const opus_int32      len,            /* I:    Signal length (must be even)   */
262     int stride
263 )
264 {
265     /* DIRECT FORM II TRANSPOSED (uses 2 element state vector) */
266     opus_int   k;
267     opus_val32 vout;
268     opus_val32 inval;
269     opus_val32 A[2], B[3];
270
271     A[0] = (opus_val32)(A_Q28[0] * (1./((opus_int32)1<<28)));
272     A[1] = (opus_val32)(A_Q28[1] * (1./((opus_int32)1<<28)));
273     B[0] = (opus_val32)(B_Q28[0] * (1./((opus_int32)1<<28)));
274     B[1] = (opus_val32)(B_Q28[1] * (1./((opus_int32)1<<28)));
275     B[2] = (opus_val32)(B_Q28[2] * (1./((opus_int32)1<<28)));
276
277     /* Negate A_Q28 values and split in two parts */
278
279     for( k = 0; k < len; k++ ) {
280         /* S[ 0 ], S[ 1 ]: Q12 */
281         inval = in[ k*stride ];
282         vout = S[ 0 ] + B[0]*inval;
283
284         S[ 0 ] = S[1] - vout*A[0] + B[1]*inval;
285
286         S[ 1 ] = - vout*A[1] + B[2]*inval;
287
288         /* Scale back to Q0 and saturate */
289         out[ k*stride ] = vout;
290     }
291 }
292 #endif
293
294 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)
295 {
296    opus_int32 B_Q28[ 3 ], A_Q28[ 2 ];
297    opus_int32 Fc_Q19, r_Q28, r_Q22;
298
299    silk_assert( cutoff_Hz <= silk_int32_MAX / SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ) );
300    Fc_Q19 = silk_DIV32_16( silk_SMULBB( SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ), cutoff_Hz ), Fs/1000 );
301    silk_assert( Fc_Q19 > 0 && Fc_Q19 < 32768 );
302
303    r_Q28 = SILK_FIX_CONST( 1.0, 28 ) - silk_MUL( SILK_FIX_CONST( 0.92, 9 ), Fc_Q19 );
304
305    /* b = r * [ 1; -2; 1 ]; */
306    /* a = [ 1; -2 * r * ( 1 - 0.5 * Fc^2 ); r^2 ]; */
307    B_Q28[ 0 ] = r_Q28;
308    B_Q28[ 1 ] = silk_LSHIFT( -r_Q28, 1 );
309    B_Q28[ 2 ] = r_Q28;
310
311    /* -r * ( 2 - Fc * Fc ); */
312    r_Q22  = silk_RSHIFT( r_Q28, 6 );
313    A_Q28[ 0 ] = silk_SMULWW( r_Q22, silk_SMULWW( Fc_Q19, Fc_Q19 ) - SILK_FIX_CONST( 2.0,  22 ) );
314    A_Q28[ 1 ] = silk_SMULWW( r_Q22, r_Q22 );
315
316 #ifdef FIXED_POINT
317    silk_biquad_alt( in, B_Q28, A_Q28, hp_mem, out, len, channels );
318    if( channels == 2 ) {
319        silk_biquad_alt( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
320    }
321 #else
322    silk_biquad_float( in, B_Q28, A_Q28, hp_mem, out, len, channels );
323    if( channels == 2 ) {
324        silk_biquad_float( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
325    }
326 #endif
327 }
328
329 static void stereo_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2,
330         int overlap, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
331 {
332     int i;
333     int inc = 48000/Fs;
334     g1 = Q15ONE-g1;
335     g2 = Q15ONE-g2;
336     for (i=0;i<overlap;i++)
337     {
338        opus_val32 diff;
339        opus_val16 g, w;
340        w = MULT16_16_Q15(window[i*inc], window[i*inc]);
341        g = SHR32(MAC16_16(MULT16_16(w,g2),
342              Q15ONE-w, g1), 15);
343        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
344        diff = MULT16_16_Q15(g, diff);
345        out[i*channels] = out[i*channels] - diff;
346        out[i*channels+1] = out[i*channels+1] + diff;
347     }
348     for (;i<frame_size;i++)
349     {
350        opus_val32 diff;
351        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
352        diff = MULT16_16_Q15(g2, diff);
353        out[i*channels] = out[i*channels] - diff;
354        out[i*channels+1] = out[i*channels+1] + diff;
355     }
356 }
357
358 OpusEncoder *opus_encoder_create(opus_int32 Fs, int channels, int application, int *error)
359 {
360    int ret;
361    OpusEncoder *st;
362    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
363        (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
364        && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
365    {
366       if (error)
367          *error = OPUS_BAD_ARG;
368       return NULL;
369    }
370    st = (OpusEncoder *)opus_alloc(opus_encoder_get_size(channels));
371    if (st == NULL)
372    {
373       if (error)
374          *error = OPUS_ALLOC_FAIL;
375       return NULL;
376    }
377    ret = opus_encoder_init(st, Fs, channels, application);
378    if (error)
379       *error = ret;
380    if (ret != OPUS_OK)
381    {
382       opus_free(st);
383       st = NULL;
384    }
385    return st;
386 }
387
388 static opus_int32 user_bitrate_to_bitrate(OpusEncoder *st, int frame_size, int max_data_bytes)
389 {
390   if(!frame_size)frame_size=st->Fs/400;
391   if (st->user_bitrate_bps==OPUS_AUTO)
392     return 60*st->Fs/frame_size + st->Fs*st->channels;
393   else if (st->user_bitrate_bps==OPUS_BITRATE_MAX)
394     return max_data_bytes*8*st->Fs/frame_size;
395   else
396     return st->user_bitrate_bps;
397 }
398
399 #ifdef FIXED_POINT
400 #define opus_encode_native opus_encode
401 int opus_encode(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
402                 unsigned char *data, int max_data_bytes)
403 #else
404 #define opus_encode_native opus_encode_float
405 int opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
406                       unsigned char *data, int max_data_bytes)
407 #endif
408 {
409     void *silk_enc;
410     CELTEncoder *celt_enc;
411     int i;
412     int ret=0;
413     int nBytes;
414     ec_enc enc;
415     int bytes_target;
416     int prefill=0;
417     int start_band = 0;
418     int redundancy = 0;
419     int redundancy_bytes = 0;
420     int celt_to_silk = 0;
421     VARDECL(opus_val16, pcm_buf);
422     int nb_compr_bytes;
423     int to_celt = 0;
424     opus_uint32 redundant_rng = 0;
425     int cutoff_Hz, hp_freq_smth1;
426     int voice_est;
427     opus_int32 equiv_rate;
428     int delay_compensation;
429     VARDECL(opus_val16, tmp_prefill);
430
431     ALLOC_STACK;
432
433     max_data_bytes = IMIN(1276, max_data_bytes);
434
435     st->rangeFinal = 0;
436     if (400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
437          50*frame_size != st->Fs &&  25*frame_size != st->Fs &&  50*frame_size != 3*st->Fs)
438     {
439        RESTORE_STACK;
440        return OPUS_BAD_ARG;
441     }
442     silk_enc = (char*)st+st->silk_enc_offset;
443     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
444
445     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
446        delay_compensation = 0;
447     else
448        delay_compensation = st->delay_compensation;
449
450     st->bitrate_bps = user_bitrate_to_bitrate(st, frame_size, max_data_bytes);
451
452     /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */
453     equiv_rate = st->bitrate_bps - 60*(st->Fs/frame_size - 50);
454
455     if (st->signal_type == OPUS_SIGNAL_VOICE)
456        voice_est = 127;
457     else if (st->signal_type == OPUS_SIGNAL_MUSIC)
458        voice_est = 0;
459     else if (st->voice_ratio >= 0)
460        voice_est = st->voice_ratio*327>>8;
461     else if (st->application == OPUS_APPLICATION_VOIP)
462        voice_est = 115;
463     else
464        voice_est = 64;
465
466     if (st->force_channels!=OPUS_AUTO && st->channels == 2)
467     {
468         st->stream_channels = st->force_channels;
469     } else {
470 #ifdef FUZZING
471        /* Random mono/stereo decision */
472        if (st->channels == 2 && (rand()&0x1F)==0)
473           st->stream_channels = 3-st->stream_channels;
474 #else
475        /* Rate-dependent mono-stereo decision */
476        if (st->channels == 2)
477        {
478           opus_int32 stereo_threshold;
479           stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14);
480           if (st->stream_channels == 2)
481              stereo_threshold -= 4000;
482           else
483              stereo_threshold += 4000;
484           st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1;
485        } else {
486           st->stream_channels = st->channels;
487        }
488 #endif
489     }
490
491     /* Mode selection depending on application and signal type */
492     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
493     {
494        st->mode = MODE_CELT_ONLY;
495     } else if (st->user_forced_mode == OPUS_AUTO)
496     {
497 #ifdef FUZZING
498        /* Random mode switching */
499        if ((rand()&0xF)==0)
500        {
501           if ((rand()&0x1)==0)
502              st->mode = MODE_CELT_ONLY;
503           else
504              st->mode = MODE_SILK_ONLY;
505        } else {
506           if (st->prev_mode==MODE_CELT_ONLY)
507              st->mode = MODE_CELT_ONLY;
508           else
509              st->mode = MODE_SILK_ONLY;
510        }
511 #else
512        int chan;
513        opus_int32 mode_voice, mode_music;
514        opus_int32 threshold;
515
516        chan = (st->channels==2) && st->force_channels!=1;
517        mode_voice = mode_thresholds[chan][0];
518        mode_music = mode_thresholds[chan][1];
519        threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14);
520
521        /* Hysteresis */
522        if (st->prev_mode == MODE_CELT_ONLY)
523            threshold -= 4000;
524        else if (st->prev_mode>0)
525            threshold += 4000;
526
527        st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY;
528 #endif
529     } else {
530        st->mode = st->user_forced_mode;
531     }
532
533     /* Override the chosen mode to make sure we meet the requested frame size */
534     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
535        st->mode = MODE_CELT_ONLY;
536
537     if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0
538           && st->mode != MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)
539     {
540        /* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */
541        st->silk_mode.toMono = 1;
542        st->stream_channels = 2;
543     } else {
544        st->silk_mode.toMono = 0;
545     }
546
547     if (st->prev_mode > 0 &&
548         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
549     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
550     {
551         redundancy = 1;
552         celt_to_silk = (st->mode != MODE_CELT_ONLY);
553         if (!celt_to_silk)
554         {
555             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
556             if (frame_size >= st->Fs/100)
557             {
558                 st->mode = st->prev_mode;
559                 to_celt = 1;
560             } else {
561                 redundancy=0;
562             }
563         }
564     }
565     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
566     {
567         silk_EncControlStruct dummy;
568         silk_InitEncoder( silk_enc, &dummy);
569         prefill=1;
570     }
571
572     /* Automatic (rate-dependent) bandwidth selection */
573     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
574     {
575         const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds;
576         opus_int32 bandwidth_thresholds[8];
577         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
578
579         if (st->channels==2 && st->force_channels!=1)
580         {
581            voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds;
582            music_bandwidth_thresholds = stereo_music_bandwidth_thresholds;
583         } else {
584            voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds;
585            music_bandwidth_thresholds = mono_music_bandwidth_thresholds;
586         }
587         /* Interpolate bandwidth thresholds depending on voice estimation */
588         for (i=0;i<8;i++)
589         {
590            bandwidth_thresholds[i] = music_bandwidth_thresholds[i]
591                     + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14);
592         }
593         do {
594             int threshold, hysteresis;
595             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
596             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
597             if (!st->first)
598             {
599                 if (st->bandwidth >= bandwidth)
600                     threshold -= hysteresis;
601                 else
602                     threshold += hysteresis;
603             }
604             if (equiv_rate >= threshold)
605                 break;
606         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
607         st->bandwidth = bandwidth;
608         /* Prevents any transition to SWB/FB until the SILK layer has fully
609            switched to WB mode and turned the variable LP filter off */
610         if (st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
611             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
612     }
613
614     if (st->user_bandwidth != OPUS_AUTO)
615         st->bandwidth = st->user_bandwidth;
616
617     /* Prevents Opus from wasting bits on frequencies that are above
618        the Nyquist rate of the input signal */
619     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
620         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
621     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
622         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
623     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
624         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
625     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
626         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
627
628
629     /* Can't support higher than wideband for >20 ms frames */
630     if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND))
631     {
632        VARDECL(unsigned char, tmp_data);
633        VARDECL(unsigned char, rp_);
634        int nb_frames;
635        int bak_mode, bak_bandwidth, bak_channels, bak_to_mono;
636        OpusRepacketizer *rp;
637        int bytes_per_frame;
638
639
640        nb_frames = frame_size > st->Fs/25 ? 3 : 2;
641        bytes_per_frame = max_data_bytes/nb_frames-3;
642
643        ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char);
644        ALLOC(rp_, opus_repacketizer_get_size(), unsigned char);
645
646        rp = opus_repacketizer_init((OpusRepacketizer*)rp_);
647
648        bak_mode = st->user_forced_mode;
649        bak_bandwidth = st->user_bandwidth;
650        bak_channels = st->force_channels;
651
652        st->user_forced_mode = st->mode;
653        st->user_bandwidth = st->bandwidth;
654        st->force_channels = st->stream_channels;
655        bak_to_mono = st->silk_mode.toMono;
656
657        if (bak_to_mono)
658           st->force_channels = 1;
659        else
660           st->prev_channels = st->stream_channels;
661        for (i=0;i<nb_frames;i++)
662        {
663           int tmp_len;
664           st->silk_mode.toMono = 0;
665           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);
666           ret = opus_repacketizer_cat(rp, tmp_data+i*bytes_per_frame, tmp_len);
667        }
668        ret = opus_repacketizer_out(rp, data, max_data_bytes);
669
670        st->user_forced_mode = bak_mode;
671        st->user_bandwidth = bak_bandwidth;
672        st->force_channels = bak_channels;
673        st->silk_mode.toMono = bak_to_mono;
674        RESTORE_STACK;
675        return ret;
676     }
677     /* CELT mode doesn't support mediumband, use wideband instead */
678     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
679         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
680
681     /* Chooses the appropriate mode for speech
682        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
683     if (st->mode == MODE_SILK_ONLY && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
684         st->mode = MODE_HYBRID;
685     if (st->mode == MODE_HYBRID && st->bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
686         st->mode = MODE_SILK_ONLY;
687
688     /* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */
689     if (max_data_bytes < 8000*frame_size / (st->Fs * 8))
690        st->mode = MODE_CELT_ONLY;
691     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, st->bandwidth); */
692     bytes_target = IMIN(max_data_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
693
694     data += 1;
695
696     ec_enc_init(&enc, data, max_data_bytes-1);
697
698     ALLOC(pcm_buf, (delay_compensation+frame_size)*st->channels, opus_val16);
699     for (i=0;i<delay_compensation*st->channels;i++)
700        pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-delay_compensation)*st->channels+i];
701
702     if (st->mode == MODE_CELT_ONLY)
703        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
704     else
705        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
706
707     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
708           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
709
710     /* convert from log scale to Hertz */
711     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
712
713     if (st->application == OPUS_APPLICATION_VOIP)
714     {
715        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[delay_compensation*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
716     } else {
717        for (i=0;i<frame_size*st->channels;i++)
718           pcm_buf[delay_compensation*st->channels + i] = pcm[i];
719     }
720
721     /* SILK processing */
722     if (st->mode != MODE_CELT_ONLY)
723     {
724 #ifdef FIXED_POINT
725        const opus_int16 *pcm_silk;
726 #else
727        VARDECL(opus_int16, pcm_silk);
728        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
729 #endif
730         st->silk_mode.bitRate = st->bitrate_bps - 8*st->Fs/frame_size;
731         if( st->mode == MODE_HYBRID ) {
732             st->silk_mode.bitRate /= st->stream_channels;
733             if( st->bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
734                 if( st->Fs == 100 * frame_size ) {
735                     /* 24 kHz, 10 ms */
736                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 2000 + st->use_vbr * 1000 ) * 2 ) / 3;
737                 } else {
738                     /* 24 kHz, 20 ms */
739                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 1000 + st->use_vbr * 1000 ) * 2 ) / 3;
740                 }
741             } else {
742                 if( st->Fs == 100 * frame_size ) {
743                     /* 48 kHz, 10 ms */
744                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 8000 + st->use_vbr * 3000 ) / 2;
745                 } else {
746                     /* 48 kHz, 20 ms */
747                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 9000 + st->use_vbr * 1000 ) / 2;
748                 }
749             }
750             st->silk_mode.bitRate *= st->stream_channels;
751             /* don't let SILK use more than 80% */
752             if( st->silk_mode.bitRate > ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5 ) {
753                 st->silk_mode.bitRate = ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5;
754             }
755         }
756         /* SILK is not allow to use more than 50% of max_data_bytes */
757         if (max_data_bytes < st->silk_mode.bitRate*frame_size / (st->Fs * 4))
758            st->silk_mode.bitRate = max_data_bytes*st->Fs*4/frame_size;
759
760         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
761         st->silk_mode.nChannelsAPI = st->channels;
762         st->silk_mode.nChannelsInternal = st->stream_channels;
763         if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
764             st->silk_mode.desiredInternalSampleRate = 8000;
765         } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
766             st->silk_mode.desiredInternalSampleRate = 12000;
767         } else {
768             silk_assert( st->mode == MODE_HYBRID || st->bandwidth == OPUS_BANDWIDTH_WIDEBAND );
769             st->silk_mode.desiredInternalSampleRate = 16000;
770         }
771         if( st->mode == MODE_HYBRID ) {
772             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
773             st->silk_mode.minInternalSampleRate = 16000;
774         } else {
775             st->silk_mode.minInternalSampleRate = 8000;
776         }
777         st->silk_mode.maxInternalSampleRate = 16000;
778
779         /* Call SILK encoder for the low band */
780         nBytes = IMIN(1275, max_data_bytes-1);
781         if (prefill)
782         {
783             int zero=0;
784 #ifdef FIXED_POINT
785             pcm_silk = st->delay_buffer;
786 #else
787             for (i=0;i<st->encoder_buffer*st->channels;i++)
788                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
789 #endif
790             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
791         }
792
793 #ifdef FIXED_POINT
794         pcm_silk = pcm_buf+delay_compensation*st->channels;
795 #else
796         for (i=0;i<frame_size*st->channels;i++)
797             pcm_silk[i] = FLOAT2INT16(pcm_buf[delay_compensation*st->channels + i]);
798 #endif
799         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
800         if( ret ) {
801             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
802             /* Handle error */
803            return OPUS_INTERNAL_ERROR;
804         }
805         if (nBytes==0)
806         {
807            data[-1] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, st->stream_channels);
808            RESTORE_STACK;
809            return 1;
810         }
811         /* Extract SILK internal bandwidth for signaling in first byte */
812         if( st->mode == MODE_SILK_ONLY ) {
813             if( st->silk_mode.internalSampleRate == 8000 ) {
814                st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
815             } else if( st->silk_mode.internalSampleRate == 12000 ) {
816                st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
817             } else if( st->silk_mode.internalSampleRate == 16000 ) {
818                st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
819             }
820         } else {
821             silk_assert( st->silk_mode.internalSampleRate == 16000 );
822         }
823     }
824
825     /* CELT processing */
826     {
827         int endband=21;
828
829         switch(st->bandwidth)
830         {
831             case OPUS_BANDWIDTH_NARROWBAND:
832                 endband = 13;
833                 break;
834             case OPUS_BANDWIDTH_MEDIUMBAND:
835             case OPUS_BANDWIDTH_WIDEBAND:
836                 endband = 17;
837                 break;
838             case OPUS_BANDWIDTH_SUPERWIDEBAND:
839                 endband = 19;
840                 break;
841             case OPUS_BANDWIDTH_FULLBAND:
842                 endband = 21;
843                 break;
844         }
845         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
846         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
847     }
848     if (st->mode != MODE_SILK_ONLY)
849     {
850         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
851         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
852         if (st->prev_mode == MODE_SILK_ONLY)
853         {
854             unsigned char dummy[10];
855             celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
856             celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
857             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
858             /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
859             celt_encode_with_ec(celt_enc, &st->delay_buffer[(st->encoder_buffer-delay_compensation-st->Fs/400)*st->channels], st->Fs/400, dummy, 10, NULL);
860         } else {
861             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
862         }
863
864         if (st->mode == MODE_HYBRID)
865         {
866             int len;
867
868             len = (ec_tell(&enc)+7)>>3;
869             if (redundancy)
870                len += st->mode == MODE_HYBRID ? 3 : 1;
871             if( st->use_vbr ) {
872                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
873             } else {
874                 /* check if SILK used up too much */
875                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
876             }
877         } else {
878             if (st->use_vbr)
879             {
880                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
881                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
882                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps));
883                 nb_compr_bytes = max_data_bytes-1;
884             } else {
885                 nb_compr_bytes = bytes_target;
886             }
887         }
888
889     } else {
890         nb_compr_bytes = 0;
891     }
892
893     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
894     if (redundancy && celt_to_silk && st->mode == MODE_HYBRID)
895     {
896        for (i=0;i<st->channels*st->Fs/400;i++)
897           tmp_prefill[i] = st->delay_buffer[(st->encoder_buffer-st->delay_compensation-st->Fs/400)*st->channels + i];
898     }
899
900     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+delay_compensation));i++)
901         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
902     for (;i<st->encoder_buffer*st->channels;i++)
903         st->delay_buffer[i] = pcm_buf[(frame_size+delay_compensation-st->encoder_buffer)*st->channels+i];
904
905
906     if (st->mode != MODE_HYBRID || st->stream_channels==1)
907        st->silk_mode.stereoWidth_Q14 = 1<<14;
908     if( st->channels == 2 ) {
909         /* Apply stereo width reduction (at low bitrates) */
910         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
911             opus_val16 g1, g2;
912             const CELTMode *celt_mode;
913
914             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
915             g1 = st->hybrid_stereo_width_Q14;
916             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
917 #ifdef FIXED_POINT
918             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
919             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
920 #else
921             g1 *= (1./16384);
922             g2 *= (1./16384);
923 #endif
924             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
925                   frame_size, st->channels, celt_mode->window, st->Fs);
926             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
927         }
928     }
929
930     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
931     {
932         /* For SILK mode, the redundancy is inferred from the length */
933         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
934            ec_enc_bit_logp(&enc, redundancy, 12);
935         if (redundancy)
936         {
937             int max_redundancy;
938             ec_enc_bit_logp(&enc, celt_to_silk, 1);
939             if (st->mode == MODE_HYBRID)
940                max_redundancy = (max_data_bytes-1)-nb_compr_bytes-1;
941             else
942                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
943             /* Target the same bit-rate for redundancy as for the rest,
944                up to a max of 257 bytes */
945             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
946             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
947             if (st->mode == MODE_HYBRID)
948                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
949         }
950     } else {
951         redundancy = 0;
952     }
953
954     if (st->mode != MODE_CELT_ONLY)start_band=17;
955
956     if (st->mode == MODE_SILK_ONLY)
957     {
958         ret = (ec_tell(&enc)+7)>>3;
959         ec_enc_done(&enc);
960         /*When in LPC only mode it's perfectly
961           reasonable to strip off trailing zero bytes as
962           the required range decoder behavior is to
963           fill these in. This can't be done when the MDCT
964           modes are used because the decoder needs to know
965           the actual length for allocation purposes.*/
966         if(!redundancy)
967             while(ret>2&&data[ret-1]==0)ret--;
968         nb_compr_bytes = ret;
969     } else {
970        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
971        ec_enc_shrink(&enc, nb_compr_bytes);
972     }
973
974
975     /* 5 ms redundant frame for CELT->SILK */
976     if (redundancy && celt_to_silk)
977     {
978         unsigned char dummy[2];
979         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
980         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
981         celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
982         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
983         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
984
985         if (st->mode == MODE_HYBRID)
986         {
987            celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
988            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
989            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
990         }
991     }
992
993     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
994
995     if (st->mode != MODE_SILK_ONLY)
996     {
997         ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
998         if (ret < 0)
999            return OPUS_INTERNAL_ERROR;
1000     }
1001
1002     /* 5 ms redundant frame for SILK->CELT */
1003     if (redundancy && !celt_to_silk)
1004     {
1005         int N2, N4;
1006         N2 = st->Fs/200;
1007         N4 = st->Fs/400;
1008
1009         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1010         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1011         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1012
1013         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1014         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, data+nb_compr_bytes, redundancy_bytes, NULL);
1015
1016         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1017         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1018     }
1019
1020
1021
1022     /* Signalling the mode in the first byte */
1023     data--;
1024     data[0] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, st->stream_channels);
1025
1026     st->rangeFinal = enc.rng ^ redundant_rng;
1027
1028     if (to_celt)
1029         st->prev_mode = MODE_CELT_ONLY;
1030     else
1031         st->prev_mode = st->mode;
1032     st->prev_channels = st->stream_channels;
1033     st->prev_framesize = frame_size;
1034
1035     st->first = 0;
1036     RESTORE_STACK;
1037     return ret+1+redundancy_bytes;
1038 }
1039
1040 #ifdef FIXED_POINT
1041
1042 #ifndef DISABLE_FLOAT_API
1043 int opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1044       unsigned char *data, int max_data_bytes)
1045 {
1046    int i, ret;
1047    VARDECL(opus_int16, in);
1048    ALLOC_STACK;
1049
1050    ALLOC(in, frame_size*st->channels, opus_int16);
1051
1052    for (i=0;i<frame_size*st->channels;i++)
1053       in[i] = FLOAT2INT16(pcm[i]);
1054    ret = opus_encode(st, in, frame_size, data, max_data_bytes);
1055    RESTORE_STACK;
1056    return ret;
1057 }
1058 #endif
1059
1060 #else
1061 int opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1062       unsigned char *data, int max_data_bytes)
1063 {
1064    int i, ret;
1065    VARDECL(float, in);
1066    ALLOC_STACK;
1067
1068    ALLOC(in, frame_size*st->channels, float);
1069
1070    for (i=0;i<frame_size*st->channels;i++)
1071       in[i] = (1.0f/32768)*pcm[i];
1072    ret = opus_encode_float(st, in, frame_size, data, max_data_bytes);
1073    RESTORE_STACK;
1074    return ret;
1075 }
1076 #endif
1077
1078
1079 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
1080 {
1081     int ret;
1082     CELTEncoder *celt_enc;
1083     va_list ap;
1084
1085     ret = OPUS_OK;
1086     va_start(ap, request);
1087
1088     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1089
1090     switch (request)
1091     {
1092         case OPUS_SET_APPLICATION_REQUEST:
1093         {
1094             opus_int32 value = va_arg(ap, opus_int32);
1095             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
1096                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1097                || (!st->first && st->application != value))
1098             {
1099                ret = OPUS_BAD_ARG;
1100                break;
1101             }
1102             st->application = value;
1103         }
1104         break;
1105         case OPUS_GET_APPLICATION_REQUEST:
1106         {
1107             opus_int32 *value = va_arg(ap, opus_int32*);
1108             *value = st->application;
1109         }
1110         break;
1111         case OPUS_SET_BITRATE_REQUEST:
1112         {
1113             opus_int32 value = va_arg(ap, opus_int32);
1114             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1115             {
1116                 if (value <= 0)
1117                     goto bad_arg;
1118                 else if (value <= 500)
1119                     value = 500;
1120                 else if (value > (opus_int32)300000*st->channels)
1121                     value = (opus_int32)300000*st->channels;
1122             }
1123             st->user_bitrate_bps = value;
1124         }
1125         break;
1126         case OPUS_GET_BITRATE_REQUEST:
1127         {
1128             opus_int32 *value = va_arg(ap, opus_int32*);
1129             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
1130         }
1131         break;
1132         case OPUS_SET_FORCE_CHANNELS_REQUEST:
1133         {
1134             opus_int32 value = va_arg(ap, opus_int32);
1135             if((value<1 || value>st->channels) && value != OPUS_AUTO)
1136                 return OPUS_BAD_ARG;
1137             st->force_channels = value;
1138         }
1139         break;
1140         case OPUS_GET_FORCE_CHANNELS_REQUEST:
1141         {
1142             opus_int32 *value = va_arg(ap, opus_int32*);
1143             *value = st->force_channels;
1144         }
1145         break;
1146         case OPUS_SET_BANDWIDTH_REQUEST:
1147         {
1148             opus_int32 value = va_arg(ap, opus_int32);
1149             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
1150                 return OPUS_BAD_ARG;
1151             st->user_bandwidth = value;
1152             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1153                 st->silk_mode.maxInternalSampleRate = 8000;
1154             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1155                 st->silk_mode.maxInternalSampleRate = 12000;
1156             } else {
1157                 st->silk_mode.maxInternalSampleRate = 16000;
1158             }
1159         }
1160         break;
1161         case OPUS_GET_BANDWIDTH_REQUEST:
1162         {
1163             opus_int32 *value = va_arg(ap, opus_int32*);
1164             *value = st->bandwidth;
1165         }
1166         break;
1167         case OPUS_SET_DTX_REQUEST:
1168         {
1169             opus_int32 value = va_arg(ap, opus_int32);
1170             if(value<0 || value>1)
1171                 return OPUS_BAD_ARG;
1172             st->silk_mode.useDTX = value;
1173         }
1174         break;
1175         case OPUS_GET_DTX_REQUEST:
1176         {
1177             opus_int32 *value = va_arg(ap, opus_int32*);
1178             *value = st->silk_mode.useDTX;
1179         }
1180         break;
1181         case OPUS_SET_COMPLEXITY_REQUEST:
1182         {
1183             opus_int32 value = va_arg(ap, opus_int32);
1184             if(value<0 || value>10)
1185                 return OPUS_BAD_ARG;
1186             st->silk_mode.complexity = value;
1187             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
1188         }
1189         break;
1190         case OPUS_GET_COMPLEXITY_REQUEST:
1191         {
1192             opus_int32 *value = va_arg(ap, opus_int32*);
1193             *value = st->silk_mode.complexity;
1194         }
1195         break;
1196         case OPUS_SET_INBAND_FEC_REQUEST:
1197         {
1198             opus_int32 value = va_arg(ap, opus_int32);
1199             if(value<0 || value>1)
1200                 return OPUS_BAD_ARG;
1201             st->silk_mode.useInBandFEC = value;
1202         }
1203         break;
1204         case OPUS_GET_INBAND_FEC_REQUEST:
1205         {
1206             opus_int32 *value = va_arg(ap, opus_int32*);
1207             *value = st->silk_mode.useInBandFEC;
1208         }
1209         break;
1210         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1211         {
1212             opus_int32 value = va_arg(ap, opus_int32);
1213             if (value < 0 || value > 100)
1214                 return OPUS_BAD_ARG;
1215             st->silk_mode.packetLossPercentage = value;
1216             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
1217         }
1218         break;
1219         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1220         {
1221             opus_int32 *value = va_arg(ap, opus_int32*);
1222             *value = st->silk_mode.packetLossPercentage;
1223         }
1224         break;
1225         case OPUS_SET_VBR_REQUEST:
1226         {
1227             opus_int32 value = va_arg(ap, opus_int32);
1228             if(value<0 || value>1)
1229                 return OPUS_BAD_ARG;
1230             st->use_vbr = value;
1231             st->silk_mode.useCBR = 1-value;
1232         }
1233         break;
1234         case OPUS_GET_VBR_REQUEST:
1235         {
1236             opus_int32 *value = va_arg(ap, opus_int32*);
1237             *value = st->use_vbr;
1238         }
1239         break;
1240         case OPUS_SET_VOICE_RATIO_REQUEST:
1241         {
1242             opus_int32 value = va_arg(ap, opus_int32);
1243             if (value>100 || value<-1)
1244                 goto bad_arg;
1245             st->voice_ratio = value;
1246         }
1247         break;
1248         case OPUS_GET_VOICE_RATIO_REQUEST:
1249         {
1250             opus_int32 *value = va_arg(ap, opus_int32*);
1251             *value = st->voice_ratio;
1252         }
1253         break;
1254         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1255         {
1256             opus_int32 value = va_arg(ap, opus_int32);
1257             if(value<0 || value>1)
1258                 return OPUS_BAD_ARG;
1259             st->vbr_constraint = value;
1260         }
1261         break;
1262         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1263         {
1264             opus_int32 *value = va_arg(ap, opus_int32*);
1265             *value = st->vbr_constraint;
1266         }
1267         break;
1268         case OPUS_SET_SIGNAL_REQUEST:
1269         {
1270             opus_int32 value = va_arg(ap, opus_int32);
1271             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
1272                 return OPUS_BAD_ARG;
1273             st->signal_type = value;
1274         }
1275         break;
1276         case OPUS_GET_SIGNAL_REQUEST:
1277         {
1278             opus_int32 *value = va_arg(ap, opus_int32*);
1279             *value = st->signal_type;
1280         }
1281         break;
1282         case OPUS_GET_LOOKAHEAD_REQUEST:
1283         {
1284             opus_int32 *value = va_arg(ap, opus_int32*);
1285             *value = st->Fs/400;
1286             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1287                 *value += st->delay_compensation;
1288         }
1289         break;
1290         case OPUS_GET_FINAL_RANGE_REQUEST:
1291         {
1292             opus_uint32 *value = va_arg(ap, opus_uint32*);
1293             *value = st->rangeFinal;
1294         }
1295         break;
1296         case OPUS_RESET_STATE:
1297         {
1298            void *silk_enc;
1299            silk_EncControlStruct dummy;
1300            silk_enc = (char*)st+st->silk_enc_offset;
1301
1302            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
1303                  sizeof(OpusEncoder)-
1304                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
1305
1306            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1307            silk_InitEncoder( silk_enc, &dummy );
1308            st->stream_channels = st->channels;
1309            st->hybrid_stereo_width_Q14 = 1 << 14;
1310            st->first = 1;
1311            st->mode = MODE_HYBRID;
1312            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
1313            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1314         }
1315         break;
1316         case OPUS_SET_FORCE_MODE_REQUEST:
1317         {
1318             opus_int32 value = va_arg(ap, opus_int32);
1319             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
1320                goto bad_arg;
1321             st->user_forced_mode = value;
1322         }
1323         break;
1324         default:
1325             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
1326             ret = OPUS_UNIMPLEMENTED;
1327             break;
1328     }
1329     va_end(ap);
1330     return ret;
1331 bad_arg:
1332     va_end(ap);
1333     return OPUS_BAD_ARG;
1334 }
1335
1336 void opus_encoder_destroy(OpusEncoder *st)
1337 {
1338     opus_free(st);
1339 }