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