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