Skip analysis if the frame contains only digital silence
[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 "pitch.h"
42 #include "opus_private.h"
43 #include "os_support.h"
44 #include "cpu_support.h"
45 #include "analysis.h"
46 #include "mathops.h"
47 #include "tuning_parameters.h"
48 #ifdef FIXED_POINT
49 #include "fixed/structs_FIX.h"
50 #else
51 #include "float/structs_FLP.h"
52 #endif
53
54 #define MAX_ENCODER_BUFFER 480
55
56 typedef struct {
57    opus_val32 XX, XY, YY;
58    opus_val16 smoothed_width;
59    opus_val16 max_follower;
60 } StereoWidthState;
61
62 struct OpusEncoder {
63     int          celt_enc_offset;
64     int          silk_enc_offset;
65     silk_EncControlStruct silk_mode;
66     int          application;
67     int          channels;
68     int          delay_compensation;
69     int          force_channels;
70     int          signal_type;
71     int          user_bandwidth;
72     int          max_bandwidth;
73     int          user_forced_mode;
74     int          voice_ratio;
75     opus_int32   Fs;
76     int          use_vbr;
77     int          vbr_constraint;
78     int          variable_duration;
79     opus_int32   bitrate_bps;
80     opus_int32   user_bitrate_bps;
81     int          lsb_depth;
82     int          encoder_buffer;
83     int          lfe;
84     int          arch;
85 #ifndef DISABLE_FLOAT_API
86     TonalityAnalysisState analysis;
87 #endif
88
89 #define OPUS_ENCODER_RESET_START stream_channels
90     int          stream_channels;
91     opus_int16   hybrid_stereo_width_Q14;
92     opus_int32   variable_HP_smth2_Q15;
93     opus_val16   prev_HB_gain;
94     opus_val32   hp_mem[4];
95     int          mode;
96     int          prev_mode;
97     int          prev_channels;
98     int          prev_framesize;
99     int          bandwidth;
100     int          silk_bw_switch;
101     /* Sampling rate (at the API level) */
102     int          first;
103     opus_val16 * energy_masking;
104     StereoWidthState width_mem;
105     opus_val16   delay_buffer[MAX_ENCODER_BUFFER*2];
106 #ifndef DISABLE_FLOAT_API
107     int          detected_bandwidth;
108 #endif
109     opus_uint32  rangeFinal;
110 };
111
112 /* Transition tables for the voice and music. First column is the
113    middle (memoriless) threshold. The second column is the hysteresis
114    (difference with the middle) */
115 static const opus_int32 mono_voice_bandwidth_thresholds[8] = {
116         11000, 1000, /* NB<->MB */
117         12500, 1000, /* MB<->WB */
118         14000, 1000, /* WB<->SWB */
119         15000, 2000, /* SWB<->FB */
120 };
121 static const opus_int32 mono_music_bandwidth_thresholds[8] = {
122         11000, 1000, /* NB<->MB */
123         12500, 1000, /* MB<->WB */
124         14000, 1000, /* WB<->SWB */
125         15000, 2000, /* SWB<->FB */
126 };
127 static const opus_int32 stereo_voice_bandwidth_thresholds[8] = {
128         11000, 1000, /* NB<->MB */
129         12500, 1000, /* MB<->WB */
130         14000, 1000, /* WB<->SWB */
131         15000, 2000, /* SWB<->FB */
132 };
133 static const opus_int32 stereo_music_bandwidth_thresholds[8] = {
134         11000, 1000, /* NB<->MB */
135         12500, 1000, /* MB<->WB */
136         14000, 1000, /* WB<->SWB */
137         15000, 2000, /* SWB<->FB */
138 };
139 /* Threshold bit-rates for switching between mono and stereo */
140 static const opus_int32 stereo_voice_threshold = 24000;
141 static const opus_int32 stereo_music_threshold = 24000;
142
143 /* Threshold bit-rate for switching between SILK/hybrid and CELT-only */
144 static const opus_int32 mode_thresholds[2][2] = {
145       /* voice */ /* music */
146       {  64000,      16000}, /* mono */
147       {  36000,      16000}, /* stereo */
148 };
149
150 int opus_encoder_get_size(int channels)
151 {
152     int silkEncSizeBytes, celtEncSizeBytes;
153     int ret;
154     if (channels<1 || channels > 2)
155         return 0;
156     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
157     if (ret)
158         return 0;
159     silkEncSizeBytes = align(silkEncSizeBytes);
160     celtEncSizeBytes = celt_encoder_get_size(channels);
161     return align(sizeof(OpusEncoder))+silkEncSizeBytes+celtEncSizeBytes;
162 }
163
164 int opus_encoder_init(OpusEncoder* st, opus_int32 Fs, int channels, int application)
165 {
166     void *silk_enc;
167     CELTEncoder *celt_enc;
168     int err;
169     int ret, silkEncSizeBytes;
170
171    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
172         (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
173         && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
174         return OPUS_BAD_ARG;
175
176     OPUS_CLEAR((char*)st, opus_encoder_get_size(channels));
177     /* Create SILK encoder */
178     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
179     if (ret)
180         return OPUS_BAD_ARG;
181     silkEncSizeBytes = align(silkEncSizeBytes);
182     st->silk_enc_offset = align(sizeof(OpusEncoder));
183     st->celt_enc_offset = st->silk_enc_offset+silkEncSizeBytes;
184     silk_enc = (char*)st+st->silk_enc_offset;
185     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
186
187     st->stream_channels = st->channels = channels;
188
189     st->Fs = Fs;
190
191     st->arch = opus_select_arch();
192
193     ret = silk_InitEncoder( silk_enc, st->arch, &st->silk_mode );
194     if(ret)return OPUS_INTERNAL_ERROR;
195
196     /* default SILK parameters */
197     st->silk_mode.nChannelsAPI              = channels;
198     st->silk_mode.nChannelsInternal         = channels;
199     st->silk_mode.API_sampleRate            = st->Fs;
200     st->silk_mode.maxInternalSampleRate     = 16000;
201     st->silk_mode.minInternalSampleRate     = 8000;
202     st->silk_mode.desiredInternalSampleRate = 16000;
203     st->silk_mode.payloadSize_ms            = 20;
204     st->silk_mode.bitRate                   = 25000;
205     st->silk_mode.packetLossPercentage      = 0;
206     st->silk_mode.complexity                = 9;
207     st->silk_mode.useInBandFEC              = 0;
208     st->silk_mode.useDTX                    = 0;
209     st->silk_mode.useCBR                    = 0;
210     st->silk_mode.reducedDependency         = 0;
211
212     /* Create CELT encoder */
213     /* Initialize CELT encoder */
214     err = celt_encoder_init(celt_enc, Fs, channels, st->arch);
215     if(err!=OPUS_OK)return OPUS_INTERNAL_ERROR;
216
217     celt_encoder_ctl(celt_enc, CELT_SET_SIGNALLING(0));
218     celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(st->silk_mode.complexity));
219
220     st->use_vbr = 1;
221     /* Makes constrained VBR the default (safer for real-time use) */
222     st->vbr_constraint = 1;
223     st->user_bitrate_bps = OPUS_AUTO;
224     st->bitrate_bps = 3000+Fs*channels;
225     st->application = application;
226     st->signal_type = OPUS_AUTO;
227     st->user_bandwidth = OPUS_AUTO;
228     st->max_bandwidth = OPUS_BANDWIDTH_FULLBAND;
229     st->force_channels = OPUS_AUTO;
230     st->user_forced_mode = OPUS_AUTO;
231     st->voice_ratio = -1;
232     st->encoder_buffer = st->Fs/100;
233     st->lsb_depth = 24;
234     st->variable_duration = OPUS_FRAMESIZE_ARG;
235
236     /* Delay compensation of 4 ms (2.5 ms for SILK's extra look-ahead
237        + 1.5 ms for SILK resamplers and stereo prediction) */
238     st->delay_compensation = st->Fs/250;
239
240     st->hybrid_stereo_width_Q14 = 1 << 14;
241     st->prev_HB_gain = Q15ONE;
242     st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
243     st->first = 1;
244     st->mode = MODE_HYBRID;
245     st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
246
247 #ifndef DISABLE_FLOAT_API
248     tonality_analysis_init(&st->analysis);
249 #endif
250
251     return OPUS_OK;
252 }
253
254 static unsigned char gen_toc(int mode, int framerate, int bandwidth, int channels)
255 {
256    int period;
257    unsigned char toc;
258    period = 0;
259    while (framerate < 400)
260    {
261        framerate <<= 1;
262        period++;
263    }
264    if (mode == MODE_SILK_ONLY)
265    {
266        toc = (bandwidth-OPUS_BANDWIDTH_NARROWBAND)<<5;
267        toc |= (period-2)<<3;
268    } else if (mode == MODE_CELT_ONLY)
269    {
270        int tmp = bandwidth-OPUS_BANDWIDTH_MEDIUMBAND;
271        if (tmp < 0)
272            tmp = 0;
273        toc = 0x80;
274        toc |= tmp << 5;
275        toc |= period<<3;
276    } else /* Hybrid */
277    {
278        toc = 0x60;
279        toc |= (bandwidth-OPUS_BANDWIDTH_SUPERWIDEBAND)<<4;
280        toc |= (period-2)<<3;
281    }
282    toc |= (channels==2)<<2;
283    return toc;
284 }
285
286 #ifndef FIXED_POINT
287 static void silk_biquad_float(
288     const opus_val16      *in,            /* I:    Input signal                   */
289     const opus_int32      *B_Q28,         /* I:    MA coefficients [3]            */
290     const opus_int32      *A_Q28,         /* I:    AR coefficients [2]            */
291     opus_val32            *S,             /* I/O:  State vector [2]               */
292     opus_val16            *out,           /* O:    Output signal                  */
293     const opus_int32      len,            /* I:    Signal length (must be even)   */
294     int stride
295 )
296 {
297     /* DIRECT FORM II TRANSPOSED (uses 2 element state vector) */
298     opus_int   k;
299     opus_val32 vout;
300     opus_val32 inval;
301     opus_val32 A[2], B[3];
302
303     A[0] = (opus_val32)(A_Q28[0] * (1.f/((opus_int32)1<<28)));
304     A[1] = (opus_val32)(A_Q28[1] * (1.f/((opus_int32)1<<28)));
305     B[0] = (opus_val32)(B_Q28[0] * (1.f/((opus_int32)1<<28)));
306     B[1] = (opus_val32)(B_Q28[1] * (1.f/((opus_int32)1<<28)));
307     B[2] = (opus_val32)(B_Q28[2] * (1.f/((opus_int32)1<<28)));
308
309     /* Negate A_Q28 values and split in two parts */
310
311     for( k = 0; k < len; k++ ) {
312         /* S[ 0 ], S[ 1 ]: Q12 */
313         inval = in[ k*stride ];
314         vout = S[ 0 ] + B[0]*inval;
315
316         S[ 0 ] = S[1] - vout*A[0] + B[1]*inval;
317
318         S[ 1 ] = - vout*A[1] + B[2]*inval + VERY_SMALL;
319
320         /* Scale back to Q0 and saturate */
321         out[ k*stride ] = vout;
322     }
323 }
324 #endif
325
326 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)
327 {
328    opus_int32 B_Q28[ 3 ], A_Q28[ 2 ];
329    opus_int32 Fc_Q19, r_Q28, r_Q22;
330
331    silk_assert( cutoff_Hz <= silk_int32_MAX / SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ) );
332    Fc_Q19 = silk_DIV32_16( silk_SMULBB( SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ), cutoff_Hz ), Fs/1000 );
333    silk_assert( Fc_Q19 > 0 && Fc_Q19 < 32768 );
334
335    r_Q28 = SILK_FIX_CONST( 1.0, 28 ) - silk_MUL( SILK_FIX_CONST( 0.92, 9 ), Fc_Q19 );
336
337    /* b = r * [ 1; -2; 1 ]; */
338    /* a = [ 1; -2 * r * ( 1 - 0.5 * Fc^2 ); r^2 ]; */
339    B_Q28[ 0 ] = r_Q28;
340    B_Q28[ 1 ] = silk_LSHIFT( -r_Q28, 1 );
341    B_Q28[ 2 ] = r_Q28;
342
343    /* -r * ( 2 - Fc * Fc ); */
344    r_Q22  = silk_RSHIFT( r_Q28, 6 );
345    A_Q28[ 0 ] = silk_SMULWW( r_Q22, silk_SMULWW( Fc_Q19, Fc_Q19 ) - SILK_FIX_CONST( 2.0,  22 ) );
346    A_Q28[ 1 ] = silk_SMULWW( r_Q22, r_Q22 );
347
348 #ifdef FIXED_POINT
349    silk_biquad_alt( in, B_Q28, A_Q28, hp_mem, out, len, channels );
350    if( channels == 2 ) {
351        silk_biquad_alt( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
352    }
353 #else
354    silk_biquad_float( in, B_Q28, A_Q28, hp_mem, out, len, channels );
355    if( channels == 2 ) {
356        silk_biquad_float( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
357    }
358 #endif
359 }
360
361 #ifdef FIXED_POINT
362 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)
363 {
364    int c, i;
365    int shift;
366
367    /* Approximates -round(log2(4.*cutoff_Hz/Fs)) */
368    shift=celt_ilog2(Fs/(cutoff_Hz*3));
369    for (c=0;c<channels;c++)
370    {
371       for (i=0;i<len;i++)
372       {
373          opus_val32 x, tmp, y;
374          x = SHL32(EXTEND32(in[channels*i+c]), 15);
375          /* First stage */
376          tmp = x-hp_mem[2*c];
377          hp_mem[2*c] = hp_mem[2*c] + PSHR32(x - hp_mem[2*c], shift);
378          /* Second stage */
379          y = tmp - hp_mem[2*c+1];
380          hp_mem[2*c+1] = hp_mem[2*c+1] + PSHR32(tmp - hp_mem[2*c+1], shift);
381          out[channels*i+c] = EXTRACT16(SATURATE(PSHR32(y, 15), 32767));
382       }
383    }
384 }
385
386 #else
387 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)
388 {
389    int c, i;
390    float coef;
391
392    coef = 4.0f*cutoff_Hz/Fs;
393    for (c=0;c<channels;c++)
394    {
395       for (i=0;i<len;i++)
396       {
397          opus_val32 x, tmp, y;
398          x = in[channels*i+c];
399          /* First stage */
400          tmp = x-hp_mem[2*c];
401          hp_mem[2*c] = hp_mem[2*c] + coef*(x - hp_mem[2*c]) + VERY_SMALL;
402          /* Second stage */
403          y = tmp - hp_mem[2*c+1];
404          hp_mem[2*c+1] = hp_mem[2*c+1] + coef*(tmp - hp_mem[2*c+1]) + VERY_SMALL;
405          out[channels*i+c] = y;
406       }
407    }
408 }
409 #endif
410
411 static void stereo_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2,
412         int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
413 {
414     int i;
415     int overlap;
416     int inc;
417     inc = 48000/Fs;
418     overlap=overlap48/inc;
419     g1 = Q15ONE-g1;
420     g2 = Q15ONE-g2;
421     for (i=0;i<overlap;i++)
422     {
423        opus_val32 diff;
424        opus_val16 g, w;
425        w = MULT16_16_Q15(window[i*inc], window[i*inc]);
426        g = SHR32(MAC16_16(MULT16_16(w,g2),
427              Q15ONE-w, g1), 15);
428        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
429        diff = MULT16_16_Q15(g, diff);
430        out[i*channels] = out[i*channels] - diff;
431        out[i*channels+1] = out[i*channels+1] + diff;
432     }
433     for (;i<frame_size;i++)
434     {
435        opus_val32 diff;
436        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
437        diff = MULT16_16_Q15(g2, diff);
438        out[i*channels] = out[i*channels] - diff;
439        out[i*channels+1] = out[i*channels+1] + diff;
440     }
441 }
442
443 static void gain_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2,
444         int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
445 {
446     int i;
447     int inc;
448     int overlap;
449     int c;
450     inc = 48000/Fs;
451     overlap=overlap48/inc;
452     if (channels==1)
453     {
454        for (i=0;i<overlap;i++)
455        {
456           opus_val16 g, w;
457           w = MULT16_16_Q15(window[i*inc], window[i*inc]);
458           g = SHR32(MAC16_16(MULT16_16(w,g2),
459                 Q15ONE-w, g1), 15);
460           out[i] = MULT16_16_Q15(g, in[i]);
461        }
462     } else {
463        for (i=0;i<overlap;i++)
464        {
465           opus_val16 g, w;
466           w = MULT16_16_Q15(window[i*inc], window[i*inc]);
467           g = SHR32(MAC16_16(MULT16_16(w,g2),
468                 Q15ONE-w, g1), 15);
469           out[i*2] = MULT16_16_Q15(g, in[i*2]);
470           out[i*2+1] = MULT16_16_Q15(g, in[i*2+1]);
471        }
472     }
473     c=0;do {
474        for (i=overlap;i<frame_size;i++)
475        {
476           out[i*channels+c] = MULT16_16_Q15(g2, in[i*channels+c]);
477        }
478     }
479     while (++c<channels);
480 }
481
482 OpusEncoder *opus_encoder_create(opus_int32 Fs, int channels, int application, int *error)
483 {
484    int ret;
485    OpusEncoder *st;
486    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
487        (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
488        && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
489    {
490       if (error)
491          *error = OPUS_BAD_ARG;
492       return NULL;
493    }
494    st = (OpusEncoder *)opus_alloc(opus_encoder_get_size(channels));
495    if (st == NULL)
496    {
497       if (error)
498          *error = OPUS_ALLOC_FAIL;
499       return NULL;
500    }
501    ret = opus_encoder_init(st, Fs, channels, application);
502    if (error)
503       *error = ret;
504    if (ret != OPUS_OK)
505    {
506       opus_free(st);
507       st = NULL;
508    }
509    return st;
510 }
511
512 static opus_int32 user_bitrate_to_bitrate(OpusEncoder *st, int frame_size, int max_data_bytes)
513 {
514   if(!frame_size)frame_size=st->Fs/400;
515   if (st->user_bitrate_bps==OPUS_AUTO)
516     return 60*st->Fs/frame_size + st->Fs*st->channels;
517   else if (st->user_bitrate_bps==OPUS_BITRATE_MAX)
518     return max_data_bytes*8*st->Fs/frame_size;
519   else
520     return st->user_bitrate_bps;
521 }
522
523 #ifndef DISABLE_FLOAT_API
524 /* Don't use more than 60 ms for the frame size analysis */
525 #define MAX_DYNAMIC_FRAMESIZE 24
526 /* Estimates how much the bitrate will be boosted based on the sub-frame energy */
527 static float transient_boost(const float *E, const float *E_1, int LM, int maxM)
528 {
529    int i;
530    int M;
531    float sumE=0, sumE_1=0;
532    float metric;
533
534    M = IMIN(maxM, (1<<LM)+1);
535    for (i=0;i<M;i++)
536    {
537       sumE += E[i];
538       sumE_1 += E_1[i];
539    }
540    metric = sumE*sumE_1/(M*M);
541    /*if (LM==3)
542       printf("%f\n", metric);*/
543    /*return metric>10 ? 1 : 0;*/
544    /*return MAX16(0,1-exp(-.25*(metric-2.)));*/
545    return MIN16(1,(float)sqrt(MAX16(0,.05f*(metric-2))));
546 }
547
548 /* Viterbi decoding trying to find the best frame size combination using look-ahead
549
550    State numbering:
551     0: unused
552     1:  2.5 ms
553     2:  5 ms (#1)
554     3:  5 ms (#2)
555     4: 10 ms (#1)
556     5: 10 ms (#2)
557     6: 10 ms (#3)
558     7: 10 ms (#4)
559     8: 20 ms (#1)
560     9: 20 ms (#2)
561    10: 20 ms (#3)
562    11: 20 ms (#4)
563    12: 20 ms (#5)
564    13: 20 ms (#6)
565    14: 20 ms (#7)
566    15: 20 ms (#8)
567 */
568 static int transient_viterbi(const float *E, const float *E_1, int N, int frame_cost, int rate)
569 {
570    int i;
571    float cost[MAX_DYNAMIC_FRAMESIZE][16];
572    int states[MAX_DYNAMIC_FRAMESIZE][16];
573    float best_cost;
574    int best_state;
575    float factor;
576    /* Take into account that we damp VBR in the 32 kb/s to 64 kb/s range. */
577    if (rate<80)
578       factor=0;
579    else if (rate>160)
580       factor=1;
581    else
582       factor = (rate-80.f)/80.f;
583    /* Makes variable framesize less aggressive at lower bitrates, but I can't
584       find any valid theoretical justification for this (other than it seems
585       to help) */
586    for (i=0;i<16;i++)
587    {
588       /* Impossible state */
589       states[0][i] = -1;
590       cost[0][i] = 1e10;
591    }
592    for (i=0;i<4;i++)
593    {
594       cost[0][1<<i] = (frame_cost + rate*(1<<i))*(1+factor*transient_boost(E, E_1, i, N+1));
595       states[0][1<<i] = i;
596    }
597    for (i=1;i<N;i++)
598    {
599       int j;
600
601       /* Follow continuations */
602       for (j=2;j<16;j++)
603       {
604          cost[i][j] = cost[i-1][j-1];
605          states[i][j] = j-1;
606       }
607
608       /* New frames */
609       for(j=0;j<4;j++)
610       {
611          int k;
612          float min_cost;
613          float curr_cost;
614          states[i][1<<j] = 1;
615          min_cost = cost[i-1][1];
616          for(k=1;k<4;k++)
617          {
618             float tmp = cost[i-1][(1<<(k+1))-1];
619             if (tmp < min_cost)
620             {
621                states[i][1<<j] = (1<<(k+1))-1;
622                min_cost = tmp;
623             }
624          }
625          curr_cost = (frame_cost + rate*(1<<j))*(1+factor*transient_boost(E+i, E_1+i, j, N-i+1));
626          cost[i][1<<j] = min_cost;
627          /* If part of the frame is outside the analysis window, only count part of the cost */
628          if (N-i < (1<<j))
629             cost[i][1<<j] += curr_cost*(float)(N-i)/(1<<j);
630          else
631             cost[i][1<<j] += curr_cost;
632       }
633    }
634
635    best_state=1;
636    best_cost = cost[N-1][1];
637    /* Find best end state (doesn't force a frame to end at N-1) */
638    for (i=2;i<16;i++)
639    {
640       if (cost[N-1][i]<best_cost)
641       {
642          best_cost = cost[N-1][i];
643          best_state = i;
644       }
645    }
646
647    /* Follow transitions back */
648    for (i=N-1;i>=0;i--)
649    {
650       /*printf("%d ", best_state);*/
651       best_state = states[i][best_state];
652    }
653    /*printf("%d\n", best_state);*/
654    return best_state;
655 }
656
657 static int optimize_framesize(const void *x, int len, int C, opus_int32 Fs,
658                 int bitrate, opus_val16 tonality, float *mem, int buffering,
659                 downmix_func downmix)
660 {
661    int N;
662    int i;
663    float e[MAX_DYNAMIC_FRAMESIZE+4];
664    float e_1[MAX_DYNAMIC_FRAMESIZE+3];
665    opus_val32 memx;
666    int bestLM=0;
667    int subframe;
668    int pos;
669    int offset;
670    VARDECL(opus_val32, sub);
671
672    subframe = Fs/400;
673    ALLOC(sub, subframe, opus_val32);
674    e[0]=mem[0];
675    e_1[0]=1.f/(EPSILON+mem[0]);
676    if (buffering)
677    {
678       /* Consider the CELT delay when not in restricted-lowdelay */
679       /* We assume the buffering is between 2.5 and 5 ms */
680       offset = 2*subframe - buffering;
681       celt_assert(offset>=0 && offset <= subframe);
682       len -= offset;
683       e[1]=mem[1];
684       e_1[1]=1.f/(EPSILON+mem[1]);
685       e[2]=mem[2];
686       e_1[2]=1.f/(EPSILON+mem[2]);
687       pos = 3;
688    } else {
689       pos=1;
690       offset=0;
691    }
692    N=IMIN(len/subframe, MAX_DYNAMIC_FRAMESIZE);
693    /* Just silencing a warning, it's really initialized later */
694    memx = 0;
695    for (i=0;i<N;i++)
696    {
697       float tmp;
698       opus_val32 tmpx;
699       int j;
700       tmp=EPSILON;
701
702       downmix(x, sub, subframe, i*subframe+offset, 0, -2, C);
703       if (i==0)
704          memx = sub[0];
705       for (j=0;j<subframe;j++)
706       {
707          tmpx = sub[j];
708          tmp += (tmpx-memx)*(float)(tmpx-memx);
709          memx = tmpx;
710       }
711       e[i+pos] = tmp;
712       e_1[i+pos] = 1.f/tmp;
713    }
714    /* Hack to get 20 ms working with APPLICATION_AUDIO
715       The real problem is that the corresponding memory needs to use 1.5 ms
716       from this frame and 1 ms from the next frame */
717    e[i+pos] = e[i+pos-1];
718    if (buffering)
719       N=IMIN(MAX_DYNAMIC_FRAMESIZE, N+2);
720    bestLM = transient_viterbi(e, e_1, N, (int)((1.f+.5f*tonality)*(60*C+40)), bitrate/400);
721    mem[0] = e[1<<bestLM];
722    if (buffering)
723    {
724       mem[1] = e[(1<<bestLM)+1];
725       mem[2] = e[(1<<bestLM)+2];
726    }
727    return bestLM;
728 }
729
730 #endif
731
732 #ifndef DISABLE_FLOAT_API
733 #ifdef FIXED_POINT
734 #define PCM2VAL(x) FLOAT2INT16(x)
735 #else
736 #define PCM2VAL(x) SCALEIN(x)
737 #endif
738 void downmix_float(const void *_x, opus_val32 *sub, int subframe, int offset, int c1, int c2, int C)
739 {
740    const float *x;
741    opus_val32 scale;
742    int j;
743    x = (const float *)_x;
744    for (j=0;j<subframe;j++)
745       sub[j] = PCM2VAL(x[(j+offset)*C+c1]);
746    if (c2>-1)
747    {
748       for (j=0;j<subframe;j++)
749          sub[j] += PCM2VAL(x[(j+offset)*C+c2]);
750    } else if (c2==-2)
751    {
752       int c;
753       for (c=1;c<C;c++)
754       {
755          for (j=0;j<subframe;j++)
756             sub[j] += PCM2VAL(x[(j+offset)*C+c]);
757       }
758    }
759 #ifdef FIXED_POINT
760    scale = (1<<SIG_SHIFT);
761 #else
762    scale = 1.f;
763 #endif
764    if (C==-2)
765       scale /= C;
766    else
767       scale /= 2;
768    for (j=0;j<subframe;j++)
769       sub[j] *= scale;
770 }
771 #endif
772
773 void downmix_int(const void *_x, opus_val32 *sub, int subframe, int offset, int c1, int c2, int C)
774 {
775    const opus_int16 *x;
776    opus_val32 scale;
777    int j;
778    x = (const opus_int16 *)_x;
779    for (j=0;j<subframe;j++)
780       sub[j] = x[(j+offset)*C+c1];
781    if (c2>-1)
782    {
783       for (j=0;j<subframe;j++)
784          sub[j] += x[(j+offset)*C+c2];
785    } else if (c2==-2)
786    {
787       int c;
788       for (c=1;c<C;c++)
789       {
790          for (j=0;j<subframe;j++)
791             sub[j] += x[(j+offset)*C+c];
792       }
793    }
794 #ifdef FIXED_POINT
795    scale = (1<<SIG_SHIFT);
796 #else
797    scale = 1.f/32768;
798 #endif
799    if (C==-2)
800       scale /= C;
801    else
802       scale /= 2;
803    for (j=0;j<subframe;j++)
804       sub[j] *= scale;
805 }
806
807 opus_int32 frame_size_select(opus_int32 frame_size, int variable_duration, opus_int32 Fs)
808 {
809    int new_size;
810    if (frame_size<Fs/400)
811       return -1;
812    if (variable_duration == OPUS_FRAMESIZE_ARG)
813       new_size = frame_size;
814    else if (variable_duration == OPUS_FRAMESIZE_VARIABLE)
815       new_size = Fs/50;
816    else if (variable_duration >= OPUS_FRAMESIZE_2_5_MS && variable_duration <= OPUS_FRAMESIZE_60_MS)
817       new_size = IMIN(3*Fs/50, (Fs/400)<<(variable_duration-OPUS_FRAMESIZE_2_5_MS));
818    else
819       return -1;
820    if (new_size>frame_size)
821       return -1;
822    if (400*new_size!=Fs && 200*new_size!=Fs && 100*new_size!=Fs &&
823             50*new_size!=Fs && 25*new_size!=Fs && 50*new_size!=3*Fs)
824       return -1;
825    return new_size;
826 }
827
828 opus_int32 compute_frame_size(const void *analysis_pcm, int frame_size,
829       int variable_duration, int C, opus_int32 Fs, int bitrate_bps,
830       int delay_compensation, downmix_func downmix
831 #ifndef DISABLE_FLOAT_API
832       , float *subframe_mem
833 #endif
834       )
835 {
836 #ifndef DISABLE_FLOAT_API
837    if (variable_duration == OPUS_FRAMESIZE_VARIABLE && frame_size >= Fs/200)
838    {
839       int LM = 3;
840       LM = optimize_framesize(analysis_pcm, frame_size, C, Fs, bitrate_bps,
841             0, subframe_mem, delay_compensation, downmix);
842       while ((Fs/400<<LM)>frame_size)
843          LM--;
844       frame_size = (Fs/400<<LM);
845    } else
846 #else
847    (void)analysis_pcm;
848    (void)C;
849    (void)bitrate_bps;
850    (void)delay_compensation;
851    (void)downmix;
852 #endif
853    {
854       frame_size = frame_size_select(frame_size, variable_duration, Fs);
855    }
856    if (frame_size<0)
857       return -1;
858    return frame_size;
859 }
860
861 opus_val16 compute_stereo_width(const opus_val16 *pcm, int frame_size, opus_int32 Fs, StereoWidthState *mem)
862 {
863    opus_val32 xx, xy, yy;
864    opus_val16 sqrt_xx, sqrt_yy;
865    opus_val16 qrrt_xx, qrrt_yy;
866    int frame_rate;
867    int i;
868    opus_val16 short_alpha;
869
870    frame_rate = Fs/frame_size;
871    short_alpha = Q15ONE - MULT16_16(25, Q15ONE)/IMAX(50,frame_rate);
872    xx=xy=yy=0;
873    /* Unroll by 4. The frame size is always a multiple of 4 *except* for
874       2.5 ms frames at 12 kHz. Since this setting is very rare (and very
875       stupid), we just discard the last two samples. */
876    for (i=0;i<frame_size-3;i+=4)
877    {
878       opus_val32 pxx=0;
879       opus_val32 pxy=0;
880       opus_val32 pyy=0;
881       opus_val16 x, y;
882       x = pcm[2*i];
883       y = pcm[2*i+1];
884       pxx = SHR32(MULT16_16(x,x),2);
885       pxy = SHR32(MULT16_16(x,y),2);
886       pyy = SHR32(MULT16_16(y,y),2);
887       x = pcm[2*i+2];
888       y = pcm[2*i+3];
889       pxx += SHR32(MULT16_16(x,x),2);
890       pxy += SHR32(MULT16_16(x,y),2);
891       pyy += SHR32(MULT16_16(y,y),2);
892       x = pcm[2*i+4];
893       y = pcm[2*i+5];
894       pxx += SHR32(MULT16_16(x,x),2);
895       pxy += SHR32(MULT16_16(x,y),2);
896       pyy += SHR32(MULT16_16(y,y),2);
897       x = pcm[2*i+6];
898       y = pcm[2*i+7];
899       pxx += SHR32(MULT16_16(x,x),2);
900       pxy += SHR32(MULT16_16(x,y),2);
901       pyy += SHR32(MULT16_16(y,y),2);
902
903       xx += SHR32(pxx, 10);
904       xy += SHR32(pxy, 10);
905       yy += SHR32(pyy, 10);
906    }
907    mem->XX += MULT16_32_Q15(short_alpha, xx-mem->XX);
908    mem->XY += MULT16_32_Q15(short_alpha, xy-mem->XY);
909    mem->YY += MULT16_32_Q15(short_alpha, yy-mem->YY);
910    mem->XX = MAX32(0, mem->XX);
911    mem->XY = MAX32(0, mem->XY);
912    mem->YY = MAX32(0, mem->YY);
913    if (MAX32(mem->XX, mem->YY)>QCONST16(8e-4f, 18))
914    {
915       opus_val16 corr;
916       opus_val16 ldiff;
917       opus_val16 width;
918       sqrt_xx = celt_sqrt(mem->XX);
919       sqrt_yy = celt_sqrt(mem->YY);
920       qrrt_xx = celt_sqrt(sqrt_xx);
921       qrrt_yy = celt_sqrt(sqrt_yy);
922       /* Inter-channel correlation */
923       mem->XY = MIN32(mem->XY, sqrt_xx*sqrt_yy);
924       corr = SHR32(frac_div32(mem->XY,EPSILON+MULT16_16(sqrt_xx,sqrt_yy)),16);
925       /* Approximate loudness difference */
926       ldiff = MULT16_16(Q15ONE, ABS16(qrrt_xx-qrrt_yy))/(EPSILON+qrrt_xx+qrrt_yy);
927       width = MULT16_16_Q15(celt_sqrt(QCONST32(1.f,30)-MULT16_16(corr,corr)), ldiff);
928       /* Smoothing over one second */
929       mem->smoothed_width += (width-mem->smoothed_width)/frame_rate;
930       /* Peak follower */
931       mem->max_follower = MAX16(mem->max_follower-QCONST16(.02f,15)/frame_rate, mem->smoothed_width);
932    }
933    /*printf("%f %f %f %f %f ", corr/(float)Q15ONE, ldiff/(float)Q15ONE, width/(float)Q15ONE, mem->smoothed_width/(float)Q15ONE, mem->max_follower/(float)Q15ONE);*/
934    return EXTRACT16(MIN32(Q15ONE, MULT16_16(20, mem->max_follower)));
935 }
936
937 static int compute_silk_rate_for_hybrid(int rate, int bandwidth, int frame20ms, int vbr) {
938    int entry;
939    int i;
940    int N;
941    int silk_rate;
942    static int rate_table[][5] = {
943   /*  |total| |-------- SILK------------|
944               SWB-10  FB-10 SWB-20  FB-20 */
945       {    0,     0,     0,     0,     0},
946       {12000, 10000, 10000, 10000, 10000},
947       {16000, 14000, 14000, 14000, 14000},
948       {20000, 16000, 16000, 16000, 16000},
949       {24000, 18000, 18000, 18000, 18000},
950       {32000, 22000, 22000, 22000, 22000},
951       {64000, 38000, 38000, 38000, 38000}
952    };
953    entry = 1 + 2*frame20ms + (bandwidth==OPUS_BANDWIDTH_FULLBAND);
954    N = sizeof(rate_table)/sizeof(rate_table[0]);
955    for (i=1;i<N;i++)
956    {
957       if (rate_table[i][0] > rate) break;
958    }
959    if (i == N)
960    {
961       silk_rate = rate_table[i-1][entry];
962       /* For now, just give 50% of the extra bits to SILK. */
963       silk_rate += (rate-rate_table[i-1][0])/2;
964    } else {
965       opus_int32 lo, hi, x0, x1;
966       lo = rate_table[i-1][entry];
967       hi = rate_table[i][entry];
968       x0 = rate_table[i-1][0];
969       x1 = rate_table[i][0];
970       silk_rate = (lo*(x1-rate) + hi*(rate-x0))/(x1-x0);
971    }
972    if (!vbr)
973    {
974       if (silk_rate > 8000)
975          silk_rate -= 1000;
976    }
977    return silk_rate;
978 }
979
980 /* Returns the equivalent bitrate corresponding to 20 ms frames,
981    complexity 10 VBR operation. */
982 static opus_int32 compute_equiv_rate(opus_int32 bitrate, int channels,
983       int frame_rate, int vbr, int mode, int complexity)
984 {
985    int equiv;
986    equiv = bitrate;
987    /* Take into account overhead from smaller frames. */
988    equiv -= (40*channels+20)*(frame_rate - 50);
989    /* CBR is about a 10% penalty for both SILK and CELT. */
990    if (!vbr)
991       equiv = equiv*9/10;
992    /* Complexity makes about 10% difference (from 0 to 10) in general. */
993    equiv = equiv * (90+complexity)/100;
994    if (mode == MODE_SILK_ONLY || mode == MODE_HYBRID)
995    {
996       /* SILK complexity 0-3 uses the non-delayed-decision NSQ, which
997          costs about 20%. */
998       if (complexity<4)
999          equiv = equiv*4/5;
1000    } else if (mode == MODE_CELT_ONLY) {
1001       /* CELT complexity 0-4 doesn't have the pitch filter, which costs
1002          about 10%. */
1003       if (complexity<5)
1004          equiv = equiv*9/10;
1005    } else {
1006       /* Mode not known yet */
1007    }
1008    return equiv;
1009 }
1010
1011 #ifndef DISABLE_FLOAT_API
1012
1013 static int is_digital_silence(const opus_val16* pcm, int frame_size, int lsb_depth)
1014 {
1015    int silence = 0;
1016    opus_val32 sample_max = 0;
1017
1018    sample_max = celt_maxabs16(pcm, frame_size);
1019
1020 #ifdef FIXED_POINT
1021    silence = (sample_max == 0);
1022 #else
1023    silence = (sample_max <= (opus_val16) 1 / (1 << lsb_depth));
1024 #endif
1025
1026    return silence;
1027 }
1028
1029 #endif
1030
1031 opus_int32 opus_encode_native(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
1032                 unsigned char *data, opus_int32 out_data_bytes, int lsb_depth,
1033                 const void *analysis_pcm, opus_int32 analysis_size, int c1, int c2,
1034                 int analysis_channels, downmix_func downmix, int float_api)
1035 {
1036     void *silk_enc;
1037     CELTEncoder *celt_enc;
1038     int i;
1039     int ret=0;
1040     opus_int32 nBytes;
1041     ec_enc enc;
1042     int bytes_target;
1043     int prefill=0;
1044     int start_band = 0;
1045     int redundancy = 0;
1046     int redundancy_bytes = 0; /* Number of bytes to use for redundancy frame */
1047     int celt_to_silk = 0;
1048     VARDECL(opus_val16, pcm_buf);
1049     int nb_compr_bytes;
1050     int to_celt = 0;
1051     opus_uint32 redundant_rng = 0;
1052     int cutoff_Hz, hp_freq_smth1;
1053     int voice_est; /* Probability of voice in Q7 */
1054     opus_int32 equiv_rate;
1055     int delay_compensation;
1056     int frame_rate;
1057     opus_int32 max_rate; /* Max bitrate we're allowed to use */
1058     int curr_bandwidth;
1059     opus_val16 HB_gain;
1060     opus_int32 max_data_bytes; /* Max number of bytes we're allowed to use */
1061     int total_buffer;
1062     opus_val16 stereo_width;
1063     const CELTMode *celt_mode;
1064 #ifndef DISABLE_FLOAT_API
1065     AnalysisInfo analysis_info;
1066     int analysis_read_pos_bak=-1;
1067     int analysis_read_subframe_bak=-1;
1068     int is_silence = 0;
1069 #endif
1070     VARDECL(opus_val16, tmp_prefill);
1071
1072     ALLOC_STACK;
1073
1074     max_data_bytes = IMIN(1276, out_data_bytes);
1075
1076     st->rangeFinal = 0;
1077     if ((!st->variable_duration && 400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
1078          50*frame_size != st->Fs &&  25*frame_size != st->Fs &&  50*frame_size != 3*st->Fs)
1079          || (400*frame_size < st->Fs)
1080          || max_data_bytes<=0
1081          )
1082     {
1083        RESTORE_STACK;
1084        return OPUS_BAD_ARG;
1085     }
1086     silk_enc = (char*)st+st->silk_enc_offset;
1087     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1088     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1089        delay_compensation = 0;
1090     else
1091        delay_compensation = st->delay_compensation;
1092
1093     lsb_depth = IMIN(lsb_depth, st->lsb_depth);
1094
1095     celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1096 #ifndef DISABLE_FLOAT_API
1097     analysis_info.valid = 0;
1098 #ifdef FIXED_POINT
1099     if (st->silk_mode.complexity >= 10 && st->Fs==48000)
1100 #else
1101     if (st->silk_mode.complexity >= 7 && st->Fs==48000)
1102 #endif
1103     {
1104        if (is_digital_silence(pcm, frame_size, lsb_depth))
1105        {
1106           is_silence = 1;
1107        } else {
1108           analysis_read_pos_bak = st->analysis.read_pos;
1109           analysis_read_subframe_bak = st->analysis.read_subframe;
1110           run_analysis(&st->analysis, celt_mode, analysis_pcm, analysis_size, frame_size,
1111                 c1, c2, analysis_channels, st->Fs,
1112                 lsb_depth, downmix, &analysis_info);
1113        }
1114     }
1115 #else
1116     (void)analysis_pcm;
1117     (void)analysis_size;
1118 #endif
1119
1120 #ifndef DISABLE_FLOAT_API
1121     /* Reset voice_ratio if this frame is not silent or if analysis is disabled.
1122      * Otherwise, preserve voice_ratio from the last non-silent frame */
1123     if (!is_silence)
1124       st->voice_ratio = -1;
1125
1126     st->detected_bandwidth = 0;
1127     if (analysis_info.valid)
1128     {
1129        int analysis_bandwidth;
1130        if (st->signal_type == OPUS_AUTO)
1131           st->voice_ratio = (int)floor(.5+100*(1-analysis_info.music_prob));
1132
1133        analysis_bandwidth = analysis_info.bandwidth;
1134        if (analysis_bandwidth<=12)
1135           st->detected_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1136        else if (analysis_bandwidth<=14)
1137           st->detected_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1138        else if (analysis_bandwidth<=16)
1139           st->detected_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1140        else if (analysis_bandwidth<=18)
1141           st->detected_bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1142        else
1143           st->detected_bandwidth = OPUS_BANDWIDTH_FULLBAND;
1144     }
1145 #else
1146     st->voice_ratio = -1;
1147 #endif
1148
1149     if (st->channels==2 && st->force_channels!=1)
1150        stereo_width = compute_stereo_width(pcm, frame_size, st->Fs, &st->width_mem);
1151     else
1152        stereo_width = 0;
1153     total_buffer = delay_compensation;
1154     st->bitrate_bps = user_bitrate_to_bitrate(st, frame_size, max_data_bytes);
1155
1156     frame_rate = st->Fs/frame_size;
1157     if (!st->use_vbr)
1158     {
1159        int cbrBytes;
1160        /* Multiply by 3 to make sure the division is exact. */
1161        int frame_rate3 = 3*st->Fs/frame_size;
1162        /* We need to make sure that "int" values always fit in 16 bits. */
1163        cbrBytes = IMIN( (3*st->bitrate_bps/8 + frame_rate3/2)/frame_rate3, max_data_bytes);
1164        st->bitrate_bps = cbrBytes*(opus_int32)frame_rate3*8/3;
1165        max_data_bytes = cbrBytes;
1166     }
1167     if (max_data_bytes<3 || st->bitrate_bps < 3*frame_rate*8
1168        || (frame_rate<50 && (max_data_bytes*frame_rate<300 || st->bitrate_bps < 2400)))
1169     {
1170        /*If the space is too low to do something useful, emit 'PLC' frames.*/
1171        int tocmode = st->mode;
1172        int bw = st->bandwidth == 0 ? OPUS_BANDWIDTH_NARROWBAND : st->bandwidth;
1173        if (tocmode==0)
1174           tocmode = MODE_SILK_ONLY;
1175        if (frame_rate>100)
1176           tocmode = MODE_CELT_ONLY;
1177        if (frame_rate < 50)
1178           tocmode = MODE_SILK_ONLY;
1179        if(tocmode==MODE_SILK_ONLY&&bw>OPUS_BANDWIDTH_WIDEBAND)
1180           bw=OPUS_BANDWIDTH_WIDEBAND;
1181        else if (tocmode==MODE_CELT_ONLY&&bw==OPUS_BANDWIDTH_MEDIUMBAND)
1182           bw=OPUS_BANDWIDTH_NARROWBAND;
1183        else if (tocmode==MODE_HYBRID&&bw<=OPUS_BANDWIDTH_SUPERWIDEBAND)
1184           bw=OPUS_BANDWIDTH_SUPERWIDEBAND;
1185        data[0] = gen_toc(tocmode, frame_rate, bw, st->stream_channels);
1186        ret = 1;
1187        if (!st->use_vbr)
1188        {
1189           ret = opus_packet_pad(data, ret, max_data_bytes);
1190           if (ret == OPUS_OK)
1191              ret = max_data_bytes;
1192        }
1193        RESTORE_STACK;
1194        return ret;
1195     }
1196     max_rate = frame_rate*max_data_bytes*8;
1197
1198     /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */
1199     equiv_rate = compute_equiv_rate(st->bitrate_bps, st->channels, st->Fs/frame_size,
1200           st->use_vbr, 0, st->silk_mode.complexity);
1201
1202     if (st->signal_type == OPUS_SIGNAL_VOICE)
1203        voice_est = 127;
1204     else if (st->signal_type == OPUS_SIGNAL_MUSIC)
1205        voice_est = 0;
1206     else if (st->voice_ratio >= 0)
1207     {
1208        voice_est = st->voice_ratio*327>>8;
1209        /* For AUDIO, never be more than 90% confident of having speech */
1210        if (st->application == OPUS_APPLICATION_AUDIO)
1211           voice_est = IMIN(voice_est, 115);
1212     } else if (st->application == OPUS_APPLICATION_VOIP)
1213        voice_est = 115;
1214     else
1215        voice_est = 48;
1216
1217     if (st->force_channels!=OPUS_AUTO && st->channels == 2)
1218     {
1219         st->stream_channels = st->force_channels;
1220     } else {
1221 #ifdef FUZZING
1222        /* Random mono/stereo decision */
1223        if (st->channels == 2 && (rand()&0x1F)==0)
1224           st->stream_channels = 3-st->stream_channels;
1225 #else
1226        /* Rate-dependent mono-stereo decision */
1227        if (st->channels == 2)
1228        {
1229           opus_int32 stereo_threshold;
1230           stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14);
1231           if (st->stream_channels == 2)
1232              stereo_threshold -= 1000;
1233           else
1234              stereo_threshold += 1000;
1235           st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1;
1236        } else {
1237           st->stream_channels = st->channels;
1238        }
1239 #endif
1240     }
1241     /* Update equivalent rate for channels decision. */
1242     equiv_rate = compute_equiv_rate(st->bitrate_bps, st->stream_channels, st->Fs/frame_size,
1243           st->use_vbr, 0, st->silk_mode.complexity);
1244
1245     /* Mode selection depending on application and signal type */
1246     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1247     {
1248        st->mode = MODE_CELT_ONLY;
1249     } else if (st->user_forced_mode == OPUS_AUTO)
1250     {
1251 #ifdef FUZZING
1252        /* Random mode switching */
1253        if ((rand()&0xF)==0)
1254        {
1255           if ((rand()&0x1)==0)
1256              st->mode = MODE_CELT_ONLY;
1257           else
1258              st->mode = MODE_SILK_ONLY;
1259        } else {
1260           if (st->prev_mode==MODE_CELT_ONLY)
1261              st->mode = MODE_CELT_ONLY;
1262           else
1263              st->mode = MODE_SILK_ONLY;
1264        }
1265 #else
1266        opus_int32 mode_voice, mode_music;
1267        opus_int32 threshold;
1268
1269        /* Interpolate based on stereo width */
1270        mode_voice = (opus_int32)(MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[0][0])
1271              + MULT16_32_Q15(stereo_width,mode_thresholds[1][0]));
1272        mode_music = (opus_int32)(MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[1][1])
1273              + MULT16_32_Q15(stereo_width,mode_thresholds[1][1]));
1274        /* Interpolate based on speech/music probability */
1275        threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14);
1276        /* Bias towards SILK for VoIP because of some useful features */
1277        if (st->application == OPUS_APPLICATION_VOIP)
1278           threshold += 8000;
1279
1280        /*printf("%f %d\n", stereo_width/(float)Q15ONE, threshold);*/
1281        /* Hysteresis */
1282        if (st->prev_mode == MODE_CELT_ONLY)
1283            threshold -= 4000;
1284        else if (st->prev_mode>0)
1285            threshold += 4000;
1286
1287        st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY;
1288
1289        /* When FEC is enabled and there's enough packet loss, use SILK */
1290        if (st->silk_mode.useInBandFEC && st->silk_mode.packetLossPercentage > (128-voice_est)>>4)
1291           st->mode = MODE_SILK_ONLY;
1292        /* When encoding voice and DTX is enabled, set the encoder to SILK mode (at least for now) */
1293        if (st->silk_mode.useDTX && voice_est > 100)
1294           st->mode = MODE_SILK_ONLY;
1295 #endif
1296     } else {
1297        st->mode = st->user_forced_mode;
1298     }
1299
1300     /* Override the chosen mode to make sure we meet the requested frame size */
1301     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
1302        st->mode = MODE_CELT_ONLY;
1303     if (st->lfe)
1304        st->mode = MODE_CELT_ONLY;
1305     /* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */
1306     if (max_data_bytes < (frame_rate > 50 ? 12000 : 8000)*frame_size / (st->Fs * 8))
1307        st->mode = MODE_CELT_ONLY;
1308
1309     if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0
1310           && st->mode != MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)
1311     {
1312        /* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */
1313        st->silk_mode.toMono = 1;
1314        st->stream_channels = 2;
1315     } else {
1316        st->silk_mode.toMono = 0;
1317     }
1318
1319     if (st->prev_mode > 0 &&
1320         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
1321     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
1322     {
1323         redundancy = 1;
1324         celt_to_silk = (st->mode != MODE_CELT_ONLY);
1325         if (!celt_to_silk)
1326         {
1327             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
1328             if (frame_size >= st->Fs/100)
1329             {
1330                 st->mode = st->prev_mode;
1331                 to_celt = 1;
1332             } else {
1333                 redundancy=0;
1334             }
1335         }
1336     }
1337
1338     /* Update equivalent rate with mode decision. */
1339     equiv_rate = compute_equiv_rate(st->bitrate_bps, st->stream_channels, st->Fs/frame_size,
1340           st->use_vbr, st->mode, st->silk_mode.complexity);
1341
1342     /* For the first frame at a new SILK bandwidth */
1343     if (st->silk_bw_switch)
1344     {
1345        redundancy = 1;
1346        celt_to_silk = 1;
1347        st->silk_bw_switch = 0;
1348        prefill=1;
1349     }
1350
1351     if (redundancy)
1352     {
1353        /* Fair share of the max size allowed */
1354        redundancy_bytes = IMIN(257, max_data_bytes*(opus_int32)(st->Fs/200)/(frame_size+st->Fs/200));
1355        /* For VBR, target the actual bitrate (subject to the limit above) */
1356        if (st->use_vbr)
1357           redundancy_bytes = IMIN(redundancy_bytes, st->bitrate_bps/1600);
1358     }
1359
1360     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
1361     {
1362         silk_EncControlStruct dummy;
1363         silk_InitEncoder( silk_enc, st->arch, &dummy);
1364         prefill=1;
1365     }
1366
1367     /* Automatic (rate-dependent) bandwidth selection */
1368     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
1369     {
1370         const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds;
1371         opus_int32 bandwidth_thresholds[8];
1372         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
1373
1374         if (st->channels==2 && st->force_channels!=1)
1375         {
1376            voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds;
1377            music_bandwidth_thresholds = stereo_music_bandwidth_thresholds;
1378         } else {
1379            voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds;
1380            music_bandwidth_thresholds = mono_music_bandwidth_thresholds;
1381         }
1382         /* Interpolate bandwidth thresholds depending on voice estimation */
1383         for (i=0;i<8;i++)
1384         {
1385            bandwidth_thresholds[i] = music_bandwidth_thresholds[i]
1386                     + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14);
1387         }
1388         do {
1389             int threshold, hysteresis;
1390             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
1391             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
1392             if (!st->first)
1393             {
1394                 if (st->bandwidth >= bandwidth)
1395                     threshold -= hysteresis;
1396                 else
1397                     threshold += hysteresis;
1398             }
1399             if (equiv_rate >= threshold)
1400                 break;
1401         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
1402         st->bandwidth = bandwidth;
1403         /* Prevents any transition to SWB/FB until the SILK layer has fully
1404            switched to WB mode and turned the variable LP filter off */
1405         if (!st->first && st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1406             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1407     }
1408
1409     if (st->bandwidth>st->max_bandwidth)
1410        st->bandwidth = st->max_bandwidth;
1411
1412     if (st->user_bandwidth != OPUS_AUTO)
1413         st->bandwidth = st->user_bandwidth;
1414
1415     /* This prevents us from using hybrid at unsafe CBR/max rates */
1416     if (st->mode != MODE_CELT_ONLY && max_rate < 15000)
1417     {
1418        st->bandwidth = IMIN(st->bandwidth, OPUS_BANDWIDTH_WIDEBAND);
1419     }
1420
1421     /* Prevents Opus from wasting bits on frequencies that are above
1422        the Nyquist rate of the input signal */
1423     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
1424         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1425     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1426         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1427     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
1428         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1429     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
1430         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1431 #ifndef DISABLE_FLOAT_API
1432     /* Use detected bandwidth to reduce the encoded bandwidth. */
1433     if (st->detected_bandwidth && st->user_bandwidth == OPUS_AUTO)
1434     {
1435        int min_detected_bandwidth;
1436        /* Makes bandwidth detection more conservative just in case the detector
1437           gets it wrong when we could have coded a high bandwidth transparently.
1438           When operating in SILK/hybrid mode, we don't go below wideband to avoid
1439           more complicated switches that require redundancy. */
1440        if (equiv_rate <= 18000*st->stream_channels && st->mode == MODE_CELT_ONLY)
1441           min_detected_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1442        else if (equiv_rate <= 24000*st->stream_channels && st->mode == MODE_CELT_ONLY)
1443           min_detected_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1444        else if (equiv_rate <= 30000*st->stream_channels)
1445           min_detected_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1446        else if (equiv_rate <= 44000*st->stream_channels)
1447           min_detected_bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1448        else
1449           min_detected_bandwidth = OPUS_BANDWIDTH_FULLBAND;
1450
1451        st->detected_bandwidth = IMAX(st->detected_bandwidth, min_detected_bandwidth);
1452        st->bandwidth = IMIN(st->bandwidth, st->detected_bandwidth);
1453     }
1454 #endif
1455     celt_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(lsb_depth));
1456
1457     /* CELT mode doesn't support mediumband, use wideband instead */
1458     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1459         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1460     if (st->lfe)
1461        st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1462
1463     /* Can't support higher than wideband for >20 ms frames */
1464     if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND))
1465     {
1466        VARDECL(unsigned char, tmp_data);
1467        int nb_frames;
1468        int bak_mode, bak_bandwidth, bak_channels, bak_to_mono;
1469        VARDECL(OpusRepacketizer, rp);
1470        opus_int32 bytes_per_frame;
1471        opus_int32 repacketize_len;
1472
1473 #ifndef DISABLE_FLOAT_API
1474        if (analysis_read_pos_bak!= -1)
1475        {
1476           st->analysis.read_pos = analysis_read_pos_bak;
1477           st->analysis.read_subframe = analysis_read_subframe_bak;
1478        }
1479 #endif
1480
1481        nb_frames = frame_size > st->Fs/25 ? 3 : 2;
1482        bytes_per_frame = IMIN(1276,(out_data_bytes-3)/nb_frames);
1483
1484        ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char);
1485
1486        ALLOC(rp, 1, OpusRepacketizer);
1487        opus_repacketizer_init(rp);
1488
1489        bak_mode = st->user_forced_mode;
1490        bak_bandwidth = st->user_bandwidth;
1491        bak_channels = st->force_channels;
1492
1493        st->user_forced_mode = st->mode;
1494        st->user_bandwidth = st->bandwidth;
1495        st->force_channels = st->stream_channels;
1496        bak_to_mono = st->silk_mode.toMono;
1497
1498        if (bak_to_mono)
1499           st->force_channels = 1;
1500        else
1501           st->prev_channels = st->stream_channels;
1502        for (i=0;i<nb_frames;i++)
1503        {
1504           int tmp_len;
1505           st->silk_mode.toMono = 0;
1506           /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
1507           if (to_celt && i==nb_frames-1)
1508              st->user_forced_mode = MODE_CELT_ONLY;
1509           tmp_len = opus_encode_native(st, pcm+i*(st->channels*st->Fs/50), st->Fs/50,
1510                 tmp_data+i*bytes_per_frame, bytes_per_frame, lsb_depth,
1511                 NULL, 0, c1, c2, analysis_channels, downmix, float_api);
1512           if (tmp_len<0)
1513           {
1514              RESTORE_STACK;
1515              return OPUS_INTERNAL_ERROR;
1516           }
1517           ret = opus_repacketizer_cat(rp, tmp_data+i*bytes_per_frame, tmp_len);
1518           if (ret<0)
1519           {
1520              RESTORE_STACK;
1521              return OPUS_INTERNAL_ERROR;
1522           }
1523        }
1524        if (st->use_vbr)
1525           repacketize_len = out_data_bytes;
1526        else
1527           repacketize_len = IMIN(3*st->bitrate_bps/(3*8*50/nb_frames), out_data_bytes);
1528        ret = opus_repacketizer_out_range_impl(rp, 0, nb_frames, data, repacketize_len, 0, !st->use_vbr);
1529        if (ret<0)
1530        {
1531           RESTORE_STACK;
1532           return OPUS_INTERNAL_ERROR;
1533        }
1534        st->user_forced_mode = bak_mode;
1535        st->user_bandwidth = bak_bandwidth;
1536        st->force_channels = bak_channels;
1537        st->silk_mode.toMono = bak_to_mono;
1538        RESTORE_STACK;
1539        return ret;
1540     }
1541     curr_bandwidth = st->bandwidth;
1542
1543     /* Chooses the appropriate mode for speech
1544        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
1545     if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1546         st->mode = MODE_HYBRID;
1547     if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
1548         st->mode = MODE_SILK_ONLY;
1549
1550     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
1551     bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
1552
1553     data += 1;
1554
1555     ec_enc_init(&enc, data, max_data_bytes-1);
1556
1557     ALLOC(pcm_buf, (total_buffer+frame_size)*st->channels, opus_val16);
1558     OPUS_COPY(pcm_buf, &st->delay_buffer[(st->encoder_buffer-total_buffer)*st->channels], total_buffer*st->channels);
1559
1560     if (st->mode == MODE_CELT_ONLY)
1561        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1562     else
1563        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
1564
1565     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
1566           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
1567
1568     /* convert from log scale to Hertz */
1569     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
1570
1571     if (st->application == OPUS_APPLICATION_VOIP)
1572     {
1573        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1574     } else {
1575        dc_reject(pcm, 3, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1576     }
1577 #ifndef FIXED_POINT
1578     if (float_api)
1579     {
1580        opus_val32 sum;
1581        sum = celt_inner_prod(&pcm_buf[total_buffer*st->channels], &pcm_buf[total_buffer*st->channels], frame_size*st->channels, st->arch);
1582        /* This should filter out both NaNs and ridiculous signals that could
1583           cause NaNs further down. */
1584        if (!(sum < 1e9f) || celt_isnan(sum))
1585        {
1586           OPUS_CLEAR(&pcm_buf[total_buffer*st->channels], frame_size*st->channels);
1587           st->hp_mem[0] = st->hp_mem[1] = st->hp_mem[2] = st->hp_mem[3] = 0;
1588        }
1589     }
1590 #endif
1591
1592
1593     /* SILK processing */
1594     HB_gain = Q15ONE;
1595     if (st->mode != MODE_CELT_ONLY)
1596     {
1597         opus_int32 total_bitRate, celt_rate;
1598 #ifdef FIXED_POINT
1599        const opus_int16 *pcm_silk;
1600 #else
1601        VARDECL(opus_int16, pcm_silk);
1602        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
1603 #endif
1604
1605         /* Distribute bits between SILK and CELT */
1606         total_bitRate = 8 * bytes_target * frame_rate;
1607         if( st->mode == MODE_HYBRID ) {
1608             /* Base rate for SILK */
1609             st->silk_mode.bitRate = compute_silk_rate_for_hybrid(total_bitRate,
1610                   curr_bandwidth, st->Fs == 50 * frame_size, st->use_vbr);
1611             if (!st->energy_masking)
1612             {
1613                /* Increasingly attenuate high band when it gets allocated fewer bits */
1614                celt_rate = total_bitRate - st->silk_mode.bitRate;
1615                HB_gain = Q15ONE - SHR32(celt_exp2(-celt_rate * QCONST16(1.f/1024, 10)), 1);
1616             }
1617         } else {
1618             /* SILK gets all bits */
1619             st->silk_mode.bitRate = total_bitRate;
1620         }
1621
1622         /* Surround masking for SILK */
1623         if (st->energy_masking && st->use_vbr && !st->lfe)
1624         {
1625            opus_val32 mask_sum=0;
1626            opus_val16 masking_depth;
1627            opus_int32 rate_offset;
1628            int c;
1629            int end = 17;
1630            opus_int16 srate = 16000;
1631            if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND)
1632            {
1633               end = 13;
1634               srate = 8000;
1635            } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1636            {
1637               end = 15;
1638               srate = 12000;
1639            }
1640            for (c=0;c<st->channels;c++)
1641            {
1642               for(i=0;i<end;i++)
1643               {
1644                  opus_val16 mask;
1645                  mask = MAX16(MIN16(st->energy_masking[21*c+i],
1646                         QCONST16(.5f, DB_SHIFT)), -QCONST16(2.0f, DB_SHIFT));
1647                  if (mask > 0)
1648                     mask = HALF16(mask);
1649                  mask_sum += mask;
1650               }
1651            }
1652            /* Conservative rate reduction, we cut the masking in half */
1653            masking_depth = mask_sum / end*st->channels;
1654            masking_depth += QCONST16(.2f, DB_SHIFT);
1655            rate_offset = (opus_int32)PSHR32(MULT16_16(srate, masking_depth), DB_SHIFT);
1656            rate_offset = MAX32(rate_offset, -2*st->silk_mode.bitRate/3);
1657            /* Split the rate change between the SILK and CELT part for hybrid. */
1658            if (st->bandwidth==OPUS_BANDWIDTH_SUPERWIDEBAND || st->bandwidth==OPUS_BANDWIDTH_FULLBAND)
1659               st->silk_mode.bitRate += 3*rate_offset/5;
1660            else
1661               st->silk_mode.bitRate += rate_offset;
1662            bytes_target += rate_offset * frame_size / (8 * st->Fs);
1663         }
1664
1665         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
1666         st->silk_mode.nChannelsAPI = st->channels;
1667         st->silk_mode.nChannelsInternal = st->stream_channels;
1668         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1669             st->silk_mode.desiredInternalSampleRate = 8000;
1670         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1671             st->silk_mode.desiredInternalSampleRate = 12000;
1672         } else {
1673             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
1674             st->silk_mode.desiredInternalSampleRate = 16000;
1675         }
1676         if( st->mode == MODE_HYBRID ) {
1677             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
1678             st->silk_mode.minInternalSampleRate = 16000;
1679         } else {
1680             st->silk_mode.minInternalSampleRate = 8000;
1681         }
1682
1683         if (st->mode == MODE_SILK_ONLY)
1684         {
1685            opus_int32 effective_max_rate = max_rate;
1686            st->silk_mode.maxInternalSampleRate = 16000;
1687            if (frame_rate > 50)
1688               effective_max_rate = effective_max_rate*2/3;
1689            if (effective_max_rate < 13000)
1690            {
1691               st->silk_mode.maxInternalSampleRate = 12000;
1692               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
1693            }
1694            if (effective_max_rate < 9600)
1695            {
1696               st->silk_mode.maxInternalSampleRate = 8000;
1697               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
1698            }
1699         } else {
1700            st->silk_mode.maxInternalSampleRate = 16000;
1701         }
1702
1703         st->silk_mode.useCBR = !st->use_vbr;
1704
1705         /* Call SILK encoder for the low band */
1706         nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes);
1707
1708         st->silk_mode.maxBits = nBytes*8;
1709         /* Only allow up to 90% of the bits for hybrid mode*/
1710         if (st->mode == MODE_HYBRID)
1711            st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
1712         if (st->silk_mode.useCBR)
1713         {
1714            st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
1715            /* Reduce the initial target to make it easier to reach the CBR rate */
1716            st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000);
1717         }
1718
1719         if (prefill)
1720         {
1721             opus_int32 zero=0;
1722             int prefill_offset;
1723             /* Use a smooth onset for the SILK prefill to avoid the encoder trying to encode
1724                a discontinuity. The exact location is what we need to avoid leaving any "gap"
1725                in the audio when mixing with the redundant CELT frame. Here we can afford to
1726                overwrite st->delay_buffer because the only thing that uses it before it gets
1727                rewritten is tmp_prefill[] and even then only the part after the ramp really
1728                gets used (rather than sent to the encoder and discarded) */
1729             prefill_offset = st->channels*(st->encoder_buffer-st->delay_compensation-st->Fs/400);
1730             gain_fade(st->delay_buffer+prefill_offset, st->delay_buffer+prefill_offset,
1731                   0, Q15ONE, celt_mode->overlap, st->Fs/400, st->channels, celt_mode->window, st->Fs);
1732             OPUS_CLEAR(st->delay_buffer, prefill_offset);
1733 #ifdef FIXED_POINT
1734             pcm_silk = st->delay_buffer;
1735 #else
1736             for (i=0;i<st->encoder_buffer*st->channels;i++)
1737                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
1738 #endif
1739             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
1740         }
1741
1742 #ifdef FIXED_POINT
1743         pcm_silk = pcm_buf+total_buffer*st->channels;
1744 #else
1745         for (i=0;i<frame_size*st->channels;i++)
1746             pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
1747 #endif
1748         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
1749         if( ret ) {
1750             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
1751             /* Handle error */
1752            RESTORE_STACK;
1753            return OPUS_INTERNAL_ERROR;
1754         }
1755         if (nBytes==0)
1756         {
1757            st->rangeFinal = 0;
1758            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1759            RESTORE_STACK;
1760            return 1;
1761         }
1762         /* Extract SILK internal bandwidth for signaling in first byte */
1763         if( st->mode == MODE_SILK_ONLY ) {
1764             if( st->silk_mode.internalSampleRate == 8000 ) {
1765                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1766             } else if( st->silk_mode.internalSampleRate == 12000 ) {
1767                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1768             } else if( st->silk_mode.internalSampleRate == 16000 ) {
1769                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1770             }
1771         } else {
1772             silk_assert( st->silk_mode.internalSampleRate == 16000 );
1773         }
1774
1775         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
1776         /* FIXME: How do we allocate the redundancy for CBR? */
1777         if (st->silk_mode.opusCanSwitch)
1778         {
1779            redundancy = 1;
1780            celt_to_silk = 0;
1781            st->silk_bw_switch = 1;
1782         }
1783     }
1784
1785     /* CELT processing */
1786     {
1787         int endband=21;
1788
1789         switch(curr_bandwidth)
1790         {
1791             case OPUS_BANDWIDTH_NARROWBAND:
1792                 endband = 13;
1793                 break;
1794             case OPUS_BANDWIDTH_MEDIUMBAND:
1795             case OPUS_BANDWIDTH_WIDEBAND:
1796                 endband = 17;
1797                 break;
1798             case OPUS_BANDWIDTH_SUPERWIDEBAND:
1799                 endband = 19;
1800                 break;
1801             case OPUS_BANDWIDTH_FULLBAND:
1802                 endband = 21;
1803                 break;
1804         }
1805         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
1806         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
1807     }
1808     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1809     if (st->mode != MODE_SILK_ONLY)
1810     {
1811         opus_val32 celt_pred=2;
1812         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1813         /* We may still decide to disable prediction later */
1814         if (st->silk_mode.reducedDependency)
1815            celt_pred = 0;
1816         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(celt_pred));
1817
1818         if (st->mode == MODE_HYBRID)
1819         {
1820             int len;
1821
1822             len = (ec_tell(&enc)+7)>>3;
1823             if (redundancy)
1824                len += st->mode == MODE_HYBRID ? 3 : 1;
1825             if( st->use_vbr ) {
1826                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps-st->silk_mode.bitRate));
1827                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
1828                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(0));
1829             } else {
1830                 /* check if SILK used up too much */
1831                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
1832             }
1833         } else {
1834             if (st->use_vbr)
1835             {
1836                 opus_int32 bonus=0;
1837 #ifndef DISABLE_FLOAT_API
1838                 if (st->variable_duration==OPUS_FRAMESIZE_VARIABLE && frame_size != st->Fs/50)
1839                 {
1840                    bonus = (60*st->stream_channels+40)*(st->Fs/frame_size-50);
1841                    if (analysis_info.valid)
1842                       bonus = (opus_int32)(bonus*(1.f+.5f*analysis_info.tonality));
1843                 }
1844 #endif
1845                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
1846                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
1847                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps+bonus));
1848                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
1849             } else {
1850                 nb_compr_bytes = bytes_target;
1851             }
1852         }
1853
1854     } else {
1855         nb_compr_bytes = 0;
1856     }
1857
1858     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
1859     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
1860     {
1861        OPUS_COPY(tmp_prefill, &st->delay_buffer[(st->encoder_buffer-total_buffer-st->Fs/400)*st->channels], st->channels*st->Fs/400);
1862     }
1863
1864     if (st->channels*(st->encoder_buffer-(frame_size+total_buffer)) > 0)
1865     {
1866        OPUS_MOVE(st->delay_buffer, &st->delay_buffer[st->channels*frame_size], st->channels*(st->encoder_buffer-frame_size-total_buffer));
1867        OPUS_COPY(&st->delay_buffer[st->channels*(st->encoder_buffer-frame_size-total_buffer)],
1868              &pcm_buf[0],
1869              (frame_size+total_buffer)*st->channels);
1870     } else {
1871        OPUS_COPY(st->delay_buffer, &pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels], st->encoder_buffer*st->channels);
1872     }
1873     /* gain_fade() and stereo_fade() need to be after the buffer copying
1874        because we don't want any of this to affect the SILK part */
1875     if( st->prev_HB_gain < Q15ONE || HB_gain < Q15ONE ) {
1876        gain_fade(pcm_buf, pcm_buf,
1877              st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs);
1878     }
1879     st->prev_HB_gain = HB_gain;
1880     if (st->mode != MODE_HYBRID || st->stream_channels==1)
1881        st->silk_mode.stereoWidth_Q14 = IMIN((1<<14),2*IMAX(0,equiv_rate-24000));
1882     if( !st->energy_masking && st->channels == 2 ) {
1883         /* Apply stereo width reduction (at low bitrates) */
1884         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1885             opus_val16 g1, g2;
1886             g1 = st->hybrid_stereo_width_Q14;
1887             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1888 #ifdef FIXED_POINT
1889             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
1890             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
1891 #else
1892             g1 *= (1.f/16384);
1893             g2 *= (1.f/16384);
1894 #endif
1895             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
1896                   frame_size, st->channels, celt_mode->window, st->Fs);
1897             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1898         }
1899     }
1900
1901     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
1902     {
1903         /* For SILK mode, the redundancy is inferred from the length */
1904         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
1905            ec_enc_bit_logp(&enc, redundancy, 12);
1906         if (redundancy)
1907         {
1908             int max_redundancy;
1909             ec_enc_bit_logp(&enc, celt_to_silk, 1);
1910             if (st->mode == MODE_HYBRID)
1911                max_redundancy = (max_data_bytes-1)-nb_compr_bytes;
1912             else
1913                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1914             /* Target the same bit-rate for redundancy as for the rest,
1915                up to a max of 257 bytes */
1916             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
1917             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
1918             if (st->mode == MODE_HYBRID)
1919                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
1920         }
1921     } else {
1922         redundancy = 0;
1923     }
1924
1925     if (!redundancy)
1926     {
1927        st->silk_bw_switch = 0;
1928        redundancy_bytes = 0;
1929     }
1930     if (st->mode != MODE_CELT_ONLY)start_band=17;
1931
1932     if (st->mode == MODE_SILK_ONLY)
1933     {
1934         ret = (ec_tell(&enc)+7)>>3;
1935         ec_enc_done(&enc);
1936         nb_compr_bytes = ret;
1937     } else {
1938        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
1939        ec_enc_shrink(&enc, nb_compr_bytes);
1940     }
1941
1942 #ifndef DISABLE_FLOAT_API
1943     if (redundancy || st->mode != MODE_SILK_ONLY)
1944        celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(&analysis_info));
1945 #endif
1946     if (st->mode == MODE_HYBRID) {
1947        SILKInfo info;
1948        info.signalType = st->silk_mode.signalType;
1949        info.offset = st->silk_mode.offset;
1950        celt_encoder_ctl(celt_enc, CELT_SET_SILK_INFO(&info));
1951     } else {
1952        celt_encoder_ctl(celt_enc, CELT_SET_SILK_INFO((SILKInfo*)NULL));
1953     }
1954
1955     /* 5 ms redundant frame for CELT->SILK */
1956     if (redundancy && celt_to_silk)
1957     {
1958         int err;
1959         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1960         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1961         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1962         err = celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
1963         if (err < 0)
1964         {
1965            RESTORE_STACK;
1966            return OPUS_INTERNAL_ERROR;
1967         }
1968         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1969         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1970     }
1971
1972     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
1973
1974     if (st->mode != MODE_SILK_ONLY)
1975     {
1976         if (st->mode != st->prev_mode && st->prev_mode > 0)
1977         {
1978            unsigned char dummy[2];
1979            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1980
1981            /* Prefilling */
1982            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
1983            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1984         }
1985         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
1986         if (ec_tell(&enc) <= 8*nb_compr_bytes)
1987         {
1988            /* Set the bitrate again if it was overridden in the redundancy code above*/
1989            if (redundancy && celt_to_silk && st->mode==MODE_HYBRID && st->use_vbr)
1990               celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps-st->silk_mode.bitRate));
1991            celt_encoder_ctl(celt_enc, OPUS_SET_VBR(st->use_vbr));
1992            ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
1993            if (ret < 0)
1994            {
1995               RESTORE_STACK;
1996               return OPUS_INTERNAL_ERROR;
1997            }
1998            /* Put CELT->SILK redundancy data in the right place. */
1999            if (redundancy && celt_to_silk && st->mode==MODE_HYBRID && st->use_vbr)
2000            {
2001               OPUS_COPY(data+ret, data+nb_compr_bytes, redundancy_bytes);
2002               nb_compr_bytes = nb_compr_bytes+redundancy_bytes;
2003            }
2004         }
2005     }
2006
2007     /* 5 ms redundant frame for SILK->CELT */
2008     if (redundancy && !celt_to_silk)
2009     {
2010         int err;
2011         unsigned char dummy[2];
2012         int N2, N4;
2013         N2 = st->Fs/200;
2014         N4 = st->Fs/400;
2015
2016         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2017         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
2018         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
2019         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
2020         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
2021
2022         if (st->mode == MODE_HYBRID)
2023         {
2024            /* Shrink packet to what the encoder actually used. */
2025            nb_compr_bytes = ret;
2026            ec_enc_shrink(&enc, nb_compr_bytes);
2027         }
2028         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
2029         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL);
2030
2031         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
2032         if (err < 0)
2033         {
2034            RESTORE_STACK;
2035            return OPUS_INTERNAL_ERROR;
2036         }
2037         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
2038     }
2039
2040
2041
2042     /* Signalling the mode in the first byte */
2043     data--;
2044     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
2045
2046     st->rangeFinal = enc.rng ^ redundant_rng;
2047
2048     if (to_celt)
2049         st->prev_mode = MODE_CELT_ONLY;
2050     else
2051         st->prev_mode = st->mode;
2052     st->prev_channels = st->stream_channels;
2053     st->prev_framesize = frame_size;
2054
2055     st->first = 0;
2056
2057     /* In the unlikely case that the SILK encoder busted its target, tell
2058        the decoder to call the PLC */
2059     if (ec_tell(&enc) > (max_data_bytes-1)*8)
2060     {
2061        if (max_data_bytes < 2)
2062        {
2063           RESTORE_STACK;
2064           return OPUS_BUFFER_TOO_SMALL;
2065        }
2066        data[1] = 0;
2067        ret = 1;
2068        st->rangeFinal = 0;
2069     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
2070     {
2071        /*When in LPC only mode it's perfectly
2072          reasonable to strip off trailing zero bytes as
2073          the required range decoder behavior is to
2074          fill these in. This can't be done when the MDCT
2075          modes are used because the decoder needs to know
2076          the actual length for allocation purposes.*/
2077        while(ret>2&&data[ret]==0)ret--;
2078     }
2079     /* Count ToC and redundancy */
2080     ret += 1+redundancy_bytes;
2081     if (!st->use_vbr)
2082     {
2083        if (opus_packet_pad(data, ret, max_data_bytes) != OPUS_OK)
2084
2085        {
2086           RESTORE_STACK;
2087           return OPUS_INTERNAL_ERROR;
2088        }
2089        ret = max_data_bytes;
2090     }
2091     RESTORE_STACK;
2092     return ret;
2093 }
2094
2095 #ifdef FIXED_POINT
2096
2097 #ifndef DISABLE_FLOAT_API
2098 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int analysis_frame_size,
2099       unsigned char *data, opus_int32 max_data_bytes)
2100 {
2101    int i, ret;
2102    int frame_size;
2103    int delay_compensation;
2104    VARDECL(opus_int16, in);
2105    ALLOC_STACK;
2106
2107    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2108       delay_compensation = 0;
2109    else
2110       delay_compensation = st->delay_compensation;
2111    frame_size = compute_frame_size(pcm, analysis_frame_size,
2112          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2113          delay_compensation, downmix_float, st->analysis.subframe_mem);
2114
2115    ALLOC(in, frame_size*st->channels, opus_int16);
2116
2117    for (i=0;i<frame_size*st->channels;i++)
2118       in[i] = FLOAT2INT16(pcm[i]);
2119    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16,
2120                             pcm, analysis_frame_size, 0, -2, st->channels, downmix_float, 1);
2121    RESTORE_STACK;
2122    return ret;
2123 }
2124 #endif
2125
2126 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int analysis_frame_size,
2127                 unsigned char *data, opus_int32 out_data_bytes)
2128 {
2129    int frame_size;
2130    int delay_compensation;
2131    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2132       delay_compensation = 0;
2133    else
2134       delay_compensation = st->delay_compensation;
2135    frame_size = compute_frame_size(pcm, analysis_frame_size,
2136          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2137          delay_compensation, downmix_int
2138 #ifndef DISABLE_FLOAT_API
2139          , st->analysis.subframe_mem
2140 #endif
2141          );
2142    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 16,
2143                              pcm, analysis_frame_size, 0, -2, st->channels, downmix_int, 0);
2144 }
2145
2146 #else
2147 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int analysis_frame_size,
2148       unsigned char *data, opus_int32 max_data_bytes)
2149 {
2150    int i, ret;
2151    int frame_size;
2152    int delay_compensation;
2153    VARDECL(float, in);
2154    ALLOC_STACK;
2155
2156    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2157       delay_compensation = 0;
2158    else
2159       delay_compensation = st->delay_compensation;
2160    frame_size = compute_frame_size(pcm, analysis_frame_size,
2161          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2162          delay_compensation, downmix_int, st->analysis.subframe_mem);
2163
2164    ALLOC(in, frame_size*st->channels, float);
2165
2166    for (i=0;i<frame_size*st->channels;i++)
2167       in[i] = (1.0f/32768)*pcm[i];
2168    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16,
2169                             pcm, analysis_frame_size, 0, -2, st->channels, downmix_int, 0);
2170    RESTORE_STACK;
2171    return ret;
2172 }
2173 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int analysis_frame_size,
2174                       unsigned char *data, opus_int32 out_data_bytes)
2175 {
2176    int frame_size;
2177    int delay_compensation;
2178    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2179       delay_compensation = 0;
2180    else
2181       delay_compensation = st->delay_compensation;
2182    frame_size = compute_frame_size(pcm, analysis_frame_size,
2183          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2184          delay_compensation, downmix_float, st->analysis.subframe_mem);
2185    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 24,
2186                              pcm, analysis_frame_size, 0, -2, st->channels, downmix_float, 1);
2187 }
2188 #endif
2189
2190
2191 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
2192 {
2193     int ret;
2194     CELTEncoder *celt_enc;
2195     va_list ap;
2196
2197     ret = OPUS_OK;
2198     va_start(ap, request);
2199
2200     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
2201
2202     switch (request)
2203     {
2204         case OPUS_SET_APPLICATION_REQUEST:
2205         {
2206             opus_int32 value = va_arg(ap, opus_int32);
2207             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
2208                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2209                || (!st->first && st->application != value))
2210             {
2211                ret = OPUS_BAD_ARG;
2212                break;
2213             }
2214             st->application = value;
2215         }
2216         break;
2217         case OPUS_GET_APPLICATION_REQUEST:
2218         {
2219             opus_int32 *value = va_arg(ap, opus_int32*);
2220             if (!value)
2221             {
2222                goto bad_arg;
2223             }
2224             *value = st->application;
2225         }
2226         break;
2227         case OPUS_SET_BITRATE_REQUEST:
2228         {
2229             opus_int32 value = va_arg(ap, opus_int32);
2230             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
2231             {
2232                 if (value <= 0)
2233                     goto bad_arg;
2234                 else if (value <= 500)
2235                     value = 500;
2236                 else if (value > (opus_int32)300000*st->channels)
2237                     value = (opus_int32)300000*st->channels;
2238             }
2239             st->user_bitrate_bps = value;
2240         }
2241         break;
2242         case OPUS_GET_BITRATE_REQUEST:
2243         {
2244             opus_int32 *value = va_arg(ap, opus_int32*);
2245             if (!value)
2246             {
2247                goto bad_arg;
2248             }
2249             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
2250         }
2251         break;
2252         case OPUS_SET_FORCE_CHANNELS_REQUEST:
2253         {
2254             opus_int32 value = va_arg(ap, opus_int32);
2255             if((value<1 || value>st->channels) && value != OPUS_AUTO)
2256             {
2257                goto bad_arg;
2258             }
2259             st->force_channels = value;
2260         }
2261         break;
2262         case OPUS_GET_FORCE_CHANNELS_REQUEST:
2263         {
2264             opus_int32 *value = va_arg(ap, opus_int32*);
2265             if (!value)
2266             {
2267                goto bad_arg;
2268             }
2269             *value = st->force_channels;
2270         }
2271         break;
2272         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
2273         {
2274             opus_int32 value = va_arg(ap, opus_int32);
2275             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND)
2276             {
2277                goto bad_arg;
2278             }
2279             st->max_bandwidth = value;
2280             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2281                 st->silk_mode.maxInternalSampleRate = 8000;
2282             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2283                 st->silk_mode.maxInternalSampleRate = 12000;
2284             } else {
2285                 st->silk_mode.maxInternalSampleRate = 16000;
2286             }
2287         }
2288         break;
2289         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
2290         {
2291             opus_int32 *value = va_arg(ap, opus_int32*);
2292             if (!value)
2293             {
2294                goto bad_arg;
2295             }
2296             *value = st->max_bandwidth;
2297         }
2298         break;
2299         case OPUS_SET_BANDWIDTH_REQUEST:
2300         {
2301             opus_int32 value = va_arg(ap, opus_int32);
2302             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
2303             {
2304                goto bad_arg;
2305             }
2306             st->user_bandwidth = value;
2307             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2308                 st->silk_mode.maxInternalSampleRate = 8000;
2309             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2310                 st->silk_mode.maxInternalSampleRate = 12000;
2311             } else {
2312                 st->silk_mode.maxInternalSampleRate = 16000;
2313             }
2314         }
2315         break;
2316         case OPUS_GET_BANDWIDTH_REQUEST:
2317         {
2318             opus_int32 *value = va_arg(ap, opus_int32*);
2319             if (!value)
2320             {
2321                goto bad_arg;
2322             }
2323             *value = st->bandwidth;
2324         }
2325         break;
2326         case OPUS_SET_DTX_REQUEST:
2327         {
2328             opus_int32 value = va_arg(ap, opus_int32);
2329             if(value<0 || value>1)
2330             {
2331                goto bad_arg;
2332             }
2333             st->silk_mode.useDTX = value;
2334         }
2335         break;
2336         case OPUS_GET_DTX_REQUEST:
2337         {
2338             opus_int32 *value = va_arg(ap, opus_int32*);
2339             if (!value)
2340             {
2341                goto bad_arg;
2342             }
2343             *value = st->silk_mode.useDTX;
2344         }
2345         break;
2346         case OPUS_SET_COMPLEXITY_REQUEST:
2347         {
2348             opus_int32 value = va_arg(ap, opus_int32);
2349             if(value<0 || value>10)
2350             {
2351                goto bad_arg;
2352             }
2353             st->silk_mode.complexity = value;
2354             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
2355         }
2356         break;
2357         case OPUS_GET_COMPLEXITY_REQUEST:
2358         {
2359             opus_int32 *value = va_arg(ap, opus_int32*);
2360             if (!value)
2361             {
2362                goto bad_arg;
2363             }
2364             *value = st->silk_mode.complexity;
2365         }
2366         break;
2367         case OPUS_SET_INBAND_FEC_REQUEST:
2368         {
2369             opus_int32 value = va_arg(ap, opus_int32);
2370             if(value<0 || value>1)
2371             {
2372                goto bad_arg;
2373             }
2374             st->silk_mode.useInBandFEC = value;
2375         }
2376         break;
2377         case OPUS_GET_INBAND_FEC_REQUEST:
2378         {
2379             opus_int32 *value = va_arg(ap, opus_int32*);
2380             if (!value)
2381             {
2382                goto bad_arg;
2383             }
2384             *value = st->silk_mode.useInBandFEC;
2385         }
2386         break;
2387         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
2388         {
2389             opus_int32 value = va_arg(ap, opus_int32);
2390             if (value < 0 || value > 100)
2391             {
2392                goto bad_arg;
2393             }
2394             st->silk_mode.packetLossPercentage = value;
2395             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
2396         }
2397         break;
2398         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
2399         {
2400             opus_int32 *value = va_arg(ap, opus_int32*);
2401             if (!value)
2402             {
2403                goto bad_arg;
2404             }
2405             *value = st->silk_mode.packetLossPercentage;
2406         }
2407         break;
2408         case OPUS_SET_VBR_REQUEST:
2409         {
2410             opus_int32 value = va_arg(ap, opus_int32);
2411             if(value<0 || value>1)
2412             {
2413                goto bad_arg;
2414             }
2415             st->use_vbr = value;
2416             st->silk_mode.useCBR = 1-value;
2417         }
2418         break;
2419         case OPUS_GET_VBR_REQUEST:
2420         {
2421             opus_int32 *value = va_arg(ap, opus_int32*);
2422             if (!value)
2423             {
2424                goto bad_arg;
2425             }
2426             *value = st->use_vbr;
2427         }
2428         break;
2429         case OPUS_SET_VOICE_RATIO_REQUEST:
2430         {
2431             opus_int32 value = va_arg(ap, opus_int32);
2432             if (value<-1 || value>100)
2433             {
2434                goto bad_arg;
2435             }
2436             st->voice_ratio = value;
2437         }
2438         break;
2439         case OPUS_GET_VOICE_RATIO_REQUEST:
2440         {
2441             opus_int32 *value = va_arg(ap, opus_int32*);
2442             if (!value)
2443             {
2444                goto bad_arg;
2445             }
2446             *value = st->voice_ratio;
2447         }
2448         break;
2449         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
2450         {
2451             opus_int32 value = va_arg(ap, opus_int32);
2452             if(value<0 || value>1)
2453             {
2454                goto bad_arg;
2455             }
2456             st->vbr_constraint = value;
2457         }
2458         break;
2459         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
2460         {
2461             opus_int32 *value = va_arg(ap, opus_int32*);
2462             if (!value)
2463             {
2464                goto bad_arg;
2465             }
2466             *value = st->vbr_constraint;
2467         }
2468         break;
2469         case OPUS_SET_SIGNAL_REQUEST:
2470         {
2471             opus_int32 value = va_arg(ap, opus_int32);
2472             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
2473             {
2474                goto bad_arg;
2475             }
2476             st->signal_type = value;
2477         }
2478         break;
2479         case OPUS_GET_SIGNAL_REQUEST:
2480         {
2481             opus_int32 *value = va_arg(ap, opus_int32*);
2482             if (!value)
2483             {
2484                goto bad_arg;
2485             }
2486             *value = st->signal_type;
2487         }
2488         break;
2489         case OPUS_GET_LOOKAHEAD_REQUEST:
2490         {
2491             opus_int32 *value = va_arg(ap, opus_int32*);
2492             if (!value)
2493             {
2494                goto bad_arg;
2495             }
2496             *value = st->Fs/400;
2497             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2498                 *value += st->delay_compensation;
2499         }
2500         break;
2501         case OPUS_GET_SAMPLE_RATE_REQUEST:
2502         {
2503             opus_int32 *value = va_arg(ap, opus_int32*);
2504             if (!value)
2505             {
2506                goto bad_arg;
2507             }
2508             *value = st->Fs;
2509         }
2510         break;
2511         case OPUS_GET_FINAL_RANGE_REQUEST:
2512         {
2513             opus_uint32 *value = va_arg(ap, opus_uint32*);
2514             if (!value)
2515             {
2516                goto bad_arg;
2517             }
2518             *value = st->rangeFinal;
2519         }
2520         break;
2521         case OPUS_SET_LSB_DEPTH_REQUEST:
2522         {
2523             opus_int32 value = va_arg(ap, opus_int32);
2524             if (value<8 || value>24)
2525             {
2526                goto bad_arg;
2527             }
2528             st->lsb_depth=value;
2529         }
2530         break;
2531         case OPUS_GET_LSB_DEPTH_REQUEST:
2532         {
2533             opus_int32 *value = va_arg(ap, opus_int32*);
2534             if (!value)
2535             {
2536                goto bad_arg;
2537             }
2538             *value = st->lsb_depth;
2539         }
2540         break;
2541         case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
2542         {
2543             opus_int32 value = va_arg(ap, opus_int32);
2544             if (value != OPUS_FRAMESIZE_ARG   && value != OPUS_FRAMESIZE_2_5_MS &&
2545                 value != OPUS_FRAMESIZE_5_MS  && value != OPUS_FRAMESIZE_10_MS  &&
2546                 value != OPUS_FRAMESIZE_20_MS && value != OPUS_FRAMESIZE_40_MS  &&
2547                 value != OPUS_FRAMESIZE_60_MS && value != OPUS_FRAMESIZE_VARIABLE)
2548             {
2549                goto bad_arg;
2550             }
2551             st->variable_duration = value;
2552             celt_encoder_ctl(celt_enc, OPUS_SET_EXPERT_FRAME_DURATION(value));
2553         }
2554         break;
2555         case OPUS_GET_EXPERT_FRAME_DURATION_REQUEST:
2556         {
2557             opus_int32 *value = va_arg(ap, opus_int32*);
2558             if (!value)
2559             {
2560                goto bad_arg;
2561             }
2562             *value = st->variable_duration;
2563         }
2564         break;
2565         case OPUS_SET_PREDICTION_DISABLED_REQUEST:
2566         {
2567            opus_int32 value = va_arg(ap, opus_int32);
2568            if (value > 1 || value < 0)
2569               goto bad_arg;
2570            st->silk_mode.reducedDependency = value;
2571         }
2572         break;
2573         case OPUS_GET_PREDICTION_DISABLED_REQUEST:
2574         {
2575            opus_int32 *value = va_arg(ap, opus_int32*);
2576            if (!value)
2577               goto bad_arg;
2578            *value = st->silk_mode.reducedDependency;
2579         }
2580         break;
2581         case OPUS_RESET_STATE:
2582         {
2583            void *silk_enc;
2584            silk_EncControlStruct dummy;
2585            char *start;
2586            silk_enc = (char*)st+st->silk_enc_offset;
2587 #ifndef DISABLE_FLOAT_API
2588            tonality_analysis_reset(&st->analysis);
2589 #endif
2590
2591            start = (char*)&st->OPUS_ENCODER_RESET_START;
2592            OPUS_CLEAR(start, sizeof(OpusEncoder) - (start - (char*)st));
2593
2594            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2595            silk_InitEncoder( silk_enc, st->arch, &dummy );
2596            st->stream_channels = st->channels;
2597            st->hybrid_stereo_width_Q14 = 1 << 14;
2598            st->prev_HB_gain = Q15ONE;
2599            st->first = 1;
2600            st->mode = MODE_HYBRID;
2601            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
2602            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
2603         }
2604         break;
2605         case OPUS_SET_FORCE_MODE_REQUEST:
2606         {
2607             opus_int32 value = va_arg(ap, opus_int32);
2608             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
2609             {
2610                goto bad_arg;
2611             }
2612             st->user_forced_mode = value;
2613         }
2614         break;
2615         case OPUS_SET_LFE_REQUEST:
2616         {
2617             opus_int32 value = va_arg(ap, opus_int32);
2618             st->lfe = value;
2619             ret = celt_encoder_ctl(celt_enc, OPUS_SET_LFE(value));
2620         }
2621         break;
2622         case OPUS_SET_ENERGY_MASK_REQUEST:
2623         {
2624             opus_val16 *value = va_arg(ap, opus_val16*);
2625             st->energy_masking = value;
2626             ret = celt_encoder_ctl(celt_enc, OPUS_SET_ENERGY_MASK(value));
2627         }
2628         break;
2629
2630         case CELT_GET_MODE_REQUEST:
2631         {
2632            const CELTMode ** value = va_arg(ap, const CELTMode**);
2633            if (!value)
2634            {
2635               goto bad_arg;
2636            }
2637            ret = celt_encoder_ctl(celt_enc, CELT_GET_MODE(value));
2638         }
2639         break;
2640         default:
2641             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
2642             ret = OPUS_UNIMPLEMENTED;
2643             break;
2644     }
2645     va_end(ap);
2646     return ret;
2647 bad_arg:
2648     va_end(ap);
2649     return OPUS_BAD_ARG;
2650 }
2651
2652 void opus_encoder_destroy(OpusEncoder *st)
2653 {
2654     opus_free(st);
2655 }