Only free state once in kiss-fft failed init path
[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           /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
666           if (to_celt && i==nb_frames-1)
667              st->user_forced_mode = MODE_CELT_ONLY;
668           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);
669           ret = opus_repacketizer_cat(rp, tmp_data+i*bytes_per_frame, tmp_len);
670        }
671        ret = opus_repacketizer_out(rp, data, max_data_bytes);
672
673        st->user_forced_mode = bak_mode;
674        st->user_bandwidth = bak_bandwidth;
675        st->force_channels = bak_channels;
676        st->silk_mode.toMono = bak_to_mono;
677        RESTORE_STACK;
678        return ret;
679     }
680     /* CELT mode doesn't support mediumband, use wideband instead */
681     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
682         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
683
684     /* Chooses the appropriate mode for speech
685        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
686     if (st->mode == MODE_SILK_ONLY && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
687         st->mode = MODE_HYBRID;
688     if (st->mode == MODE_HYBRID && st->bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
689         st->mode = MODE_SILK_ONLY;
690
691     /* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */
692     if (max_data_bytes < 8000*frame_size / (st->Fs * 8))
693        st->mode = MODE_CELT_ONLY;
694     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, st->bandwidth); */
695     bytes_target = IMIN(max_data_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
696
697     data += 1;
698
699     ec_enc_init(&enc, data, max_data_bytes-1);
700
701     ALLOC(pcm_buf, (delay_compensation+frame_size)*st->channels, opus_val16);
702     for (i=0;i<delay_compensation*st->channels;i++)
703        pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-delay_compensation)*st->channels+i];
704
705     if (st->mode == MODE_CELT_ONLY)
706        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
707     else
708        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
709
710     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
711           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
712
713     /* convert from log scale to Hertz */
714     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
715
716     if (st->application == OPUS_APPLICATION_VOIP)
717     {
718        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[delay_compensation*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
719     } else {
720        for (i=0;i<frame_size*st->channels;i++)
721           pcm_buf[delay_compensation*st->channels + i] = pcm[i];
722     }
723
724     /* SILK processing */
725     if (st->mode != MODE_CELT_ONLY)
726     {
727 #ifdef FIXED_POINT
728        const opus_int16 *pcm_silk;
729 #else
730        VARDECL(opus_int16, pcm_silk);
731        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
732 #endif
733         st->silk_mode.bitRate = st->bitrate_bps - 8*st->Fs/frame_size;
734         if( st->mode == MODE_HYBRID ) {
735             st->silk_mode.bitRate /= st->stream_channels;
736             if( st->bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
737                 if( st->Fs == 100 * frame_size ) {
738                     /* 24 kHz, 10 ms */
739                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 2000 + st->use_vbr * 1000 ) * 2 ) / 3;
740                 } else {
741                     /* 24 kHz, 20 ms */
742                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 1000 + st->use_vbr * 1000 ) * 2 ) / 3;
743                 }
744             } else {
745                 if( st->Fs == 100 * frame_size ) {
746                     /* 48 kHz, 10 ms */
747                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 8000 + st->use_vbr * 3000 ) / 2;
748                 } else {
749                     /* 48 kHz, 20 ms */
750                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 9000 + st->use_vbr * 1000 ) / 2;
751                 }
752             }
753             st->silk_mode.bitRate *= st->stream_channels;
754             /* don't let SILK use more than 80% */
755             if( st->silk_mode.bitRate > ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5 ) {
756                 st->silk_mode.bitRate = ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5;
757             }
758         }
759         /* SILK is not allow to use more than 50% of max_data_bytes */
760         if (max_data_bytes < st->silk_mode.bitRate*frame_size / (st->Fs * 4))
761            st->silk_mode.bitRate = max_data_bytes*st->Fs*4/frame_size;
762
763         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
764         st->silk_mode.nChannelsAPI = st->channels;
765         st->silk_mode.nChannelsInternal = st->stream_channels;
766         if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
767             st->silk_mode.desiredInternalSampleRate = 8000;
768         } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
769             st->silk_mode.desiredInternalSampleRate = 12000;
770         } else {
771             silk_assert( st->mode == MODE_HYBRID || st->bandwidth == OPUS_BANDWIDTH_WIDEBAND );
772             st->silk_mode.desiredInternalSampleRate = 16000;
773         }
774         if( st->mode == MODE_HYBRID ) {
775             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
776             st->silk_mode.minInternalSampleRate = 16000;
777         } else {
778             st->silk_mode.minInternalSampleRate = 8000;
779         }
780         st->silk_mode.maxInternalSampleRate = 16000;
781
782         /* Call SILK encoder for the low band */
783         nBytes = IMIN(1275, max_data_bytes-1);
784         if (prefill)
785         {
786             int zero=0;
787 #ifdef FIXED_POINT
788             pcm_silk = st->delay_buffer;
789 #else
790             for (i=0;i<st->encoder_buffer*st->channels;i++)
791                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
792 #endif
793             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
794         }
795
796 #ifdef FIXED_POINT
797         pcm_silk = pcm_buf+delay_compensation*st->channels;
798 #else
799         for (i=0;i<frame_size*st->channels;i++)
800             pcm_silk[i] = FLOAT2INT16(pcm_buf[delay_compensation*st->channels + i]);
801 #endif
802         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
803         if( ret ) {
804             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
805             /* Handle error */
806            return OPUS_INTERNAL_ERROR;
807         }
808         if (nBytes==0)
809         {
810            data[-1] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, st->stream_channels);
811            RESTORE_STACK;
812            return 1;
813         }
814         /* Extract SILK internal bandwidth for signaling in first byte */
815         if( st->mode == MODE_SILK_ONLY ) {
816             if( st->silk_mode.internalSampleRate == 8000 ) {
817                st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
818             } else if( st->silk_mode.internalSampleRate == 12000 ) {
819                st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
820             } else if( st->silk_mode.internalSampleRate == 16000 ) {
821                st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
822             }
823         } else {
824             silk_assert( st->silk_mode.internalSampleRate == 16000 );
825         }
826     }
827
828     /* CELT processing */
829     {
830         int endband=21;
831
832         switch(st->bandwidth)
833         {
834             case OPUS_BANDWIDTH_NARROWBAND:
835                 endband = 13;
836                 break;
837             case OPUS_BANDWIDTH_MEDIUMBAND:
838             case OPUS_BANDWIDTH_WIDEBAND:
839                 endband = 17;
840                 break;
841             case OPUS_BANDWIDTH_SUPERWIDEBAND:
842                 endband = 19;
843                 break;
844             case OPUS_BANDWIDTH_FULLBAND:
845                 endband = 21;
846                 break;
847         }
848         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
849         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
850     }
851     if (st->mode != MODE_SILK_ONLY)
852     {
853         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
854         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
855         /* Allow prediction unless we decide to disable it later */
856         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
857
858         if (st->mode == MODE_HYBRID)
859         {
860             int len;
861
862             len = (ec_tell(&enc)+7)>>3;
863             if (redundancy)
864                len += st->mode == MODE_HYBRID ? 3 : 1;
865             if( st->use_vbr ) {
866                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
867             } else {
868                 /* check if SILK used up too much */
869                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
870             }
871         } else {
872             if (st->use_vbr)
873             {
874                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
875                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
876                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps));
877                 nb_compr_bytes = max_data_bytes-1;
878             } else {
879                 nb_compr_bytes = bytes_target;
880             }
881         }
882
883     } else {
884         nb_compr_bytes = 0;
885     }
886
887     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
888     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
889     {
890        for (i=0;i<st->channels*st->Fs/400;i++)
891           tmp_prefill[i] = st->delay_buffer[(st->encoder_buffer-st->delay_compensation-st->Fs/400)*st->channels + i];
892     }
893
894     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+delay_compensation));i++)
895         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
896     for (;i<st->encoder_buffer*st->channels;i++)
897         st->delay_buffer[i] = pcm_buf[(frame_size+delay_compensation-st->encoder_buffer)*st->channels+i];
898
899
900     if (st->mode != MODE_HYBRID || st->stream_channels==1)
901        st->silk_mode.stereoWidth_Q14 = 1<<14;
902     if( st->channels == 2 ) {
903         /* Apply stereo width reduction (at low bitrates) */
904         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
905             opus_val16 g1, g2;
906             const CELTMode *celt_mode;
907
908             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
909             g1 = st->hybrid_stereo_width_Q14;
910             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
911 #ifdef FIXED_POINT
912             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
913             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
914 #else
915             g1 *= (1./16384);
916             g2 *= (1./16384);
917 #endif
918             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
919                   frame_size, st->channels, celt_mode->window, st->Fs);
920             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
921         }
922     }
923
924     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
925     {
926         /* For SILK mode, the redundancy is inferred from the length */
927         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
928            ec_enc_bit_logp(&enc, redundancy, 12);
929         if (redundancy)
930         {
931             int max_redundancy;
932             ec_enc_bit_logp(&enc, celt_to_silk, 1);
933             if (st->mode == MODE_HYBRID)
934                max_redundancy = (max_data_bytes-1)-nb_compr_bytes-1;
935             else
936                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
937             /* Target the same bit-rate for redundancy as for the rest,
938                up to a max of 257 bytes */
939             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
940             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
941             if (st->mode == MODE_HYBRID)
942                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
943         }
944     } else {
945         redundancy = 0;
946     }
947
948     if (st->mode != MODE_CELT_ONLY)start_band=17;
949
950     if (st->mode == MODE_SILK_ONLY)
951     {
952         ret = (ec_tell(&enc)+7)>>3;
953         ec_enc_done(&enc);
954         /*When in LPC only mode it's perfectly
955           reasonable to strip off trailing zero bytes as
956           the required range decoder behavior is to
957           fill these in. This can't be done when the MDCT
958           modes are used because the decoder needs to know
959           the actual length for allocation purposes.*/
960         if(!redundancy)
961             while(ret>2&&data[ret-1]==0)ret--;
962         nb_compr_bytes = ret;
963     } else {
964        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
965        ec_enc_shrink(&enc, nb_compr_bytes);
966     }
967
968
969     /* 5 ms redundant frame for CELT->SILK */
970     if (redundancy && celt_to_silk)
971     {
972         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
973         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
974         celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
975         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
976         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
977     }
978
979     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
980
981     if (st->mode != MODE_SILK_ONLY)
982     {
983         if (st->mode != st->prev_mode && st->prev_mode > 0)
984         {
985            unsigned char dummy[2];
986            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
987
988            /* Prefilling */
989            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
990            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
991         }
992         ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
993         if (ret < 0)
994            return OPUS_INTERNAL_ERROR;
995     }
996
997     /* 5 ms redundant frame for SILK->CELT */
998     if (redundancy && !celt_to_silk)
999     {
1000         unsigned char dummy[2];
1001         int N2, N4;
1002         N2 = st->Fs/200;
1003         N4 = st->Fs/400;
1004
1005         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1006         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1007         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1008
1009         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1010         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL);
1011
1012         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1013         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1014     }
1015
1016
1017
1018     /* Signalling the mode in the first byte */
1019     data--;
1020     data[0] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, st->stream_channels);
1021
1022     st->rangeFinal = enc.rng ^ redundant_rng;
1023
1024     if (to_celt)
1025         st->prev_mode = MODE_CELT_ONLY;
1026     else
1027         st->prev_mode = st->mode;
1028     st->prev_channels = st->stream_channels;
1029     st->prev_framesize = frame_size;
1030
1031     st->first = 0;
1032     RESTORE_STACK;
1033     return ret+1+redundancy_bytes;
1034 }
1035
1036 #ifdef FIXED_POINT
1037
1038 #ifndef DISABLE_FLOAT_API
1039 int opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1040       unsigned char *data, int max_data_bytes)
1041 {
1042    int i, ret;
1043    VARDECL(opus_int16, in);
1044    ALLOC_STACK;
1045
1046    ALLOC(in, frame_size*st->channels, opus_int16);
1047
1048    for (i=0;i<frame_size*st->channels;i++)
1049       in[i] = FLOAT2INT16(pcm[i]);
1050    ret = opus_encode(st, in, frame_size, data, max_data_bytes);
1051    RESTORE_STACK;
1052    return ret;
1053 }
1054 #endif
1055
1056 #else
1057 int opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1058       unsigned char *data, int max_data_bytes)
1059 {
1060    int i, ret;
1061    VARDECL(float, in);
1062    ALLOC_STACK;
1063
1064    ALLOC(in, frame_size*st->channels, float);
1065
1066    for (i=0;i<frame_size*st->channels;i++)
1067       in[i] = (1.0f/32768)*pcm[i];
1068    ret = opus_encode_float(st, in, frame_size, data, max_data_bytes);
1069    RESTORE_STACK;
1070    return ret;
1071 }
1072 #endif
1073
1074
1075 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
1076 {
1077     int ret;
1078     CELTEncoder *celt_enc;
1079     va_list ap;
1080
1081     ret = OPUS_OK;
1082     va_start(ap, request);
1083
1084     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1085
1086     switch (request)
1087     {
1088         case OPUS_SET_APPLICATION_REQUEST:
1089         {
1090             opus_int32 value = va_arg(ap, opus_int32);
1091             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
1092                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1093                || (!st->first && st->application != value))
1094             {
1095                ret = OPUS_BAD_ARG;
1096                break;
1097             }
1098             st->application = value;
1099         }
1100         break;
1101         case OPUS_GET_APPLICATION_REQUEST:
1102         {
1103             opus_int32 *value = va_arg(ap, opus_int32*);
1104             *value = st->application;
1105         }
1106         break;
1107         case OPUS_SET_BITRATE_REQUEST:
1108         {
1109             opus_int32 value = va_arg(ap, opus_int32);
1110             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1111             {
1112                 if (value <= 0)
1113                     goto bad_arg;
1114                 else if (value <= 500)
1115                     value = 500;
1116                 else if (value > (opus_int32)300000*st->channels)
1117                     value = (opus_int32)300000*st->channels;
1118             }
1119             st->user_bitrate_bps = value;
1120         }
1121         break;
1122         case OPUS_GET_BITRATE_REQUEST:
1123         {
1124             opus_int32 *value = va_arg(ap, opus_int32*);
1125             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
1126         }
1127         break;
1128         case OPUS_SET_FORCE_CHANNELS_REQUEST:
1129         {
1130             opus_int32 value = va_arg(ap, opus_int32);
1131             if((value<1 || value>st->channels) && value != OPUS_AUTO)
1132                 return OPUS_BAD_ARG;
1133             st->force_channels = value;
1134         }
1135         break;
1136         case OPUS_GET_FORCE_CHANNELS_REQUEST:
1137         {
1138             opus_int32 *value = va_arg(ap, opus_int32*);
1139             *value = st->force_channels;
1140         }
1141         break;
1142         case OPUS_SET_BANDWIDTH_REQUEST:
1143         {
1144             opus_int32 value = va_arg(ap, opus_int32);
1145             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
1146                 return OPUS_BAD_ARG;
1147             st->user_bandwidth = value;
1148             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1149                 st->silk_mode.maxInternalSampleRate = 8000;
1150             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1151                 st->silk_mode.maxInternalSampleRate = 12000;
1152             } else {
1153                 st->silk_mode.maxInternalSampleRate = 16000;
1154             }
1155         }
1156         break;
1157         case OPUS_GET_BANDWIDTH_REQUEST:
1158         {
1159             opus_int32 *value = va_arg(ap, opus_int32*);
1160             *value = st->bandwidth;
1161         }
1162         break;
1163         case OPUS_SET_DTX_REQUEST:
1164         {
1165             opus_int32 value = va_arg(ap, opus_int32);
1166             if(value<0 || value>1)
1167                 return OPUS_BAD_ARG;
1168             st->silk_mode.useDTX = value;
1169         }
1170         break;
1171         case OPUS_GET_DTX_REQUEST:
1172         {
1173             opus_int32 *value = va_arg(ap, opus_int32*);
1174             *value = st->silk_mode.useDTX;
1175         }
1176         break;
1177         case OPUS_SET_COMPLEXITY_REQUEST:
1178         {
1179             opus_int32 value = va_arg(ap, opus_int32);
1180             if(value<0 || value>10)
1181                 return OPUS_BAD_ARG;
1182             st->silk_mode.complexity = value;
1183             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
1184         }
1185         break;
1186         case OPUS_GET_COMPLEXITY_REQUEST:
1187         {
1188             opus_int32 *value = va_arg(ap, opus_int32*);
1189             *value = st->silk_mode.complexity;
1190         }
1191         break;
1192         case OPUS_SET_INBAND_FEC_REQUEST:
1193         {
1194             opus_int32 value = va_arg(ap, opus_int32);
1195             if(value<0 || value>1)
1196                 return OPUS_BAD_ARG;
1197             st->silk_mode.useInBandFEC = value;
1198         }
1199         break;
1200         case OPUS_GET_INBAND_FEC_REQUEST:
1201         {
1202             opus_int32 *value = va_arg(ap, opus_int32*);
1203             *value = st->silk_mode.useInBandFEC;
1204         }
1205         break;
1206         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1207         {
1208             opus_int32 value = va_arg(ap, opus_int32);
1209             if (value < 0 || value > 100)
1210                 return OPUS_BAD_ARG;
1211             st->silk_mode.packetLossPercentage = value;
1212             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
1213         }
1214         break;
1215         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1216         {
1217             opus_int32 *value = va_arg(ap, opus_int32*);
1218             *value = st->silk_mode.packetLossPercentage;
1219         }
1220         break;
1221         case OPUS_SET_VBR_REQUEST:
1222         {
1223             opus_int32 value = va_arg(ap, opus_int32);
1224             if(value<0 || value>1)
1225                 return OPUS_BAD_ARG;
1226             st->use_vbr = value;
1227             st->silk_mode.useCBR = 1-value;
1228         }
1229         break;
1230         case OPUS_GET_VBR_REQUEST:
1231         {
1232             opus_int32 *value = va_arg(ap, opus_int32*);
1233             *value = st->use_vbr;
1234         }
1235         break;
1236         case OPUS_SET_VOICE_RATIO_REQUEST:
1237         {
1238             opus_int32 value = va_arg(ap, opus_int32);
1239             if (value>100 || value<-1)
1240                 goto bad_arg;
1241             st->voice_ratio = value;
1242         }
1243         break;
1244         case OPUS_GET_VOICE_RATIO_REQUEST:
1245         {
1246             opus_int32 *value = va_arg(ap, opus_int32*);
1247             *value = st->voice_ratio;
1248         }
1249         break;
1250         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1251         {
1252             opus_int32 value = va_arg(ap, opus_int32);
1253             if(value<0 || value>1)
1254                 return OPUS_BAD_ARG;
1255             st->vbr_constraint = value;
1256         }
1257         break;
1258         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1259         {
1260             opus_int32 *value = va_arg(ap, opus_int32*);
1261             *value = st->vbr_constraint;
1262         }
1263         break;
1264         case OPUS_SET_SIGNAL_REQUEST:
1265         {
1266             opus_int32 value = va_arg(ap, opus_int32);
1267             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
1268                 return OPUS_BAD_ARG;
1269             st->signal_type = value;
1270         }
1271         break;
1272         case OPUS_GET_SIGNAL_REQUEST:
1273         {
1274             opus_int32 *value = va_arg(ap, opus_int32*);
1275             *value = st->signal_type;
1276         }
1277         break;
1278         case OPUS_GET_LOOKAHEAD_REQUEST:
1279         {
1280             opus_int32 *value = va_arg(ap, opus_int32*);
1281             *value = st->Fs/400;
1282             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1283                 *value += st->delay_compensation;
1284         }
1285         break;
1286         case OPUS_GET_FINAL_RANGE_REQUEST:
1287         {
1288             opus_uint32 *value = va_arg(ap, opus_uint32*);
1289             *value = st->rangeFinal;
1290         }
1291         break;
1292         case OPUS_RESET_STATE:
1293         {
1294            void *silk_enc;
1295            silk_EncControlStruct dummy;
1296            silk_enc = (char*)st+st->silk_enc_offset;
1297
1298            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
1299                  sizeof(OpusEncoder)-
1300                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
1301
1302            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1303            silk_InitEncoder( silk_enc, &dummy );
1304            st->stream_channels = st->channels;
1305            st->hybrid_stereo_width_Q14 = 1 << 14;
1306            st->first = 1;
1307            st->mode = MODE_HYBRID;
1308            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
1309            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1310         }
1311         break;
1312         case OPUS_SET_FORCE_MODE_REQUEST:
1313         {
1314             opus_int32 value = va_arg(ap, opus_int32);
1315             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
1316                goto bad_arg;
1317             st->user_forced_mode = value;
1318         }
1319         break;
1320         default:
1321             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
1322             ret = OPUS_UNIMPLEMENTED;
1323             break;
1324     }
1325     va_end(ap);
1326     return ret;
1327 bad_arg:
1328     va_end(ap);
1329     return OPUS_BAD_ARG;
1330 }
1331
1332 void opus_encoder_destroy(OpusEncoder *st)
1333 {
1334     opus_free(st);
1335 }