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