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