7cff842816e085e513d0a61d488af02b4985ad35
[opus.git] / src / opus_encoder.c
1 /* Copyright (c) 2010-2011 Xiph.Org Foundation, Skype Limited
2    Written by Jean-Marc Valin and Koen Vos */
3 /*
4    Redistribution and use in source and binary forms, with or without
5    modification, are permitted provided that the following conditions
6    are met:
7
8    - Redistributions of source code must retain the above copyright
9    notice, this list of conditions and the following disclaimer.
10
11    - Redistributions in binary form must reproduce the above copyright
12    notice, this list of conditions and the following disclaimer in the
13    documentation and/or other materials provided with the distribution.
14
15    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
18    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
19    OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
23    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
24    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #ifdef HAVE_CONFIG_H
29 #include "config.h"
30 #endif
31
32 #include <stdarg.h>
33 #include "celt.h"
34 #include "entenc.h"
35 #include "modes.h"
36 #include "API.h"
37 #include "stack_alloc.h"
38 #include "float_cast.h"
39 #include "opus.h"
40 #include "arch.h"
41 #include "opus_private.h"
42 #include "os_support.h"
43 #include "analysis.h"
44 #include "mathops.h"
45 #include "tuning_parameters.h"
46 #ifdef FIXED_POINT
47 #include "fixed/structs_FIX.h"
48 #else
49 #include "float/structs_FLP.h"
50 #endif
51
52 #define MAX_ENCODER_BUFFER 480
53
54 struct OpusEncoder {
55     int          celt_enc_offset;
56     int          silk_enc_offset;
57     silk_EncControlStruct silk_mode;
58     int          application;
59     int          channels;
60     int          delay_compensation;
61     int          force_channels;
62     int          signal_type;
63     int          user_bandwidth;
64     int          max_bandwidth;
65     int          user_forced_mode;
66     int          voice_ratio;
67     opus_int32   Fs;
68     int          use_vbr;
69     int          vbr_constraint;
70     int          variable_duration;
71     opus_int32   bitrate_bps;
72     opus_int32   user_bitrate_bps;
73     int          lsb_depth;
74     int          encoder_buffer;
75
76 #define OPUS_ENCODER_RESET_START stream_channels
77     int          stream_channels;
78     opus_int16   hybrid_stereo_width_Q14;
79     opus_int32   variable_HP_smth2_Q15;
80     opus_val16   prev_HB_gain;
81     opus_val32   hp_mem[4];
82     int          mode;
83     int          prev_mode;
84     int          prev_channels;
85     int          prev_framesize;
86     int          bandwidth;
87     int          silk_bw_switch;
88     /* Sampling rate (at the API level) */
89     int          first;
90     opus_val16   delay_buffer[MAX_ENCODER_BUFFER*2];
91 #ifndef FIXED_POINT
92     TonalityAnalysisState analysis;
93     int          detected_bandwidth;
94     int          analysis_offset;
95 #endif
96     opus_uint32  rangeFinal;
97 };
98
99 /* Transition tables for the voice and music. First column is the
100    middle (memoriless) threshold. The second column is the hysteresis
101    (difference with the middle) */
102 static const opus_int32 mono_voice_bandwidth_thresholds[8] = {
103         11000, 1000, /* NB<->MB */
104         14000, 1000, /* MB<->WB */
105         17000, 1000, /* WB<->SWB */
106         20000, 1000, /* SWB<->FB */
107 };
108 static const opus_int32 mono_music_bandwidth_thresholds[8] = {
109         14000, 1000, /* MB not allowed */
110         18000, 2000, /* MB<->WB */
111         24000, 2000, /* WB<->SWB */
112         33000, 2000, /* SWB<->FB */
113 };
114 static const opus_int32 stereo_voice_bandwidth_thresholds[8] = {
115         11000, 1000, /* NB<->MB */
116         14000, 1000, /* MB<->WB */
117         21000, 2000, /* WB<->SWB */
118         32000, 2000, /* SWB<->FB */
119 };
120 static const opus_int32 stereo_music_bandwidth_thresholds[8] = {
121         14000, 1000, /* MB not allowed */
122         18000, 2000, /* MB<->WB */
123         24000, 2000, /* WB<->SWB */
124         48000, 2000, /* SWB<->FB */
125 };
126 /* Threshold bit-rates for switching between mono and stereo */
127 static const opus_int32 stereo_voice_threshold = 26000;
128 static const opus_int32 stereo_music_threshold = 36000;
129
130 /* Threshold bit-rate for switching between SILK/hybrid and CELT-only */
131 static const opus_int32 mode_thresholds[2][2] = {
132       /* voice */ /* music */
133       {  48000,      24000}, /* mono */
134       {  48000,      24000}, /* stereo */
135 };
136
137 int opus_encoder_get_size(int channels)
138 {
139     int silkEncSizeBytes, celtEncSizeBytes;
140     int ret;
141     if (channels<1 || channels > 2)
142         return 0;
143     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
144     if (ret)
145         return 0;
146     silkEncSizeBytes = align(silkEncSizeBytes);
147     celtEncSizeBytes = celt_encoder_get_size(channels);
148     return align(sizeof(OpusEncoder))+silkEncSizeBytes+celtEncSizeBytes;
149 }
150
151 int opus_encoder_init(OpusEncoder* st, opus_int32 Fs, int channels, int application)
152 {
153     void *silk_enc;
154     CELTEncoder *celt_enc;
155     int err;
156     int ret, silkEncSizeBytes;
157
158    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
159         (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
160         && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
161         return OPUS_BAD_ARG;
162
163     OPUS_CLEAR((char*)st, opus_encoder_get_size(channels));
164     /* Create SILK encoder */
165     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
166     if (ret)
167         return OPUS_BAD_ARG;
168     silkEncSizeBytes = align(silkEncSizeBytes);
169     st->silk_enc_offset = align(sizeof(OpusEncoder));
170     st->celt_enc_offset = st->silk_enc_offset+silkEncSizeBytes;
171     silk_enc = (char*)st+st->silk_enc_offset;
172     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
173
174     st->stream_channels = st->channels = channels;
175
176     st->Fs = Fs;
177
178     ret = silk_InitEncoder( silk_enc, &st->silk_mode );
179     if(ret)return OPUS_INTERNAL_ERROR;
180
181     /* default SILK parameters */
182     st->silk_mode.nChannelsAPI              = channels;
183     st->silk_mode.nChannelsInternal         = channels;
184     st->silk_mode.API_sampleRate            = st->Fs;
185     st->silk_mode.maxInternalSampleRate     = 16000;
186     st->silk_mode.minInternalSampleRate     = 8000;
187     st->silk_mode.desiredInternalSampleRate = 16000;
188     st->silk_mode.payloadSize_ms            = 20;
189     st->silk_mode.bitRate                   = 25000;
190     st->silk_mode.packetLossPercentage      = 0;
191     st->silk_mode.complexity                = 10;
192     st->silk_mode.useInBandFEC              = 0;
193     st->silk_mode.useDTX                    = 0;
194     st->silk_mode.useCBR                    = 0;
195
196     /* Create CELT encoder */
197     /* Initialize CELT encoder */
198     err = celt_encoder_init(celt_enc, Fs, channels);
199     if(err!=OPUS_OK)return OPUS_INTERNAL_ERROR;
200
201     celt_encoder_ctl(celt_enc, CELT_SET_SIGNALLING(0));
202     celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(10));
203
204     st->use_vbr = 1;
205     /* Makes constrained VBR the default (safer for real-time use) */
206     st->vbr_constraint = 1;
207     st->user_bitrate_bps = OPUS_AUTO;
208     st->bitrate_bps = 3000+Fs*channels;
209     st->application = application;
210     st->signal_type = OPUS_AUTO;
211     st->user_bandwidth = OPUS_AUTO;
212     st->max_bandwidth = OPUS_BANDWIDTH_FULLBAND;
213     st->force_channels = OPUS_AUTO;
214     st->user_forced_mode = OPUS_AUTO;
215     st->voice_ratio = -1;
216     st->encoder_buffer = st->Fs/100;
217     st->lsb_depth = 24;
218     st->variable_duration = OPUS_FRAMESIZE_ARG;
219
220     /* Delay compensation of 4 ms (2.5 ms for SILK's extra look-ahead 
221        + 1.5 ms for SILK resamplers and stereo prediction) */
222     st->delay_compensation = st->Fs/250;
223
224     st->hybrid_stereo_width_Q14 = 1 << 14;
225     st->prev_HB_gain = Q15ONE;
226     st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
227     st->first = 1;
228     st->mode = MODE_HYBRID;
229     st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
230
231     return OPUS_OK;
232 }
233
234 static int pad_frame(unsigned char *data, opus_int32 len, opus_int32 new_len)
235 {
236    if (len == new_len)
237       return 0;
238    if (len > new_len)
239       return 1;
240
241    if ((data[0]&0x3)==0)
242    {
243       int i;
244       int padding, nb_255s;
245
246       padding = new_len - len;
247       if (padding >= 2)
248       {
249          nb_255s = (padding-2)/255;
250
251          for (i=len-1;i>=1;i--)
252             data[i+nb_255s+2] = data[i];
253          data[0] |= 0x3;
254          data[1] = 0x41;
255          for (i=0;i<nb_255s;i++)
256             data[i+2] = 255;
257          data[nb_255s+2] = padding-255*nb_255s-2;
258          for (i=len+3+nb_255s;i<new_len;i++)
259             data[i] = 0;
260       } else {
261          for (i=len-1;i>=1;i--)
262             data[i+1] = data[i];
263          data[0] |= 0x3;
264          data[1] = 1;
265       }
266       return 0;
267    } else {
268       return 1;
269    }
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;
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)
345 {
346    opus_int32 B_Q28[ 3 ], A_Q28[ 2 ];
347    opus_int32 Fc_Q19, r_Q28, r_Q22;
348
349    silk_assert( cutoff_Hz <= silk_int32_MAX / SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ) );
350    Fc_Q19 = silk_DIV32_16( silk_SMULBB( SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ), cutoff_Hz ), Fs/1000 );
351    silk_assert( Fc_Q19 > 0 && Fc_Q19 < 32768 );
352
353    r_Q28 = SILK_FIX_CONST( 1.0, 28 ) - silk_MUL( SILK_FIX_CONST( 0.92, 9 ), Fc_Q19 );
354
355    /* b = r * [ 1; -2; 1 ]; */
356    /* a = [ 1; -2 * r * ( 1 - 0.5 * Fc^2 ); r^2 ]; */
357    B_Q28[ 0 ] = r_Q28;
358    B_Q28[ 1 ] = silk_LSHIFT( -r_Q28, 1 );
359    B_Q28[ 2 ] = r_Q28;
360
361    /* -r * ( 2 - Fc * Fc ); */
362    r_Q22  = silk_RSHIFT( r_Q28, 6 );
363    A_Q28[ 0 ] = silk_SMULWW( r_Q22, silk_SMULWW( Fc_Q19, Fc_Q19 ) - SILK_FIX_CONST( 2.0,  22 ) );
364    A_Q28[ 1 ] = silk_SMULWW( r_Q22, r_Q22 );
365
366 #ifdef FIXED_POINT
367    silk_biquad_alt( in, B_Q28, A_Q28, hp_mem, out, len, channels );
368    if( channels == 2 ) {
369        silk_biquad_alt( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
370    }
371 #else
372    silk_biquad_float( in, B_Q28, A_Q28, hp_mem, out, len, channels );
373    if( channels == 2 ) {
374        silk_biquad_float( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
375    }
376 #endif
377 }
378
379 #ifdef FIXED_POINT
380 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)
381 {
382    int c, i;
383    int shift;
384
385    /* Approximates -round(log2(4.*cutoff_Hz/Fs)) */
386    shift=celt_ilog2(Fs/(cutoff_Hz*3));
387    for (c=0;c<channels;c++)
388    {
389       for (i=0;i<len;i++)
390       {
391          opus_val32 x, tmp, y;
392          x = SHL32(EXTEND32(in[channels*i+c]), 15);
393          /* First stage */
394          tmp = x-hp_mem[2*c];
395          hp_mem[2*c] = hp_mem[2*c] + PSHR32(x - hp_mem[2*c], shift);
396          /* Second stage */
397          y = tmp - hp_mem[2*c+1];
398          hp_mem[2*c+1] = hp_mem[2*c+1] + PSHR32(tmp - hp_mem[2*c+1], shift);
399          out[channels*i+c] = EXTRACT16(SATURATE(PSHR32(y, 15), 32767));
400       }
401    }
402 }
403
404 #else
405 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)
406 {
407    int c, i;
408    float coef;
409
410    coef = 4.0f*cutoff_Hz/Fs;
411    for (c=0;c<channels;c++)
412    {
413       for (i=0;i<len;i++)
414       {
415          opus_val32 x, tmp, y;
416          x = in[channels*i+c];
417          /* First stage */
418          tmp = x-hp_mem[2*c];
419          hp_mem[2*c] = hp_mem[2*c] + coef*(x - hp_mem[2*c]);
420          /* Second stage */
421          y = tmp - hp_mem[2*c+1];
422          hp_mem[2*c+1] = hp_mem[2*c+1] + coef*(tmp - hp_mem[2*c+1]);
423          out[channels*i+c] = y;
424       }
425    }
426 }
427 #endif
428
429 static void stereo_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2,
430         int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
431 {
432     int i;
433     int overlap;
434     int inc;
435     inc = 48000/Fs;
436     overlap=overlap48/inc;
437     g1 = Q15ONE-g1;
438     g2 = Q15ONE-g2;
439     for (i=0;i<overlap;i++)
440     {
441        opus_val32 diff;
442        opus_val16 g, w;
443        w = MULT16_16_Q15(window[i*inc], window[i*inc]);
444        g = SHR32(MAC16_16(MULT16_16(w,g2),
445              Q15ONE-w, g1), 15);
446        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
447        diff = MULT16_16_Q15(g, diff);
448        out[i*channels] = out[i*channels] - diff;
449        out[i*channels+1] = out[i*channels+1] + diff;
450     }
451     for (;i<frame_size;i++)
452     {
453        opus_val32 diff;
454        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
455        diff = MULT16_16_Q15(g2, diff);
456        out[i*channels] = out[i*channels] - diff;
457        out[i*channels+1] = out[i*channels+1] + diff;
458     }
459 }
460
461 static void gain_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2,
462         int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
463 {
464     int i;
465     int inc;
466     int overlap;
467     int c;
468     inc = 48000/Fs;
469     overlap=overlap48/inc;
470     if (channels==1)
471     {
472        for (i=0;i<overlap;i++)
473        {
474           opus_val16 g, w;
475           w = MULT16_16_Q15(window[i*inc], window[i*inc]);
476           g = SHR32(MAC16_16(MULT16_16(w,g2),
477                 Q15ONE-w, g1), 15);
478           out[i] = MULT16_16_Q15(g, in[i]);
479        }
480     } else {
481        for (i=0;i<overlap;i++)
482        {
483           opus_val16 g, w;
484           w = MULT16_16_Q15(window[i*inc], window[i*inc]);
485           g = SHR32(MAC16_16(MULT16_16(w,g2),
486                 Q15ONE-w, g1), 15);
487           out[i*2] = MULT16_16_Q15(g, in[i*2]);
488           out[i*2+1] = MULT16_16_Q15(g, in[i*2+1]);
489        }
490     }
491     c=0;do {
492        for (i=overlap;i<frame_size;i++)
493        {
494           out[i*channels+c] = MULT16_16_Q15(g2, in[i*channels+c]);
495        }
496     }
497     while (++c<channels);
498 }
499
500 OpusEncoder *opus_encoder_create(opus_int32 Fs, int channels, int application, int *error)
501 {
502    int ret;
503    OpusEncoder *st;
504    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
505        (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
506        && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
507    {
508       if (error)
509          *error = OPUS_BAD_ARG;
510       return NULL;
511    }
512    st = (OpusEncoder *)opus_alloc(opus_encoder_get_size(channels));
513    if (st == NULL)
514    {
515       if (error)
516          *error = OPUS_ALLOC_FAIL;
517       return NULL;
518    }
519    ret = opus_encoder_init(st, Fs, channels, application);
520    if (error)
521       *error = ret;
522    if (ret != OPUS_OK)
523    {
524       opus_free(st);
525       st = NULL;
526    }
527    return st;
528 }
529
530 static opus_int32 user_bitrate_to_bitrate(OpusEncoder *st, int frame_size, int max_data_bytes)
531 {
532   if(!frame_size)frame_size=st->Fs/400;
533   if (st->user_bitrate_bps==OPUS_AUTO)
534     return 60*st->Fs/frame_size + st->Fs*st->channels;
535   else if (st->user_bitrate_bps==OPUS_BITRATE_MAX)
536     return max_data_bytes*8*st->Fs/frame_size;
537   else
538     return st->user_bitrate_bps;
539 }
540
541 #ifndef FIXED_POINT
542 /* Don't use more than 60 ms for the frame size analysis */
543 #define MAX_DYNAMIC_FRAMESIZE 24
544 /* Estimates how much the bitrate will be boosted based on the sub-frame energy */
545 static float transient_boost(const float *E, const float *E_1, int LM, int maxM)
546 {
547    int i;
548    int M;
549    float sumE=0, sumE_1=0;
550    float metric;
551
552    M = IMIN(maxM, (1<<LM)+1);
553    for (i=0;i<M;i++)
554    {
555       sumE += E[i];
556       sumE_1 += E_1[i];
557    }
558    metric = sumE*sumE_1/(M*M);
559    /*if (LM==3)
560       printf("%f\n", metric);*/
561    /*return metric>10 ? 1 : 0;*/
562    /*return MAX16(0,1-exp(-.25*(metric-2.)));*/
563    return MIN16(1,sqrt(MAX16(0,.05*(metric-2))));
564 }
565
566 /* Viterbi decoding trying to find the best frame size combination using look-ahead
567
568    State numbering:
569     0: unused
570     1:  2.5 ms
571     2:  5 ms (#1)
572     3:  5 ms (#2)
573     4: 10 ms (#1)
574     5: 10 ms (#2)
575     6: 10 ms (#3)
576     7: 10 ms (#4)
577     8: 20 ms (#1)
578     9: 20 ms (#2)
579    10: 20 ms (#3)
580    11: 20 ms (#4)
581    12: 20 ms (#5)
582    13: 20 ms (#6)
583    14: 20 ms (#7)
584    15: 20 ms (#8)
585 */
586 static int transient_viterbi(const float *E, const float *E_1, int N, int frame_cost, int rate)
587 {
588    int i;
589    float cost[MAX_DYNAMIC_FRAMESIZE][16];
590    int states[MAX_DYNAMIC_FRAMESIZE][16];
591    float best_cost;
592    int best_state;
593
594    /* Makes variable framesize less aggressive at lower bitrates, but I can't
595       find any valid theretical justification for this (other than it seems
596       to help) */
597    frame_cost *= 720/rate;
598    for (i=0;i<16;i++)
599    {
600       /* Impossible state */
601       states[0][i] = -1;
602       cost[0][i] = 1e10;
603    }
604    for (i=0;i<4;i++)
605    {
606       cost[0][1<<i] = frame_cost + rate*(1<<i)*transient_boost(E, E_1, i, N+1);
607       states[0][1<<i] = i;
608    }
609    for (i=1;i<N;i++)
610    {
611       int j;
612
613       /* Follow continuations */
614       for (j=2;j<16;j++)
615       {
616          cost[i][j] = cost[i-1][j-1];
617          states[i][j] = j-1;
618       }
619
620       /* New frames */
621       for(j=0;j<4;j++)
622       {
623          int k;
624          float min_cost;
625          float curr_cost;
626          states[i][1<<j] = 1;
627          min_cost = cost[i-1][1];
628          for(k=1;k<4;k++)
629          {
630             float tmp = cost[i-1][(1<<(k+1))-1];
631             if (tmp < min_cost)
632             {
633                states[i][1<<j] = (1<<(k+1))-1;
634                min_cost = tmp;
635             }
636          }
637          curr_cost = frame_cost+rate*(1<<j)*transient_boost(E+i, E_1+i, j, N-i+1);
638          cost[i][1<<j] = min_cost;
639          /* If part of the frame is outside the analysis window, only count part of the cost */
640          if (N-i < (1<<j))
641             cost[i][1<<j] += curr_cost*(float)(N-i)/(1<<j);
642          else
643             cost[i][1<<j] += curr_cost;
644       }
645    }
646
647    best_state=1;
648    best_cost = cost[N-1][1];
649    /* Find best end state (doesn't force a frame to end at N-1) */
650    for (i=2;i<16;i++)
651    {
652       if (cost[N-1][i]<best_cost)
653       {
654          best_cost = cost[N-1][i];
655          best_state = i;
656       }
657    }
658
659    /* Follow transitions back */
660    for (i=N-1;i>=0;i--)
661    {
662       /*printf("%d ", best_state);*/
663       best_state = states[i][best_state];
664    }
665    /*printf("%d\n", best_state);*/
666    return best_state;
667 }
668
669 void downmix_float(const void *_x, float *sub, int subframe, int offset, int C)
670 {
671    const float *x;
672    int c, j;
673    x = (const float *)_x;
674    for (j=0;j<subframe;j++)
675       sub[j] = x[(j+offset)*C];
676    for (c=1;c<C;c++)
677       for (j=0;j<subframe;j++)
678          sub[j] += x[(j+offset)*C+c];
679 }
680
681 void downmix_int(const void *_x, float *sub, int subframe, int offset, int C)
682 {
683    const opus_int16 *x;
684    int c, j;
685    x = (const opus_int16 *)_x;
686    for (j=0;j<subframe;j++)
687       sub[j] = x[(j+offset)*C];
688    for (c=1;c<C;c++)
689       for (j=0;j<subframe;j++)
690          sub[j] += x[(j+offset)*C+c];
691 }
692
693 int optimize_framesize(const opus_val16 *x, int len, int C, opus_int32 Fs,
694                 int bitrate, opus_val16 tonality, opus_val32 *mem, int buffering,
695                 downmix_func downmix)
696 {
697    int N;
698    int i;
699    float e[MAX_DYNAMIC_FRAMESIZE+4];
700    float e_1[MAX_DYNAMIC_FRAMESIZE+3];
701    float memx;
702    int bestLM=0;
703    int subframe;
704    int pos;
705    VARDECL(opus_val16, sub);
706
707    subframe = Fs/400;
708    ALLOC(sub, subframe, opus_val16);
709    e[0]=mem[0];
710    e_1[0]=1./(EPSILON+mem[0]);
711    if (buffering)
712    {
713       /* Consider the CELT delay when not in restricted-lowdelay */
714       /* We assume the buffering is between 2.5 and 5 ms */
715       int offset = 2*subframe - buffering;
716       celt_assert(offset>=0 && offset <= subframe);
717       x += C*offset;
718       len -= offset;
719       e[1]=mem[1];
720       e_1[1]=1./(EPSILON+mem[1]);
721       e[2]=mem[2];
722       e_1[2]=1./(EPSILON+mem[2]);
723       pos = 3;
724    } else {
725       pos=1;
726    }
727    N=IMIN(len/subframe, MAX_DYNAMIC_FRAMESIZE);
728    memx = x[0];
729    for (i=0;i<N;i++)
730    {
731       float tmp;
732       float tmpx;
733       int j;
734       tmp=EPSILON;
735
736       downmix(x, sub, subframe, i*subframe, C);
737       if (i==0)
738          memx = sub[0];
739       for (j=0;j<subframe;j++)
740       {
741          tmpx = sub[j];
742          tmp += (tmpx-memx)*(tmpx-memx);
743          memx = tmpx;
744       }
745       e[i+pos] = tmp;
746       e_1[i+pos] = 1.f/tmp;
747    }
748    /* Hack to get 20 ms working with APPLICATION_AUDIO
749       The real problem is that the corresponding memory needs to use 1.5 ms
750       from this frame and 1 ms from the next frame */
751    e[i+pos] = e[i+pos-1];
752    if (buffering)
753       N=IMIN(MAX_DYNAMIC_FRAMESIZE, N+2);
754    bestLM = transient_viterbi(e, e_1, N, (1.f+.5*tonality)*(40*C+40), bitrate/400);
755    mem[0] = e[1<<bestLM];
756    if (buffering)
757    {
758       mem[1] = e[(1<<bestLM)+1];
759       mem[2] = e[(1<<bestLM)+2];
760    }
761    return bestLM;
762 }
763
764 #endif
765
766 opus_int32 frame_size_select(opus_int32 frame_size, int variable_duration, opus_int32 Fs)
767 {
768    int new_size;
769    if (frame_size<Fs/400)
770       return -1;
771    if (variable_duration == OPUS_FRAMESIZE_ARG)
772       new_size = frame_size;
773    else if (variable_duration == OPUS_FRAMESIZE_VARIABLE)
774       new_size = Fs/50;
775    else if (variable_duration >= OPUS_FRAMESIZE_2_5_MS && variable_duration <= OPUS_FRAMESIZE_60_MS)
776       new_size = IMIN(3*Fs/50, (Fs/400)<<(variable_duration-OPUS_FRAMESIZE_2_5_MS));
777    else
778       return -1;
779    if (new_size>frame_size)
780       return -1;
781    if (400*new_size!=Fs && 200*new_size!=Fs && 100*new_size!=Fs &&
782             50*new_size!=Fs && 25*new_size!=Fs && 50*new_size!=3*Fs)
783       return -1;
784    return new_size;
785 }
786
787 opus_int32 opus_encode_native(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
788                 unsigned char *data, opus_int32 out_data_bytes, int lsb_depth
789 #ifndef FIXED_POINT
790                 , AnalysisInfo *analysis_info
791 #endif
792                 )
793 {
794     void *silk_enc;
795     CELTEncoder *celt_enc;
796     int i;
797     int ret=0;
798     opus_int32 nBytes;
799     ec_enc enc;
800     int bytes_target;
801     int prefill=0;
802     int start_band = 0;
803     int redundancy = 0;
804     int redundancy_bytes = 0; /* Number of bytes to use for redundancy frame */
805     int celt_to_silk = 0;
806     VARDECL(opus_val16, pcm_buf);
807     int nb_compr_bytes;
808     int to_celt = 0;
809     opus_uint32 redundant_rng = 0;
810     int cutoff_Hz, hp_freq_smth1;
811     int voice_est; /* Probability of voice in Q7 */
812     opus_int32 equiv_rate;
813     int delay_compensation;
814     int frame_rate;
815     opus_int32 max_rate; /* Max bitrate we're allowed to use */
816     int curr_bandwidth;
817     opus_val16 HB_gain;
818     opus_int32 max_data_bytes; /* Max number of bytes we're allowed to use */
819     int total_buffer;
820     VARDECL(opus_val16, tmp_prefill);
821
822     ALLOC_STACK;
823
824     max_data_bytes = IMIN(1276, out_data_bytes);
825
826     st->rangeFinal = 0;
827     if ((!st->variable_duration && 400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
828          50*frame_size != st->Fs &&  25*frame_size != st->Fs &&  50*frame_size != 3*st->Fs)
829          || (400*frame_size < st->Fs)
830          || max_data_bytes<=0
831          )
832     {
833        RESTORE_STACK;
834        return OPUS_BAD_ARG;
835     }
836     silk_enc = (char*)st+st->silk_enc_offset;
837     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
838     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
839        delay_compensation = 0;
840     else
841        delay_compensation = st->delay_compensation;
842
843     lsb_depth = IMIN(lsb_depth, st->lsb_depth);
844
845     st->voice_ratio = -1;
846
847 #ifndef FIXED_POINT
848     st->detected_bandwidth = 0;
849     if (analysis_info->valid)
850     {
851        if (st->signal_type == OPUS_AUTO)
852           st->voice_ratio = (int)floor(.5+100*(1-analysis_info->music_prob));
853        st->detected_bandwidth = analysis_info->opus_bandwidth;
854     }
855 #endif
856
857     total_buffer = delay_compensation;
858     st->bitrate_bps = user_bitrate_to_bitrate(st, frame_size, max_data_bytes);
859
860     frame_rate = st->Fs/frame_size;
861     if (max_data_bytes<3 || st->bitrate_bps < 3*frame_rate*8
862        || (frame_rate<50 && (max_data_bytes*frame_rate<300 || st->bitrate_bps < 2400)))
863     {
864        /*If the space is too low to do something useful, emit 'PLC' frames.*/
865        int tocmode = st->mode;
866        int bw = st->bandwidth == 0 ? OPUS_BANDWIDTH_NARROWBAND : st->bandwidth;
867        if (tocmode==0)
868           tocmode = MODE_SILK_ONLY;
869        if (frame_rate>100)
870           tocmode = MODE_CELT_ONLY;
871        if (frame_rate < 50)
872           tocmode = MODE_SILK_ONLY;
873        if(tocmode==MODE_SILK_ONLY&&bw>OPUS_BANDWIDTH_WIDEBAND)
874           bw=OPUS_BANDWIDTH_WIDEBAND;
875        else if (tocmode==MODE_CELT_ONLY&&bw==OPUS_BANDWIDTH_MEDIUMBAND)
876           bw=OPUS_BANDWIDTH_NARROWBAND;
877        else if (bw<=OPUS_BANDWIDTH_SUPERWIDEBAND)
878           bw=OPUS_BANDWIDTH_SUPERWIDEBAND;
879        data[0] = gen_toc(tocmode, frame_rate, bw, st->stream_channels);
880        RESTORE_STACK;
881        return 1;
882     }
883     if (!st->use_vbr)
884     {
885        int cbrBytes;
886        cbrBytes = IMIN( (st->bitrate_bps + 4*frame_rate)/(8*frame_rate) , max_data_bytes);
887        st->bitrate_bps = cbrBytes * (8*frame_rate);
888        max_data_bytes = cbrBytes;
889     }
890     max_rate = frame_rate*max_data_bytes*8;
891
892     /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */
893     equiv_rate = st->bitrate_bps - 60*(st->Fs/frame_size - 50);
894
895     if (st->signal_type == OPUS_SIGNAL_VOICE)
896        voice_est = 127;
897     else if (st->signal_type == OPUS_SIGNAL_MUSIC)
898        voice_est = 0;
899     else if (st->voice_ratio >= 0)
900        voice_est = st->voice_ratio*327>>8;
901     else if (st->application == OPUS_APPLICATION_VOIP)
902        voice_est = 115;
903     else
904        voice_est = 48;
905
906     if (st->force_channels!=OPUS_AUTO && st->channels == 2)
907     {
908         st->stream_channels = st->force_channels;
909     } else {
910 #ifdef FUZZING
911        /* Random mono/stereo decision */
912        if (st->channels == 2 && (rand()&0x1F)==0)
913           st->stream_channels = 3-st->stream_channels;
914 #else
915        /* Rate-dependent mono-stereo decision */
916        if (st->channels == 2)
917        {
918           opus_int32 stereo_threshold;
919           stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14);
920           if (st->stream_channels == 2)
921              stereo_threshold -= 4000;
922           else
923              stereo_threshold += 4000;
924           st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1;
925        } else {
926           st->stream_channels = st->channels;
927        }
928 #endif
929     }
930
931     /* Mode selection depending on application and signal type */
932     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
933     {
934        st->mode = MODE_CELT_ONLY;
935     } else if (st->user_forced_mode == OPUS_AUTO)
936     {
937 #ifdef FUZZING
938        /* Random mode switching */
939        if ((rand()&0xF)==0)
940        {
941           if ((rand()&0x1)==0)
942              st->mode = MODE_CELT_ONLY;
943           else
944              st->mode = MODE_SILK_ONLY;
945        } else {
946           if (st->prev_mode==MODE_CELT_ONLY)
947              st->mode = MODE_CELT_ONLY;
948           else
949              st->mode = MODE_SILK_ONLY;
950        }
951 #else
952        int chan;
953        opus_int32 mode_voice, mode_music;
954        opus_int32 threshold;
955
956        chan = (st->channels==2) && st->force_channels!=1;
957        mode_voice = mode_thresholds[chan][0];
958        mode_music = mode_thresholds[chan][1];
959        threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14);
960
961        /* Hysteresis */
962        if (st->prev_mode == MODE_CELT_ONLY)
963            threshold -= 4000;
964        else if (st->prev_mode>0)
965            threshold += 4000;
966
967        st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY;
968
969        /* When FEC is enabled and there's enough packet loss, use SILK */
970        if (st->silk_mode.useInBandFEC && st->silk_mode.packetLossPercentage > (128-voice_est)>>4)
971           st->mode = MODE_SILK_ONLY;
972        /* When encoding voice and DTX is enabled, set the encoder to SILK mode (at least for now) */
973        if (st->silk_mode.useDTX && voice_est > 100)
974           st->mode = MODE_SILK_ONLY;
975 #endif
976     } else {
977        st->mode = st->user_forced_mode;
978     }
979
980     /* Override the chosen mode to make sure we meet the requested frame size */
981     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
982        st->mode = MODE_CELT_ONLY;
983
984     if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0
985           && st->mode != MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)
986     {
987        /* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */
988        st->silk_mode.toMono = 1;
989        st->stream_channels = 2;
990     } else {
991        st->silk_mode.toMono = 0;
992     }
993
994     if (st->prev_mode > 0 &&
995         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
996     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
997     {
998         redundancy = 1;
999         celt_to_silk = (st->mode != MODE_CELT_ONLY);
1000         if (!celt_to_silk)
1001         {
1002             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
1003             if (frame_size >= st->Fs/100)
1004             {
1005                 st->mode = st->prev_mode;
1006                 to_celt = 1;
1007             } else {
1008                 redundancy=0;
1009             }
1010         }
1011     }
1012     /* For the first frame at a new SILK bandwidth */
1013     if (st->silk_bw_switch)
1014     {
1015        redundancy = 1;
1016        celt_to_silk = 1;
1017        st->silk_bw_switch = 0;
1018     }
1019
1020     if (redundancy)
1021     {
1022        /* Fair share of the max size allowed */
1023        redundancy_bytes = IMIN(257, max_data_bytes*(opus_int32)(st->Fs/200)/(frame_size+st->Fs/200));
1024        /* For VBR, target the actual bitrate (subject to the limit above) */
1025        if (st->use_vbr)
1026           redundancy_bytes = IMIN(redundancy_bytes, st->bitrate_bps/1600);
1027     }
1028
1029     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
1030     {
1031         silk_EncControlStruct dummy;
1032         silk_InitEncoder( silk_enc, &dummy);
1033         prefill=1;
1034     }
1035
1036     /* Automatic (rate-dependent) bandwidth selection */
1037     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
1038     {
1039         const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds;
1040         opus_int32 bandwidth_thresholds[8];
1041         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
1042         opus_int32 equiv_rate2;
1043
1044         equiv_rate2 = equiv_rate;
1045         if (st->mode != MODE_CELT_ONLY)
1046         {
1047            /* Adjust the threshold +/- 10% depending on complexity */
1048            equiv_rate2 = equiv_rate2 * (45+st->silk_mode.complexity)/50;
1049            /* CBR is less efficient by ~1 kb/s */
1050            if (!st->use_vbr)
1051               equiv_rate2 -= 1000;
1052         }
1053         if (st->channels==2 && st->force_channels!=1)
1054         {
1055            voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds;
1056            music_bandwidth_thresholds = stereo_music_bandwidth_thresholds;
1057         } else {
1058            voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds;
1059            music_bandwidth_thresholds = mono_music_bandwidth_thresholds;
1060         }
1061         /* Interpolate bandwidth thresholds depending on voice estimation */
1062         for (i=0;i<8;i++)
1063         {
1064            bandwidth_thresholds[i] = music_bandwidth_thresholds[i]
1065                     + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14);
1066         }
1067         do {
1068             int threshold, hysteresis;
1069             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
1070             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
1071             if (!st->first)
1072             {
1073                 if (st->bandwidth >= bandwidth)
1074                     threshold -= hysteresis;
1075                 else
1076                     threshold += hysteresis;
1077             }
1078             if (equiv_rate2 >= threshold)
1079                 break;
1080         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
1081         st->bandwidth = bandwidth;
1082         /* Prevents any transition to SWB/FB until the SILK layer has fully
1083            switched to WB mode and turned the variable LP filter off */
1084         if (!st->first && st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1085             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1086     }
1087
1088     if (st->bandwidth>st->max_bandwidth)
1089        st->bandwidth = st->max_bandwidth;
1090
1091     if (st->user_bandwidth != OPUS_AUTO)
1092         st->bandwidth = st->user_bandwidth;
1093
1094     /* This prevents us from using hybrid at unsafe CBR/max rates */
1095     if (st->mode != MODE_CELT_ONLY && max_rate < 15000)
1096     {
1097        st->bandwidth = IMIN(st->bandwidth, OPUS_BANDWIDTH_WIDEBAND);
1098     }
1099
1100     /* Prevents Opus from wasting bits on frequencies that are above
1101        the Nyquist rate of the input signal */
1102     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
1103         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1104     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1105         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1106     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
1107         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1108     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
1109         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1110 #ifndef FIXED_POINT
1111     if (st->detected_bandwidth && st->user_bandwidth == OPUS_AUTO)
1112     {
1113        st->bandwidth = IMIN(st->bandwidth, st->detected_bandwidth);
1114     }
1115 #endif
1116     celt_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(lsb_depth));
1117
1118     /* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */
1119     if (max_data_bytes < (frame_rate > 50 ? 12000 : 8000)*frame_size / (st->Fs * 8))
1120        st->mode = MODE_CELT_ONLY;
1121
1122     /* CELT mode doesn't support mediumband, use wideband instead */
1123     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1124         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1125
1126     /* Can't support higher than wideband for >20 ms frames */
1127     if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND))
1128     {
1129        VARDECL(unsigned char, tmp_data);
1130        int nb_frames;
1131        int bak_mode, bak_bandwidth, bak_channels, bak_to_mono;
1132        OpusRepacketizer rp;
1133        opus_int32 bytes_per_frame;
1134
1135
1136        nb_frames = frame_size > st->Fs/25 ? 3 : 2;
1137        bytes_per_frame = IMIN(1276,(out_data_bytes-3)/nb_frames);
1138
1139        ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char);
1140
1141        opus_repacketizer_init(&rp);
1142
1143        bak_mode = st->user_forced_mode;
1144        bak_bandwidth = st->user_bandwidth;
1145        bak_channels = st->force_channels;
1146
1147        st->user_forced_mode = st->mode;
1148        st->user_bandwidth = st->bandwidth;
1149        st->force_channels = st->stream_channels;
1150        bak_to_mono = st->silk_mode.toMono;
1151
1152        if (bak_to_mono)
1153           st->force_channels = 1;
1154        else
1155           st->prev_channels = st->stream_channels;
1156        for (i=0;i<nb_frames;i++)
1157        {
1158           int tmp_len;
1159           st->silk_mode.toMono = 0;
1160           /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
1161           if (to_celt && i==nb_frames-1)
1162              st->user_forced_mode = MODE_CELT_ONLY;
1163           tmp_len = opus_encode_native(st, pcm+i*(st->channels*st->Fs/50), st->Fs/50, tmp_data+i*bytes_per_frame, bytes_per_frame, lsb_depth
1164 #ifndef FIXED_POINT
1165                 , analysis_info
1166 #endif
1167                 );
1168           if (tmp_len<0)
1169           {
1170              RESTORE_STACK;
1171              return OPUS_INTERNAL_ERROR;
1172           }
1173           ret = opus_repacketizer_cat(&rp, tmp_data+i*bytes_per_frame, tmp_len);
1174           if (ret<0)
1175           {
1176              RESTORE_STACK;
1177              return OPUS_INTERNAL_ERROR;
1178           }
1179        }
1180        ret = opus_repacketizer_out(&rp, data, out_data_bytes);
1181        if (ret<0)
1182        {
1183           RESTORE_STACK;
1184           return OPUS_INTERNAL_ERROR;
1185        }
1186        st->user_forced_mode = bak_mode;
1187        st->user_bandwidth = bak_bandwidth;
1188        st->force_channels = bak_channels;
1189        st->silk_mode.toMono = bak_to_mono;
1190        RESTORE_STACK;
1191        return ret;
1192     }
1193     curr_bandwidth = st->bandwidth;
1194
1195     /* Chooses the appropriate mode for speech
1196        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
1197     if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1198         st->mode = MODE_HYBRID;
1199     if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
1200         st->mode = MODE_SILK_ONLY;
1201
1202     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
1203     bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
1204
1205     data += 1;
1206
1207     ec_enc_init(&enc, data, max_data_bytes-1);
1208
1209     ALLOC(pcm_buf, (total_buffer+frame_size)*st->channels, opus_val16);
1210     for (i=0;i<total_buffer*st->channels;i++)
1211        pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-total_buffer)*st->channels+i];
1212
1213     if (st->mode == MODE_CELT_ONLY)
1214        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1215     else
1216        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
1217
1218     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
1219           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
1220
1221     /* convert from log scale to Hertz */
1222     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
1223
1224     if (st->application == OPUS_APPLICATION_VOIP)
1225     {
1226        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1227     } else {
1228        dc_reject(pcm, 3, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1229     }
1230
1231
1232
1233     /* SILK processing */
1234     HB_gain = Q15ONE;
1235     if (st->mode != MODE_CELT_ONLY)
1236     {
1237         opus_int32 total_bitRate, celt_rate;
1238 #ifdef FIXED_POINT
1239        const opus_int16 *pcm_silk;
1240 #else
1241        VARDECL(opus_int16, pcm_silk);
1242        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
1243 #endif
1244
1245         /* Distribute bits between SILK and CELT */
1246         total_bitRate = 8 * bytes_target * frame_rate;
1247         if( st->mode == MODE_HYBRID ) {
1248             int HB_gain_ref;
1249             /* Base rate for SILK */
1250             st->silk_mode.bitRate = st->stream_channels * ( 5000 + 1000 * ( st->Fs == 100 * frame_size ) );
1251             if( curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
1252                 /* SILK gets 2/3 of the remaining bits */
1253                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 2 / 3;
1254             } else { /* FULLBAND */
1255                 /* SILK gets 3/5 of the remaining bits */
1256                 st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 3 / 5;
1257             }
1258             /* Don't let SILK use more than 80% */
1259             if( st->silk_mode.bitRate > total_bitRate * 4/5 ) {
1260                 st->silk_mode.bitRate = total_bitRate * 4/5;
1261             }
1262             /* Increasingly attenuate high band when it gets allocated fewer bits */
1263             celt_rate = total_bitRate - st->silk_mode.bitRate;
1264             HB_gain_ref = (curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND) ? 2000 : 2400;
1265             HB_gain = SHL32((opus_val32)celt_rate, 9) / SHR32((opus_val32)celt_rate + st->stream_channels*HB_gain_ref, 6);
1266         } else {
1267             /* SILK gets all bits */
1268             st->silk_mode.bitRate = total_bitRate;
1269         }
1270
1271         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
1272         st->silk_mode.nChannelsAPI = st->channels;
1273         st->silk_mode.nChannelsInternal = st->stream_channels;
1274         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1275             st->silk_mode.desiredInternalSampleRate = 8000;
1276         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1277             st->silk_mode.desiredInternalSampleRate = 12000;
1278         } else {
1279             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
1280             st->silk_mode.desiredInternalSampleRate = 16000;
1281         }
1282         if( st->mode == MODE_HYBRID ) {
1283             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
1284             st->silk_mode.minInternalSampleRate = 16000;
1285         } else {
1286             st->silk_mode.minInternalSampleRate = 8000;
1287         }
1288
1289         if (st->mode == MODE_SILK_ONLY)
1290         {
1291            opus_int32 effective_max_rate = max_rate;
1292            st->silk_mode.maxInternalSampleRate = 16000;
1293            if (frame_rate > 50)
1294               effective_max_rate = effective_max_rate*2/3;
1295            if (effective_max_rate < 13000)
1296            {
1297               st->silk_mode.maxInternalSampleRate = 12000;
1298               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
1299            }
1300            if (effective_max_rate < 9600)
1301            {
1302               st->silk_mode.maxInternalSampleRate = 8000;
1303               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
1304            }
1305         } else {
1306            st->silk_mode.maxInternalSampleRate = 16000;
1307         }
1308
1309         st->silk_mode.useCBR = !st->use_vbr;
1310
1311         /* Call SILK encoder for the low band */
1312         nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes);
1313
1314         st->silk_mode.maxBits = nBytes*8;
1315         /* Only allow up to 90% of the bits for hybrid mode*/
1316         if (st->mode == MODE_HYBRID)
1317            st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
1318         if (st->silk_mode.useCBR)
1319         {
1320            st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
1321            /* Reduce the initial target to make it easier to reach the CBR rate */
1322            st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000);
1323         }
1324
1325         if (prefill)
1326         {
1327             opus_int32 zero=0;
1328             const CELTMode *celt_mode;
1329             int prefill_offset;
1330             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1331             /* Use a smooth onset for the SILK prefill to avoid the encoder trying to encode
1332                a discontinuity. The exact location is what we need to avoid leaving any "gap"
1333                in the audio when mixing with the redundant CELT frame. Here we can afford to
1334                overwrite st->delay_buffer because the only thing that uses it before it gets
1335                rewritten is tmp_prefill[] and even then only the part after the ramp really
1336                gets used (rather than sent to the encoder and discarded) */
1337             prefill_offset = st->channels*(st->encoder_buffer-st->delay_compensation-st->Fs/400);
1338             gain_fade(st->delay_buffer+prefill_offset, st->delay_buffer+prefill_offset,
1339                   0, Q15ONE, celt_mode->overlap, st->Fs/400, st->channels, celt_mode->window, st->Fs);
1340             for(i=0;i<prefill_offset;i++)
1341                st->delay_buffer[i]=0;
1342 #ifdef FIXED_POINT
1343             pcm_silk = st->delay_buffer;
1344 #else
1345             for (i=0;i<st->encoder_buffer*st->channels;i++)
1346                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
1347 #endif
1348             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
1349         }
1350
1351 #ifdef FIXED_POINT
1352         pcm_silk = pcm_buf+total_buffer*st->channels;
1353 #else
1354         for (i=0;i<frame_size*st->channels;i++)
1355             pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
1356 #endif
1357         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
1358         if( ret ) {
1359             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
1360             /* Handle error */
1361            RESTORE_STACK;
1362            return OPUS_INTERNAL_ERROR;
1363         }
1364         if (nBytes==0)
1365         {
1366            st->rangeFinal = 0;
1367            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1368            RESTORE_STACK;
1369            return 1;
1370         }
1371         /* Extract SILK internal bandwidth for signaling in first byte */
1372         if( st->mode == MODE_SILK_ONLY ) {
1373             if( st->silk_mode.internalSampleRate == 8000 ) {
1374                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1375             } else if( st->silk_mode.internalSampleRate == 12000 ) {
1376                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1377             } else if( st->silk_mode.internalSampleRate == 16000 ) {
1378                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1379             }
1380         } else {
1381             silk_assert( st->silk_mode.internalSampleRate == 16000 );
1382         }
1383
1384         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
1385         /* FIXME: How do we allocate the redundancy for CBR? */
1386         if (st->silk_mode.opusCanSwitch)
1387         {
1388            redundancy = 1;
1389            celt_to_silk = 0;
1390            st->silk_bw_switch = 1;
1391         }
1392     }
1393
1394     /* CELT processing */
1395     {
1396         int endband=21;
1397
1398         switch(curr_bandwidth)
1399         {
1400             case OPUS_BANDWIDTH_NARROWBAND:
1401                 endband = 13;
1402                 break;
1403             case OPUS_BANDWIDTH_MEDIUMBAND:
1404             case OPUS_BANDWIDTH_WIDEBAND:
1405                 endband = 17;
1406                 break;
1407             case OPUS_BANDWIDTH_SUPERWIDEBAND:
1408                 endband = 19;
1409                 break;
1410             case OPUS_BANDWIDTH_FULLBAND:
1411                 endband = 21;
1412                 break;
1413         }
1414         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
1415         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
1416     }
1417     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
1418     if (st->mode != MODE_SILK_ONLY)
1419     {
1420         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1421         /* Allow prediction unless we decide to disable it later */
1422         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
1423
1424         if (st->mode == MODE_HYBRID)
1425         {
1426             int len;
1427
1428             len = (ec_tell(&enc)+7)>>3;
1429             if (redundancy)
1430                len += st->mode == MODE_HYBRID ? 3 : 1;
1431             if( st->use_vbr ) {
1432                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
1433             } else {
1434                 /* check if SILK used up too much */
1435                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
1436             }
1437         } else {
1438             if (st->use_vbr)
1439             {
1440                 opus_int32 bonus=0;
1441 #ifndef FIXED_POINT
1442                 if (st->variable_duration==OPUS_FRAMESIZE_VARIABLE && frame_size != st->Fs/50)
1443                 {
1444                    bonus = (40*st->stream_channels+40)*(st->Fs/frame_size-50);
1445                    if (analysis_info->valid)
1446                       bonus = bonus*(1.f+.5*analysis_info->tonality);
1447                 }
1448 #endif
1449                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
1450                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
1451                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps+bonus));
1452                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
1453             } else {
1454                 nb_compr_bytes = bytes_target;
1455             }
1456         }
1457
1458     } else {
1459         nb_compr_bytes = 0;
1460     }
1461
1462     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
1463     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
1464     {
1465        for (i=0;i<st->channels*st->Fs/400;i++)
1466           tmp_prefill[i] = st->delay_buffer[(st->encoder_buffer-total_buffer-st->Fs/400)*st->channels + i];
1467     }
1468
1469     for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+total_buffer));i++)
1470         st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
1471     for (;i<st->encoder_buffer*st->channels;i++)
1472         st->delay_buffer[i] = pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels+i];
1473
1474     /* gain_fade() and stereo_fade() need to be after the buffer copying
1475        because we don't want any of this to affect the SILK part */
1476     if( st->prev_HB_gain < Q15ONE || HB_gain < Q15ONE ) {
1477        const CELTMode *celt_mode;
1478
1479        celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1480        gain_fade(pcm_buf, pcm_buf,
1481              st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs);
1482     }
1483     st->prev_HB_gain = HB_gain;
1484     if (st->mode != MODE_HYBRID || st->stream_channels==1)
1485        st->silk_mode.stereoWidth_Q14 = 1<<14;
1486     if( st->channels == 2 ) {
1487         /* Apply stereo width reduction (at low bitrates) */
1488         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1489             opus_val16 g1, g2;
1490             const CELTMode *celt_mode;
1491
1492             celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1493             g1 = st->hybrid_stereo_width_Q14;
1494             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1495 #ifdef FIXED_POINT
1496             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
1497             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
1498 #else
1499             g1 *= (1.f/16384);
1500             g2 *= (1.f/16384);
1501 #endif
1502             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
1503                   frame_size, st->channels, celt_mode->window, st->Fs);
1504             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1505         }
1506     }
1507
1508     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
1509     {
1510         /* For SILK mode, the redundancy is inferred from the length */
1511         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
1512            ec_enc_bit_logp(&enc, redundancy, 12);
1513         if (redundancy)
1514         {
1515             int max_redundancy;
1516             ec_enc_bit_logp(&enc, celt_to_silk, 1);
1517             if (st->mode == MODE_HYBRID)
1518                max_redundancy = (max_data_bytes-1)-nb_compr_bytes-1;
1519             else
1520                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1521             /* Target the same bit-rate for redundancy as for the rest,
1522                up to a max of 257 bytes */
1523             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
1524             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
1525             if (st->mode == MODE_HYBRID)
1526                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
1527         }
1528     } else {
1529         redundancy = 0;
1530     }
1531
1532     if (!redundancy)
1533     {
1534        st->silk_bw_switch = 0;
1535        redundancy_bytes = 0;
1536     }
1537     if (st->mode != MODE_CELT_ONLY)start_band=17;
1538
1539     if (st->mode == MODE_SILK_ONLY)
1540     {
1541         ret = (ec_tell(&enc)+7)>>3;
1542         ec_enc_done(&enc);
1543         nb_compr_bytes = ret;
1544     } else {
1545        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
1546        ec_enc_shrink(&enc, nb_compr_bytes);
1547     }
1548
1549
1550     /* 5 ms redundant frame for CELT->SILK */
1551     if (redundancy && celt_to_silk)
1552     {
1553         int err;
1554         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1555         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
1556         err = celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
1557         if (err < 0)
1558         {
1559            RESTORE_STACK;
1560            return OPUS_INTERNAL_ERROR;
1561         }
1562         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1563         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1564     }
1565
1566     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
1567
1568     if (st->mode != MODE_SILK_ONLY)
1569     {
1570         if (st->mode != st->prev_mode && st->prev_mode > 0)
1571         {
1572            unsigned char dummy[2];
1573            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1574
1575            /* Prefilling */
1576            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
1577            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1578         }
1579         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
1580         if (ec_tell(&enc) <= 8*nb_compr_bytes)
1581         {
1582 #ifndef FIXED_POINT
1583            celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(analysis_info));
1584 #endif
1585            ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
1586            if (ret < 0)
1587            {
1588               RESTORE_STACK;
1589               return OPUS_INTERNAL_ERROR;
1590            }
1591         }
1592     }
1593
1594     /* 5 ms redundant frame for SILK->CELT */
1595     if (redundancy && !celt_to_silk)
1596     {
1597         int err;
1598         unsigned char dummy[2];
1599         int N2, N4;
1600         N2 = st->Fs/200;
1601         N4 = st->Fs/400;
1602
1603         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1604         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
1605         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
1606
1607         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1608         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL);
1609
1610         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
1611         if (err < 0)
1612         {
1613            RESTORE_STACK;
1614            return OPUS_INTERNAL_ERROR;
1615         }
1616         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
1617     }
1618
1619
1620
1621     /* Signalling the mode in the first byte */
1622     data--;
1623     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1624
1625     st->rangeFinal = enc.rng ^ redundant_rng;
1626
1627     if (to_celt)
1628         st->prev_mode = MODE_CELT_ONLY;
1629     else
1630         st->prev_mode = st->mode;
1631     st->prev_channels = st->stream_channels;
1632     st->prev_framesize = frame_size;
1633
1634     st->first = 0;
1635
1636     /* In the unlikely case that the SILK encoder busted its target, tell
1637        the decoder to call the PLC */
1638     if (ec_tell(&enc) > (max_data_bytes-1)*8)
1639     {
1640        if (max_data_bytes < 2)
1641        {
1642           RESTORE_STACK;
1643           return OPUS_BUFFER_TOO_SMALL;
1644        }
1645        data[1] = 0;
1646        ret = 1;
1647        st->rangeFinal = 0;
1648     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
1649     {
1650        /*When in LPC only mode it's perfectly
1651          reasonable to strip off trailing zero bytes as
1652          the required range decoder behavior is to
1653          fill these in. This can't be done when the MDCT
1654          modes are used because the decoder needs to know
1655          the actual length for allocation purposes.*/
1656        while(ret>2&&data[ret]==0)ret--;
1657     }
1658     /* Count ToC and redundancy */
1659     ret += 1+redundancy_bytes;
1660     if (!st->use_vbr && ret >= 3)
1661     {
1662        if (pad_frame(data, ret, max_data_bytes))
1663        {
1664           RESTORE_STACK;
1665           return OPUS_INTERNAL_ERROR;
1666        }
1667        ret = max_data_bytes;
1668     }
1669     RESTORE_STACK;
1670     return ret;
1671 }
1672
1673 #ifdef FIXED_POINT
1674
1675 #ifndef DISABLE_FLOAT_API
1676 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1677       unsigned char *data, opus_int32 max_data_bytes)
1678 {
1679    int i, ret;
1680    VARDECL(opus_int16, in);
1681    ALLOC_STACK;
1682
1683    frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1684    if(frame_size<0)
1685    {
1686       RESTORE_STACK;
1687       return OPUS_BAD_ARG;
1688    }
1689
1690    ALLOC(in, frame_size*st->channels, opus_int16);
1691
1692    for (i=0;i<frame_size*st->channels;i++)
1693       in[i] = FLOAT2INT16(pcm[i]);
1694    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16);
1695    RESTORE_STACK;
1696    return ret;
1697 }
1698 #endif
1699
1700 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1701                 unsigned char *data, opus_int32 out_data_bytes)
1702 {
1703    frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1704    if(frame_size<0)
1705    {
1706       RESTORE_STACK;
1707       return OPUS_BAD_ARG;
1708    }
1709    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 16);
1710 }
1711
1712 #else
1713 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
1714       unsigned char *data, opus_int32 max_data_bytes)
1715 {
1716    int i, ret;
1717    const CELTMode *celt_mode;
1718    int delay_compensation;
1719    int lsb_depth;
1720    VARDECL(float, in);
1721    AnalysisInfo analysis_info;
1722    ALLOC_STACK;
1723
1724    opus_encoder_ctl(st, CELT_GET_MODE(&celt_mode));
1725    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1726       delay_compensation = 0;
1727    else
1728       delay_compensation = st->delay_compensation;
1729
1730    lsb_depth = IMIN(16, st->lsb_depth);
1731
1732    analysis_info.valid = 0;
1733    if (st->silk_mode.complexity >= 7 && st->Fs==48000)
1734    {
1735       frame_size = run_analysis(&st->analysis, celt_mode, pcm, pcm+st->channels*st->analysis.analysis_offset,
1736             frame_size, st->variable_duration, st->channels, st->Fs, st->bitrate_bps, delay_compensation, lsb_depth, downmix_int, &analysis_info);
1737    } else {
1738       frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1739    }
1740    if(frame_size<0)
1741    {
1742       RESTORE_STACK;
1743       return OPUS_BAD_ARG;
1744    }
1745
1746    ALLOC(in, frame_size*st->channels, float);
1747
1748    for (i=0;i<frame_size*st->channels;i++)
1749       in[i] = (1.0f/32768)*pcm[i];
1750    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16, &analysis_info);
1751    RESTORE_STACK;
1752    return ret;
1753 }
1754 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
1755                       unsigned char *data, opus_int32 out_data_bytes)
1756 {
1757    const CELTMode *celt_mode;
1758    int delay_compensation;
1759    int lsb_depth;
1760    AnalysisInfo analysis_info;
1761
1762    opus_encoder_ctl(st, CELT_GET_MODE(&celt_mode));
1763    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1764       delay_compensation = 0;
1765    else
1766       delay_compensation = st->delay_compensation;
1767
1768    lsb_depth = IMIN(24, st->lsb_depth);
1769
1770    analysis_info.valid = 0;
1771    if (st->silk_mode.complexity >= 7 && st->Fs==48000)
1772    {
1773       frame_size = run_analysis(&st->analysis, celt_mode, pcm, pcm+st->channels*st->analysis.analysis_offset,
1774             frame_size, st->variable_duration, st->channels, st->Fs, st->bitrate_bps, delay_compensation, lsb_depth, downmix_float, &analysis_info);
1775    } else {
1776       frame_size = frame_size_select(frame_size, st->variable_duration, st->Fs);
1777    }
1778    if(frame_size<0)
1779    {
1780       RESTORE_STACK;
1781       return OPUS_BAD_ARG;
1782    }
1783
1784    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 24, &analysis_info);
1785
1786 }
1787 #endif
1788
1789
1790 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
1791 {
1792     int ret;
1793     CELTEncoder *celt_enc;
1794     va_list ap;
1795
1796     ret = OPUS_OK;
1797     va_start(ap, request);
1798
1799     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1800
1801     switch (request)
1802     {
1803         case OPUS_SET_APPLICATION_REQUEST:
1804         {
1805             opus_int32 value = va_arg(ap, opus_int32);
1806             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
1807                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1808                || (!st->first && st->application != value))
1809             {
1810                ret = OPUS_BAD_ARG;
1811                break;
1812             }
1813             st->application = value;
1814         }
1815         break;
1816         case OPUS_GET_APPLICATION_REQUEST:
1817         {
1818             opus_int32 *value = va_arg(ap, opus_int32*);
1819             *value = st->application;
1820         }
1821         break;
1822         case OPUS_SET_BITRATE_REQUEST:
1823         {
1824             opus_int32 value = va_arg(ap, opus_int32);
1825             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1826             {
1827                 if (value <= 0)
1828                     goto bad_arg;
1829                 else if (value <= 500)
1830                     value = 500;
1831                 else if (value > (opus_int32)300000*st->channels)
1832                     value = (opus_int32)300000*st->channels;
1833             }
1834             st->user_bitrate_bps = value;
1835         }
1836         break;
1837         case OPUS_GET_BITRATE_REQUEST:
1838         {
1839             opus_int32 *value = va_arg(ap, opus_int32*);
1840             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
1841         }
1842         break;
1843         case OPUS_SET_FORCE_CHANNELS_REQUEST:
1844         {
1845             opus_int32 value = va_arg(ap, opus_int32);
1846             if((value<1 || value>st->channels) && value != OPUS_AUTO)
1847                 return OPUS_BAD_ARG;
1848             st->force_channels = value;
1849         }
1850         break;
1851         case OPUS_GET_FORCE_CHANNELS_REQUEST:
1852         {
1853             opus_int32 *value = va_arg(ap, opus_int32*);
1854             *value = st->force_channels;
1855         }
1856         break;
1857         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
1858         {
1859             opus_int32 value = va_arg(ap, opus_int32);
1860             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND)
1861                 return OPUS_BAD_ARG;
1862             st->max_bandwidth = value;
1863             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1864                 st->silk_mode.maxInternalSampleRate = 8000;
1865             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1866                 st->silk_mode.maxInternalSampleRate = 12000;
1867             } else {
1868                 st->silk_mode.maxInternalSampleRate = 16000;
1869             }
1870         }
1871         break;
1872         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
1873         {
1874             opus_int32 *value = va_arg(ap, opus_int32*);
1875             *value = st->max_bandwidth;
1876         }
1877         break;
1878         case OPUS_SET_BANDWIDTH_REQUEST:
1879         {
1880             opus_int32 value = va_arg(ap, opus_int32);
1881             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
1882                 return OPUS_BAD_ARG;
1883             st->user_bandwidth = value;
1884             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1885                 st->silk_mode.maxInternalSampleRate = 8000;
1886             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1887                 st->silk_mode.maxInternalSampleRate = 12000;
1888             } else {
1889                 st->silk_mode.maxInternalSampleRate = 16000;
1890             }
1891         }
1892         break;
1893         case OPUS_GET_BANDWIDTH_REQUEST:
1894         {
1895             opus_int32 *value = va_arg(ap, opus_int32*);
1896             *value = st->bandwidth;
1897         }
1898         break;
1899         case OPUS_SET_DTX_REQUEST:
1900         {
1901             opus_int32 value = va_arg(ap, opus_int32);
1902             if(value<0 || value>1)
1903                 return OPUS_BAD_ARG;
1904             st->silk_mode.useDTX = value;
1905         }
1906         break;
1907         case OPUS_GET_DTX_REQUEST:
1908         {
1909             opus_int32 *value = va_arg(ap, opus_int32*);
1910             *value = st->silk_mode.useDTX;
1911         }
1912         break;
1913         case OPUS_SET_COMPLEXITY_REQUEST:
1914         {
1915             opus_int32 value = va_arg(ap, opus_int32);
1916             if(value<0 || value>10)
1917                 return OPUS_BAD_ARG;
1918             st->silk_mode.complexity = value;
1919             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
1920         }
1921         break;
1922         case OPUS_GET_COMPLEXITY_REQUEST:
1923         {
1924             opus_int32 *value = va_arg(ap, opus_int32*);
1925             *value = st->silk_mode.complexity;
1926         }
1927         break;
1928         case OPUS_SET_INBAND_FEC_REQUEST:
1929         {
1930             opus_int32 value = va_arg(ap, opus_int32);
1931             if(value<0 || value>1)
1932                 return OPUS_BAD_ARG;
1933             st->silk_mode.useInBandFEC = value;
1934         }
1935         break;
1936         case OPUS_GET_INBAND_FEC_REQUEST:
1937         {
1938             opus_int32 *value = va_arg(ap, opus_int32*);
1939             *value = st->silk_mode.useInBandFEC;
1940         }
1941         break;
1942         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1943         {
1944             opus_int32 value = va_arg(ap, opus_int32);
1945             if (value < 0 || value > 100)
1946                 return OPUS_BAD_ARG;
1947             st->silk_mode.packetLossPercentage = value;
1948             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
1949         }
1950         break;
1951         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1952         {
1953             opus_int32 *value = va_arg(ap, opus_int32*);
1954             *value = st->silk_mode.packetLossPercentage;
1955         }
1956         break;
1957         case OPUS_SET_VBR_REQUEST:
1958         {
1959             opus_int32 value = va_arg(ap, opus_int32);
1960             if(value<0 || value>1)
1961                 return OPUS_BAD_ARG;
1962             st->use_vbr = value;
1963             st->silk_mode.useCBR = 1-value;
1964         }
1965         break;
1966         case OPUS_GET_VBR_REQUEST:
1967         {
1968             opus_int32 *value = va_arg(ap, opus_int32*);
1969             *value = st->use_vbr;
1970         }
1971         break;
1972         case OPUS_SET_VOICE_RATIO_REQUEST:
1973         {
1974             opus_int32 value = va_arg(ap, opus_int32);
1975             if (value>100 || value<-1)
1976                 goto bad_arg;
1977             st->voice_ratio = value;
1978         }
1979         break;
1980         case OPUS_GET_VOICE_RATIO_REQUEST:
1981         {
1982             opus_int32 *value = va_arg(ap, opus_int32*);
1983             *value = st->voice_ratio;
1984         }
1985         break;
1986         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1987         {
1988             opus_int32 value = va_arg(ap, opus_int32);
1989             if(value<0 || value>1)
1990                 return OPUS_BAD_ARG;
1991             st->vbr_constraint = value;
1992         }
1993         break;
1994         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1995         {
1996             opus_int32 *value = va_arg(ap, opus_int32*);
1997             *value = st->vbr_constraint;
1998         }
1999         break;
2000         case OPUS_SET_SIGNAL_REQUEST:
2001         {
2002             opus_int32 value = va_arg(ap, opus_int32);
2003             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
2004                 return OPUS_BAD_ARG;
2005             st->signal_type = value;
2006         }
2007         break;
2008         case OPUS_GET_SIGNAL_REQUEST:
2009         {
2010             opus_int32 *value = va_arg(ap, opus_int32*);
2011             *value = st->signal_type;
2012         }
2013         break;
2014         case OPUS_GET_LOOKAHEAD_REQUEST:
2015         {
2016             opus_int32 *value = va_arg(ap, opus_int32*);
2017             *value = st->Fs/400;
2018             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2019                 *value += st->delay_compensation;
2020         }
2021         break;
2022         case OPUS_GET_SAMPLE_RATE_REQUEST:
2023         {
2024             opus_int32 *value = va_arg(ap, opus_int32*);
2025             if (value==NULL)
2026             {
2027                 ret = OPUS_BAD_ARG;
2028                 break;
2029             }
2030             *value = st->Fs;
2031         }
2032         break;
2033         case OPUS_GET_FINAL_RANGE_REQUEST:
2034         {
2035             opus_uint32 *value = va_arg(ap, opus_uint32*);
2036             *value = st->rangeFinal;
2037         }
2038         break;
2039         case OPUS_SET_LSB_DEPTH_REQUEST:
2040         {
2041             opus_int32 value = va_arg(ap, opus_int32);
2042             if (value<8 || value>24)
2043                goto bad_arg;
2044             st->lsb_depth=value;
2045         }
2046         break;
2047         case OPUS_GET_LSB_DEPTH_REQUEST:
2048         {
2049             opus_int32 *value = va_arg(ap, opus_int32*);
2050             *value = st->lsb_depth;
2051         }
2052         break;
2053         case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
2054         {
2055             opus_int32 value = va_arg(ap, opus_int32);
2056             st->variable_duration = value;
2057         }
2058         break;
2059         case OPUS_GET_EXPERT_FRAME_DURATION_REQUEST:
2060         {
2061             opus_int32 *value = va_arg(ap, opus_int32*);
2062             *value = st->variable_duration;
2063         }
2064         break;
2065         case OPUS_RESET_STATE:
2066         {
2067            void *silk_enc;
2068            silk_EncControlStruct dummy;
2069            silk_enc = (char*)st+st->silk_enc_offset;
2070
2071            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
2072                  sizeof(OpusEncoder)-
2073                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
2074
2075            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2076            silk_InitEncoder( silk_enc, &dummy );
2077            st->stream_channels = st->channels;
2078            st->hybrid_stereo_width_Q14 = 1 << 14;
2079            st->prev_HB_gain = Q15ONE;
2080            st->first = 1;
2081            st->mode = MODE_HYBRID;
2082            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
2083            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
2084         }
2085         break;
2086         case OPUS_SET_FORCE_MODE_REQUEST:
2087         {
2088             opus_int32 value = va_arg(ap, opus_int32);
2089             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
2090                goto bad_arg;
2091             st->user_forced_mode = value;
2092         }
2093         break;
2094
2095         case CELT_GET_MODE_REQUEST:
2096         {
2097            const CELTMode ** value = va_arg(ap, const CELTMode**);
2098            if (value==0)
2099               goto bad_arg;
2100            celt_encoder_ctl(celt_enc, CELT_GET_MODE(value));
2101         }
2102         break;
2103         default:
2104             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
2105             ret = OPUS_UNIMPLEMENTED;
2106             break;
2107     }
2108     va_end(ap);
2109     return ret;
2110 bad_arg:
2111     va_end(ap);
2112     return OPUS_BAD_ARG;
2113 }
2114
2115 void opus_encoder_destroy(OpusEncoder *st)
2116 {
2117     opus_free(st);
2118 }