Removes code that became useless with the Opus-level highpass
[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 FOUNDATION OR
19    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 "silk_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
44 #include "silk_tuning_parameters.h"
45 #ifdef FIXED_POINT
46 #include "fixed/silk_structs_FIX.h"
47 #else
48 #include "float/silk_structs_FLP.h"
49 #endif
50
51 #define MAX_ENCODER_BUFFER 480
52
53 struct OpusEncoder {
54     int          celt_enc_offset;
55     int          silk_enc_offset;
56     silk_EncControlStruct silk_mode;
57     int          application;
58     int          channels;
59     int          delay_compensation;
60     int          force_mono;
61     int          signal_type;
62     int          user_bandwidth;
63     int          voice_ratio;
64     int          Fs;
65     int          use_vbr;
66     int          vbr_constraint;
67     int          bitrate_bps;
68     int          user_bitrate_bps;
69     int          encoder_buffer;
70
71 #define OPUS_ENCODER_RESET_START stream_channels
72     int          stream_channels;
73     int          hybrid_stereo_width_Q14;
74     opus_int32   variable_HP_smth2_Q15;
75     opus_val32   hp_mem[4];
76     int          mode;
77     int          prev_mode;
78     int          bandwidth;
79     /* Sampling rate (at the API level) */
80     int          first;
81     opus_val16   delay_buffer[MAX_ENCODER_BUFFER*2];
82
83     int          rangeFinal;
84 };
85
86 /* Transition tables for the voice and audio modes. First column is the
87    middle (memoriless) threshold. The second column is the hysteresis
88    (difference with the middle) */
89 static const int voice_bandwidth_thresholds[10] = {
90         11000, 1000, /* NB<->MB */
91         14000, 1000, /* MB<->WB */
92         21000, 2000, /* WB<->SWB */
93         29000, 2000, /* SWB<->FB */
94 };
95 static const int audio_bandwidth_thresholds[10] = {
96         30000,    0, /* MB not allowed */
97         20000, 2000, /* MB<->WB */
98         26000, 2000, /* WB<->SWB */
99         33000, 2000, /* SWB<->FB */
100 };
101
102
103 int opus_encoder_get_size(int channels)
104 {
105     int silkEncSizeBytes, celtEncSizeBytes;
106     int ret;
107     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
108     if (ret)
109         return 0;
110     silkEncSizeBytes = align(silkEncSizeBytes);
111     celtEncSizeBytes = celt_encoder_get_size(channels);
112     return align(sizeof(OpusEncoder))+silkEncSizeBytes+celtEncSizeBytes;
113 }
114
115 int opus_encoder_init(OpusEncoder* st, int Fs, int channels, int application)
116 {
117     void *silk_enc;
118     CELTEncoder *celt_enc;
119     int err;
120     int ret, silkEncSizeBytes;
121
122     if (channels > 2 || channels < 1)
123         return OPUS_BAD_ARG;
124     if (application < OPUS_APPLICATION_VOIP || application > OPUS_APPLICATION_AUDIO)
125         return OPUS_BAD_ARG;
126     if (Fs != 8000 && Fs != 12000 && Fs != 16000 && Fs != 24000 && Fs != 48000)
127         return OPUS_BAD_ARG;
128
129     OPUS_CLEAR((char*)st, opus_encoder_get_size(channels));
130     /* Create SILK encoder */
131     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
132     if (ret)
133         return OPUS_BAD_ARG;
134     silkEncSizeBytes = align(silkEncSizeBytes);
135     st->silk_enc_offset = align(sizeof(OpusEncoder));
136     st->celt_enc_offset = st->silk_enc_offset+silkEncSizeBytes;
137     silk_enc = (char*)st+st->silk_enc_offset;
138     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
139
140     st->stream_channels = st->channels = channels;
141
142     st->Fs = Fs;
143
144     ret = silk_InitEncoder( silk_enc, &st->silk_mode );
145     if (ret)
146         goto failure;
147
148     /* default SILK parameters */
149     st->silk_mode.nChannelsAPI              = channels;
150     st->silk_mode.nChannelsInternal         = channels;
151     st->silk_mode.API_sampleRate            = st->Fs;
152     st->silk_mode.maxInternalSampleRate     = 16000;
153     st->silk_mode.minInternalSampleRate     = 8000;
154     st->silk_mode.desiredInternalSampleRate = 16000;
155     st->silk_mode.payloadSize_ms            = 20;
156     st->silk_mode.bitRate                   = 25000;
157     st->silk_mode.packetLossPercentage      = 0;
158     st->silk_mode.complexity                = 10;
159     st->silk_mode.useInBandFEC              = 0;
160     st->silk_mode.useDTX                    = 0;
161     st->silk_mode.useCBR                    = 0;
162
163     /* Create CELT encoder */
164     /* Initialize CELT encoder */
165     err = celt_encoder_init(celt_enc, Fs, channels);
166     if (err != OPUS_OK)
167         goto failure;
168     celt_encoder_ctl(celt_enc, CELT_SET_SIGNALLING(0));
169
170     st->use_vbr = 0;
171     st->user_bitrate_bps = OPUS_BITRATE_AUTO;
172     st->bitrate_bps = 3000+Fs*channels;
173     st->application = application;
174     st->signal_type = OPUS_SIGNAL_AUTO;
175     st->user_bandwidth = OPUS_BANDWIDTH_AUTO;
176     st->voice_ratio = 90;
177     st->encoder_buffer = st->Fs/100;
178
179     st->delay_compensation = st->Fs/400;
180     /* This part is meant to compensate for the resampler delay as a function
181        of the API sampling rate */
182     if (st->Fs == 48000)
183         st->delay_compensation += 23;
184     else if (st->Fs == 24000)
185        st->delay_compensation += 15;
186     else
187        st->delay_compensation += 2;
188
189     st->hybrid_stereo_width_Q14             = 1 << 14;
190     st->variable_HP_smth2_Q15 = SKP_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
191     st->first = 1;
192     st->mode = MODE_HYBRID;
193     st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
194
195     return OPUS_OK;
196
197 failure:
198     opus_free(st);
199     return OPUS_INTERNAL_ERROR;
200 }
201
202 static unsigned char gen_toc(int mode, int framerate, int bandwidth, int silk_bandwidth, int channels)
203 {
204    int period;
205    unsigned char toc;
206    period = 0;
207    while (framerate < 400)
208    {
209        framerate <<= 1;
210        period++;
211    }
212    if (mode == MODE_SILK_ONLY)
213    {
214        toc = (silk_bandwidth-OPUS_BANDWIDTH_NARROWBAND)<<5;
215        toc |= (period-2)<<3;
216    } else if (mode == MODE_CELT_ONLY)
217    {
218        int tmp = bandwidth-OPUS_BANDWIDTH_MEDIUMBAND;
219        if (tmp < 0)
220            tmp = 0;
221        toc = 0x80;
222        toc |= tmp << 5;
223        toc |= period<<3;
224    } else /* Hybrid */
225    {
226        toc = 0x60;
227        toc |= (bandwidth-OPUS_BANDWIDTH_SUPERWIDEBAND)<<4;
228        toc |= (period-2)<<3;
229    }
230    toc |= (channels==2)<<2;
231    return toc;
232 }
233
234 #ifndef FIXED_POINT
235 void silk_biquad_float(
236     const opus_val16      *in,            /* I:    Input signal                   */
237     const opus_int32      *B_Q28,         /* I:    MA coefficients [3]            */
238     const opus_int32      *A_Q28,         /* I:    AR coefficients [2]            */
239     opus_val32            *S,             /* I/O:  State vector [2]               */
240     opus_val16            *out,           /* O:    Output signal                  */
241     const opus_int32      len,            /* I:    Signal length (must be even)   */
242     int stride
243 )
244 {
245     /* DIRECT FORM II TRANSPOSED (uses 2 element state vector) */
246     opus_int   k;
247     opus_val32 vout;
248     opus_val32 inval;
249     opus_val32 A[2], B[3];
250
251     A[0] = A_Q28[0] * (1./((opus_int32)1<<28));
252     A[1] = A_Q28[1] * (1./((opus_int32)1<<28));
253     B[0] = B_Q28[0] * (1./((opus_int32)1<<28));
254     B[1] = B_Q28[1] * (1./((opus_int32)1<<28));
255     B[2] = B_Q28[2] * (1./((opus_int32)1<<28));
256
257     /* Negate A_Q28 values and split in two parts */
258
259     for( k = 0; k < len; k++ ) {
260         /* S[ 0 ], S[ 1 ]: Q12 */
261         inval = in[ k*stride ];
262         vout = S[ 0 ] + B[0]*inval;
263
264         S[ 0 ] = S[1] - vout*A[0] + B[1]*inval;
265
266         S[ 1 ] = - vout*A[1] + B[2]*inval;
267
268         /* Scale back to Q0 and saturate */
269         out[ k*stride ] = vout;
270     }
271 }
272 #endif
273
274 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)
275 {
276    opus_int32 B_Q28[ 3 ], A_Q28[ 2 ];
277    opus_int32 Fc_Q19, r_Q28, r_Q22;
278
279    SKP_assert( cutoff_Hz <= SKP_int32_MAX / SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ) );
280    Fc_Q19 = SKP_DIV32_16( SKP_SMULBB( SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ), cutoff_Hz ), Fs/1000 );
281    SKP_assert( Fc_Q19 > 0 && Fc_Q19 < 32768 );
282
283    r_Q28 = SILK_FIX_CONST( 1.0, 28 ) - SKP_MUL( SILK_FIX_CONST( 0.92, 9 ), Fc_Q19 );
284
285    /* b = r * [ 1; -2; 1 ]; */
286    /* a = [ 1; -2 * r * ( 1 - 0.5 * Fc^2 ); r^2 ]; */
287    B_Q28[ 0 ] = r_Q28;
288    B_Q28[ 1 ] = SKP_LSHIFT( -r_Q28, 1 );
289    B_Q28[ 2 ] = r_Q28;
290
291    /* -r * ( 2 - Fc * Fc ); */
292    r_Q22  = SKP_RSHIFT( r_Q28, 6 );
293    A_Q28[ 0 ] = SKP_SMULWW( r_Q22, SKP_SMULWW( Fc_Q19, Fc_Q19 ) - SILK_FIX_CONST( 2.0,  22 ) );
294    A_Q28[ 1 ] = SKP_SMULWW( r_Q22, r_Q22 );
295
296 #ifdef FIXED_POINT
297    silk_biquad_alt( in, B_Q28, A_Q28, hp_mem, out, len, channels );
298    if( channels == 2 ) {
299        silk_biquad_alt( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
300    }
301 #else
302    silk_biquad_float( in, B_Q28, A_Q28, hp_mem, out, len, channels );
303    if( channels == 2 ) {
304        silk_biquad_float( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
305    }
306 #endif
307 }
308
309 OpusEncoder *opus_encoder_create(int Fs, int channels, int mode, int *error)
310 {
311    int ret;
312    OpusEncoder *st = (OpusEncoder *)opus_alloc(opus_encoder_get_size(channels));
313    if (st == NULL)
314    {
315       if (error)
316          *error = OPUS_ALLOC_FAIL;
317       return NULL;
318    }
319    ret = opus_encoder_init(st, Fs, channels, mode);
320    if (error)
321       *error = ret;
322    if (ret != OPUS_OK)
323    {
324       opus_free(st);
325       st = NULL;
326    }
327    return st;
328 }
329 #ifdef FIXED_POINT
330 int opus_encode(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
331                 unsigned char *data, int max_data_bytes)
332 #else
333 int opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
334                       unsigned char *data, int max_data_bytes)
335 #endif
336 {
337     void *silk_enc;
338     CELTEncoder *celt_enc;
339     int i;
340     int ret=0;
341     int nBytes;
342     ec_enc enc;
343     int silk_internal_bandwidth=-1;
344     int bytes_target;
345     int prefill=0;
346     int start_band = 0;
347     int redundancy = 0;
348     int redundancy_bytes = 0;
349     int celt_to_silk = 0;
350     VARDECL(opus_val16, pcm_buf);
351     int nb_compr_bytes;
352     int to_celt = 0;
353     opus_int32 mono_rate;
354     opus_uint32 redundant_rng = 0;
355     int cutoff_Hz, hp_freq_smth1;
356     ALLOC_STACK;
357
358     st->rangeFinal = 0;
359     if (400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
360          50*frame_size != st->Fs &&  25*frame_size != st->Fs &&  50*frame_size != 3*st->Fs)
361     {
362        RESTORE_STACK;
363        return OPUS_BAD_ARG;
364     }
365     silk_enc = (char*)st+st->silk_enc_offset;
366     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
367
368     if (st->user_bitrate_bps==OPUS_BITRATE_AUTO)
369         st->bitrate_bps = 60*st->Fs/frame_size + st->Fs*st->channels;
370     else
371         st->bitrate_bps = st->user_bitrate_bps;
372
373     /* Rate-dependent mono-stereo decision */
374     if (st->force_mono)
375     {
376         st->stream_channels = 1;
377     } else if (st->mode == MODE_CELT_ONLY && st->channels == 2)
378     {
379         opus_int32 decision_rate;
380         decision_rate = st->bitrate_bps + st->voice_ratio*st->voice_ratio;
381         /* Add some hysteresis */
382         if (st->stream_channels == 2)
383             decision_rate += 4000;
384         else
385             decision_rate -= 4000;
386         if (decision_rate>48000)
387             st->stream_channels = 2;
388         else
389             st->stream_channels = 1;
390     } else {
391             st->stream_channels = st->channels;
392     }
393
394 #ifdef FUZZING
395     if (st->channels == 2 && (rand()&0x1F)==0)
396        st->stream_channels = 3-st->stream_channels;
397 #endif
398
399     /* Equivalent bit-rate for mono */
400     mono_rate = st->bitrate_bps;
401     if (st->stream_channels==2)
402         mono_rate = 2*mono_rate/3;
403     /* Compensate for smaller frame sizes assuming an equivalent overhead
404        of 60 bits/frame */
405     mono_rate -= 60*(st->Fs/frame_size - 50);
406
407 #ifdef FUZZING
408     if ((rand()&0xF)==0)
409     {
410        if ((rand()&0x1)==0)
411           st->mode = MODE_CELT_ONLY;
412        else
413           st->mode = MODE_SILK_ONLY;
414     } else {
415        if (st->prev_mode==MODE_CELT_ONLY)
416           st->mode = MODE_CELT_ONLY;
417        else
418           st->mode = MODE_SILK_ONLY;
419     }
420 #else
421     /* Mode selection depending on application and signal type */
422     if (st->application==OPUS_APPLICATION_VOIP)
423     {
424         opus_int32 threshold;
425         threshold = 20000;
426         /* OPUS_APPLICATION_VOIP default to auto high-pass */
427         /* Hysteresis */
428         if (st->prev_mode == MODE_CELT_ONLY)
429             threshold -= 4000;
430         else if (st->prev_mode>0)
431             threshold += 4000;
432
433         /* OPUS_APPLICATION_VOIP defaults to MODE_SILK_ONLY */
434         if (st->signal_type == OPUS_SIGNAL_MUSIC && mono_rate > threshold)
435             st->mode = MODE_CELT_ONLY;
436         else
437             st->mode = MODE_SILK_ONLY;
438     } else {/* OPUS_APPLICATION_AUDIO */
439         opus_int32 threshold;
440         /* SILK/CELT threshold is higher for voice than for music */
441         threshold = 36000;
442         /* OPUS_APPLICATION_AUDIO disables the high-pass */
443         if (st->signal_type == OPUS_SIGNAL_MUSIC)
444             threshold -= 20000;
445         else if (st->signal_type == OPUS_SIGNAL_VOICE)
446             threshold += 8000;
447
448         /* Hysteresis */
449         if (st->prev_mode == MODE_CELT_ONLY)
450             threshold -= 4000;
451         else if (st->prev_mode>0)
452             threshold += 4000;
453
454         if (mono_rate>threshold)
455             st->mode = MODE_CELT_ONLY;
456         else
457             st->mode = MODE_SILK_ONLY;
458     }
459 #endif
460     /* Override the chosen mode to make sure we meet the requested frame size */
461     if (st->mode == MODE_CELT_ONLY && frame_size > st->Fs/50)
462        st->mode = MODE_SILK_ONLY;
463     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
464        st->mode = MODE_CELT_ONLY;
465
466     if (st->prev_mode > 0 &&
467         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
468     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
469     {
470         redundancy = 1;
471         celt_to_silk = (st->mode != MODE_CELT_ONLY);
472         if (!celt_to_silk)
473         {
474             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
475             if (frame_size >= st->Fs/100)
476             {
477                 st->mode = st->prev_mode;
478                 to_celt = 1;
479             } else {
480                 redundancy=0;
481             }
482         }
483     }
484     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
485     {
486         silk_EncControlStruct dummy;
487         silk_InitEncoder( silk_enc, &dummy);
488         prefill=1;
489     }
490
491     /* Automatic (rate-dependent) bandwidth selection */
492     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
493     {
494         const int *bandwidth_thresholds;
495         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
496
497         bandwidth_thresholds = st->mode == MODE_CELT_ONLY ? audio_bandwidth_thresholds : voice_bandwidth_thresholds;
498         do {
499             int threshold, hysteresis;
500             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
501             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
502             if (!st->first)
503             {
504                 if (st->bandwidth >= bandwidth)
505                     threshold -= hysteresis;
506                 else
507                     threshold += hysteresis;
508             }
509             if (mono_rate >= threshold)
510                 break;
511         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
512         st->bandwidth = bandwidth;
513         /* Prevents any transition to SWB/FB until the SILK layer has fully
514            switched to WB mode and turned the variable LP filter off */
515         if (st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
516             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
517     }
518
519     /* Prevents Opus from wasting bits on frequencies that are above
520        the Nyquist rate of the input signal */
521     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
522         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
523     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
524         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
525     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
526         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
527     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
528         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
529
530     if (st->user_bandwidth != OPUS_BANDWIDTH_AUTO)
531         st->bandwidth = st->user_bandwidth;
532
533     /* Can't support higher than wideband for >20 ms frames */
534     if (frame_size > st->Fs/50 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
535        st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
536
537     /* CELT mode doesn't support mediumband, use wideband instead */
538     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
539         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
540
541     /* Chooses the appropriate mode for speech
542        *NEVER* switch to/from CELT-only mode here as this will */
543     if (st->mode == MODE_SILK_ONLY && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
544         st->mode = MODE_HYBRID;
545     if (st->mode == MODE_HYBRID && st->bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
546         st->mode = MODE_SILK_ONLY;
547
548     bytes_target = st->bitrate_bps * frame_size / (st->Fs * 8) - 1;
549
550     data += 1;
551
552     ec_enc_init(&enc, data, max_data_bytes-1);
553
554     ALLOC(pcm_buf, (st->delay_compensation+frame_size)*st->channels, opus_val16);
555     for (i=0;i<st->delay_compensation*st->channels;i++)
556        pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-st->delay_compensation)*st->channels+i];
557
558     if (st->mode == MODE_CELT_ONLY)
559        hp_freq_smth1 = SKP_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
560     else
561        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
562
563     st->variable_HP_smth2_Q15 = SKP_SMLAWB( st->variable_HP_smth2_Q15,
564           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
565
566     /* convert from log scale to Hertz */
567     cutoff_Hz = silk_log2lin( SKP_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
568
569     if (st->application == OPUS_APPLICATION_VOIP)
570     {
571        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[st->delay_compensation*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
572     } else {
573        for (i=0;i<frame_size*st->channels;i++)
574           pcm_buf[st->delay_compensation*st->channels + i] = pcm[i];
575     }
576
577     /* SILK processing */
578     if (st->mode != MODE_CELT_ONLY)
579     {
580 #ifdef FIXED_POINT
581        const opus_int16 *pcm_silk;
582 #else
583        VARDECL(opus_int16, pcm_silk);
584        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
585 #endif
586         st->silk_mode.bitRate = st->bitrate_bps - 8*st->Fs/frame_size;
587         if( st->mode == MODE_HYBRID ) {
588             st->silk_mode.bitRate /= st->stream_channels;
589             if( st->bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
590                 if( st->Fs == 100 * frame_size ) {
591                     /* 24 kHz, 10 ms */
592                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 2000 + st->use_vbr * 1000 ) * 2 ) / 3;
593                 } else {
594                     /* 24 kHz, 20 ms */
595                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 1000 + st->use_vbr * 1000 ) * 2 ) / 3;
596                 }
597             } else {
598                 if( st->Fs == 100 * frame_size ) {
599                     /* 48 kHz, 10 ms */
600                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 8000 + st->use_vbr * 3000 ) / 2;
601                 } else {
602                     /* 48 kHz, 20 ms */
603                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 9000 + st->use_vbr * 1000 ) / 2;
604                 }
605             }
606             st->silk_mode.bitRate *= st->stream_channels;
607             /* don't let SILK use more than 80% */
608             if( st->silk_mode.bitRate > ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5 ) {
609                 st->silk_mode.bitRate = ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5;
610             }
611         }
612
613         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
614         st->silk_mode.nChannelsAPI = st->channels;
615         st->silk_mode.nChannelsInternal = st->stream_channels;
616         if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
617             st->silk_mode.desiredInternalSampleRate = 8000;
618         } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
619             st->silk_mode.desiredInternalSampleRate = 12000;
620         } else {
621             SKP_assert( st->mode == MODE_HYBRID || st->bandwidth == OPUS_BANDWIDTH_WIDEBAND );
622             st->silk_mode.desiredInternalSampleRate = 16000;
623         }
624         if( st->mode == MODE_HYBRID ) {
625             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
626             st->silk_mode.minInternalSampleRate = 16000;
627         } else {
628             st->silk_mode.minInternalSampleRate = 8000;
629         }
630         st->silk_mode.maxInternalSampleRate = 16000;
631
632         /* Call SILK encoder for the low band */
633         nBytes = IMIN(1275, max_data_bytes-1);
634         if (prefill)
635         {
636             int zero=0;
637 #ifdef FIXED_POINT
638             pcm_silk = st->delay_buffer;
639 #else
640             for (i=0;i<st->encoder_buffer*st->channels;i++)
641                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
642 #endif
643             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
644         }
645
646 #ifdef FIXED_POINT
647         pcm_silk = pcm_buf+st->delay_compensation*st->channels;
648 #else
649         for (i=0;i<frame_size*st->channels;i++)
650             pcm_silk[i] = FLOAT2INT16(pcm_buf[st->delay_compensation*st->channels + i]);
651 #endif
652         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
653         if( ret ) {
654             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
655             /* Handle error */
656            return OPUS_INTERNAL_ERROR;
657         }
658         if (nBytes==0)
659         {
660            data[-1] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, silk_internal_bandwidth, st->stream_channels);
661            RESTORE_STACK;
662            return 1;
663         }
664         /* Extract SILK internal bandwidth for signaling in first byte */
665         if( st->mode == MODE_SILK_ONLY ) {
666             if( st->silk_mode.internalSampleRate == 8000 ) {
667                 silk_internal_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
668             } else if( st->silk_mode.internalSampleRate == 12000 ) {
669                 silk_internal_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
670             } else if( st->silk_mode.internalSampleRate == 16000 ) {
671                 silk_internal_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
672             }
673         } else {
674             SKP_assert( st->silk_mode.internalSampleRate == 16000 );
675         }
676     }
677
678     /* CELT processing */
679     {
680         int endband=21;
681
682         switch(st->bandwidth)
683         {
684             case OPUS_BANDWIDTH_NARROWBAND:
685                 endband = 13;
686                 break;
687             case OPUS_BANDWIDTH_MEDIUMBAND:
688             case OPUS_BANDWIDTH_WIDEBAND:
689                 endband = 17;
690                 break;
691             case OPUS_BANDWIDTH_SUPERWIDEBAND:
692                 endband = 19;
693                 break;
694             case OPUS_BANDWIDTH_FULLBAND:
695                 endband = 21;
696                 break;
697         }
698         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
699         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
700     }
701     if (st->mode != MODE_SILK_ONLY)
702     {
703         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
704         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(-1));
705         if (st->prev_mode == MODE_SILK_ONLY)
706         {
707             unsigned char dummy[10];
708             celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
709             celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
710             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
711             /* TODO: This wastes CPU a bit compared to just prefilling the buffer */
712             celt_encode_with_ec(celt_enc, &st->delay_buffer[(st->encoder_buffer-st->delay_compensation-st->Fs/400)*st->channels], st->Fs/400, dummy, 10, NULL);
713         } else {
714             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
715         }
716
717         if (st->mode == MODE_HYBRID)
718         {
719             int len;
720
721             len = (ec_tell(&enc)+7)>>3;
722             if( st->use_vbr ) {
723                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
724             } else {
725                 /* check if SILK used up too much */
726                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
727             }
728         } else {
729             if (st->use_vbr)
730             {
731                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
732                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
733                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps));
734                 nb_compr_bytes = max_data_bytes-1;
735             } else {
736                 nb_compr_bytes = bytes_target;
737             }
738         }
739
740     } else {
741         nb_compr_bytes = 0;
742     }
743
744     for (i=0;i<st->encoder_buffer*st->channels;i++)
745         st->delay_buffer[i] = pcm_buf[(frame_size+st->delay_compensation-st->encoder_buffer)*st->channels+i];
746
747
748     if( st->mode == MODE_HYBRID && st->stream_channels == 2 ) {
749         /* Apply stereo width reduction (at low bitrates) */
750         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
751             int width_Q14, delta_Q14, nSamples_8ms, diff;
752             nSamples_8ms = ( st->Fs * 8 ) / 1000;
753             width_Q14 = (1 << 14 ) - st->hybrid_stereo_width_Q14;
754             delta_Q14 = ( st->hybrid_stereo_width_Q14 - st->silk_mode.stereoWidth_Q14 ) / nSamples_8ms;
755             for( i = 0; i < nSamples_8ms; i++ ) {
756                 width_Q14 += delta_Q14;
757                 diff = pcm_buf[ 2*i+1 ] - (opus_int32)pcm_buf[ 2*i ];
758                 diff = ( diff * width_Q14 ) >> 15;
759                 pcm_buf[ 2*i ]   = (opus_int16)( pcm_buf[ 2*i ]   + diff );
760                 pcm_buf[ 2*i+1 ] = (opus_int16)( pcm_buf[ 2*i+1 ] - diff );
761             }
762             for( ; i < frame_size; i++ ) {
763                 diff = pcm_buf[ 2*i+1 ] - (opus_int32)pcm_buf[ 2*i ];
764                 diff = ( diff * width_Q14 ) >> 15;
765                 pcm_buf[ 2*i ]   = (opus_int16)( pcm_buf[ 2*i ]   + diff );
766                 pcm_buf[ 2*i+1 ] = (opus_int16)( pcm_buf[ 2*i+1 ] - diff );
767             }
768             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
769         }
770     }
771
772     if (st->mode != MODE_CELT_ONLY)
773     {
774         /* Check if we have a redundant 0-8 kHz band */
775         ec_enc_bit_logp(&enc, redundancy, 12);
776         if (redundancy)
777         {
778             /* Target the same bit-rate for redundancy as for the rest,
779                up to a max of 257 bytes */
780             redundancy_bytes = IMIN(257, st->bitrate_bps/1600);
781             ec_enc_bit_logp(&enc, celt_to_silk, 1);
782             if (st->mode == MODE_HYBRID)
783                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
784         }
785         start_band = 17;
786     }
787
788     if (st->mode == MODE_SILK_ONLY)
789     {
790         ret = (ec_tell(&enc)+7)>>3;
791         ec_enc_done(&enc);
792         /*When in LPC only mode it's perfectly
793           reasonable to strip off trailing zero bytes as
794           the required range decoder behavior is to
795           fill these in. This can't be done when the MDCT
796           modes are used because the decoder needs to know
797           the actual length for allocation purposes.*/
798         if(!redundancy)
799             while(ret>2&&data[ret-1]==0)ret--;
800         nb_compr_bytes = ret;
801     } else {
802        nb_compr_bytes = IMIN(1275-redundancy_bytes, nb_compr_bytes);
803        ec_enc_shrink(&enc, nb_compr_bytes);
804     }
805
806
807     /* 5 ms redundant frame for CELT->SILK */
808     if (redundancy && celt_to_silk)
809     {
810         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
811         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
812         celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
813         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
814         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
815     }
816
817     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
818
819     if (st->mode != MODE_SILK_ONLY)
820     {
821         ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
822     }
823
824     /* 5 ms redundant frame for SILK->CELT */
825     if (redundancy && !celt_to_silk)
826     {
827         int N2, N4;
828         N2 = st->Fs/200;
829         N4 = st->Fs/400;
830
831         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
832         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
833         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
834
835         /* TODO: We could speed up prefilling here */
836         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, data+nb_compr_bytes, redundancy_bytes, NULL);
837
838         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
839         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
840     }
841
842
843
844     /* Signalling the mode in the first byte */
845     data--;
846     data[0] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, silk_internal_bandwidth, st->stream_channels);
847
848     st->rangeFinal = enc.rng ^ redundant_rng;
849
850     if (to_celt)
851         st->prev_mode = MODE_CELT_ONLY;
852     else
853         st->prev_mode = st->mode;
854     st->first = 0;
855     RESTORE_STACK;
856     return ret+1+redundancy_bytes;
857 }
858
859 #ifdef FIXED_POINT
860
861 #ifndef DISABLE_FLOAT_API
862 int opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
863       unsigned char *data, int max_data_bytes)
864 {
865    int i, ret;
866    VARDECL(opus_int16, in);
867    ALLOC_STACK;
868
869    ALLOC(in, frame_size*st->channels, opus_int16);
870
871    for (i=0;i<frame_size*st->channels;i++)
872       in[i] = FLOAT2INT16(pcm[i]);
873    ret = opus_encode(st, in, frame_size, data, max_data_bytes);
874    RESTORE_STACK;
875    return ret;
876 }
877 #endif
878
879 #else
880 int opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
881       unsigned char *data, int max_data_bytes)
882 {
883    int i, ret;
884    VARDECL(float, in);
885    ALLOC_STACK;
886
887    ALLOC(in, frame_size*st->channels, float);
888
889    for (i=0;i<frame_size*st->channels;i++)
890       in[i] = (1./32768)*pcm[i];
891    ret = opus_encode_float(st, in, frame_size, data, max_data_bytes);
892    RESTORE_STACK;
893    return ret;
894 }
895 #endif
896
897
898 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
899 {
900     int ret;
901     CELTEncoder *celt_enc;
902     va_list ap;
903
904     ret = OPUS_OK;
905     va_start(ap, request);
906
907     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
908
909     switch (request)
910     {
911         case OPUS_SET_APPLICATION_REQUEST:
912         {
913             opus_int32 value = va_arg(ap, opus_int32);
914             st->application = value;
915         }
916         break;
917         case OPUS_GET_APPLICATION_REQUEST:
918         {
919             opus_int32 *value = va_arg(ap, opus_int32*);
920             *value = st->mode;
921         }
922         break;
923         case OPUS_SET_BITRATE_REQUEST:
924         {
925             opus_int32 value = va_arg(ap, opus_int32);
926             if (value != OPUS_BITRATE_AUTO)
927             {
928                 if (value <= 0)
929                     goto bad_arg;
930                 else if (value <= 500)
931                     value = 500;
932             }
933             st->user_bitrate_bps = value;
934         }
935         break;
936         case OPUS_GET_BITRATE_REQUEST:
937         {
938             opus_int32 *value = va_arg(ap, opus_int32*);
939             *value = st->bitrate_bps;
940         }
941         break;
942         case OPUS_SET_FORCE_MONO_REQUEST:
943         {
944             opus_int32 value = va_arg(ap, opus_int32);
945             st->force_mono = value;
946         }
947         break;
948         case OPUS_GET_FORCE_MONO_REQUEST:
949         {
950             opus_int32 *value = va_arg(ap, opus_int32*);
951             *value = !!st->force_mono;
952         }
953         break;
954         case OPUS_SET_BANDWIDTH_REQUEST:
955         {
956             opus_int32 value = va_arg(ap, opus_int32);
957             if (value < OPUS_BANDWIDTH_AUTO || value > OPUS_BANDWIDTH_FULLBAND)
958                 return OPUS_BAD_ARG;
959             st->user_bandwidth = value;
960             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
961                 st->silk_mode.maxInternalSampleRate = 8000;
962             } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
963                 st->silk_mode.maxInternalSampleRate = 12000;
964             } else {
965                 st->silk_mode.maxInternalSampleRate = 16000;
966             }
967         }
968         break;
969         case OPUS_GET_BANDWIDTH_REQUEST:
970         {
971             opus_int32 *value = va_arg(ap, opus_int32*);
972             *value = st->bandwidth;
973         }
974         break;
975         case OPUS_SET_DTX_REQUEST:
976         {
977             opus_int32 value = va_arg(ap, opus_int32);
978             st->silk_mode.useDTX = value;
979         }
980         break;
981         case OPUS_GET_DTX_REQUEST:
982         {
983             opus_int32 *value = va_arg(ap, opus_int32*);
984             *value = st->silk_mode.useDTX;
985         }
986         break;
987         case OPUS_SET_COMPLEXITY_REQUEST:
988         {
989             opus_int32 value = va_arg(ap, opus_int32);
990             st->silk_mode.complexity = value;
991             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
992         }
993         break;
994         case OPUS_GET_COMPLEXITY_REQUEST:
995         {
996             opus_int32 *value = va_arg(ap, opus_int32*);
997             *value = st->silk_mode.complexity;
998         }
999         break;
1000         case OPUS_SET_INBAND_FEC_REQUEST:
1001         {
1002             opus_int32 value = va_arg(ap, opus_int32);
1003             st->silk_mode.useInBandFEC = value;
1004         }
1005         break;
1006         case OPUS_GET_INBAND_FEC_REQUEST:
1007         {
1008             opus_int32 *value = va_arg(ap, opus_int32*);
1009             *value = st->silk_mode.useInBandFEC;
1010         }
1011         break;
1012         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1013         {
1014             opus_int32 value = va_arg(ap, opus_int32);
1015             if (value < 0 || value > 100)
1016                 return OPUS_BAD_ARG;
1017             st->silk_mode.packetLossPercentage = value;
1018             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
1019         }
1020         break;
1021         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1022         {
1023             opus_int32 *value = va_arg(ap, opus_int32*);
1024             *value = st->silk_mode.packetLossPercentage;
1025         }
1026         break;
1027         case OPUS_SET_VBR_REQUEST:
1028         {
1029             opus_int32 value = va_arg(ap, opus_int32);
1030             st->use_vbr = value;
1031             st->silk_mode.useCBR = 1-value;
1032         }
1033         break;
1034         case OPUS_GET_VBR_REQUEST:
1035         {
1036             opus_int32 *value = va_arg(ap, opus_int32*);
1037             *value = st->use_vbr;
1038         }
1039         break;
1040         case OPUS_SET_VOICE_RATIO_REQUEST:
1041         {
1042             opus_int32 value = va_arg(ap, opus_int32);
1043             if (value>100 || value<0)
1044                 goto bad_arg;
1045             st->voice_ratio = value;
1046         }
1047         break;
1048         case OPUS_GET_VOICE_RATIO_REQUEST:
1049         {
1050             opus_int32 *value = va_arg(ap, opus_int32*);
1051             *value = st->voice_ratio;
1052         }
1053         break;
1054         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1055         {
1056             opus_int32 value = va_arg(ap, opus_int32);
1057             st->vbr_constraint = value;
1058         }
1059         break;
1060         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1061         {
1062             opus_int32 *value = va_arg(ap, opus_int32*);
1063             *value = st->vbr_constraint;
1064         }
1065         break;
1066         case OPUS_SET_SIGNAL_REQUEST:
1067         {
1068             opus_int32 value = va_arg(ap, opus_int32);
1069             st->signal_type = value;
1070         }
1071         break;
1072         case OPUS_GET_SIGNAL_REQUEST:
1073         {
1074             opus_int32 *value = va_arg(ap, opus_int32*);
1075             *value = st->signal_type;
1076         }
1077         break;
1078         case OPUS_GET_LOOKAHEAD_REQUEST:
1079         {
1080             opus_int32 *value = va_arg(ap, opus_int32*);
1081             *value = st->delay_compensation+st->Fs/400;
1082         }
1083         break;
1084         case OPUS_GET_FINAL_RANGE_REQUEST:
1085         {
1086             opus_uint32 *value = va_arg(ap, opus_uint32*);
1087             *value = st->rangeFinal;
1088         }
1089         break;
1090         case OPUS_RESET_STATE:
1091         {
1092            void *silk_enc;
1093            silk_EncControlStruct dummy;
1094            silk_enc = (char*)st+st->silk_enc_offset;
1095
1096            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
1097                  opus_encoder_get_size(st->channels)-
1098                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
1099
1100            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1101            silk_InitEncoder( silk_enc, &dummy );
1102            st->stream_channels = st->channels;
1103            st->hybrid_stereo_width_Q14             = 1 << 14;
1104            st->first = 1;
1105            st->mode = MODE_HYBRID;
1106            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
1107            st->variable_HP_smth2_Q15 = SKP_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1108         }
1109         break;
1110         default:
1111             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
1112             ret = OPUS_UNIMPLEMENTED;
1113             break;
1114     }
1115     va_end(ap);
1116     return ret;
1117 bad_arg:
1118     va_end(ap);
1119     return OPUS_BAD_ARG;
1120 }
1121
1122 void opus_encoder_destroy(OpusEncoder *st)
1123 {
1124     opus_free(st);
1125 }