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