Builds the analysis files more cleanly than #including C files
[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.h"
44 #include "mathops.h"
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 #ifdef FIXED_POINT
372 static void dc_reject(const opus_val16 *in, opus_int32 cutoff_Hz, opus_val16 *out, opus_val32 *hp_mem, int len, int channels, opus_int32 Fs)
373 {
374    int c, i;
375    int shift;
376
377    /* Approximates -round(log2(4.*cutoff_Hz/Fs)) */
378    shift=celt_ilog2(Fs/(cutoff_Hz*3));
379    for (c=0;c<channels;c++)
380    {
381       for (i=0;i<len;i++)
382       {
383          opus_val32 x, tmp, y;
384          x = SHL32(EXTEND32(in[channels*i+c]), 15);
385          /* First stage */
386          tmp = x-hp_mem[2*c];
387          hp_mem[2*c] = hp_mem[2*c] + PSHR32(x - hp_mem[2*c], shift);
388          /* Second stage */
389          y = tmp - hp_mem[2*c+1];
390          hp_mem[2*c+1] = hp_mem[2*c+1] + PSHR32(tmp - hp_mem[2*c+1], shift);
391          out[channels*i+c] = EXTRACT16(SATURATE(PSHR32(y, 15), 32767));
392       }
393    }
394 }
395
396 #else
397 static void dc_reject(const opus_val16 *in, opus_int32 cutoff_Hz, opus_val16 *out, opus_val32 *hp_mem, int len, int channels, opus_int32 Fs)
398 {
399    int c, i;
400    float coef;
401
402    coef = 4.*cutoff_Hz/Fs;
403    for (c=0;c<channels;c++)
404    {
405       for (i=0;i<len;i++)
406       {
407          opus_val32 x, tmp, y;
408          x = in[channels*i+c];
409          /* First stage */
410          tmp = x-hp_mem[2*c];
411          hp_mem[2*c] = hp_mem[2*c] + coef*(x - hp_mem[2*c]);
412          /* Second stage */
413          y = tmp - hp_mem[2*c+1];
414          hp_mem[2*c+1] = hp_mem[2*c+1] + coef*(tmp - hp_mem[2*c+1]);
415          out[channels*i+c] = y;
416       }
417    }
418 }
419 #endif
420
421 static void stereo_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2,
422         int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
423 {
424     int i;
425     int overlap;
426     int inc;
427     inc = 48000/Fs;
428     overlap=overlap48/inc;
429     g1 = Q15ONE-g1;
430     g2 = Q15ONE-g2;
431     for (i=0;i<overlap;i++)
432     {
433        opus_val32 diff;
434        opus_val16 g, w;
435        w = MULT16_16_Q15(window[i*inc], window[i*inc]);
436        g = SHR32(MAC16_16(MULT16_16(w,g2),
437              Q15ONE-w, g1), 15);
438        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
439        diff = MULT16_16_Q15(g, diff);
440        out[i*channels] = out[i*channels] - diff;
441        out[i*channels+1] = out[i*channels+1] + diff;
442     }
443     for (;i<frame_size;i++)
444     {
445        opus_val32 diff;
446        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
447        diff = MULT16_16_Q15(g2, diff);
448        out[i*channels] = out[i*channels] - diff;
449        out[i*channels+1] = out[i*channels+1] + diff;
450     }
451 }
452
453 OpusEncoder *opus_encoder_create(opus_int32 Fs, int channels, int application, int *error)
454 {
455    int ret;
456    OpusEncoder *st;
457    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
458        (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
459        && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
460    {
461       if (error)
462          *error = OPUS_BAD_ARG;
463       return NULL;
464    }
465    st = (OpusEncoder *)opus_alloc(opus_encoder_get_size(channels));
466    if (st == NULL)
467    {
468       if (error)
469          *error = OPUS_ALLOC_FAIL;
470       return NULL;
471    }
472    ret = opus_encoder_init(st, Fs, channels, application);
473    if (error)
474       *error = ret;
475    if (ret != OPUS_OK)
476    {
477       opus_free(st);
478       st = NULL;
479    }
480    return st;
481 }
482
483 static opus_int32 user_bitrate_to_bitrate(OpusEncoder *st, int frame_size, int max_data_bytes)
484 {
485   if(!frame_size)frame_size=st->Fs/400;
486   if (st->user_bitrate_bps==OPUS_AUTO)
487     return 60*st->Fs/frame_size + st->Fs*st->channels;
488   else if (st->user_bitrate_bps==OPUS_BITRATE_MAX)
489     return max_data_bytes*8*st->Fs/frame_size;
490   else
491     return st->user_bitrate_bps;
492 }
493
494 #ifdef FIXED_POINT
495 #define opus_encode_native opus_encode
496 opus_int32 opus_encode(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
497                 unsigned char *data, opus_int32 out_data_bytes)
498 #else
499 #define opus_encode_native opus_encode_float
500 opus_int32 opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
501                       unsigned char *data, opus_int32 out_data_bytes)
502 #endif
503 {
504     void *silk_enc;
505     CELTEncoder *celt_enc;
506     int i;
507     int ret=0;
508     opus_int32 nBytes;
509     ec_enc enc;
510     int bytes_target;
511     int prefill=0;
512     int start_band = 0;
513     int redundancy = 0;
514     int redundancy_bytes = 0;
515     int celt_to_silk = 0;
516     VARDECL(opus_val16, pcm_buf);
517     int nb_compr_bytes;
518     int to_celt = 0;
519     opus_uint32 redundant_rng = 0;
520     int cutoff_Hz, hp_freq_smth1;
521     int voice_est;
522     opus_int32 equiv_rate;
523     int delay_compensation;
524     int frame_rate;
525     opus_int32 max_rate;
526     int curr_bandwidth;
527     opus_int32 max_data_bytes;
528     int extra_buffer, total_buffer;
529     int perform_analysis=0;
530 #ifndef FIXED_POINT
531     AnalysisInfo analysis_info;
532 #endif
533     VARDECL(opus_val16, tmp_prefill);
534
535     ALLOC_STACK;
536
537     max_data_bytes = IMIN(1276, out_data_bytes);
538
539     st->rangeFinal = 0;
540     if (400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
541          50*frame_size != st->Fs &&  25*frame_size != st->Fs &&  50*frame_size != 3*st->Fs)
542     {
543        RESTORE_STACK;
544        return OPUS_BAD_ARG;
545     }
546     if (max_data_bytes<=0)
547     {
548        RESTORE_STACK;
549        return OPUS_BAD_ARG;
550     }
551     silk_enc = (char*)st+st->silk_enc_offset;
552     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
553
554 #ifndef FIXED_POINT
555     perform_analysis = st->silk_mode.complexity >= 7 && frame_size >= st->Fs/100 && st->Fs==48000;
556 #endif
557     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
558        delay_compensation = 0;
559     else
560        delay_compensation = st->delay_compensation;
561     if (perform_analysis)
562     {
563        total_buffer = IMAX(st->Fs/200, delay_compensation);
564     } else {
565        total_buffer = delay_compensation;
566     }
567     extra_buffer = total_buffer-delay_compensation;
568     st->bitrate_bps = user_bitrate_to_bitrate(st, frame_size, max_data_bytes);
569
570     frame_rate = st->Fs/frame_size;
571     if (max_data_bytes<3 || st->bitrate_bps < 3*frame_rate*8
572        || (frame_rate<50 && (max_data_bytes*frame_rate<300 || st->bitrate_bps < 2400)))
573     {
574        int tocmode = st->mode;
575        if (tocmode==0)
576           tocmode = MODE_SILK_ONLY;
577        if (frame_rate>100)
578           tocmode = MODE_CELT_ONLY;
579        if (frame_rate < 50)
580           tocmode = MODE_SILK_ONLY;
581        data[0] = gen_toc(tocmode, frame_rate,
582                          st->bandwidth == 0 ? OPUS_BANDWIDTH_NARROWBAND : st->bandwidth,
583                          st->stream_channels);
584        RESTORE_STACK;
585        return 1;
586     }
587     if (!st->use_vbr)
588     {
589        int cbrBytes;
590        cbrBytes = IMIN( (st->bitrate_bps + 4*frame_rate)/(8*frame_rate) , max_data_bytes);
591        st->bitrate_bps = cbrBytes * (8*frame_rate);
592        max_data_bytes = cbrBytes;
593     }
594     max_rate = frame_rate*max_data_bytes*8;
595
596     /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */
597     equiv_rate = st->bitrate_bps - 60*(st->Fs/frame_size - 50);
598
599     if (st->signal_type == OPUS_SIGNAL_VOICE)
600        voice_est = 127;
601     else if (st->signal_type == OPUS_SIGNAL_MUSIC)
602        voice_est = 0;
603     else if (st->voice_ratio >= 0)
604        voice_est = st->voice_ratio*327>>8;
605     else if (st->application == OPUS_APPLICATION_VOIP)
606        voice_est = 115;
607     else
608        voice_est = 48;
609
610     if (st->force_channels!=OPUS_AUTO && st->channels == 2)
611     {
612         st->stream_channels = st->force_channels;
613     } else {
614 #ifdef FUZZING
615        /* Random mono/stereo decision */
616        if (st->channels == 2 && (rand()&0x1F)==0)
617           st->stream_channels = 3-st->stream_channels;
618 #else
619        /* Rate-dependent mono-stereo decision */
620        if (st->channels == 2)
621        {
622           opus_int32 stereo_threshold;
623           stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14);
624           if (st->stream_channels == 2)
625              stereo_threshold -= 4000;
626           else
627              stereo_threshold += 4000;
628           st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1;
629        } else {
630           st->stream_channels = st->channels;
631        }
632 #endif
633     }
634
635     /* Mode selection depending on application and signal type */
636     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
637     {
638        st->mode = MODE_CELT_ONLY;
639     } else if (st->user_forced_mode == OPUS_AUTO)
640     {
641 #ifdef FUZZING
642        /* Random mode switching */
643        if ((rand()&0xF)==0)
644        {
645           if ((rand()&0x1)==0)
646              st->mode = MODE_CELT_ONLY;
647           else
648              st->mode = MODE_SILK_ONLY;
649        } else {
650           if (st->prev_mode==MODE_CELT_ONLY)
651              st->mode = MODE_CELT_ONLY;
652           else
653              st->mode = MODE_SILK_ONLY;
654        }
655 #else
656        int chan;
657        opus_int32 mode_voice, mode_music;
658        opus_int32 threshold;
659
660        chan = (st->channels==2) && st->force_channels!=1;
661        mode_voice = mode_thresholds[chan][0];
662        mode_music = mode_thresholds[chan][1];
663        threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14);
664
665        /* Hysteresis */
666        if (st->prev_mode == MODE_CELT_ONLY)
667            threshold -= 4000;
668        else if (st->prev_mode>0)
669            threshold += 4000;
670
671        st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY;
672
673        /* When FEC is enabled and there's enough packet loss, use SILK */
674        if (st->silk_mode.useInBandFEC && st->silk_mode.packetLossPercentage > (128-voice_est)>>4)
675           st->mode = MODE_SILK_ONLY;
676        /* When encoding voice and DTX is enabled, set the encoder to SILK mode (at least for now) */
677        if (st->silk_mode.useDTX && voice_est > 100)
678           st->mode = MODE_SILK_ONLY;
679 #endif
680     } else {
681        st->mode = st->user_forced_mode;
682     }
683
684     /* Override the chosen mode to make sure we meet the requested frame size */
685     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
686        st->mode = MODE_CELT_ONLY;
687
688     if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0
689           && st->mode != MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)
690     {
691        /* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */
692        st->silk_mode.toMono = 1;
693        st->stream_channels = 2;
694     } else {
695        st->silk_mode.toMono = 0;
696     }
697
698     if (st->prev_mode > 0 &&
699         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
700     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
701     {
702         redundancy = 1;
703         celt_to_silk = (st->mode != MODE_CELT_ONLY);
704         if (!celt_to_silk)
705         {
706             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
707             if (frame_size >= st->Fs/100)
708             {
709                 st->mode = st->prev_mode;
710                 to_celt = 1;
711             } else {
712                 redundancy=0;
713             }
714         }
715     }
716     if (st->silk_bw_switch)
717     {
718        redundancy = 1;
719        celt_to_silk = 1;
720        st->silk_bw_switch = 0;
721     }
722
723     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
724     {
725         silk_EncControlStruct dummy;
726         silk_InitEncoder( silk_enc, &dummy);
727         prefill=1;
728     }
729
730     /* Automatic (rate-dependent) bandwidth selection */
731     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
732     {
733         const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds;
734         opus_int32 bandwidth_thresholds[8];
735         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
736         opus_int32 equiv_rate2;
737
738         equiv_rate2 = equiv_rate;
739         if (st->mode != MODE_CELT_ONLY)
740         {
741            /* Adjust the threshold +/- 10% depending on complexity */
742            equiv_rate2 = equiv_rate2 * (45+st->silk_mode.complexity)/50;
743            /* CBR is less efficient by ~1 kb/s */
744            if (!st->use_vbr)
745               equiv_rate2 -= 1000;
746         }
747         if (st->channels==2 && st->force_channels!=1)
748         {
749            voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds;
750            music_bandwidth_thresholds = stereo_music_bandwidth_thresholds;
751         } else {
752            voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds;
753            music_bandwidth_thresholds = mono_music_bandwidth_thresholds;
754         }
755         /* Interpolate bandwidth thresholds depending on voice estimation */
756         for (i=0;i<8;i++)
757         {
758            bandwidth_thresholds[i] = music_bandwidth_thresholds[i]
759                     + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14);
760         }
761         do {
762             int threshold, hysteresis;
763             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
764             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
765             if (!st->first)
766             {
767                 if (st->bandwidth >= bandwidth)
768                     threshold -= hysteresis;
769                 else
770                     threshold += hysteresis;
771             }
772             if (equiv_rate2 >= threshold)
773                 break;
774         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
775         st->bandwidth = bandwidth;
776         /* Prevents any transition to SWB/FB until the SILK layer has fully
777            switched to WB mode and turned the variable LP filter off */
778         if (!st->first && st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
779             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
780     }
781
782     if (st->bandwidth>st->max_bandwidth)
783        st->bandwidth = st->max_bandwidth;
784
785     if (st->user_bandwidth != OPUS_AUTO)
786         st->bandwidth = st->user_bandwidth;
787
788     /* This prevents us from using hybrid at unsafe CBR/max rates */
789     if (st->mode != MODE_CELT_ONLY && max_rate < 15000)
790     {
791        st->bandwidth = IMIN(st->bandwidth, OPUS_BANDWIDTH_WIDEBAND);
792     }
793
794     /* Prevents Opus from wasting bits on frequencies that are above
795        the Nyquist rate of the input signal */
796     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
797         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
798     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
799         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
800     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
801         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
802     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
803         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
804
805     /* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */
806     if (max_data_bytes < (frame_rate > 50 ? 12000 : 8000)*frame_size / (st->Fs * 8))
807        st->mode = MODE_CELT_ONLY;
808
809     /* CELT mode doesn't support mediumband, use wideband instead */
810     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
811         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
812
813     /* Can't support higher than wideband for >20 ms frames */
814     if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND))
815     {
816        VARDECL(unsigned char, tmp_data);
817        int nb_frames;
818        int bak_mode, bak_bandwidth, bak_channels, bak_to_mono;
819        OpusRepacketizer rp;
820        opus_int32 bytes_per_frame;
821
822
823        nb_frames = frame_size > st->Fs/25 ? 3 : 2;
824        bytes_per_frame = IMIN(1276,(out_data_bytes-3)/nb_frames);
825
826        ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char);
827
828        opus_repacketizer_init(&rp);
829
830        bak_mode = st->user_forced_mode;
831        bak_bandwidth = st->user_bandwidth;
832        bak_channels = st->force_channels;
833
834        st->user_forced_mode = st->mode;
835        st->user_bandwidth = st->bandwidth;
836        st->force_channels = st->stream_channels;
837        bak_to_mono = st->silk_mode.toMono;
838
839        if (bak_to_mono)
840           st->force_channels = 1;
841        else
842           st->prev_channels = st->stream_channels;
843        for (i=0;i<nb_frames;i++)
844        {
845           int tmp_len;
846           st->silk_mode.toMono = 0;
847           /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
848           if (to_celt && i==nb_frames-1)
849              st->user_forced_mode = MODE_CELT_ONLY;
850           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);
851           if (tmp_len<0)
852           {
853              RESTORE_STACK;
854              return OPUS_INTERNAL_ERROR;
855           }
856           ret = opus_repacketizer_cat(&rp, tmp_data+i*bytes_per_frame, tmp_len);
857           if (ret<0)
858           {
859              RESTORE_STACK;
860              return OPUS_INTERNAL_ERROR;
861           }
862        }
863        ret = opus_repacketizer_out(&rp, data, out_data_bytes);
864        if (ret<0)
865        {
866           RESTORE_STACK;
867           return OPUS_INTERNAL_ERROR;
868        }
869        st->user_forced_mode = bak_mode;
870        st->user_bandwidth = bak_bandwidth;
871        st->force_channels = bak_channels;
872        st->silk_mode.toMono = bak_to_mono;
873        RESTORE_STACK;
874        return ret;
875     }
876
877     curr_bandwidth = st->bandwidth;
878
879     /* Chooses the appropriate mode for speech
880        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
881     if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND)
882         st->mode = MODE_HYBRID;
883     if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
884         st->mode = MODE_SILK_ONLY;
885
886     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
887     bytes_target = IMIN(max_data_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
888
889     data += 1;
890
891     ec_enc_init(&enc, data, max_data_bytes-1);
892
893     ALLOC(pcm_buf, (total_buffer+frame_size)*st->channels, opus_val16);
894     for (i=0;i<total_buffer*st->channels;i++)
895        pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-total_buffer)*st->channels+i];
896
897     if (st->mode == MODE_CELT_ONLY)
898        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
899     else
900        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
901
902     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
903           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
904
905     /* convert from log scale to Hertz */
906     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
907
908     if (st->application == OPUS_APPLICATION_VOIP)
909     {
910        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
911     } else {
912        dc_reject(pcm, 3, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
913     }
914
915 #ifndef FIXED_POINT
916     if (perform_analysis)
917     {
918        int nb_analysis_frames;
919        nb_analysis_frames = frame_size/(st->Fs/100);
920        for (i=0;i<nb_analysis_frames;i++)
921           tonality_analysis(&st->analysis, &analysis_info, celt_enc, pcm_buf+i*(st->Fs/100)*st->channels, st->channels);
922        if (st->signal_type == OPUS_AUTO)
923           st->voice_ratio = floor(.5+100*(1-analysis_info.music_prob));
924     } else {
925        analysis_info.valid = 0;
926        st->voice_ratio = -1;
927     }
928 #endif
929
930     /* SILK processing */
931     if (st->mode != MODE_CELT_ONLY)
932     {
933 #ifdef FIXED_POINT
934        const opus_int16 *pcm_silk;
935 #else
936        VARDECL(opus_int16, pcm_silk);
937        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
938 #endif
939         st->silk_mode.bitRate = 8*bytes_target*frame_rate;
940         if( st->mode == MODE_HYBRID ) {
941             st->silk_mode.bitRate /= st->stream_channels;
942             if( curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
943                 if( st->Fs == 100 * frame_size ) {
944                     /* 24 kHz, 10 ms */
945                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 2000 + st->use_vbr * 1000 ) * 2 ) / 3;
946                 } else {
947                     /* 24 kHz, 20 ms */
948                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 1000 + st->use_vbr * 1000 ) * 2 ) / 3;
949                 }
950             } else {
951                 if( st->Fs == 100 * frame_size ) {
952                     /* 48 kHz, 10 ms */
953                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 8000 + st->use_vbr * 3000 ) / 2;
954                 } else {
955                     /* 48 kHz, 20 ms */
956                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 9000 + st->use_vbr * 1000 ) / 2;
957                 }
958             }
959             st->silk_mode.bitRate *= st->stream_channels;
960             /* don't let SILK use more than 80% */
961             if( st->silk_mode.bitRate > ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5 ) {
962                 st->silk_mode.bitRate = ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5;
963             }
964         }
965
966         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
967         st->silk_mode.nChannelsAPI = st->channels;
968         st->silk_mode.nChannelsInternal = st->stream_channels;
969         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
970             st->silk_mode.desiredInternalSampleRate = 8000;
971         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
972             st->silk_mode.desiredInternalSampleRate = 12000;
973         } else {
974             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
975             st->silk_mode.desiredInternalSampleRate = 16000;
976         }
977         if( st->mode == MODE_HYBRID ) {
978             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
979             st->silk_mode.minInternalSampleRate = 16000;
980         } else {
981             st->silk_mode.minInternalSampleRate = 8000;
982         }
983
984         if (st->mode == MODE_SILK_ONLY)
985         {
986            opus_int32 effective_max_rate = max_rate;
987            st->silk_mode.maxInternalSampleRate = 16000;
988            if (frame_rate > 50)
989               effective_max_rate = effective_max_rate*2/3;
990            if (effective_max_rate < 13000)
991            {
992               st->silk_mode.maxInternalSampleRate = 12000;
993               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
994            }
995            if (effective_max_rate < 9600)
996            {
997               st->silk_mode.maxInternalSampleRate = 8000;
998               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
999            }
1000         } else {
1001            st->silk_mode.maxInternalSampleRate = 16000;
1002         }
1003
1004         st->silk_mode.useCBR = !st->use_vbr;
1005
1006         /* Call SILK encoder for the low band */
1007         nBytes = IMIN(1275, max_data_bytes-1);
1008
1009         st->silk_mode.maxBits = nBytes*8;
1010         /* Only allow up to 90% of the bits for hybrid mode*/
1011         if (st->mode == MODE_HYBRID)
1012            st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
1013         if (st->silk_mode.useCBR)
1014         {
1015            st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
1016            /* Reduce the initial target to make it easier to reach the CBR rate */
1017            st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000);
1018         }
1019         if (redundancy)
1020            st->silk_mode.maxBits -= st->silk_mode.maxBits/(1 + frame_size/(st->Fs/200));
1021
1022         if (prefill)
1023         {
1024             opus_int32 zero=0;
1025 #ifdef FIXED_POINT
1026             pcm_silk = st->delay_buffer;
1027 #else
1028             for (i=0;i<st->encoder_buffer*st->channels;i++)
1029                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
1030 #endif
1031             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
1032         }
1033
1034 #ifdef FIXED_POINT
1035         pcm_silk = pcm_buf+total_buffer*st->channels;
1036 #else
1037         for (i=0;i<frame_size*st->channels;i++)
1038             pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
1039 #endif
1040         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
1041         if( ret ) {
1042             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
1043             /* Handle error */
1044            RESTORE_STACK;
1045            return OPUS_INTERNAL_ERROR;
1046         }
1047         if (nBytes==0)
1048         {
1049            st->rangeFinal = 0;
1050            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1051            RESTORE_STACK;
1052            return 1;
1053         }
1054         /* Extract SILK internal bandwidth for signaling in first byte */
1055         if( st->mode == MODE_SILK_ONLY ) {
1056             if( st->silk_mode.internalSampleRate == 8000 ) {
1057                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1058             } else if( st->silk_mode.internalSampleRate == 12000 ) {
1059                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1060             } else if( st->silk_mode.internalSampleRate == 16000 ) {
1061                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1062             }
1063         } else {
1064             silk_assert( st->silk_mode.internalSampleRate == 16000 );
1065         }
1066
1067         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
1068         if (st->silk_mode.opusCanSwitch)
1069         {
1070            redundancy = 1;
1071            celt_to_silk = 0;
1072            st->silk_bw_switch = 1;
1073         }
1074     }
1075
1076     /* CELT processing */
1077     {
1078         int endband=21;
1079
1080         switch(curr_bandwidth)
1081         {
1082             case OPUS_BANDWIDTH_NARROWBAND:
1083                 endband = 13;
1084                 break;
1085             case OPUS_BANDWIDTH_MEDIUMBAND:
1086             case OPUS_BANDWIDTH_WIDEBAND:
1087                 endband = 17;
1088                 break;
1089             case OPUS_BANDWIDTH_SUPERWIDEBAND:
1090                 endband = 19;
1091                 break;
1092             case OPUS_BANDWIDTH_FULLBAND:
1093                 endband = 21;
1094                 break;
1095         }
1096         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
1097         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
1098     }
1099     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1100     if (st->mode != MODE_SILK_ONLY)
1101     {
1102         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1103         /* Allow prediction unless we decide to disable it later */
1104         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
1105
1106         if (st->mode == MODE_HYBRID)
1107         {
1108             int len;
1109
1110             len = (ec_tell(&enc)+7)>>3;
1111             if (redundancy)
1112                len += st->mode == MODE_HYBRID ? 3 : 1;
1113             if( st->use_vbr ) {
1114                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
1115             } else {
1116                 /* check if SILK used up too much */
1117                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
1118             }
1119         } else {
1120             if (st->use_vbr)
1121             {
1122                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
1123                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
1124                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps));
1125                 nb_compr_bytes = max_data_bytes-1;
1126             } else {
1127                 nb_compr_bytes = bytes_target;
1128             }
1129         }
1130
1131     } else {
1132         nb_compr_bytes = 0;
1133     }
1134
1135     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
1136     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
1137     {
1138        for (i=0;i<st->channels*st->Fs/400;i++)
1139           tmp_prefill[i] = st->delay_buffer[(st->encoder_buffer-total_buffer-st->Fs/400)*st->channels + i];
1140     }
1141
1142     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+total_buffer));i++)
1143         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
1144     for (;i<st->encoder_buffer*st->channels;i++)
1145         st->delay_buffer[i] = pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels+i];
1146
1147
1148     if (st->mode != MODE_HYBRID || st->stream_channels==1)
1149        st->silk_mode.stereoWidth_Q14 = 1<<14;
1150     if( st->channels == 2 ) {
1151         /* Apply stereo width reduction (at low bitrates) */
1152         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1153             opus_val16 g1, g2;
1154             const CELTMode *celt_mode;
1155
1156             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1157             g1 = st->hybrid_stereo_width_Q14;
1158             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1159 #ifdef FIXED_POINT
1160             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
1161             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
1162 #else
1163             g1 *= (1./16384);
1164             g2 *= (1./16384);
1165 #endif
1166             stereo_fade(pcm_buf+extra_buffer*st->channels, pcm_buf+extra_buffer*st->channels, g1, g2, celt_mode->overlap,
1167                   frame_size, st->channels, celt_mode->window, st->Fs);
1168             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1169         }
1170     }
1171
1172     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
1173     {
1174         /* For SILK mode, the redundancy is inferred from the length */
1175         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
1176            ec_enc_bit_logp(&enc, redundancy, 12);
1177         if (redundancy)
1178         {
1179             int max_redundancy;
1180             ec_enc_bit_logp(&enc, celt_to_silk, 1);
1181             if (st->mode == MODE_HYBRID)
1182                max_redundancy = (max_data_bytes-1)-nb_compr_bytes-1;
1183             else
1184                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1185             /* Target the same bit-rate for redundancy as for the rest,
1186                up to a max of 257 bytes */
1187             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
1188             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
1189             if (st->mode == MODE_HYBRID)
1190                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
1191         }
1192     } else {
1193         redundancy = 0;
1194     }
1195
1196     if (!redundancy)
1197        st->silk_bw_switch = 0;
1198
1199     if (st->mode != MODE_CELT_ONLY)start_band=17;
1200
1201     if (st->mode == MODE_SILK_ONLY)
1202     {
1203         ret = (ec_tell(&enc)+7)>>3;
1204         ec_enc_done(&enc);
1205         nb_compr_bytes = ret;
1206     } else {
1207        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
1208        ec_enc_shrink(&enc, nb_compr_bytes);
1209     }
1210
1211
1212     /* 5 ms redundant frame for CELT->SILK */
1213     if (redundancy && celt_to_silk)
1214     {
1215         int err;
1216         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1217         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1218         err = celt_encode_with_ec(celt_enc, pcm_buf+extra_buffer*st->channels, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
1219         if (err < 0)
1220         {
1221            RESTORE_STACK;
1222            return OPUS_INTERNAL_ERROR;
1223         }
1224         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1225         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1226     }
1227
1228     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
1229
1230     if (st->mode != MODE_SILK_ONLY)
1231     {
1232         if (st->mode != st->prev_mode && st->prev_mode > 0)
1233         {
1234            unsigned char dummy[2];
1235            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1236
1237            /* Prefilling */
1238            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
1239            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1240         }
1241         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
1242         if (ec_tell(&enc) <= 8*nb_compr_bytes)
1243         {
1244 #ifndef FIXED_POINT
1245            if (perform_analysis)
1246               celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(&analysis_info));
1247 #endif
1248            ret = celt_encode_with_ec(celt_enc, pcm_buf+extra_buffer*st->channels, frame_size, NULL, nb_compr_bytes, &enc);
1249            if (ret < 0)
1250            {
1251               RESTORE_STACK;
1252               return OPUS_INTERNAL_ERROR;
1253            }
1254         }
1255     }
1256
1257     /* 5 ms redundant frame for SILK->CELT */
1258     if (redundancy && !celt_to_silk)
1259     {
1260         int err;
1261         unsigned char dummy[2];
1262         int N2, N4;
1263         N2 = st->Fs/200;
1264         N4 = st->Fs/400;
1265
1266         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1267         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1268         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1269
1270         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1271         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(extra_buffer+frame_size-N2-N4), N4, dummy, 2, NULL);
1272
1273         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(extra_buffer+frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1274         if (err < 0)
1275         {
1276            RESTORE_STACK;
1277            return OPUS_INTERNAL_ERROR;
1278         }
1279         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1280     }
1281
1282
1283
1284     /* Signalling the mode in the first byte */
1285     data--;
1286     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1287
1288     st->rangeFinal = enc.rng ^ redundant_rng;
1289
1290     if (to_celt)
1291         st->prev_mode = MODE_CELT_ONLY;
1292     else
1293         st->prev_mode = st->mode;
1294     st->prev_channels = st->stream_channels;
1295     st->prev_framesize = frame_size;
1296
1297     st->first = 0;
1298
1299     /* In the unlikely case that the SILK encoder busted its target, tell
1300        the decoder to call the PLC */
1301     if (ec_tell(&enc) > (max_data_bytes-1)*8)
1302     {
1303        if (max_data_bytes < 2)
1304        {
1305           RESTORE_STACK;
1306           return OPUS_BUFFER_TOO_SMALL;
1307        }
1308        data[1] = 0;
1309        ret = 1;
1310        st->rangeFinal = 0;
1311     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
1312     {
1313        /*When in LPC only mode it's perfectly
1314          reasonable to strip off trailing zero bytes as
1315          the required range decoder behavior is to
1316          fill these in. This can't be done when the MDCT
1317          modes are used because the decoder needs to know
1318          the actual length for allocation purposes.*/
1319        while(ret>2&&data[ret]==0)ret--;
1320     }
1321     /* Count ToC and redundancy */
1322     ret += 1+redundancy_bytes;
1323     if (!st->use_vbr && ret >= 3)
1324     {
1325        if (pad_frame(data, ret, max_data_bytes))
1326        {
1327           RESTORE_STACK;
1328           return OPUS_INTERNAL_ERROR;
1329        }
1330        ret = max_data_bytes;
1331     }
1332     RESTORE_STACK;
1333     return ret;
1334 }
1335
1336 #ifdef FIXED_POINT
1337
1338 #ifndef DISABLE_FLOAT_API
1339 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1340       unsigned char *data, opus_int32 max_data_bytes)
1341 {
1342    int i, ret;
1343    VARDECL(opus_int16, in);
1344    ALLOC_STACK;
1345
1346    if(frame_size<0)
1347    {
1348       RESTORE_STACK;
1349       return OPUS_BAD_ARG;
1350    }
1351
1352    ALLOC(in, frame_size*st->channels, opus_int16);
1353
1354    for (i=0;i<frame_size*st->channels;i++)
1355       in[i] = FLOAT2INT16(pcm[i]);
1356    ret = opus_encode(st, in, frame_size, data, max_data_bytes);
1357    RESTORE_STACK;
1358    return ret;
1359 }
1360 #endif
1361
1362 #else
1363 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1364       unsigned char *data, opus_int32 max_data_bytes)
1365 {
1366    int i, ret;
1367    VARDECL(float, in);
1368    ALLOC_STACK;
1369
1370    ALLOC(in, frame_size*st->channels, float);
1371
1372    for (i=0;i<frame_size*st->channels;i++)
1373       in[i] = (1.0f/32768)*pcm[i];
1374    ret = opus_encode_float(st, in, frame_size, data, max_data_bytes);
1375    RESTORE_STACK;
1376    return ret;
1377 }
1378 #endif
1379
1380
1381 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
1382 {
1383     int ret;
1384     CELTEncoder *celt_enc;
1385     va_list ap;
1386
1387     ret = OPUS_OK;
1388     va_start(ap, request);
1389
1390     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1391
1392     switch (request)
1393     {
1394         case OPUS_SET_APPLICATION_REQUEST:
1395         {
1396             opus_int32 value = va_arg(ap, opus_int32);
1397             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
1398                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1399                || (!st->first && st->application != value))
1400             {
1401                ret = OPUS_BAD_ARG;
1402                break;
1403             }
1404             st->application = value;
1405         }
1406         break;
1407         case OPUS_GET_APPLICATION_REQUEST:
1408         {
1409             opus_int32 *value = va_arg(ap, opus_int32*);
1410             *value = st->application;
1411         }
1412         break;
1413         case OPUS_SET_BITRATE_REQUEST:
1414         {
1415             opus_int32 value = va_arg(ap, opus_int32);
1416             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1417             {
1418                 if (value <= 0)
1419                     goto bad_arg;
1420                 else if (value <= 500)
1421                     value = 500;
1422                 else if (value > (opus_int32)300000*st->channels)
1423                     value = (opus_int32)300000*st->channels;
1424             }
1425             st->user_bitrate_bps = value;
1426         }
1427         break;
1428         case OPUS_GET_BITRATE_REQUEST:
1429         {
1430             opus_int32 *value = va_arg(ap, opus_int32*);
1431             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
1432         }
1433         break;
1434         case OPUS_SET_FORCE_CHANNELS_REQUEST:
1435         {
1436             opus_int32 value = va_arg(ap, opus_int32);
1437             if((value<1 || value>st->channels) && value != OPUS_AUTO)
1438                 return OPUS_BAD_ARG;
1439             st->force_channels = value;
1440         }
1441         break;
1442         case OPUS_GET_FORCE_CHANNELS_REQUEST:
1443         {
1444             opus_int32 *value = va_arg(ap, opus_int32*);
1445             *value = st->force_channels;
1446         }
1447         break;
1448         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
1449         {
1450             opus_int32 value = va_arg(ap, opus_int32);
1451             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND)
1452                 return OPUS_BAD_ARG;
1453             st->max_bandwidth = value;
1454             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1455                 st->silk_mode.maxInternalSampleRate = 8000;
1456             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1457                 st->silk_mode.maxInternalSampleRate = 12000;
1458             } else {
1459                 st->silk_mode.maxInternalSampleRate = 16000;
1460             }
1461         }
1462         break;
1463         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
1464         {
1465             opus_int32 *value = va_arg(ap, opus_int32*);
1466             *value = st->max_bandwidth;
1467         }
1468         break;
1469         case OPUS_SET_BANDWIDTH_REQUEST:
1470         {
1471             opus_int32 value = va_arg(ap, opus_int32);
1472             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
1473                 return OPUS_BAD_ARG;
1474             st->user_bandwidth = value;
1475             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1476                 st->silk_mode.maxInternalSampleRate = 8000;
1477             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1478                 st->silk_mode.maxInternalSampleRate = 12000;
1479             } else {
1480                 st->silk_mode.maxInternalSampleRate = 16000;
1481             }
1482         }
1483         break;
1484         case OPUS_GET_BANDWIDTH_REQUEST:
1485         {
1486             opus_int32 *value = va_arg(ap, opus_int32*);
1487             *value = st->bandwidth;
1488         }
1489         break;
1490         case OPUS_SET_DTX_REQUEST:
1491         {
1492             opus_int32 value = va_arg(ap, opus_int32);
1493             if(value<0 || value>1)
1494                 return OPUS_BAD_ARG;
1495             st->silk_mode.useDTX = value;
1496         }
1497         break;
1498         case OPUS_GET_DTX_REQUEST:
1499         {
1500             opus_int32 *value = va_arg(ap, opus_int32*);
1501             *value = st->silk_mode.useDTX;
1502         }
1503         break;
1504         case OPUS_SET_COMPLEXITY_REQUEST:
1505         {
1506             opus_int32 value = va_arg(ap, opus_int32);
1507             if(value<0 || value>10)
1508                 return OPUS_BAD_ARG;
1509             st->silk_mode.complexity = value;
1510             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
1511         }
1512         break;
1513         case OPUS_GET_COMPLEXITY_REQUEST:
1514         {
1515             opus_int32 *value = va_arg(ap, opus_int32*);
1516             *value = st->silk_mode.complexity;
1517         }
1518         break;
1519         case OPUS_SET_INBAND_FEC_REQUEST:
1520         {
1521             opus_int32 value = va_arg(ap, opus_int32);
1522             if(value<0 || value>1)
1523                 return OPUS_BAD_ARG;
1524             st->silk_mode.useInBandFEC = value;
1525         }
1526         break;
1527         case OPUS_GET_INBAND_FEC_REQUEST:
1528         {
1529             opus_int32 *value = va_arg(ap, opus_int32*);
1530             *value = st->silk_mode.useInBandFEC;
1531         }
1532         break;
1533         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1534         {
1535             opus_int32 value = va_arg(ap, opus_int32);
1536             if (value < 0 || value > 100)
1537                 return OPUS_BAD_ARG;
1538             st->silk_mode.packetLossPercentage = value;
1539             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
1540         }
1541         break;
1542         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1543         {
1544             opus_int32 *value = va_arg(ap, opus_int32*);
1545             *value = st->silk_mode.packetLossPercentage;
1546         }
1547         break;
1548         case OPUS_SET_VBR_REQUEST:
1549         {
1550             opus_int32 value = va_arg(ap, opus_int32);
1551             if(value<0 || value>1)
1552                 return OPUS_BAD_ARG;
1553             st->use_vbr = value;
1554             st->silk_mode.useCBR = 1-value;
1555         }
1556         break;
1557         case OPUS_GET_VBR_REQUEST:
1558         {
1559             opus_int32 *value = va_arg(ap, opus_int32*);
1560             *value = st->use_vbr;
1561         }
1562         break;
1563         case OPUS_SET_VOICE_RATIO_REQUEST:
1564         {
1565             opus_int32 value = va_arg(ap, opus_int32);
1566             if (value>100 || value<-1)
1567                 goto bad_arg;
1568             st->voice_ratio = value;
1569         }
1570         break;
1571         case OPUS_GET_VOICE_RATIO_REQUEST:
1572         {
1573             opus_int32 *value = va_arg(ap, opus_int32*);
1574             *value = st->voice_ratio;
1575         }
1576         break;
1577         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1578         {
1579             opus_int32 value = va_arg(ap, opus_int32);
1580             if(value<0 || value>1)
1581                 return OPUS_BAD_ARG;
1582             st->vbr_constraint = value;
1583         }
1584         break;
1585         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1586         {
1587             opus_int32 *value = va_arg(ap, opus_int32*);
1588             *value = st->vbr_constraint;
1589         }
1590         break;
1591         case OPUS_SET_SIGNAL_REQUEST:
1592         {
1593             opus_int32 value = va_arg(ap, opus_int32);
1594             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
1595                 return OPUS_BAD_ARG;
1596             st->signal_type = value;
1597         }
1598         break;
1599         case OPUS_GET_SIGNAL_REQUEST:
1600         {
1601             opus_int32 *value = va_arg(ap, opus_int32*);
1602             *value = st->signal_type;
1603         }
1604         break;
1605         case OPUS_GET_LOOKAHEAD_REQUEST:
1606         {
1607             opus_int32 *value = va_arg(ap, opus_int32*);
1608             *value = st->Fs/400;
1609             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1610                 *value += st->delay_compensation;
1611         }
1612         break;
1613         case OPUS_GET_FINAL_RANGE_REQUEST:
1614         {
1615             opus_uint32 *value = va_arg(ap, opus_uint32*);
1616             *value = st->rangeFinal;
1617         }
1618         break;
1619         case OPUS_RESET_STATE:
1620         {
1621            void *silk_enc;
1622            silk_EncControlStruct dummy;
1623            silk_enc = (char*)st+st->silk_enc_offset;
1624
1625            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
1626                  sizeof(OpusEncoder)-
1627                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
1628
1629            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1630            silk_InitEncoder( silk_enc, &dummy );
1631            st->stream_channels = st->channels;
1632            st->hybrid_stereo_width_Q14 = 1 << 14;
1633            st->first = 1;
1634            st->mode = MODE_HYBRID;
1635            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
1636            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1637         }
1638         break;
1639         case OPUS_SET_FORCE_MODE_REQUEST:
1640         {
1641             opus_int32 value = va_arg(ap, opus_int32);
1642             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
1643                goto bad_arg;
1644             st->user_forced_mode = value;
1645         }
1646         break;
1647         default:
1648             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
1649             ret = OPUS_UNIMPLEMENTED;
1650             break;
1651     }
1652     va_end(ap);
1653     return ret;
1654 bad_arg:
1655     va_end(ap);
1656     return OPUS_BAD_ARG;
1657 }
1658
1659 void opus_encoder_destroy(OpusEncoder *st)
1660 {
1661     opus_free(st);
1662 }