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