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