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