Redundancy fixes
[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 silk_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 = (silk_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] = A_Q28[0] * (1./((opus_int32)1<<28));
272     A[1] = A_Q28[1] * (1./((opus_int32)1<<28));
273     B[0] = B_Q28[0] * (1./((opus_int32)1<<28));
274     B[1] = B_Q28[1] * (1./((opus_int32)1<<28));
275     B[2] = 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 silk_internal_bandwidth=-1;
416     int bytes_target;
417     int prefill=0;
418     int start_band = 0;
419     int redundancy = 0;
420     int redundancy_bytes = 0;
421     int celt_to_silk = 0;
422     VARDECL(opus_val16, pcm_buf);
423     int nb_compr_bytes;
424     int to_celt = 0;
425     opus_uint32 redundant_rng = 0;
426     int cutoff_Hz, hp_freq_smth1;
427     int voice_est;
428     opus_int32 equiv_rate;
429     int delay_compensation;
430     ALLOC_STACK;
431
432     max_data_bytes = IMIN(1276, max_data_bytes);
433
434     st->rangeFinal = 0;
435     if (400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
436          50*frame_size != st->Fs &&  25*frame_size != st->Fs &&  50*frame_size != 3*st->Fs)
437     {
438        RESTORE_STACK;
439        return OPUS_BAD_ARG;
440     }
441     silk_enc = (char*)st+st->silk_enc_offset;
442     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
443
444     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
445        delay_compensation = 0;
446     else
447        delay_compensation = st->delay_compensation;
448
449     st->bitrate_bps = user_bitrate_to_bitrate(st, frame_size, max_data_bytes);
450
451     /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */
452     equiv_rate = st->bitrate_bps - 60*(st->Fs/frame_size - 50);
453
454     if (st->signal_type == OPUS_SIGNAL_VOICE)
455        voice_est = 127;
456     else if (st->signal_type == OPUS_SIGNAL_MUSIC)
457        voice_est = 0;
458     else if (st->voice_ratio >= 0)
459        voice_est = st->voice_ratio*327>>8;
460     else if (st->application == OPUS_APPLICATION_VOIP)
461        voice_est = 115;
462     else
463        voice_est = 64;
464
465     if (st->force_channels!=OPUS_AUTO && st->channels == 2)
466     {
467         st->stream_channels = st->force_channels;
468     } else {
469 #ifdef FUZZING
470        /* Random mono/stereo decision */
471        if (st->channels == 2 && (rand()&0x1F)==0)
472           st->stream_channels = 3-st->stream_channels;
473 #else
474        /* Rate-dependent mono-stereo decision */
475        if (st->channels == 2)
476        {
477           opus_int32 stereo_threshold;
478           stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14);
479           if (st->stream_channels == 2)
480              stereo_threshold -= 4000;
481           else
482              stereo_threshold += 4000;
483           st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1;
484        } else {
485           st->stream_channels = st->channels;
486        }
487 #endif
488     }
489
490     /* Mode selection depending on application and signal type */
491     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
492     {
493        st->mode = MODE_CELT_ONLY;
494     } else if (st->user_forced_mode == OPUS_AUTO)
495     {
496 #ifdef FUZZING
497        /* Random mode switching */
498        if ((rand()&0xF)==0)
499        {
500           if ((rand()&0x1)==0)
501              st->mode = MODE_CELT_ONLY;
502           else
503              st->mode = MODE_SILK_ONLY;
504        } else {
505           if (st->prev_mode==MODE_CELT_ONLY)
506              st->mode = MODE_CELT_ONLY;
507           else
508              st->mode = MODE_SILK_ONLY;
509        }
510 #else
511        int chan;
512        opus_int32 mode_voice, mode_music;
513        opus_int32 threshold;
514
515        chan = (st->channels==2) && st->force_channels!=1;
516        mode_voice = mode_thresholds[chan][0];
517        mode_music = mode_thresholds[chan][1];
518        threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14);
519
520        /* Hysteresis */
521        if (st->prev_mode == MODE_CELT_ONLY)
522            threshold -= 4000;
523        else if (st->prev_mode>0)
524            threshold += 4000;
525
526        st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY;
527 #endif
528     } else {
529        st->mode = st->user_forced_mode;
530     }
531
532     /* Override the chosen mode to make sure we meet the requested frame size */
533     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
534        st->mode = MODE_CELT_ONLY;
535
536     if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0
537           && st->mode != MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)
538     {
539        /* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */
540        st->silk_mode.toMono = 1;
541        st->stream_channels = 2;
542     } else {
543        st->silk_mode.toMono = 0;
544     }
545
546     if (st->prev_mode > 0 &&
547         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
548     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
549     {
550         redundancy = 1;
551         celt_to_silk = (st->mode != MODE_CELT_ONLY);
552         if (!celt_to_silk)
553         {
554             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
555             if (frame_size >= st->Fs/100)
556             {
557                 st->mode = st->prev_mode;
558                 to_celt = 1;
559             } else {
560                 redundancy=0;
561             }
562         }
563     }
564     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
565     {
566         silk_EncControlStruct dummy;
567         silk_InitEncoder( silk_enc, &dummy);
568         prefill=1;
569     }
570
571     /* Automatic (rate-dependent) bandwidth selection */
572     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
573     {
574         const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds;
575         opus_int32 bandwidth_thresholds[8];
576         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
577
578         if (st->channels==2 && st->force_channels!=1)
579         {
580            voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds;
581            music_bandwidth_thresholds = stereo_music_bandwidth_thresholds;
582         } else {
583            voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds;
584            music_bandwidth_thresholds = mono_music_bandwidth_thresholds;
585         }
586         /* Interpolate bandwidth thresholds depending on voice estimation */
587         for (i=0;i<8;i++)
588         {
589            bandwidth_thresholds[i] = music_bandwidth_thresholds[i]
590                     + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14);
591         }
592         do {
593             int threshold, hysteresis;
594             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
595             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
596             if (!st->first)
597             {
598                 if (st->bandwidth >= bandwidth)
599                     threshold -= hysteresis;
600                 else
601                     threshold += hysteresis;
602             }
603             if (equiv_rate >= threshold)
604                 break;
605         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
606         st->bandwidth = bandwidth;
607         /* Prevents any transition to SWB/FB until the SILK layer has fully
608            switched to WB mode and turned the variable LP filter off */
609         if (st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
610             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
611     }
612
613     if (st->user_bandwidth != OPUS_AUTO)
614         st->bandwidth = st->user_bandwidth;
615
616     /* Prevents Opus from wasting bits on frequencies that are above
617        the Nyquist rate of the input signal */
618     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
619         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
620     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
621         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
622     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
623         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
624     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
625         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
626
627
628     /* Can't support higher than wideband for >20 ms frames */
629     if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND))
630     {
631        VARDECL(unsigned char, tmp_data);
632        VARDECL(unsigned char, rp_);
633        int nb_frames;
634        int bak_mode, bak_bandwidth, bak_channels, bak_to_mono;
635        OpusRepacketizer *rp;
636        int bytes_per_frame;
637
638
639        nb_frames = frame_size > st->Fs/25 ? 3 : 2;
640        bytes_per_frame = max_data_bytes/nb_frames-3;
641
642        ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char);
643        ALLOC(rp_, opus_repacketizer_get_size(), unsigned char);
644
645        rp = opus_repacketizer_init((OpusRepacketizer*)rp_);
646
647        bak_mode = st->user_forced_mode;
648        bak_bandwidth = st->user_bandwidth;
649        bak_channels = st->force_channels;
650
651        st->user_forced_mode = st->mode;
652        st->user_bandwidth = st->bandwidth;
653        st->force_channels = st->stream_channels;
654        bak_to_mono = st->silk_mode.toMono;
655
656        if (bak_to_mono)
657           st->force_channels = 1;
658        else
659           st->prev_channels = st->stream_channels;
660        for (i=0;i<nb_frames;i++)
661        {
662           int tmp_len;
663           st->silk_mode.toMono = 0;
664           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);
665           ret = opus_repacketizer_cat(rp, tmp_data+i*bytes_per_frame, tmp_len);
666        }
667        ret = opus_repacketizer_out(rp, data, max_data_bytes);
668
669        st->user_forced_mode = bak_mode;
670        st->user_bandwidth = bak_bandwidth;
671        st->force_channels = bak_channels;
672        st->silk_mode.toMono = bak_to_mono;
673        RESTORE_STACK;
674        return ret;
675     }
676     /* CELT mode doesn't support mediumband, use wideband instead */
677     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
678         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
679
680     /* Chooses the appropriate mode for speech
681        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
682     if (st->mode == MODE_SILK_ONLY && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
683         st->mode = MODE_HYBRID;
684     if (st->mode == MODE_HYBRID && st->bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
685         st->mode = MODE_SILK_ONLY;
686
687     /* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */
688     if (max_data_bytes < 8000*frame_size / (st->Fs * 8))
689        st->mode = MODE_CELT_ONLY;
690     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, st->bandwidth); */
691     bytes_target = IMIN(max_data_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
692
693     data += 1;
694
695     ec_enc_init(&enc, data, max_data_bytes-1);
696
697     ALLOC(pcm_buf, (delay_compensation+frame_size)*st->channels, opus_val16);
698     for (i=0;i<delay_compensation*st->channels;i++)
699        pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-delay_compensation)*st->channels+i];
700
701     if (st->mode == MODE_CELT_ONLY)
702        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
703     else
704        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
705
706     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
707           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
708
709     /* convert from log scale to Hertz */
710     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
711
712     if (st->application == OPUS_APPLICATION_VOIP)
713     {
714        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[delay_compensation*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
715     } else {
716        for (i=0;i<frame_size*st->channels;i++)
717           pcm_buf[delay_compensation*st->channels + i] = pcm[i];
718     }
719
720     /* SILK processing */
721     if (st->mode != MODE_CELT_ONLY)
722     {
723 #ifdef FIXED_POINT
724        const opus_int16 *pcm_silk;
725 #else
726        VARDECL(opus_int16, pcm_silk);
727        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
728 #endif
729         st->silk_mode.bitRate = st->bitrate_bps - 8*st->Fs/frame_size;
730         if( st->mode == MODE_HYBRID ) {
731             st->silk_mode.bitRate /= st->stream_channels;
732             if( st->bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
733                 if( st->Fs == 100 * frame_size ) {
734                     /* 24 kHz, 10 ms */
735                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 2000 + st->use_vbr * 1000 ) * 2 ) / 3;
736                 } else {
737                     /* 24 kHz, 20 ms */
738                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 1000 + st->use_vbr * 1000 ) * 2 ) / 3;
739                 }
740             } else {
741                 if( st->Fs == 100 * frame_size ) {
742                     /* 48 kHz, 10 ms */
743                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 8000 + st->use_vbr * 3000 ) / 2;
744                 } else {
745                     /* 48 kHz, 20 ms */
746                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 9000 + st->use_vbr * 1000 ) / 2;
747                 }
748             }
749             st->silk_mode.bitRate *= st->stream_channels;
750             /* don't let SILK use more than 80% */
751             if( st->silk_mode.bitRate > ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5 ) {
752                 st->silk_mode.bitRate = ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5;
753             }
754         }
755         /* SILK is not allow to use more than 50% of max_data_bytes */
756         if (max_data_bytes < 2*st->silk_mode.bitRate*frame_size / (st->Fs * 8))
757            st->silk_mode.bitRate = max_data_bytes*st->Fs*4/frame_size;
758
759         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
760         st->silk_mode.nChannelsAPI = st->channels;
761         st->silk_mode.nChannelsInternal = st->stream_channels;
762         if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
763             st->silk_mode.desiredInternalSampleRate = 8000;
764         } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
765             st->silk_mode.desiredInternalSampleRate = 12000;
766         } else {
767             silk_assert( st->mode == MODE_HYBRID || st->bandwidth == OPUS_BANDWIDTH_WIDEBAND );
768             st->silk_mode.desiredInternalSampleRate = 16000;
769         }
770         if( st->mode == MODE_HYBRID ) {
771             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
772             st->silk_mode.minInternalSampleRate = 16000;
773         } else {
774             st->silk_mode.minInternalSampleRate = 8000;
775         }
776         st->silk_mode.maxInternalSampleRate = 16000;
777
778         /* Call SILK encoder for the low band */
779         nBytes = IMIN(1275, max_data_bytes-1);
780         if (prefill)
781         {
782             int zero=0;
783 #ifdef FIXED_POINT
784             pcm_silk = st->delay_buffer;
785 #else
786             for (i=0;i<st->encoder_buffer*st->channels;i++)
787                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
788 #endif
789             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
790         }
791
792 #ifdef FIXED_POINT
793         pcm_silk = pcm_buf+delay_compensation*st->channels;
794 #else
795         for (i=0;i<frame_size*st->channels;i++)
796             pcm_silk[i] = FLOAT2INT16(pcm_buf[delay_compensation*st->channels + i]);
797 #endif
798         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
799         if( ret ) {
800             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
801             /* Handle error */
802            return OPUS_INTERNAL_ERROR;
803         }
804         if (nBytes==0)
805         {
806            data[-1] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, silk_internal_bandwidth, st->stream_channels);
807            RESTORE_STACK;
808            return 1;
809         }
810         /* Extract SILK internal bandwidth for signaling in first byte */
811         if( st->mode == MODE_SILK_ONLY ) {
812             if( st->silk_mode.internalSampleRate == 8000 ) {
813                 silk_internal_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
814             } else if( st->silk_mode.internalSampleRate == 12000 ) {
815                 silk_internal_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
816             } else if( st->silk_mode.internalSampleRate == 16000 ) {
817                 silk_internal_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
818             }
819         } else {
820             silk_assert( st->silk_mode.internalSampleRate == 16000 );
821         }
822     }
823
824     /* CELT processing */
825     {
826         int endband=21;
827
828         switch(st->bandwidth)
829         {
830             case OPUS_BANDWIDTH_NARROWBAND:
831                 endband = 13;
832                 break;
833             case OPUS_BANDWIDTH_MEDIUMBAND:
834             case OPUS_BANDWIDTH_WIDEBAND:
835                 endband = 17;
836                 break;
837             case OPUS_BANDWIDTH_SUPERWIDEBAND:
838                 endband = 19;
839                 break;
840             case OPUS_BANDWIDTH_FULLBAND:
841                 endband = 21;
842                 break;
843         }
844         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
845         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
846     }
847     if (st->mode != MODE_SILK_ONLY)
848     {
849         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
850         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
851         if (st->prev_mode == MODE_SILK_ONLY)
852         {
853             unsigned char dummy[10];
854             celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
855             celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
856             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
857             /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
858             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);
859         } else {
860             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
861         }
862
863         if (st->mode == MODE_HYBRID)
864         {
865             int len;
866
867             len = (ec_tell(&enc)+7)>>3;
868             if( st->use_vbr ) {
869                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
870             } else {
871                 /* check if SILK used up too much */
872                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
873             }
874         } else {
875             if (st->use_vbr)
876             {
877                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
878                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
879                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps));
880                 nb_compr_bytes = max_data_bytes-1;
881             } else {
882                 nb_compr_bytes = bytes_target;
883             }
884         }
885
886     } else {
887         nb_compr_bytes = 0;
888     }
889
890     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+delay_compensation));i++)
891         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
892     for (;i<st->encoder_buffer*st->channels;i++)
893         st->delay_buffer[i] = pcm_buf[(frame_size+delay_compensation-st->encoder_buffer)*st->channels+i];
894
895
896     if (st->mode != MODE_HYBRID || st->stream_channels==1)
897        st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14 = 1<<14;
898     if( st->channels == 2 ) {
899         /* Apply stereo width reduction (at low bitrates) */
900         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
901             opus_val16 g1, g2;
902             const CELTMode *celt_mode;
903
904             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
905             g1 = st->hybrid_stereo_width_Q14;
906             g2 = st->silk_mode.stereoWidth_Q14;
907 #ifdef FIXED_POINT
908             g1 *= (1./16384);
909             g2 *= (1./16384);
910 #else
911             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
912             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
913 #endif
914             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
915                   frame_size, st->channels, celt_mode->window, st->Fs);
916             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
917         }
918     }
919
920     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) < 8*(max_data_bytes-1))
921     {
922         /* For SILK mode, the redundancy is inferred from the length */
923         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 < 8*nb_compr_bytes))
924            ec_enc_bit_logp(&enc, redundancy, 12);
925         if (redundancy)
926         {
927             int max_redundancy;
928             ec_enc_bit_logp(&enc, celt_to_silk, 1);
929             if (st->mode == MODE_HYBRID)
930                max_redundancy = (max_data_bytes-1)-nb_compr_bytes-1;
931             else
932                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
933             /* Target the same bit-rate for redundancy as for the rest,
934                up to a max of 257 bytes */
935             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
936             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
937             if (st->mode == MODE_HYBRID)
938                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
939         }
940     } else {
941         redundancy = 0;
942     }
943
944     if (st->mode != MODE_CELT_ONLY)start_band=17;
945
946     if (st->mode == MODE_SILK_ONLY)
947     {
948         ret = (ec_tell(&enc)+7)>>3;
949         ec_enc_done(&enc);
950         /*When in LPC only mode it's perfectly
951           reasonable to strip off trailing zero bytes as
952           the required range decoder behavior is to
953           fill these in. This can't be done when the MDCT
954           modes are used because the decoder needs to know
955           the actual length for allocation purposes.*/
956         if(!redundancy)
957             while(ret>2&&data[ret-1]==0)ret--;
958         nb_compr_bytes = ret;
959     } else {
960        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
961        ec_enc_shrink(&enc, nb_compr_bytes);
962     }
963
964
965     /* 5 ms redundant frame for CELT->SILK */
966     if (redundancy && celt_to_silk)
967     {
968         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
969         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
970         celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
971         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
972         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
973     }
974
975     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
976
977     if (st->mode != MODE_SILK_ONLY)
978     {
979         ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
980         if (ret < 0)
981            return OPUS_INTERNAL_ERROR;
982     }
983
984     /* 5 ms redundant frame for SILK->CELT */
985     if (redundancy && !celt_to_silk)
986     {
987         int N2, N4;
988         N2 = st->Fs/200;
989         N4 = st->Fs/400;
990
991         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
992         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
993         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
994
995         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
996         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, data+nb_compr_bytes, redundancy_bytes, NULL);
997
998         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
999         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1000     }
1001
1002
1003
1004     /* Signalling the mode in the first byte */
1005     data--;
1006     data[0] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, silk_internal_bandwidth, st->stream_channels);
1007
1008     st->rangeFinal = enc.rng ^ redundant_rng;
1009
1010     if (to_celt)
1011         st->prev_mode = MODE_CELT_ONLY;
1012     else
1013         st->prev_mode = st->mode;
1014     st->prev_channels = st->stream_channels;
1015     st->prev_framesize = frame_size;
1016
1017     st->first = 0;
1018     RESTORE_STACK;
1019     return ret+1+redundancy_bytes;
1020 }
1021
1022 #ifdef FIXED_POINT
1023
1024 #ifndef DISABLE_FLOAT_API
1025 int opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1026       unsigned char *data, int max_data_bytes)
1027 {
1028    int i, ret;
1029    VARDECL(opus_int16, in);
1030    ALLOC_STACK;
1031
1032    ALLOC(in, frame_size*st->channels, opus_int16);
1033
1034    for (i=0;i<frame_size*st->channels;i++)
1035       in[i] = FLOAT2INT16(pcm[i]);
1036    ret = opus_encode(st, in, frame_size, data, max_data_bytes);
1037    RESTORE_STACK;
1038    return ret;
1039 }
1040 #endif
1041
1042 #else
1043 int opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1044       unsigned char *data, int max_data_bytes)
1045 {
1046    int i, ret;
1047    VARDECL(float, in);
1048    ALLOC_STACK;
1049
1050    ALLOC(in, frame_size*st->channels, float);
1051
1052    for (i=0;i<frame_size*st->channels;i++)
1053       in[i] = (1./32768)*pcm[i];
1054    ret = opus_encode_float(st, in, frame_size, data, max_data_bytes);
1055    RESTORE_STACK;
1056    return ret;
1057 }
1058 #endif
1059
1060
1061 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
1062 {
1063     int ret;
1064     CELTEncoder *celt_enc;
1065     va_list ap;
1066
1067     ret = OPUS_OK;
1068     va_start(ap, request);
1069
1070     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1071
1072     switch (request)
1073     {
1074         case OPUS_SET_APPLICATION_REQUEST:
1075         {
1076             opus_int32 value = va_arg(ap, opus_int32);
1077             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
1078                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1079                || (!st->first && st->application != value))
1080             {
1081                ret = OPUS_BAD_ARG;
1082                break;
1083             }
1084             st->application = value;
1085         }
1086         break;
1087         case OPUS_GET_APPLICATION_REQUEST:
1088         {
1089             opus_int32 *value = va_arg(ap, opus_int32*);
1090             *value = st->application;
1091         }
1092         break;
1093         case OPUS_SET_BITRATE_REQUEST:
1094         {
1095             opus_int32 value = va_arg(ap, opus_int32);
1096             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1097             {
1098                 if (value <= 0)
1099                     goto bad_arg;
1100                 else if (value <= 500)
1101                     value = 500;
1102                 else if (value > (opus_int32)300000*st->channels)
1103                     value = (opus_int32)300000*st->channels;
1104             }
1105             st->user_bitrate_bps = value;
1106         }
1107         break;
1108         case OPUS_GET_BITRATE_REQUEST:
1109         {
1110             opus_int32 *value = va_arg(ap, opus_int32*);
1111             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
1112         }
1113         break;
1114         case OPUS_SET_FORCE_CHANNELS_REQUEST:
1115         {
1116             opus_int32 value = va_arg(ap, opus_int32);
1117             if((value<1 || value>st->channels) && value != OPUS_AUTO)
1118                 return OPUS_BAD_ARG;
1119             st->force_channels = value;
1120         }
1121         break;
1122         case OPUS_GET_FORCE_CHANNELS_REQUEST:
1123         {
1124             opus_int32 *value = va_arg(ap, opus_int32*);
1125             *value = st->force_channels;
1126         }
1127         break;
1128         case OPUS_SET_BANDWIDTH_REQUEST:
1129         {
1130             opus_int32 value = va_arg(ap, opus_int32);
1131             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
1132                 return OPUS_BAD_ARG;
1133             st->user_bandwidth = value;
1134             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1135                 st->silk_mode.maxInternalSampleRate = 8000;
1136             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1137                 st->silk_mode.maxInternalSampleRate = 12000;
1138             } else {
1139                 st->silk_mode.maxInternalSampleRate = 16000;
1140             }
1141         }
1142         break;
1143         case OPUS_GET_BANDWIDTH_REQUEST:
1144         {
1145             opus_int32 *value = va_arg(ap, opus_int32*);
1146             *value = st->bandwidth;
1147         }
1148         break;
1149         case OPUS_SET_DTX_REQUEST:
1150         {
1151             opus_int32 value = va_arg(ap, opus_int32);
1152             if(value<0 || value>1)
1153                 return OPUS_BAD_ARG;
1154             st->silk_mode.useDTX = value;
1155         }
1156         break;
1157         case OPUS_GET_DTX_REQUEST:
1158         {
1159             opus_int32 *value = va_arg(ap, opus_int32*);
1160             *value = st->silk_mode.useDTX;
1161         }
1162         break;
1163         case OPUS_SET_COMPLEXITY_REQUEST:
1164         {
1165             opus_int32 value = va_arg(ap, opus_int32);
1166             if(value<0 || value>10)
1167                 return OPUS_BAD_ARG;
1168             st->silk_mode.complexity = value;
1169             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
1170         }
1171         break;
1172         case OPUS_GET_COMPLEXITY_REQUEST:
1173         {
1174             opus_int32 *value = va_arg(ap, opus_int32*);
1175             *value = st->silk_mode.complexity;
1176         }
1177         break;
1178         case OPUS_SET_INBAND_FEC_REQUEST:
1179         {
1180             opus_int32 value = va_arg(ap, opus_int32);
1181             if(value<0 || value>1)
1182                 return OPUS_BAD_ARG;
1183             st->silk_mode.useInBandFEC = value;
1184         }
1185         break;
1186         case OPUS_GET_INBAND_FEC_REQUEST:
1187         {
1188             opus_int32 *value = va_arg(ap, opus_int32*);
1189             *value = st->silk_mode.useInBandFEC;
1190         }
1191         break;
1192         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1193         {
1194             opus_int32 value = va_arg(ap, opus_int32);
1195             if (value < 0 || value > 100)
1196                 return OPUS_BAD_ARG;
1197             st->silk_mode.packetLossPercentage = value;
1198             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
1199         }
1200         break;
1201         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1202         {
1203             opus_int32 *value = va_arg(ap, opus_int32*);
1204             *value = st->silk_mode.packetLossPercentage;
1205         }
1206         break;
1207         case OPUS_SET_VBR_REQUEST:
1208         {
1209             opus_int32 value = va_arg(ap, opus_int32);
1210             if(value<0 || value>1)
1211                 return OPUS_BAD_ARG;
1212             st->use_vbr = value;
1213             st->silk_mode.useCBR = 1-value;
1214         }
1215         break;
1216         case OPUS_GET_VBR_REQUEST:
1217         {
1218             opus_int32 *value = va_arg(ap, opus_int32*);
1219             *value = st->use_vbr;
1220         }
1221         break;
1222         case OPUS_SET_VOICE_RATIO_REQUEST:
1223         {
1224             opus_int32 value = va_arg(ap, opus_int32);
1225             if (value>100 || value<-1)
1226                 goto bad_arg;
1227             st->voice_ratio = value;
1228         }
1229         break;
1230         case OPUS_GET_VOICE_RATIO_REQUEST:
1231         {
1232             opus_int32 *value = va_arg(ap, opus_int32*);
1233             *value = st->voice_ratio;
1234         }
1235         break;
1236         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1237         {
1238             opus_int32 value = va_arg(ap, opus_int32);
1239             if(value<0 || value>1)
1240                 return OPUS_BAD_ARG;
1241             st->vbr_constraint = value;
1242         }
1243         break;
1244         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1245         {
1246             opus_int32 *value = va_arg(ap, opus_int32*);
1247             *value = st->vbr_constraint;
1248         }
1249         break;
1250         case OPUS_SET_SIGNAL_REQUEST:
1251         {
1252             opus_int32 value = va_arg(ap, opus_int32);
1253             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
1254                 return OPUS_BAD_ARG;
1255             st->signal_type = value;
1256         }
1257         break;
1258         case OPUS_GET_SIGNAL_REQUEST:
1259         {
1260             opus_int32 *value = va_arg(ap, opus_int32*);
1261             *value = st->signal_type;
1262         }
1263         break;
1264         case OPUS_GET_LOOKAHEAD_REQUEST:
1265         {
1266             opus_int32 *value = va_arg(ap, opus_int32*);
1267             *value = st->Fs/400;
1268             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1269                *value += st->delay_compensation;
1270         }
1271         break;
1272         case OPUS_GET_FINAL_RANGE_REQUEST:
1273         {
1274             opus_uint32 *value = va_arg(ap, opus_uint32*);
1275             *value = st->rangeFinal;
1276         }
1277         break;
1278         case OPUS_RESET_STATE:
1279         {
1280            void *silk_enc;
1281            silk_EncControlStruct dummy;
1282            silk_enc = (char*)st+st->silk_enc_offset;
1283
1284            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
1285                  sizeof(OpusEncoder)-
1286                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
1287
1288            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1289            silk_InitEncoder( silk_enc, &dummy );
1290            st->stream_channels = st->channels;
1291            st->hybrid_stereo_width_Q14             = 1 << 14;
1292            st->first = 1;
1293            st->mode = MODE_HYBRID;
1294            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
1295            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1296         }
1297         break;
1298         case OPUS_SET_FORCE_MODE_REQUEST:
1299         {
1300             opus_int32 value = va_arg(ap, opus_int32);
1301             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
1302                goto bad_arg;
1303             st->user_forced_mode = value;
1304         }
1305         break;
1306         default:
1307             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
1308             ret = OPUS_UNIMPLEMENTED;
1309             break;
1310     }
1311     va_end(ap);
1312     return ret;
1313 bad_arg:
1314     va_end(ap);
1315     return OPUS_BAD_ARG;
1316 }
1317
1318 void opus_encoder_destroy(OpusEncoder *st)
1319 {
1320     opus_free(st);
1321 }