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