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