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