This should fix switching from SILK/hybrid to 60ms CELT
[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         if (st->prev_mode == MODE_SILK_ONLY)
856         {
857             unsigned char dummy[10];
858             celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
859             celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
860             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
861             /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
862             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);
863         } else {
864             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
865         }
866
867         if (st->mode == MODE_HYBRID)
868         {
869             int len;
870
871             len = (ec_tell(&enc)+7)>>3;
872             if (redundancy)
873                len += st->mode == MODE_HYBRID ? 3 : 1;
874             if( st->use_vbr ) {
875                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
876             } else {
877                 /* check if SILK used up too much */
878                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
879             }
880         } else {
881             if (st->use_vbr)
882             {
883                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
884                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
885                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps));
886                 nb_compr_bytes = max_data_bytes-1;
887             } else {
888                 nb_compr_bytes = bytes_target;
889             }
890         }
891
892     } else {
893         nb_compr_bytes = 0;
894     }
895
896     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
897     if (redundancy && celt_to_silk && st->mode == MODE_HYBRID)
898     {
899        for (i=0;i<st->channels*st->Fs/400;i++)
900           tmp_prefill[i] = st->delay_buffer[(st->encoder_buffer-st->delay_compensation-st->Fs/400)*st->channels + i];
901     }
902
903     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+delay_compensation));i++)
904         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
905     for (;i<st->encoder_buffer*st->channels;i++)
906         st->delay_buffer[i] = pcm_buf[(frame_size+delay_compensation-st->encoder_buffer)*st->channels+i];
907
908
909     if (st->mode != MODE_HYBRID || st->stream_channels==1)
910        st->silk_mode.stereoWidth_Q14 = 1<<14;
911     if( st->channels == 2 ) {
912         /* Apply stereo width reduction (at low bitrates) */
913         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
914             opus_val16 g1, g2;
915             const CELTMode *celt_mode;
916
917             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
918             g1 = st->hybrid_stereo_width_Q14;
919             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
920 #ifdef FIXED_POINT
921             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
922             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
923 #else
924             g1 *= (1./16384);
925             g2 *= (1./16384);
926 #endif
927             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
928                   frame_size, st->channels, celt_mode->window, st->Fs);
929             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
930         }
931     }
932
933     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
934     {
935         /* For SILK mode, the redundancy is inferred from the length */
936         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
937            ec_enc_bit_logp(&enc, redundancy, 12);
938         if (redundancy)
939         {
940             int max_redundancy;
941             ec_enc_bit_logp(&enc, celt_to_silk, 1);
942             if (st->mode == MODE_HYBRID)
943                max_redundancy = (max_data_bytes-1)-nb_compr_bytes-1;
944             else
945                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
946             /* Target the same bit-rate for redundancy as for the rest,
947                up to a max of 257 bytes */
948             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
949             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
950             if (st->mode == MODE_HYBRID)
951                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
952         }
953     } else {
954         redundancy = 0;
955     }
956
957     if (st->mode != MODE_CELT_ONLY)start_band=17;
958
959     if (st->mode == MODE_SILK_ONLY)
960     {
961         ret = (ec_tell(&enc)+7)>>3;
962         ec_enc_done(&enc);
963         /*When in LPC only mode it's perfectly
964           reasonable to strip off trailing zero bytes as
965           the required range decoder behavior is to
966           fill these in. This can't be done when the MDCT
967           modes are used because the decoder needs to know
968           the actual length for allocation purposes.*/
969         if(!redundancy)
970             while(ret>2&&data[ret-1]==0)ret--;
971         nb_compr_bytes = ret;
972     } else {
973        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
974        ec_enc_shrink(&enc, nb_compr_bytes);
975     }
976
977
978     /* 5 ms redundant frame for CELT->SILK */
979     if (redundancy && celt_to_silk)
980     {
981         unsigned char dummy[2];
982         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
983         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
984         celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
985         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
986         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
987
988         if (st->mode == MODE_HYBRID)
989         {
990            celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
991            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
992            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
993         }
994     }
995
996     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
997
998     if (st->mode != MODE_SILK_ONLY)
999     {
1000         ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
1001         if (ret < 0)
1002            return OPUS_INTERNAL_ERROR;
1003     }
1004
1005     /* 5 ms redundant frame for SILK->CELT */
1006     if (redundancy && !celt_to_silk)
1007     {
1008         int N2, N4;
1009         N2 = st->Fs/200;
1010         N4 = st->Fs/400;
1011
1012         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1013         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1014         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1015
1016         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1017         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, data+nb_compr_bytes, redundancy_bytes, NULL);
1018
1019         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1020         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1021     }
1022
1023
1024
1025     /* Signalling the mode in the first byte */
1026     data--;
1027     data[0] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, st->stream_channels);
1028
1029     st->rangeFinal = enc.rng ^ redundant_rng;
1030
1031     if (to_celt)
1032         st->prev_mode = MODE_CELT_ONLY;
1033     else
1034         st->prev_mode = st->mode;
1035     st->prev_channels = st->stream_channels;
1036     st->prev_framesize = frame_size;
1037
1038     st->first = 0;
1039     RESTORE_STACK;
1040     return ret+1+redundancy_bytes;
1041 }
1042
1043 #ifdef FIXED_POINT
1044
1045 #ifndef DISABLE_FLOAT_API
1046 int opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1047       unsigned char *data, int max_data_bytes)
1048 {
1049    int i, ret;
1050    VARDECL(opus_int16, in);
1051    ALLOC_STACK;
1052
1053    ALLOC(in, frame_size*st->channels, opus_int16);
1054
1055    for (i=0;i<frame_size*st->channels;i++)
1056       in[i] = FLOAT2INT16(pcm[i]);
1057    ret = opus_encode(st, in, frame_size, data, max_data_bytes);
1058    RESTORE_STACK;
1059    return ret;
1060 }
1061 #endif
1062
1063 #else
1064 int opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1065       unsigned char *data, int max_data_bytes)
1066 {
1067    int i, ret;
1068    VARDECL(float, in);
1069    ALLOC_STACK;
1070
1071    ALLOC(in, frame_size*st->channels, float);
1072
1073    for (i=0;i<frame_size*st->channels;i++)
1074       in[i] = (1.0f/32768)*pcm[i];
1075    ret = opus_encode_float(st, in, frame_size, data, max_data_bytes);
1076    RESTORE_STACK;
1077    return ret;
1078 }
1079 #endif
1080
1081
1082 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
1083 {
1084     int ret;
1085     CELTEncoder *celt_enc;
1086     va_list ap;
1087
1088     ret = OPUS_OK;
1089     va_start(ap, request);
1090
1091     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1092
1093     switch (request)
1094     {
1095         case OPUS_SET_APPLICATION_REQUEST:
1096         {
1097             opus_int32 value = va_arg(ap, opus_int32);
1098             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
1099                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1100                || (!st->first && st->application != value))
1101             {
1102                ret = OPUS_BAD_ARG;
1103                break;
1104             }
1105             st->application = value;
1106         }
1107         break;
1108         case OPUS_GET_APPLICATION_REQUEST:
1109         {
1110             opus_int32 *value = va_arg(ap, opus_int32*);
1111             *value = st->application;
1112         }
1113         break;
1114         case OPUS_SET_BITRATE_REQUEST:
1115         {
1116             opus_int32 value = va_arg(ap, opus_int32);
1117             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1118             {
1119                 if (value <= 0)
1120                     goto bad_arg;
1121                 else if (value <= 500)
1122                     value = 500;
1123                 else if (value > (opus_int32)300000*st->channels)
1124                     value = (opus_int32)300000*st->channels;
1125             }
1126             st->user_bitrate_bps = value;
1127         }
1128         break;
1129         case OPUS_GET_BITRATE_REQUEST:
1130         {
1131             opus_int32 *value = va_arg(ap, opus_int32*);
1132             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
1133         }
1134         break;
1135         case OPUS_SET_FORCE_CHANNELS_REQUEST:
1136         {
1137             opus_int32 value = va_arg(ap, opus_int32);
1138             if((value<1 || value>st->channels) && value != OPUS_AUTO)
1139                 return OPUS_BAD_ARG;
1140             st->force_channels = value;
1141         }
1142         break;
1143         case OPUS_GET_FORCE_CHANNELS_REQUEST:
1144         {
1145             opus_int32 *value = va_arg(ap, opus_int32*);
1146             *value = st->force_channels;
1147         }
1148         break;
1149         case OPUS_SET_BANDWIDTH_REQUEST:
1150         {
1151             opus_int32 value = va_arg(ap, opus_int32);
1152             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
1153                 return OPUS_BAD_ARG;
1154             st->user_bandwidth = value;
1155             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1156                 st->silk_mode.maxInternalSampleRate = 8000;
1157             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1158                 st->silk_mode.maxInternalSampleRate = 12000;
1159             } else {
1160                 st->silk_mode.maxInternalSampleRate = 16000;
1161             }
1162         }
1163         break;
1164         case OPUS_GET_BANDWIDTH_REQUEST:
1165         {
1166             opus_int32 *value = va_arg(ap, opus_int32*);
1167             *value = st->bandwidth;
1168         }
1169         break;
1170         case OPUS_SET_DTX_REQUEST:
1171         {
1172             opus_int32 value = va_arg(ap, opus_int32);
1173             if(value<0 || value>1)
1174                 return OPUS_BAD_ARG;
1175             st->silk_mode.useDTX = value;
1176         }
1177         break;
1178         case OPUS_GET_DTX_REQUEST:
1179         {
1180             opus_int32 *value = va_arg(ap, opus_int32*);
1181             *value = st->silk_mode.useDTX;
1182         }
1183         break;
1184         case OPUS_SET_COMPLEXITY_REQUEST:
1185         {
1186             opus_int32 value = va_arg(ap, opus_int32);
1187             if(value<0 || value>10)
1188                 return OPUS_BAD_ARG;
1189             st->silk_mode.complexity = value;
1190             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
1191         }
1192         break;
1193         case OPUS_GET_COMPLEXITY_REQUEST:
1194         {
1195             opus_int32 *value = va_arg(ap, opus_int32*);
1196             *value = st->silk_mode.complexity;
1197         }
1198         break;
1199         case OPUS_SET_INBAND_FEC_REQUEST:
1200         {
1201             opus_int32 value = va_arg(ap, opus_int32);
1202             if(value<0 || value>1)
1203                 return OPUS_BAD_ARG;
1204             st->silk_mode.useInBandFEC = value;
1205         }
1206         break;
1207         case OPUS_GET_INBAND_FEC_REQUEST:
1208         {
1209             opus_int32 *value = va_arg(ap, opus_int32*);
1210             *value = st->silk_mode.useInBandFEC;
1211         }
1212         break;
1213         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1214         {
1215             opus_int32 value = va_arg(ap, opus_int32);
1216             if (value < 0 || value > 100)
1217                 return OPUS_BAD_ARG;
1218             st->silk_mode.packetLossPercentage = value;
1219             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
1220         }
1221         break;
1222         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1223         {
1224             opus_int32 *value = va_arg(ap, opus_int32*);
1225             *value = st->silk_mode.packetLossPercentage;
1226         }
1227         break;
1228         case OPUS_SET_VBR_REQUEST:
1229         {
1230             opus_int32 value = va_arg(ap, opus_int32);
1231             if(value<0 || value>1)
1232                 return OPUS_BAD_ARG;
1233             st->use_vbr = value;
1234             st->silk_mode.useCBR = 1-value;
1235         }
1236         break;
1237         case OPUS_GET_VBR_REQUEST:
1238         {
1239             opus_int32 *value = va_arg(ap, opus_int32*);
1240             *value = st->use_vbr;
1241         }
1242         break;
1243         case OPUS_SET_VOICE_RATIO_REQUEST:
1244         {
1245             opus_int32 value = va_arg(ap, opus_int32);
1246             if (value>100 || value<-1)
1247                 goto bad_arg;
1248             st->voice_ratio = value;
1249         }
1250         break;
1251         case OPUS_GET_VOICE_RATIO_REQUEST:
1252         {
1253             opus_int32 *value = va_arg(ap, opus_int32*);
1254             *value = st->voice_ratio;
1255         }
1256         break;
1257         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1258         {
1259             opus_int32 value = va_arg(ap, opus_int32);
1260             if(value<0 || value>1)
1261                 return OPUS_BAD_ARG;
1262             st->vbr_constraint = value;
1263         }
1264         break;
1265         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1266         {
1267             opus_int32 *value = va_arg(ap, opus_int32*);
1268             *value = st->vbr_constraint;
1269         }
1270         break;
1271         case OPUS_SET_SIGNAL_REQUEST:
1272         {
1273             opus_int32 value = va_arg(ap, opus_int32);
1274             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
1275                 return OPUS_BAD_ARG;
1276             st->signal_type = value;
1277         }
1278         break;
1279         case OPUS_GET_SIGNAL_REQUEST:
1280         {
1281             opus_int32 *value = va_arg(ap, opus_int32*);
1282             *value = st->signal_type;
1283         }
1284         break;
1285         case OPUS_GET_LOOKAHEAD_REQUEST:
1286         {
1287             opus_int32 *value = va_arg(ap, opus_int32*);
1288             *value = st->Fs/400;
1289             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1290                 *value += st->delay_compensation;
1291         }
1292         break;
1293         case OPUS_GET_FINAL_RANGE_REQUEST:
1294         {
1295             opus_uint32 *value = va_arg(ap, opus_uint32*);
1296             *value = st->rangeFinal;
1297         }
1298         break;
1299         case OPUS_RESET_STATE:
1300         {
1301            void *silk_enc;
1302            silk_EncControlStruct dummy;
1303            silk_enc = (char*)st+st->silk_enc_offset;
1304
1305            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
1306                  sizeof(OpusEncoder)-
1307                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
1308
1309            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1310            silk_InitEncoder( silk_enc, &dummy );
1311            st->stream_channels = st->channels;
1312            st->hybrid_stereo_width_Q14 = 1 << 14;
1313            st->first = 1;
1314            st->mode = MODE_HYBRID;
1315            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
1316            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1317         }
1318         break;
1319         case OPUS_SET_FORCE_MODE_REQUEST:
1320         {
1321             opus_int32 value = va_arg(ap, opus_int32);
1322             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
1323                goto bad_arg;
1324             st->user_forced_mode = value;
1325         }
1326         break;
1327         default:
1328             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
1329             ret = OPUS_UNIMPLEMENTED;
1330             break;
1331     }
1332     va_end(ap);
1333     return ret;
1334 bad_arg:
1335     va_end(ap);
1336     return OPUS_BAD_ARG;
1337 }
1338
1339 void opus_encoder_destroy(OpusEncoder *st)
1340 {
1341     opus_free(st);
1342 }