Quality: Removes high-band attenuation in hybrid mode -- at least for now
[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         14000, 1000, /* MB<->WB */
118         17000, 1000, /* WB<->SWB */
119         21000, 2000, /* SWB<->FB */
120 };
121 static const opus_int32 mono_music_bandwidth_thresholds[8] = {
122         12000, 1000, /* NB<->MB */
123         15000, 1000, /* MB<->WB */
124         18000, 2000, /* WB<->SWB */
125         22000, 2000, /* SWB<->FB */
126 };
127 static const opus_int32 stereo_voice_bandwidth_thresholds[8] = {
128         11000, 1000, /* NB<->MB */
129         14000, 1000, /* MB<->WB */
130         21000, 2000, /* WB<->SWB */
131         28000, 2000, /* SWB<->FB */
132 };
133 static const opus_int32 stereo_music_bandwidth_thresholds[8] = {
134         12000, 1000, /* NB<->MB */
135         18000, 2000, /* MB<->WB */
136         20000, 2000, /* WB<->SWB */
137         24000, 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 opus_int32 opus_encode_native(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
981                 unsigned char *data, opus_int32 out_data_bytes, int lsb_depth,
982                 const void *analysis_pcm, opus_int32 analysis_size, int c1, int c2,
983                 int analysis_channels, downmix_func downmix, int float_api)
984 {
985     void *silk_enc;
986     CELTEncoder *celt_enc;
987     int i;
988     int ret=0;
989     opus_int32 nBytes;
990     ec_enc enc;
991     int bytes_target;
992     int prefill=0;
993     int start_band = 0;
994     int redundancy = 0;
995     int redundancy_bytes = 0; /* Number of bytes to use for redundancy frame */
996     int celt_to_silk = 0;
997     VARDECL(opus_val16, pcm_buf);
998     int nb_compr_bytes;
999     int to_celt = 0;
1000     opus_uint32 redundant_rng = 0;
1001     int cutoff_Hz, hp_freq_smth1;
1002     int voice_est; /* Probability of voice in Q7 */
1003     opus_int32 equiv_rate;
1004     int delay_compensation;
1005     int frame_rate;
1006     opus_int32 max_rate; /* Max bitrate we're allowed to use */
1007     int curr_bandwidth;
1008     opus_val16 HB_gain;
1009     opus_int32 max_data_bytes; /* Max number of bytes we're allowed to use */
1010     int total_buffer;
1011     opus_val16 stereo_width;
1012     const CELTMode *celt_mode;
1013 #ifndef DISABLE_FLOAT_API
1014     AnalysisInfo analysis_info;
1015     int analysis_read_pos_bak=-1;
1016     int analysis_read_subframe_bak=-1;
1017 #endif
1018     VARDECL(opus_val16, tmp_prefill);
1019
1020     ALLOC_STACK;
1021
1022     max_data_bytes = IMIN(1276, out_data_bytes);
1023
1024     st->rangeFinal = 0;
1025     if ((!st->variable_duration && 400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
1026          50*frame_size != st->Fs &&  25*frame_size != st->Fs &&  50*frame_size != 3*st->Fs)
1027          || (400*frame_size < st->Fs)
1028          || max_data_bytes<=0
1029          )
1030     {
1031        RESTORE_STACK;
1032        return OPUS_BAD_ARG;
1033     }
1034     silk_enc = (char*)st+st->silk_enc_offset;
1035     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1036     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1037        delay_compensation = 0;
1038     else
1039        delay_compensation = st->delay_compensation;
1040
1041     lsb_depth = IMIN(lsb_depth, st->lsb_depth);
1042
1043     celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1044 #ifndef DISABLE_FLOAT_API
1045     analysis_info.valid = 0;
1046 #ifdef FIXED_POINT
1047     if (st->silk_mode.complexity >= 10 && st->Fs==48000)
1048 #else
1049     if (st->silk_mode.complexity >= 7 && st->Fs==48000)
1050 #endif
1051     {
1052        analysis_read_pos_bak = st->analysis.read_pos;
1053        analysis_read_subframe_bak = st->analysis.read_subframe;
1054        run_analysis(&st->analysis, celt_mode, analysis_pcm, analysis_size, frame_size,
1055              c1, c2, analysis_channels, st->Fs,
1056              lsb_depth, downmix, &analysis_info);
1057     }
1058 #else
1059     (void)analysis_pcm;
1060     (void)analysis_size;
1061 #endif
1062
1063     st->voice_ratio = -1;
1064
1065 #ifndef DISABLE_FLOAT_API
1066     st->detected_bandwidth = 0;
1067     if (analysis_info.valid)
1068     {
1069        int analysis_bandwidth;
1070        if (st->signal_type == OPUS_AUTO)
1071           st->voice_ratio = (int)floor(.5+100*(1-analysis_info.music_prob));
1072
1073        analysis_bandwidth = analysis_info.bandwidth;
1074        if (analysis_bandwidth<=12)
1075           st->detected_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1076        else if (analysis_bandwidth<=14)
1077           st->detected_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1078        else if (analysis_bandwidth<=16)
1079           st->detected_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1080        else if (analysis_bandwidth<=18)
1081           st->detected_bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1082        else
1083           st->detected_bandwidth = OPUS_BANDWIDTH_FULLBAND;
1084     }
1085 #endif
1086
1087     if (st->channels==2 && st->force_channels!=1)
1088        stereo_width = compute_stereo_width(pcm, frame_size, st->Fs, &st->width_mem);
1089     else
1090        stereo_width = 0;
1091     total_buffer = delay_compensation;
1092     st->bitrate_bps = user_bitrate_to_bitrate(st, frame_size, max_data_bytes);
1093
1094     frame_rate = st->Fs/frame_size;
1095     if (!st->use_vbr)
1096     {
1097        int cbrBytes;
1098        /* Multiply by 3 to make sure the division is exact. */
1099        int frame_rate3 = 3*st->Fs/frame_size;
1100        /* We need to make sure that "int" values always fit in 16 bits. */
1101        cbrBytes = IMIN( (3*st->bitrate_bps/8 + frame_rate3/2)/frame_rate3, max_data_bytes);
1102        st->bitrate_bps = cbrBytes*(opus_int32)frame_rate3*8/3;
1103        max_data_bytes = cbrBytes;
1104     }
1105     if (max_data_bytes<3 || st->bitrate_bps < 3*frame_rate*8
1106        || (frame_rate<50 && (max_data_bytes*frame_rate<300 || st->bitrate_bps < 2400)))
1107     {
1108        /*If the space is too low to do something useful, emit 'PLC' frames.*/
1109        int tocmode = st->mode;
1110        int bw = st->bandwidth == 0 ? OPUS_BANDWIDTH_NARROWBAND : st->bandwidth;
1111        if (tocmode==0)
1112           tocmode = MODE_SILK_ONLY;
1113        if (frame_rate>100)
1114           tocmode = MODE_CELT_ONLY;
1115        if (frame_rate < 50)
1116           tocmode = MODE_SILK_ONLY;
1117        if(tocmode==MODE_SILK_ONLY&&bw>OPUS_BANDWIDTH_WIDEBAND)
1118           bw=OPUS_BANDWIDTH_WIDEBAND;
1119        else if (tocmode==MODE_CELT_ONLY&&bw==OPUS_BANDWIDTH_MEDIUMBAND)
1120           bw=OPUS_BANDWIDTH_NARROWBAND;
1121        else if (tocmode==MODE_HYBRID&&bw<=OPUS_BANDWIDTH_SUPERWIDEBAND)
1122           bw=OPUS_BANDWIDTH_SUPERWIDEBAND;
1123        data[0] = gen_toc(tocmode, frame_rate, bw, st->stream_channels);
1124        ret = 1;
1125        if (!st->use_vbr)
1126        {
1127           ret = opus_packet_pad(data, ret, max_data_bytes);
1128           if (ret == OPUS_OK)
1129              ret = max_data_bytes;
1130        }
1131        RESTORE_STACK;
1132        return ret;
1133     }
1134     max_rate = frame_rate*max_data_bytes*8;
1135
1136     /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */
1137     equiv_rate = st->bitrate_bps - (40*st->channels+20)*(st->Fs/frame_size - 50);
1138
1139     if (st->signal_type == OPUS_SIGNAL_VOICE)
1140        voice_est = 127;
1141     else if (st->signal_type == OPUS_SIGNAL_MUSIC)
1142        voice_est = 0;
1143     else if (st->voice_ratio >= 0)
1144     {
1145        voice_est = st->voice_ratio*327>>8;
1146        /* For AUDIO, never be more than 90% confident of having speech */
1147        if (st->application == OPUS_APPLICATION_AUDIO)
1148           voice_est = IMIN(voice_est, 115);
1149     } else if (st->application == OPUS_APPLICATION_VOIP)
1150        voice_est = 115;
1151     else
1152        voice_est = 48;
1153
1154     if (st->force_channels!=OPUS_AUTO && st->channels == 2)
1155     {
1156         st->stream_channels = st->force_channels;
1157     } else {
1158 #ifdef FUZZING
1159        /* Random mono/stereo decision */
1160        if (st->channels == 2 && (rand()&0x1F)==0)
1161           st->stream_channels = 3-st->stream_channels;
1162 #else
1163        /* Rate-dependent mono-stereo decision */
1164        if (st->channels == 2)
1165        {
1166           opus_int32 stereo_threshold;
1167           stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14);
1168           if (st->stream_channels == 2)
1169              stereo_threshold -= 1000;
1170           else
1171              stereo_threshold += 1000;
1172           st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1;
1173        } else {
1174           st->stream_channels = st->channels;
1175        }
1176 #endif
1177     }
1178     equiv_rate = st->bitrate_bps - (40*st->stream_channels+20)*(st->Fs/frame_size - 50);
1179
1180     /* Mode selection depending on application and signal type */
1181     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1182     {
1183        st->mode = MODE_CELT_ONLY;
1184     } else if (st->user_forced_mode == OPUS_AUTO)
1185     {
1186 #ifdef FUZZING
1187        /* Random mode switching */
1188        if ((rand()&0xF)==0)
1189        {
1190           if ((rand()&0x1)==0)
1191              st->mode = MODE_CELT_ONLY;
1192           else
1193              st->mode = MODE_SILK_ONLY;
1194        } else {
1195           if (st->prev_mode==MODE_CELT_ONLY)
1196              st->mode = MODE_CELT_ONLY;
1197           else
1198              st->mode = MODE_SILK_ONLY;
1199        }
1200 #else
1201        opus_int32 mode_voice, mode_music;
1202        opus_int32 threshold;
1203
1204        /* Interpolate based on stereo width */
1205        mode_voice = (opus_int32)(MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[0][0])
1206              + MULT16_32_Q15(stereo_width,mode_thresholds[1][0]));
1207        mode_music = (opus_int32)(MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[1][1])
1208              + MULT16_32_Q15(stereo_width,mode_thresholds[1][1]));
1209        /* Interpolate based on speech/music probability */
1210        threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14);
1211        /* Bias towards SILK for VoIP because of some useful features */
1212        if (st->application == OPUS_APPLICATION_VOIP)
1213           threshold += 8000;
1214
1215        /*printf("%f %d\n", stereo_width/(float)Q15ONE, threshold);*/
1216        /* Hysteresis */
1217        if (st->prev_mode == MODE_CELT_ONLY)
1218            threshold -= 4000;
1219        else if (st->prev_mode>0)
1220            threshold += 4000;
1221
1222        st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY;
1223
1224        /* When FEC is enabled and there's enough packet loss, use SILK */
1225        if (st->silk_mode.useInBandFEC && st->silk_mode.packetLossPercentage > (128-voice_est)>>4)
1226           st->mode = MODE_SILK_ONLY;
1227        /* When encoding voice and DTX is enabled, set the encoder to SILK mode (at least for now) */
1228        if (st->silk_mode.useDTX && voice_est > 100)
1229           st->mode = MODE_SILK_ONLY;
1230 #endif
1231     } else {
1232        st->mode = st->user_forced_mode;
1233     }
1234
1235     /* Override the chosen mode to make sure we meet the requested frame size */
1236     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
1237        st->mode = MODE_CELT_ONLY;
1238     if (st->lfe)
1239        st->mode = MODE_CELT_ONLY;
1240     /* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */
1241     if (max_data_bytes < (frame_rate > 50 ? 12000 : 8000)*frame_size / (st->Fs * 8))
1242        st->mode = MODE_CELT_ONLY;
1243
1244     if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0
1245           && st->mode != MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)
1246     {
1247        /* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */
1248        st->silk_mode.toMono = 1;
1249        st->stream_channels = 2;
1250     } else {
1251        st->silk_mode.toMono = 0;
1252     }
1253
1254     if (st->prev_mode > 0 &&
1255         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
1256     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
1257     {
1258         redundancy = 1;
1259         celt_to_silk = (st->mode != MODE_CELT_ONLY);
1260         if (!celt_to_silk)
1261         {
1262             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
1263             if (frame_size >= st->Fs/100)
1264             {
1265                 st->mode = st->prev_mode;
1266                 to_celt = 1;
1267             } else {
1268                 redundancy=0;
1269             }
1270         }
1271     }
1272     /* For the first frame at a new SILK bandwidth */
1273     if (st->silk_bw_switch)
1274     {
1275        redundancy = 1;
1276        celt_to_silk = 1;
1277        st->silk_bw_switch = 0;
1278        prefill=1;
1279     }
1280
1281     if (redundancy)
1282     {
1283        /* Fair share of the max size allowed */
1284        redundancy_bytes = IMIN(257, max_data_bytes*(opus_int32)(st->Fs/200)/(frame_size+st->Fs/200));
1285        /* For VBR, target the actual bitrate (subject to the limit above) */
1286        if (st->use_vbr)
1287           redundancy_bytes = IMIN(redundancy_bytes, st->bitrate_bps/1600);
1288     }
1289
1290     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
1291     {
1292         silk_EncControlStruct dummy;
1293         silk_InitEncoder( silk_enc, st->arch, &dummy);
1294         prefill=1;
1295     }
1296
1297     /* Automatic (rate-dependent) bandwidth selection */
1298     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
1299     {
1300         const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds;
1301         opus_int32 bandwidth_thresholds[8];
1302         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
1303         opus_int32 equiv_rate2;
1304
1305         equiv_rate2 = equiv_rate;
1306         if (st->mode != MODE_CELT_ONLY)
1307         {
1308            /* Adjust the threshold +/- 10% depending on complexity */
1309            equiv_rate2 = equiv_rate2 * (45+st->silk_mode.complexity)/50;
1310            /* CBR is less efficient by ~1 kb/s */
1311            if (!st->use_vbr)
1312               equiv_rate2 -= 1000;
1313         }
1314         if (st->channels==2 && st->force_channels!=1)
1315         {
1316            voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds;
1317            music_bandwidth_thresholds = stereo_music_bandwidth_thresholds;
1318         } else {
1319            voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds;
1320            music_bandwidth_thresholds = mono_music_bandwidth_thresholds;
1321         }
1322         /* Interpolate bandwidth thresholds depending on voice estimation */
1323         for (i=0;i<8;i++)
1324         {
1325            bandwidth_thresholds[i] = music_bandwidth_thresholds[i]
1326                     + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14);
1327         }
1328         do {
1329             int threshold, hysteresis;
1330             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
1331             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
1332             if (!st->first)
1333             {
1334                 if (st->bandwidth >= bandwidth)
1335                     threshold -= hysteresis;
1336                 else
1337                     threshold += hysteresis;
1338             }
1339             if (equiv_rate2 >= threshold)
1340                 break;
1341         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
1342         st->bandwidth = bandwidth;
1343         /* Prevents any transition to SWB/FB until the SILK layer has fully
1344            switched to WB mode and turned the variable LP filter off */
1345         if (!st->first && st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1346             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1347     }
1348
1349     if (st->bandwidth>st->max_bandwidth)
1350        st->bandwidth = st->max_bandwidth;
1351
1352     if (st->user_bandwidth != OPUS_AUTO)
1353         st->bandwidth = st->user_bandwidth;
1354
1355     /* This prevents us from using hybrid at unsafe CBR/max rates */
1356     if (st->mode != MODE_CELT_ONLY && max_rate < 15000)
1357     {
1358        st->bandwidth = IMIN(st->bandwidth, OPUS_BANDWIDTH_WIDEBAND);
1359     }
1360
1361     /* Prevents Opus from wasting bits on frequencies that are above
1362        the Nyquist rate of the input signal */
1363     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
1364         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1365     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1366         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1367     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
1368         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1369     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
1370         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1371 #ifndef DISABLE_FLOAT_API
1372     /* Use detected bandwidth to reduce the encoded bandwidth. */
1373     if (st->detected_bandwidth && st->user_bandwidth == OPUS_AUTO)
1374     {
1375        int min_detected_bandwidth;
1376        /* Makes bandwidth detection more conservative just in case the detector
1377           gets it wrong when we could have coded a high bandwidth transparently.
1378           When operating in SILK/hybrid mode, we don't go below wideband to avoid
1379           more complicated switches that require redundancy. */
1380        if (equiv_rate <= 18000*st->stream_channels && st->mode == MODE_CELT_ONLY)
1381           min_detected_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1382        else if (equiv_rate <= 24000*st->stream_channels && st->mode == MODE_CELT_ONLY)
1383           min_detected_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1384        else if (equiv_rate <= 30000*st->stream_channels)
1385           min_detected_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1386        else if (equiv_rate <= 44000*st->stream_channels)
1387           min_detected_bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1388        else
1389           min_detected_bandwidth = OPUS_BANDWIDTH_FULLBAND;
1390
1391        st->detected_bandwidth = IMAX(st->detected_bandwidth, min_detected_bandwidth);
1392        st->bandwidth = IMIN(st->bandwidth, st->detected_bandwidth);
1393     }
1394 #endif
1395     celt_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(lsb_depth));
1396
1397     /* CELT mode doesn't support mediumband, use wideband instead */
1398     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1399         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1400     if (st->lfe)
1401        st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1402
1403     /* Can't support higher than wideband for >20 ms frames */
1404     if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND))
1405     {
1406        VARDECL(unsigned char, tmp_data);
1407        int nb_frames;
1408        int bak_mode, bak_bandwidth, bak_channels, bak_to_mono;
1409        VARDECL(OpusRepacketizer, rp);
1410        opus_int32 bytes_per_frame;
1411        opus_int32 repacketize_len;
1412
1413 #ifndef DISABLE_FLOAT_API
1414        if (analysis_read_pos_bak!= -1)
1415        {
1416           st->analysis.read_pos = analysis_read_pos_bak;
1417           st->analysis.read_subframe = analysis_read_subframe_bak;
1418        }
1419 #endif
1420
1421        nb_frames = frame_size > st->Fs/25 ? 3 : 2;
1422        bytes_per_frame = IMIN(1276,(out_data_bytes-3)/nb_frames);
1423
1424        ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char);
1425
1426        ALLOC(rp, 1, OpusRepacketizer);
1427        opus_repacketizer_init(rp);
1428
1429        bak_mode = st->user_forced_mode;
1430        bak_bandwidth = st->user_bandwidth;
1431        bak_channels = st->force_channels;
1432
1433        st->user_forced_mode = st->mode;
1434        st->user_bandwidth = st->bandwidth;
1435        st->force_channels = st->stream_channels;
1436        bak_to_mono = st->silk_mode.toMono;
1437
1438        if (bak_to_mono)
1439           st->force_channels = 1;
1440        else
1441           st->prev_channels = st->stream_channels;
1442        for (i=0;i<nb_frames;i++)
1443        {
1444           int tmp_len;
1445           st->silk_mode.toMono = 0;
1446           /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
1447           if (to_celt && i==nb_frames-1)
1448              st->user_forced_mode = MODE_CELT_ONLY;
1449           tmp_len = opus_encode_native(st, pcm+i*(st->channels*st->Fs/50), st->Fs/50,
1450                 tmp_data+i*bytes_per_frame, bytes_per_frame, lsb_depth,
1451                 NULL, 0, c1, c2, analysis_channels, downmix, float_api);
1452           if (tmp_len<0)
1453           {
1454              RESTORE_STACK;
1455              return OPUS_INTERNAL_ERROR;
1456           }
1457           ret = opus_repacketizer_cat(rp, tmp_data+i*bytes_per_frame, tmp_len);
1458           if (ret<0)
1459           {
1460              RESTORE_STACK;
1461              return OPUS_INTERNAL_ERROR;
1462           }
1463        }
1464        if (st->use_vbr)
1465           repacketize_len = out_data_bytes;
1466        else
1467           repacketize_len = IMIN(3*st->bitrate_bps/(3*8*50/nb_frames), out_data_bytes);
1468        ret = opus_repacketizer_out_range_impl(rp, 0, nb_frames, data, repacketize_len, 0, !st->use_vbr);
1469        if (ret<0)
1470        {
1471           RESTORE_STACK;
1472           return OPUS_INTERNAL_ERROR;
1473        }
1474        st->user_forced_mode = bak_mode;
1475        st->user_bandwidth = bak_bandwidth;
1476        st->force_channels = bak_channels;
1477        st->silk_mode.toMono = bak_to_mono;
1478        RESTORE_STACK;
1479        return ret;
1480     }
1481     curr_bandwidth = st->bandwidth;
1482
1483     /* Chooses the appropriate mode for speech
1484        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
1485     if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1486         st->mode = MODE_HYBRID;
1487     if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
1488         st->mode = MODE_SILK_ONLY;
1489
1490     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
1491     bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
1492
1493     data += 1;
1494
1495     ec_enc_init(&enc, data, max_data_bytes-1);
1496
1497     ALLOC(pcm_buf, (total_buffer+frame_size)*st->channels, opus_val16);
1498     OPUS_COPY(pcm_buf, &st->delay_buffer[(st->encoder_buffer-total_buffer)*st->channels], total_buffer*st->channels);
1499
1500     if (st->mode == MODE_CELT_ONLY)
1501        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1502     else
1503        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
1504
1505     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
1506           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
1507
1508     /* convert from log scale to Hertz */
1509     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
1510
1511     if (st->application == OPUS_APPLICATION_VOIP)
1512     {
1513        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1514     } else {
1515        dc_reject(pcm, 3, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1516     }
1517 #ifndef FIXED_POINT
1518     if (float_api)
1519     {
1520        opus_val32 sum;
1521        sum = celt_inner_prod(&pcm_buf[total_buffer*st->channels], &pcm_buf[total_buffer*st->channels], frame_size*st->channels, st->arch);
1522        /* This should filter out both NaNs and ridiculous signals that could
1523           cause NaNs further down. */
1524        if (!(sum < 1e9f) || celt_isnan(sum))
1525        {
1526           OPUS_CLEAR(&pcm_buf[total_buffer*st->channels], frame_size*st->channels);
1527           st->hp_mem[0] = st->hp_mem[1] = st->hp_mem[2] = st->hp_mem[3] = 0;
1528        }
1529     }
1530 #endif
1531
1532
1533     /* SILK processing */
1534     HB_gain = Q15ONE;
1535     if (st->mode != MODE_CELT_ONLY)
1536     {
1537         opus_int32 total_bitRate, celt_rate;
1538 #ifdef FIXED_POINT
1539        const opus_int16 *pcm_silk;
1540 #else
1541        VARDECL(opus_int16, pcm_silk);
1542        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
1543 #endif
1544
1545         /* Distribute bits between SILK and CELT */
1546         total_bitRate = 8 * bytes_target * frame_rate;
1547         if( st->mode == MODE_HYBRID ) {
1548             int HB_gain_ref;
1549             /* Base rate for SILK */
1550             st->silk_mode.bitRate = compute_silk_rate_for_hybrid(total_bitRate,
1551                   curr_bandwidth, st->Fs == 50 * frame_size, st->use_vbr);
1552             if (!st->energy_masking)
1553             {
1554                /* Increasingly attenuate high band when it gets allocated fewer bits */
1555                celt_rate = total_bitRate - st->silk_mode.bitRate;
1556                HB_gain_ref = (curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND) ? 3000 : 3600;
1557                HB_gain = SHL32((opus_val32)celt_rate, 9) / SHR32((opus_val32)celt_rate + st->stream_channels * HB_gain_ref, 6);
1558                HB_gain = HB_gain < (opus_val32)Q15ONE*6/7 ? HB_gain + Q15ONE/7 : Q15ONE;
1559                HB_gain = Q15ONE;
1560             }
1561         } else {
1562             /* SILK gets all bits */
1563             st->silk_mode.bitRate = total_bitRate;
1564         }
1565
1566         /* Surround masking for SILK */
1567         if (st->energy_masking && st->use_vbr && !st->lfe)
1568         {
1569            opus_val32 mask_sum=0;
1570            opus_val16 masking_depth;
1571            opus_int32 rate_offset;
1572            int c;
1573            int end = 17;
1574            opus_int16 srate = 16000;
1575            if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND)
1576            {
1577               end = 13;
1578               srate = 8000;
1579            } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1580            {
1581               end = 15;
1582               srate = 12000;
1583            }
1584            for (c=0;c<st->channels;c++)
1585            {
1586               for(i=0;i<end;i++)
1587               {
1588                  opus_val16 mask;
1589                  mask = MAX16(MIN16(st->energy_masking[21*c+i],
1590                         QCONST16(.5f, DB_SHIFT)), -QCONST16(2.0f, DB_SHIFT));
1591                  if (mask > 0)
1592                     mask = HALF16(mask);
1593                  mask_sum += mask;
1594               }
1595            }
1596            /* Conservative rate reduction, we cut the masking in half */
1597            masking_depth = mask_sum / end*st->channels;
1598            masking_depth += QCONST16(.2f, DB_SHIFT);
1599            rate_offset = (opus_int32)PSHR32(MULT16_16(srate, masking_depth), DB_SHIFT);
1600            rate_offset = MAX32(rate_offset, -2*st->silk_mode.bitRate/3);
1601            /* Split the rate change between the SILK and CELT part for hybrid. */
1602            if (st->bandwidth==OPUS_BANDWIDTH_SUPERWIDEBAND || st->bandwidth==OPUS_BANDWIDTH_FULLBAND)
1603               st->silk_mode.bitRate += 3*rate_offset/5;
1604            else
1605               st->silk_mode.bitRate += rate_offset;
1606            bytes_target += rate_offset * frame_size / (8 * st->Fs);
1607         }
1608
1609         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
1610         st->silk_mode.nChannelsAPI = st->channels;
1611         st->silk_mode.nChannelsInternal = st->stream_channels;
1612         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1613             st->silk_mode.desiredInternalSampleRate = 8000;
1614         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1615             st->silk_mode.desiredInternalSampleRate = 12000;
1616         } else {
1617             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
1618             st->silk_mode.desiredInternalSampleRate = 16000;
1619         }
1620         if( st->mode == MODE_HYBRID ) {
1621             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
1622             st->silk_mode.minInternalSampleRate = 16000;
1623         } else {
1624             st->silk_mode.minInternalSampleRate = 8000;
1625         }
1626
1627         if (st->mode == MODE_SILK_ONLY)
1628         {
1629            opus_int32 effective_max_rate = max_rate;
1630            st->silk_mode.maxInternalSampleRate = 16000;
1631            if (frame_rate > 50)
1632               effective_max_rate = effective_max_rate*2/3;
1633            if (effective_max_rate < 13000)
1634            {
1635               st->silk_mode.maxInternalSampleRate = 12000;
1636               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
1637            }
1638            if (effective_max_rate < 9600)
1639            {
1640               st->silk_mode.maxInternalSampleRate = 8000;
1641               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
1642            }
1643         } else {
1644            st->silk_mode.maxInternalSampleRate = 16000;
1645         }
1646
1647         st->silk_mode.useCBR = !st->use_vbr;
1648
1649         /* Call SILK encoder for the low band */
1650         nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes);
1651
1652         st->silk_mode.maxBits = nBytes*8;
1653         /* Only allow up to 90% of the bits for hybrid mode*/
1654         if (st->mode == MODE_HYBRID)
1655            st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
1656         if (st->silk_mode.useCBR)
1657         {
1658            st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
1659            /* Reduce the initial target to make it easier to reach the CBR rate */
1660            st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000);
1661         }
1662
1663         if (prefill)
1664         {
1665             opus_int32 zero=0;
1666             int prefill_offset;
1667             /* Use a smooth onset for the SILK prefill to avoid the encoder trying to encode
1668                a discontinuity. The exact location is what we need to avoid leaving any "gap"
1669                in the audio when mixing with the redundant CELT frame. Here we can afford to
1670                overwrite st->delay_buffer because the only thing that uses it before it gets
1671                rewritten is tmp_prefill[] and even then only the part after the ramp really
1672                gets used (rather than sent to the encoder and discarded) */
1673             prefill_offset = st->channels*(st->encoder_buffer-st->delay_compensation-st->Fs/400);
1674             gain_fade(st->delay_buffer+prefill_offset, st->delay_buffer+prefill_offset,
1675                   0, Q15ONE, celt_mode->overlap, st->Fs/400, st->channels, celt_mode->window, st->Fs);
1676             OPUS_CLEAR(st->delay_buffer, prefill_offset);
1677 #ifdef FIXED_POINT
1678             pcm_silk = st->delay_buffer;
1679 #else
1680             for (i=0;i<st->encoder_buffer*st->channels;i++)
1681                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
1682 #endif
1683             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
1684         }
1685
1686 #ifdef FIXED_POINT
1687         pcm_silk = pcm_buf+total_buffer*st->channels;
1688 #else
1689         for (i=0;i<frame_size*st->channels;i++)
1690             pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
1691 #endif
1692         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
1693         if( ret ) {
1694             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
1695             /* Handle error */
1696            RESTORE_STACK;
1697            return OPUS_INTERNAL_ERROR;
1698         }
1699         if (nBytes==0)
1700         {
1701            st->rangeFinal = 0;
1702            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1703            RESTORE_STACK;
1704            return 1;
1705         }
1706         /* Extract SILK internal bandwidth for signaling in first byte */
1707         if( st->mode == MODE_SILK_ONLY ) {
1708             if( st->silk_mode.internalSampleRate == 8000 ) {
1709                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1710             } else if( st->silk_mode.internalSampleRate == 12000 ) {
1711                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1712             } else if( st->silk_mode.internalSampleRate == 16000 ) {
1713                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1714             }
1715         } else {
1716             silk_assert( st->silk_mode.internalSampleRate == 16000 );
1717         }
1718
1719         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
1720         /* FIXME: How do we allocate the redundancy for CBR? */
1721         if (st->silk_mode.opusCanSwitch)
1722         {
1723            redundancy = 1;
1724            celt_to_silk = 0;
1725            st->silk_bw_switch = 1;
1726         }
1727     }
1728
1729     /* CELT processing */
1730     {
1731         int endband=21;
1732
1733         switch(curr_bandwidth)
1734         {
1735             case OPUS_BANDWIDTH_NARROWBAND:
1736                 endband = 13;
1737                 break;
1738             case OPUS_BANDWIDTH_MEDIUMBAND:
1739             case OPUS_BANDWIDTH_WIDEBAND:
1740                 endband = 17;
1741                 break;
1742             case OPUS_BANDWIDTH_SUPERWIDEBAND:
1743                 endband = 19;
1744                 break;
1745             case OPUS_BANDWIDTH_FULLBAND:
1746                 endband = 21;
1747                 break;
1748         }
1749         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
1750         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
1751     }
1752     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1753     if (st->mode != MODE_SILK_ONLY)
1754     {
1755         opus_val32 celt_pred=2;
1756         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1757         /* We may still decide to disable prediction later */
1758         if (st->silk_mode.reducedDependency)
1759            celt_pred = 0;
1760         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(celt_pred));
1761
1762         if (st->mode == MODE_HYBRID)
1763         {
1764             int len;
1765
1766             len = (ec_tell(&enc)+7)>>3;
1767             if (redundancy)
1768                len += st->mode == MODE_HYBRID ? 3 : 1;
1769             if( st->use_vbr ) {
1770                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps-st->silk_mode.bitRate));
1771                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
1772                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(0));
1773             } else {
1774                 /* check if SILK used up too much */
1775                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
1776             }
1777         } else {
1778             if (st->use_vbr)
1779             {
1780                 opus_int32 bonus=0;
1781 #ifndef DISABLE_FLOAT_API
1782                 if (st->variable_duration==OPUS_FRAMESIZE_VARIABLE && frame_size != st->Fs/50)
1783                 {
1784                    bonus = (60*st->stream_channels+40)*(st->Fs/frame_size-50);
1785                    if (analysis_info.valid)
1786                       bonus = (opus_int32)(bonus*(1.f+.5f*analysis_info.tonality));
1787                 }
1788 #endif
1789                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
1790                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
1791                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps+bonus));
1792                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
1793             } else {
1794                 nb_compr_bytes = bytes_target;
1795             }
1796         }
1797
1798     } else {
1799         nb_compr_bytes = 0;
1800     }
1801
1802     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
1803     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
1804     {
1805        OPUS_COPY(tmp_prefill, &st->delay_buffer[(st->encoder_buffer-total_buffer-st->Fs/400)*st->channels], st->channels*st->Fs/400);
1806     }
1807
1808     if (st->channels*(st->encoder_buffer-(frame_size+total_buffer)) > 0)
1809     {
1810        OPUS_MOVE(st->delay_buffer, &st->delay_buffer[st->channels*frame_size], st->channels*(st->encoder_buffer-frame_size-total_buffer));
1811        OPUS_COPY(&st->delay_buffer[st->channels*(st->encoder_buffer-frame_size-total_buffer)],
1812              &pcm_buf[0],
1813              (frame_size+total_buffer)*st->channels);
1814     } else {
1815        OPUS_COPY(st->delay_buffer, &pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels], st->encoder_buffer*st->channels);
1816     }
1817     /* gain_fade() and stereo_fade() need to be after the buffer copying
1818        because we don't want any of this to affect the SILK part */
1819     if( st->prev_HB_gain < Q15ONE || HB_gain < Q15ONE ) {
1820        gain_fade(pcm_buf, pcm_buf,
1821              st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs);
1822     }
1823     st->prev_HB_gain = HB_gain;
1824     if (st->mode != MODE_HYBRID || st->stream_channels==1)
1825        st->silk_mode.stereoWidth_Q14 = IMIN((1<<14),2*IMAX(0,equiv_rate-24000));
1826     if( !st->energy_masking && st->channels == 2 ) {
1827         /* Apply stereo width reduction (at low bitrates) */
1828         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1829             opus_val16 g1, g2;
1830             g1 = st->hybrid_stereo_width_Q14;
1831             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1832 #ifdef FIXED_POINT
1833             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
1834             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
1835 #else
1836             g1 *= (1.f/16384);
1837             g2 *= (1.f/16384);
1838 #endif
1839             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
1840                   frame_size, st->channels, celt_mode->window, st->Fs);
1841             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1842         }
1843     }
1844
1845     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
1846     {
1847         /* For SILK mode, the redundancy is inferred from the length */
1848         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
1849            ec_enc_bit_logp(&enc, redundancy, 12);
1850         if (redundancy)
1851         {
1852             int max_redundancy;
1853             ec_enc_bit_logp(&enc, celt_to_silk, 1);
1854             if (st->mode == MODE_HYBRID)
1855                max_redundancy = (max_data_bytes-1)-nb_compr_bytes;
1856             else
1857                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1858             /* Target the same bit-rate for redundancy as for the rest,
1859                up to a max of 257 bytes */
1860             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
1861             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
1862             if (st->mode == MODE_HYBRID)
1863                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
1864         }
1865     } else {
1866         redundancy = 0;
1867     }
1868
1869     if (!redundancy)
1870     {
1871        st->silk_bw_switch = 0;
1872        redundancy_bytes = 0;
1873     }
1874     if (st->mode != MODE_CELT_ONLY)start_band=17;
1875
1876     if (st->mode == MODE_SILK_ONLY)
1877     {
1878         ret = (ec_tell(&enc)+7)>>3;
1879         ec_enc_done(&enc);
1880         nb_compr_bytes = ret;
1881     } else {
1882        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
1883        ec_enc_shrink(&enc, nb_compr_bytes);
1884     }
1885
1886 #ifndef DISABLE_FLOAT_API
1887     if (redundancy || st->mode != MODE_SILK_ONLY)
1888        celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(&analysis_info));
1889 #endif
1890
1891     /* 5 ms redundant frame for CELT->SILK */
1892     if (redundancy && celt_to_silk)
1893     {
1894         int err;
1895         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1896         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1897         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1898         err = celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
1899         if (err < 0)
1900         {
1901            RESTORE_STACK;
1902            return OPUS_INTERNAL_ERROR;
1903         }
1904         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1905         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1906     }
1907
1908     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
1909
1910     if (st->mode != MODE_SILK_ONLY)
1911     {
1912         if (st->mode != st->prev_mode && st->prev_mode > 0)
1913         {
1914            unsigned char dummy[2];
1915            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1916
1917            /* Prefilling */
1918            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
1919            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1920         }
1921         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
1922         if (ec_tell(&enc) <= 8*nb_compr_bytes)
1923         {
1924            /* Set the bitrate again if it was overridden in the redundancy code above*/
1925            if (redundancy && celt_to_silk && st->mode==MODE_HYBRID && st->use_vbr)
1926               celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps-st->silk_mode.bitRate));
1927            celt_encoder_ctl(celt_enc, OPUS_SET_VBR(st->use_vbr));
1928            ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
1929            if (ret < 0)
1930            {
1931               RESTORE_STACK;
1932               return OPUS_INTERNAL_ERROR;
1933            }
1934            /* Put CELT->SILK redundancy data in the right place. */
1935            if (redundancy && celt_to_silk && st->mode==MODE_HYBRID && st->use_vbr)
1936            {
1937               OPUS_COPY(data+ret, data+nb_compr_bytes, redundancy_bytes);
1938               nb_compr_bytes = nb_compr_bytes+redundancy_bytes;
1939            }
1940         }
1941     }
1942
1943     /* 5 ms redundant frame for SILK->CELT */
1944     if (redundancy && !celt_to_silk)
1945     {
1946         int err;
1947         unsigned char dummy[2];
1948         int N2, N4;
1949         N2 = st->Fs/200;
1950         N4 = st->Fs/400;
1951
1952         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1953         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1954         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1955         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1956         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1957
1958         if (st->mode == MODE_HYBRID)
1959         {
1960            /* Shrink packet to what the encoder actually used. */
1961            nb_compr_bytes = ret;
1962            ec_enc_shrink(&enc, nb_compr_bytes);
1963         }
1964         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1965         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL);
1966
1967         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1968         if (err < 0)
1969         {
1970            RESTORE_STACK;
1971            return OPUS_INTERNAL_ERROR;
1972         }
1973         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1974     }
1975
1976
1977
1978     /* Signalling the mode in the first byte */
1979     data--;
1980     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1981
1982     st->rangeFinal = enc.rng ^ redundant_rng;
1983
1984     if (to_celt)
1985         st->prev_mode = MODE_CELT_ONLY;
1986     else
1987         st->prev_mode = st->mode;
1988     st->prev_channels = st->stream_channels;
1989     st->prev_framesize = frame_size;
1990
1991     st->first = 0;
1992
1993     /* In the unlikely case that the SILK encoder busted its target, tell
1994        the decoder to call the PLC */
1995     if (ec_tell(&enc) > (max_data_bytes-1)*8)
1996     {
1997        if (max_data_bytes < 2)
1998        {
1999           RESTORE_STACK;
2000           return OPUS_BUFFER_TOO_SMALL;
2001        }
2002        data[1] = 0;
2003        ret = 1;
2004        st->rangeFinal = 0;
2005     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
2006     {
2007        /*When in LPC only mode it's perfectly
2008          reasonable to strip off trailing zero bytes as
2009          the required range decoder behavior is to
2010          fill these in. This can't be done when the MDCT
2011          modes are used because the decoder needs to know
2012          the actual length for allocation purposes.*/
2013        while(ret>2&&data[ret]==0)ret--;
2014     }
2015     /* Count ToC and redundancy */
2016     ret += 1+redundancy_bytes;
2017     if (!st->use_vbr)
2018     {
2019        if (opus_packet_pad(data, ret, max_data_bytes) != OPUS_OK)
2020
2021        {
2022           RESTORE_STACK;
2023           return OPUS_INTERNAL_ERROR;
2024        }
2025        ret = max_data_bytes;
2026     }
2027     RESTORE_STACK;
2028     return ret;
2029 }
2030
2031 #ifdef FIXED_POINT
2032
2033 #ifndef DISABLE_FLOAT_API
2034 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int analysis_frame_size,
2035       unsigned char *data, opus_int32 max_data_bytes)
2036 {
2037    int i, ret;
2038    int frame_size;
2039    int delay_compensation;
2040    VARDECL(opus_int16, in);
2041    ALLOC_STACK;
2042
2043    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2044       delay_compensation = 0;
2045    else
2046       delay_compensation = st->delay_compensation;
2047    frame_size = compute_frame_size(pcm, analysis_frame_size,
2048          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2049          delay_compensation, downmix_float, st->analysis.subframe_mem);
2050
2051    ALLOC(in, frame_size*st->channels, opus_int16);
2052
2053    for (i=0;i<frame_size*st->channels;i++)
2054       in[i] = FLOAT2INT16(pcm[i]);
2055    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16,
2056                             pcm, analysis_frame_size, 0, -2, st->channels, downmix_float, 1);
2057    RESTORE_STACK;
2058    return ret;
2059 }
2060 #endif
2061
2062 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int analysis_frame_size,
2063                 unsigned char *data, opus_int32 out_data_bytes)
2064 {
2065    int frame_size;
2066    int delay_compensation;
2067    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2068       delay_compensation = 0;
2069    else
2070       delay_compensation = st->delay_compensation;
2071    frame_size = compute_frame_size(pcm, analysis_frame_size,
2072          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2073          delay_compensation, downmix_int
2074 #ifndef DISABLE_FLOAT_API
2075          , st->analysis.subframe_mem
2076 #endif
2077          );
2078    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 16,
2079                              pcm, analysis_frame_size, 0, -2, st->channels, downmix_int, 0);
2080 }
2081
2082 #else
2083 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int analysis_frame_size,
2084       unsigned char *data, opus_int32 max_data_bytes)
2085 {
2086    int i, ret;
2087    int frame_size;
2088    int delay_compensation;
2089    VARDECL(float, in);
2090    ALLOC_STACK;
2091
2092    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2093       delay_compensation = 0;
2094    else
2095       delay_compensation = st->delay_compensation;
2096    frame_size = compute_frame_size(pcm, analysis_frame_size,
2097          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2098          delay_compensation, downmix_int, st->analysis.subframe_mem);
2099
2100    ALLOC(in, frame_size*st->channels, float);
2101
2102    for (i=0;i<frame_size*st->channels;i++)
2103       in[i] = (1.0f/32768)*pcm[i];
2104    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16,
2105                             pcm, analysis_frame_size, 0, -2, st->channels, downmix_int, 0);
2106    RESTORE_STACK;
2107    return ret;
2108 }
2109 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int analysis_frame_size,
2110                       unsigned char *data, opus_int32 out_data_bytes)
2111 {
2112    int frame_size;
2113    int delay_compensation;
2114    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2115       delay_compensation = 0;
2116    else
2117       delay_compensation = st->delay_compensation;
2118    frame_size = compute_frame_size(pcm, analysis_frame_size,
2119          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2120          delay_compensation, downmix_float, st->analysis.subframe_mem);
2121    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 24,
2122                              pcm, analysis_frame_size, 0, -2, st->channels, downmix_float, 1);
2123 }
2124 #endif
2125
2126
2127 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
2128 {
2129     int ret;
2130     CELTEncoder *celt_enc;
2131     va_list ap;
2132
2133     ret = OPUS_OK;
2134     va_start(ap, request);
2135
2136     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
2137
2138     switch (request)
2139     {
2140         case OPUS_SET_APPLICATION_REQUEST:
2141         {
2142             opus_int32 value = va_arg(ap, opus_int32);
2143             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
2144                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2145                || (!st->first && st->application != value))
2146             {
2147                ret = OPUS_BAD_ARG;
2148                break;
2149             }
2150             st->application = value;
2151         }
2152         break;
2153         case OPUS_GET_APPLICATION_REQUEST:
2154         {
2155             opus_int32 *value = va_arg(ap, opus_int32*);
2156             if (!value)
2157             {
2158                goto bad_arg;
2159             }
2160             *value = st->application;
2161         }
2162         break;
2163         case OPUS_SET_BITRATE_REQUEST:
2164         {
2165             opus_int32 value = va_arg(ap, opus_int32);
2166             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
2167             {
2168                 if (value <= 0)
2169                     goto bad_arg;
2170                 else if (value <= 500)
2171                     value = 500;
2172                 else if (value > (opus_int32)300000*st->channels)
2173                     value = (opus_int32)300000*st->channels;
2174             }
2175             st->user_bitrate_bps = value;
2176         }
2177         break;
2178         case OPUS_GET_BITRATE_REQUEST:
2179         {
2180             opus_int32 *value = va_arg(ap, opus_int32*);
2181             if (!value)
2182             {
2183                goto bad_arg;
2184             }
2185             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
2186         }
2187         break;
2188         case OPUS_SET_FORCE_CHANNELS_REQUEST:
2189         {
2190             opus_int32 value = va_arg(ap, opus_int32);
2191             if((value<1 || value>st->channels) && value != OPUS_AUTO)
2192             {
2193                goto bad_arg;
2194             }
2195             st->force_channels = value;
2196         }
2197         break;
2198         case OPUS_GET_FORCE_CHANNELS_REQUEST:
2199         {
2200             opus_int32 *value = va_arg(ap, opus_int32*);
2201             if (!value)
2202             {
2203                goto bad_arg;
2204             }
2205             *value = st->force_channels;
2206         }
2207         break;
2208         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
2209         {
2210             opus_int32 value = va_arg(ap, opus_int32);
2211             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND)
2212             {
2213                goto bad_arg;
2214             }
2215             st->max_bandwidth = value;
2216             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2217                 st->silk_mode.maxInternalSampleRate = 8000;
2218             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2219                 st->silk_mode.maxInternalSampleRate = 12000;
2220             } else {
2221                 st->silk_mode.maxInternalSampleRate = 16000;
2222             }
2223         }
2224         break;
2225         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
2226         {
2227             opus_int32 *value = va_arg(ap, opus_int32*);
2228             if (!value)
2229             {
2230                goto bad_arg;
2231             }
2232             *value = st->max_bandwidth;
2233         }
2234         break;
2235         case OPUS_SET_BANDWIDTH_REQUEST:
2236         {
2237             opus_int32 value = va_arg(ap, opus_int32);
2238             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
2239             {
2240                goto bad_arg;
2241             }
2242             st->user_bandwidth = value;
2243             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2244                 st->silk_mode.maxInternalSampleRate = 8000;
2245             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2246                 st->silk_mode.maxInternalSampleRate = 12000;
2247             } else {
2248                 st->silk_mode.maxInternalSampleRate = 16000;
2249             }
2250         }
2251         break;
2252         case OPUS_GET_BANDWIDTH_REQUEST:
2253         {
2254             opus_int32 *value = va_arg(ap, opus_int32*);
2255             if (!value)
2256             {
2257                goto bad_arg;
2258             }
2259             *value = st->bandwidth;
2260         }
2261         break;
2262         case OPUS_SET_DTX_REQUEST:
2263         {
2264             opus_int32 value = va_arg(ap, opus_int32);
2265             if(value<0 || value>1)
2266             {
2267                goto bad_arg;
2268             }
2269             st->silk_mode.useDTX = value;
2270         }
2271         break;
2272         case OPUS_GET_DTX_REQUEST:
2273         {
2274             opus_int32 *value = va_arg(ap, opus_int32*);
2275             if (!value)
2276             {
2277                goto bad_arg;
2278             }
2279             *value = st->silk_mode.useDTX;
2280         }
2281         break;
2282         case OPUS_SET_COMPLEXITY_REQUEST:
2283         {
2284             opus_int32 value = va_arg(ap, opus_int32);
2285             if(value<0 || value>10)
2286             {
2287                goto bad_arg;
2288             }
2289             st->silk_mode.complexity = value;
2290             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
2291         }
2292         break;
2293         case OPUS_GET_COMPLEXITY_REQUEST:
2294         {
2295             opus_int32 *value = va_arg(ap, opus_int32*);
2296             if (!value)
2297             {
2298                goto bad_arg;
2299             }
2300             *value = st->silk_mode.complexity;
2301         }
2302         break;
2303         case OPUS_SET_INBAND_FEC_REQUEST:
2304         {
2305             opus_int32 value = va_arg(ap, opus_int32);
2306             if(value<0 || value>1)
2307             {
2308                goto bad_arg;
2309             }
2310             st->silk_mode.useInBandFEC = value;
2311         }
2312         break;
2313         case OPUS_GET_INBAND_FEC_REQUEST:
2314         {
2315             opus_int32 *value = va_arg(ap, opus_int32*);
2316             if (!value)
2317             {
2318                goto bad_arg;
2319             }
2320             *value = st->silk_mode.useInBandFEC;
2321         }
2322         break;
2323         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
2324         {
2325             opus_int32 value = va_arg(ap, opus_int32);
2326             if (value < 0 || value > 100)
2327             {
2328                goto bad_arg;
2329             }
2330             st->silk_mode.packetLossPercentage = value;
2331             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
2332         }
2333         break;
2334         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
2335         {
2336             opus_int32 *value = va_arg(ap, opus_int32*);
2337             if (!value)
2338             {
2339                goto bad_arg;
2340             }
2341             *value = st->silk_mode.packetLossPercentage;
2342         }
2343         break;
2344         case OPUS_SET_VBR_REQUEST:
2345         {
2346             opus_int32 value = va_arg(ap, opus_int32);
2347             if(value<0 || value>1)
2348             {
2349                goto bad_arg;
2350             }
2351             st->use_vbr = value;
2352             st->silk_mode.useCBR = 1-value;
2353         }
2354         break;
2355         case OPUS_GET_VBR_REQUEST:
2356         {
2357             opus_int32 *value = va_arg(ap, opus_int32*);
2358             if (!value)
2359             {
2360                goto bad_arg;
2361             }
2362             *value = st->use_vbr;
2363         }
2364         break;
2365         case OPUS_SET_VOICE_RATIO_REQUEST:
2366         {
2367             opus_int32 value = va_arg(ap, opus_int32);
2368             if (value<-1 || value>100)
2369             {
2370                goto bad_arg;
2371             }
2372             st->voice_ratio = value;
2373         }
2374         break;
2375         case OPUS_GET_VOICE_RATIO_REQUEST:
2376         {
2377             opus_int32 *value = va_arg(ap, opus_int32*);
2378             if (!value)
2379             {
2380                goto bad_arg;
2381             }
2382             *value = st->voice_ratio;
2383         }
2384         break;
2385         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
2386         {
2387             opus_int32 value = va_arg(ap, opus_int32);
2388             if(value<0 || value>1)
2389             {
2390                goto bad_arg;
2391             }
2392             st->vbr_constraint = value;
2393         }
2394         break;
2395         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
2396         {
2397             opus_int32 *value = va_arg(ap, opus_int32*);
2398             if (!value)
2399             {
2400                goto bad_arg;
2401             }
2402             *value = st->vbr_constraint;
2403         }
2404         break;
2405         case OPUS_SET_SIGNAL_REQUEST:
2406         {
2407             opus_int32 value = va_arg(ap, opus_int32);
2408             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
2409             {
2410                goto bad_arg;
2411             }
2412             st->signal_type = value;
2413         }
2414         break;
2415         case OPUS_GET_SIGNAL_REQUEST:
2416         {
2417             opus_int32 *value = va_arg(ap, opus_int32*);
2418             if (!value)
2419             {
2420                goto bad_arg;
2421             }
2422             *value = st->signal_type;
2423         }
2424         break;
2425         case OPUS_GET_LOOKAHEAD_REQUEST:
2426         {
2427             opus_int32 *value = va_arg(ap, opus_int32*);
2428             if (!value)
2429             {
2430                goto bad_arg;
2431             }
2432             *value = st->Fs/400;
2433             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2434                 *value += st->delay_compensation;
2435         }
2436         break;
2437         case OPUS_GET_SAMPLE_RATE_REQUEST:
2438         {
2439             opus_int32 *value = va_arg(ap, opus_int32*);
2440             if (!value)
2441             {
2442                goto bad_arg;
2443             }
2444             *value = st->Fs;
2445         }
2446         break;
2447         case OPUS_GET_FINAL_RANGE_REQUEST:
2448         {
2449             opus_uint32 *value = va_arg(ap, opus_uint32*);
2450             if (!value)
2451             {
2452                goto bad_arg;
2453             }
2454             *value = st->rangeFinal;
2455         }
2456         break;
2457         case OPUS_SET_LSB_DEPTH_REQUEST:
2458         {
2459             opus_int32 value = va_arg(ap, opus_int32);
2460             if (value<8 || value>24)
2461             {
2462                goto bad_arg;
2463             }
2464             st->lsb_depth=value;
2465         }
2466         break;
2467         case OPUS_GET_LSB_DEPTH_REQUEST:
2468         {
2469             opus_int32 *value = va_arg(ap, opus_int32*);
2470             if (!value)
2471             {
2472                goto bad_arg;
2473             }
2474             *value = st->lsb_depth;
2475         }
2476         break;
2477         case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
2478         {
2479             opus_int32 value = va_arg(ap, opus_int32);
2480             if (value != OPUS_FRAMESIZE_ARG   && value != OPUS_FRAMESIZE_2_5_MS &&
2481                 value != OPUS_FRAMESIZE_5_MS  && value != OPUS_FRAMESIZE_10_MS  &&
2482                 value != OPUS_FRAMESIZE_20_MS && value != OPUS_FRAMESIZE_40_MS  &&
2483                 value != OPUS_FRAMESIZE_60_MS && value != OPUS_FRAMESIZE_VARIABLE)
2484             {
2485                goto bad_arg;
2486             }
2487             st->variable_duration = value;
2488             celt_encoder_ctl(celt_enc, OPUS_SET_EXPERT_FRAME_DURATION(value));
2489         }
2490         break;
2491         case OPUS_GET_EXPERT_FRAME_DURATION_REQUEST:
2492         {
2493             opus_int32 *value = va_arg(ap, opus_int32*);
2494             if (!value)
2495             {
2496                goto bad_arg;
2497             }
2498             *value = st->variable_duration;
2499         }
2500         break;
2501         case OPUS_SET_PREDICTION_DISABLED_REQUEST:
2502         {
2503            opus_int32 value = va_arg(ap, opus_int32);
2504            if (value > 1 || value < 0)
2505               goto bad_arg;
2506            st->silk_mode.reducedDependency = value;
2507         }
2508         break;
2509         case OPUS_GET_PREDICTION_DISABLED_REQUEST:
2510         {
2511            opus_int32 *value = va_arg(ap, opus_int32*);
2512            if (!value)
2513               goto bad_arg;
2514            *value = st->silk_mode.reducedDependency;
2515         }
2516         break;
2517         case OPUS_RESET_STATE:
2518         {
2519            void *silk_enc;
2520            silk_EncControlStruct dummy;
2521            char *start;
2522            silk_enc = (char*)st+st->silk_enc_offset;
2523 #ifndef DISABLE_FLOAT_API
2524            tonality_analysis_reset(&st->analysis);
2525 #endif
2526
2527            start = (char*)&st->OPUS_ENCODER_RESET_START;
2528            OPUS_CLEAR(start, sizeof(OpusEncoder) - (start - (char*)st));
2529
2530            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2531            silk_InitEncoder( silk_enc, st->arch, &dummy );
2532            st->stream_channels = st->channels;
2533            st->hybrid_stereo_width_Q14 = 1 << 14;
2534            st->prev_HB_gain = Q15ONE;
2535            st->first = 1;
2536            st->mode = MODE_HYBRID;
2537            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
2538            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
2539         }
2540         break;
2541         case OPUS_SET_FORCE_MODE_REQUEST:
2542         {
2543             opus_int32 value = va_arg(ap, opus_int32);
2544             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
2545             {
2546                goto bad_arg;
2547             }
2548             st->user_forced_mode = value;
2549         }
2550         break;
2551         case OPUS_SET_LFE_REQUEST:
2552         {
2553             opus_int32 value = va_arg(ap, opus_int32);
2554             st->lfe = value;
2555             ret = celt_encoder_ctl(celt_enc, OPUS_SET_LFE(value));
2556         }
2557         break;
2558         case OPUS_SET_ENERGY_MASK_REQUEST:
2559         {
2560             opus_val16 *value = va_arg(ap, opus_val16*);
2561             st->energy_masking = value;
2562             ret = celt_encoder_ctl(celt_enc, OPUS_SET_ENERGY_MASK(value));
2563         }
2564         break;
2565
2566         case CELT_GET_MODE_REQUEST:
2567         {
2568            const CELTMode ** value = va_arg(ap, const CELTMode**);
2569            if (!value)
2570            {
2571               goto bad_arg;
2572            }
2573            ret = celt_encoder_ctl(celt_enc, CELT_GET_MODE(value));
2574         }
2575         break;
2576         default:
2577             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
2578             ret = OPUS_UNIMPLEMENTED;
2579             break;
2580     }
2581     va_end(ap);
2582     return ret;
2583 bad_arg:
2584     va_end(ap);
2585     return OPUS_BAD_ARG;
2586 }
2587
2588 void opus_encoder_destroy(OpusEncoder *st)
2589 {
2590     opus_free(st);
2591 }