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