Including redundant frames in the final range coder state
[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     if (400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
265          50*frame_size != st->Fs &&  25*frame_size != st->Fs &&  50*frame_size != 3*st->Fs)
266         return OPUS_BAD_ARG;
267     silk_enc = (char*)st+st->silk_enc_offset;
268     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
269
270     if (st->user_bitrate_bps==OPUS_BITRATE_AUTO)
271         st->bitrate_bps = 60*st->Fs/frame_size + st->Fs*st->channels;
272     else
273         st->bitrate_bps = st->user_bitrate_bps;
274
275     /* Rate-dependent mono-stereo decision */
276     if (st->force_mono)
277     {
278         st->stream_channels = 1;
279     } else if (st->mode == MODE_CELT_ONLY && st->channels == 2)
280     {
281         opus_int32 decision_rate;
282         decision_rate = st->bitrate_bps + st->voice_ratio*st->voice_ratio;
283         /* Add some hysteresis */
284         if (st->stream_channels == 2)
285             decision_rate += 4000;
286         else
287             decision_rate -= 4000;
288         if (decision_rate>48000)
289             st->stream_channels = 2;
290         else
291             st->stream_channels = 1;
292     } else {
293             st->stream_channels = st->channels;
294     }
295
296 #ifdef FUZZING
297     if (st->channels == 2 && (rand()&0x1F)==0)
298        st->stream_channels = 3-st->stream_channels;
299 #endif
300
301     /* Equivalent bit-rate for mono */
302     mono_rate = st->bitrate_bps;
303     if (st->stream_channels==2)
304         mono_rate = 2*mono_rate/3;
305     /* Compensate for smaller frame sizes assuming an equivalent overhead
306        of 60 bits/frame */
307     mono_rate -= 60*(st->Fs/frame_size - 50);
308
309 #ifdef FUZZING
310     if ((rand()&0xF)==0)
311     {
312        if ((rand()&0x1)==0)
313           st->mode = MODE_CELT_ONLY;
314        else
315           st->mode = MODE_SILK_ONLY;
316     } else {
317        if (st->prev_mode==MODE_CELT_ONLY)
318           st->mode = MODE_CELT_ONLY;
319        else
320           st->mode = MODE_SILK_ONLY;
321     }
322 #else
323     /* Mode selection depending on application and signal type */
324     if (st->application==OPUS_APPLICATION_VOIP)
325     {
326         opus_int32 threshold = 20000;
327         /* Hysteresis */
328         if (st->prev_mode == MODE_CELT_ONLY)
329             threshold -= 4000;
330         else if (st->prev_mode>0)
331             threshold += 4000;
332
333         /* OPUS_APPLICATION_VOIP defaults to MODE_SILK_ONLY */
334         if (st->signal_type == OPUS_SIGNAL_MUSIC && mono_rate > threshold)
335             st->mode = MODE_CELT_ONLY;
336         else
337             st->mode = MODE_SILK_ONLY;
338     } else {/* OPUS_APPLICATION_AUDIO */
339         opus_int32 threshold;
340         /* SILK/CELT threshold is higher for voice than for music */
341         threshold = 36000;
342         if (st->signal_type == OPUS_SIGNAL_MUSIC)
343             threshold -= 20000;
344         else if (st->signal_type == OPUS_SIGNAL_VOICE)
345             threshold += 8000;
346
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         if (mono_rate>threshold)
354             st->mode = MODE_CELT_ONLY;
355         else
356             st->mode = MODE_SILK_ONLY;
357     }
358 #endif
359     /* Override the chosen mode to make sure we meet the requested frame size */
360     if (st->mode == MODE_CELT_ONLY && frame_size > st->Fs/50)
361        st->mode = MODE_SILK_ONLY;
362     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
363        st->mode = MODE_CELT_ONLY;
364
365     if (st->prev_mode > 0 &&
366         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
367     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
368     {
369         redundancy = 1;
370         celt_to_silk = (st->mode != MODE_CELT_ONLY);
371         if (!celt_to_silk)
372         {
373             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
374             if (frame_size >= st->Fs/100)
375             {
376                 st->mode = st->prev_mode;
377                 to_celt = 1;
378             } else {
379                 redundancy=0;
380             }
381         }
382     }
383     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
384     {
385         silk_EncControlStruct dummy;
386         silk_InitEncoder( silk_enc, &dummy);
387         prefill=1;
388     }
389
390     /* Automatic (rate-dependent) bandwidth selection */
391     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
392     {
393         const int *bandwidth_thresholds;
394         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
395
396         bandwidth_thresholds = st->mode == MODE_CELT_ONLY ? audio_bandwidth_thresholds : voice_bandwidth_thresholds;
397         do {
398             int threshold, hysteresis;
399             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
400             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
401             if (!st->first)
402             {
403                 if (st->bandwidth >= bandwidth)
404                     threshold -= hysteresis;
405                 else
406                     threshold += hysteresis;
407             }
408             if (mono_rate >= threshold)
409                 break;
410         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
411         st->bandwidth = bandwidth;
412         /* Prevents any transition to SWB/FB until the SILK layer has fully
413            switched to WB mode and turned the variable LP filter off */
414         if (st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
415             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
416     }
417
418     /* Prevents Opus from wasting bits on frequencies that are above
419        the Nyquist rate of the input signal */
420     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
421         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
422     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
423         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
424     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
425         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
426     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
427         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
428
429     if (st->user_bandwidth != OPUS_BANDWIDTH_AUTO)
430         st->bandwidth = st->user_bandwidth;
431
432     /* Can't support higher than wideband for >20 ms frames */
433     if (frame_size > st->Fs/50 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
434        st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
435
436     /* CELT mode doesn't support mediumband, use wideband instead */
437     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
438         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
439
440     /* Chooses the appropriate mode for speech
441        *NEVER* switch to/from CELT-only mode here as this will */
442     if (st->mode == MODE_SILK_ONLY && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
443         st->mode = MODE_HYBRID;
444     if (st->mode == MODE_HYBRID && st->bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
445         st->mode = MODE_SILK_ONLY;
446
447     bytes_target = st->bitrate_bps * frame_size / (st->Fs * 8) - 1;
448
449     data += 1;
450
451     ec_enc_init(&enc, data, max_data_bytes-1);
452
453     /* SILK processing */
454     if (st->mode != MODE_CELT_ONLY)
455     {
456 #ifdef FIXED_POINT
457        const opus_int16 *pcm_silk;
458 #else
459        VARDECL(opus_int16, pcm_silk);
460        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
461 #endif
462         st->silk_mode.bitRate = st->bitrate_bps - 8*st->Fs/frame_size;
463         if( st->mode == MODE_HYBRID ) {
464             st->silk_mode.bitRate /= st->stream_channels;
465             if( st->bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
466                 if( st->Fs == 100 * frame_size ) {
467                     /* 24 kHz, 10 ms */
468                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 2000 + st->use_vbr * 1000 ) * 2 ) / 3;
469                 } else {
470                     /* 24 kHz, 20 ms */
471                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 1000 + st->use_vbr * 1000 ) * 2 ) / 3;
472                 }
473             } else {
474                 if( st->Fs == 100 * frame_size ) {
475                     /* 48 kHz, 10 ms */
476                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 8000 + st->use_vbr * 3000 ) / 2;
477                 } else {
478                     /* 48 kHz, 20 ms */
479                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 9000 + st->use_vbr * 1000 ) / 2;
480                 }
481             }
482             st->silk_mode.bitRate *= st->stream_channels;
483             /* don't let SILK use more than 80% */
484             if( st->silk_mode.bitRate > ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5 ) {
485                 st->silk_mode.bitRate = ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5;
486             }
487         }
488
489         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
490         st->silk_mode.nChannelsAPI = st->channels;
491         st->silk_mode.nChannelsInternal = st->stream_channels;
492         if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
493             st->silk_mode.desiredInternalSampleRate = 8000;
494         } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
495             st->silk_mode.desiredInternalSampleRate = 12000;
496         } else {
497             SKP_assert( st->mode == MODE_HYBRID || st->bandwidth == OPUS_BANDWIDTH_WIDEBAND );
498             st->silk_mode.desiredInternalSampleRate = 16000;
499         }
500         if( st->mode == MODE_HYBRID ) {
501             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
502             st->silk_mode.minInternalSampleRate = 16000;
503         } else {
504             st->silk_mode.minInternalSampleRate = 8000;
505         }
506         st->silk_mode.maxInternalSampleRate = 16000;
507
508         /* Call SILK encoder for the low band */
509         nBytes = IMIN(1275, max_data_bytes-1);
510         if (prefill)
511         {
512             int zero=0;
513 #ifdef FIXED_POINT
514             pcm_silk = st->delay_buffer;
515 #else
516             for (i=0;i<st->encoder_buffer*st->channels;i++)
517                pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
518 #endif
519             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
520         }
521
522 #ifdef FIXED_POINT
523         pcm_silk = pcm;
524 #else
525         for (i=0;i<frame_size*st->channels;i++)
526            pcm_silk[i] = FLOAT2INT16(pcm[i]);
527 #endif
528         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
529         if( ret ) {
530             fprintf (stderr, "SILK encode error: %d\n", ret);
531             /* Handle error */
532         }
533         if (nBytes==0)
534         {
535            data[-1] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, st->stream_channels);
536            return 1;
537         }
538         /* Extract SILK internal bandwidth for signaling in first byte */
539         if( st->mode == MODE_SILK_ONLY ) {
540             if( st->silk_mode.internalSampleRate == 8000 ) {
541                 silk_internal_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
542             } else if( st->silk_mode.internalSampleRate == 12000 ) {
543                 silk_internal_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
544             } else if( st->silk_mode.internalSampleRate == 16000 ) {
545                 silk_internal_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
546             }
547         } else {
548             SKP_assert( st->silk_mode.internalSampleRate == 16000 );
549         }
550     }
551
552     /* CELT processing */
553     {
554         int endband=21;
555
556         switch(st->bandwidth)
557         {
558             case OPUS_BANDWIDTH_NARROWBAND:
559                 endband = 13;
560                 break;
561             case OPUS_BANDWIDTH_MEDIUMBAND:
562             case OPUS_BANDWIDTH_WIDEBAND:
563                 endband = 17;
564                 break;
565             case OPUS_BANDWIDTH_SUPERWIDEBAND:
566                 endband = 19;
567                 break;
568             case OPUS_BANDWIDTH_FULLBAND:
569                 endband = 21;
570                 break;
571         }
572         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
573         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
574     }
575     if (st->mode != MODE_SILK_ONLY)
576     {
577         celt_encoder_ctl(celt_enc, CELT_SET_VBR(0));
578         celt_encoder_ctl(celt_enc, CELT_SET_BITRATE(-1));
579         if (st->prev_mode == MODE_SILK_ONLY)
580         {
581             unsigned char dummy[10];
582             celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
583             celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
584             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
585             /* TODO: This wastes CPU a bit compared to just prefilling the buffer */
586             celt_encode_native(celt_enc, &st->delay_buffer[(st->encoder_buffer-st->delay_compensation-st->Fs/400)*st->channels], st->Fs/400, dummy, 10);
587         } else {
588             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
589         }
590
591         if (st->mode == MODE_HYBRID)
592         {
593             int len;
594
595             len = (ec_tell(&enc)+7)>>3;
596             if( st->use_vbr ) {
597                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
598             } else {
599                 /* check if SILK used up too much */
600                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
601             }
602         } else {
603             if (st->use_vbr)
604             {
605                 celt_encoder_ctl(celt_enc, CELT_SET_VBR(1));
606                 celt_encoder_ctl(celt_enc, CELT_SET_VBR_CONSTRAINT(st->vbr_constraint));
607                 celt_encoder_ctl(celt_enc, CELT_SET_BITRATE(st->bitrate_bps));
608                 nb_compr_bytes = max_data_bytes-1;
609             } else {
610                 nb_compr_bytes = bytes_target;
611             }
612         }
613
614     } else {
615         nb_compr_bytes = 0;
616     }
617
618     ALLOC(pcm_buf, IMAX(frame_size, st->Fs/200)*st->channels, opus_val16);
619     for (i=0;i<IMIN(frame_size, st->delay_compensation)*st->channels;i++)
620         pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-st->delay_compensation)*st->channels+i];
621     for (;i<frame_size*st->channels;i++)
622         pcm_buf[i] = pcm[i-st->delay_compensation*st->channels];
623
624     if( st->mode == MODE_HYBRID && st->stream_channels == 2 ) {
625         /* Apply stereo width reduction (at low bitrates) */
626         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
627             int width_Q14, delta_Q14, nSamples_8ms, diff;
628             nSamples_8ms = ( st->Fs * 8 ) / 1000;
629             width_Q14 = (1 << 14 ) - st->hybrid_stereo_width_Q14;
630             delta_Q14 = ( st->hybrid_stereo_width_Q14 - st->silk_mode.stereoWidth_Q14 ) / nSamples_8ms;
631             for( i = 0; i < nSamples_8ms; i++ ) {
632                 width_Q14 += delta_Q14;
633                 diff = pcm_buf[ 2*i+1 ] - (opus_int32)pcm_buf[ 2*i ];
634                 diff = ( diff * width_Q14 ) >> 15;
635                 pcm_buf[ 2*i ]   = (opus_int16)( pcm_buf[ 2*i ]   + diff );
636                 pcm_buf[ 2*i+1 ] = (opus_int16)( pcm_buf[ 2*i+1 ] - diff );
637             }
638             for( ; i < frame_size; i++ ) {
639                 diff = pcm_buf[ 2*i+1 ] - (opus_int32)pcm_buf[ 2*i ];
640                 diff = ( diff * width_Q14 ) >> 15;
641                 pcm_buf[ 2*i ]   = (opus_int16)( pcm_buf[ 2*i ]   + diff );
642                 pcm_buf[ 2*i+1 ] = (opus_int16)( pcm_buf[ 2*i+1 ] - diff );
643             }
644             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
645         }
646     }
647
648     if (st->mode != MODE_CELT_ONLY)
649     {
650         /* Check if we have a redundant 0-8 kHz band */
651         ec_enc_bit_logp(&enc, redundancy, 12);
652         if (redundancy)
653         {
654             /* Target the same bit-rate for redundancy as for the rest,
655                up to a max of 257 bytes */
656             redundancy_bytes = IMIN(257, st->bitrate_bps/1600);
657             ec_enc_bit_logp(&enc, celt_to_silk, 1);
658             if (st->mode == MODE_HYBRID)
659                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
660         }
661         start_band = 17;
662     }
663
664     if (st->mode == MODE_SILK_ONLY)
665     {
666         ret = (ec_tell(&enc)+7)>>3;
667         ec_enc_done(&enc);
668         /*When in LPC only mode it's perfectly
669           reasonable to strip off trailing zero bytes as
670           the required range decoder behavior is to
671           fill these in. This can't be done when the MDCT
672           modes are used because the decoder needs to know
673           the actual length for allocation purposes.*/
674         if(!redundancy)
675             while(ret>2&&data[ret-1]==0)ret--;
676         nb_compr_bytes = ret;
677     } else {
678        nb_compr_bytes = IMIN(1275-redundancy_bytes, nb_compr_bytes);
679        ec_enc_shrink(&enc, nb_compr_bytes);
680     }
681
682
683     /* 5 ms redundant frame for CELT->SILK */
684     if (redundancy && celt_to_silk)
685     {
686         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
687         celt_encoder_ctl(celt_enc, CELT_SET_VBR(0));
688         celt_encode_native(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes);
689         celt_encoder_ctl(celt_enc, CELT_GET_RANGE(&redundant_rng));
690         celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
691     }
692
693     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
694
695     if (st->mode != MODE_SILK_ONLY)
696     {
697         ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
698     }
699
700     /* 5 ms redundant frame for SILK->CELT */
701     if (redundancy && !celt_to_silk)
702     {
703         int N2, N4;
704         N2 = st->Fs/200;
705         N4 = st->Fs/400;
706
707         celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
708         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
709         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
710
711         /* TODO: We could speed up prefilling here */
712         celt_encode_native(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, data+nb_compr_bytes, redundancy_bytes);
713
714         celt_encode_native(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes);
715         celt_encoder_ctl(celt_enc, CELT_GET_RANGE(&redundant_rng));
716     }
717
718
719     if (frame_size>st->encoder_buffer)
720     {
721         for (i=0;i<st->encoder_buffer*st->channels;i++)
722                 st->delay_buffer[i] = pcm[(frame_size-st->encoder_buffer)*st->channels+i];
723     } else {
724         int tmp = st->encoder_buffer-frame_size;
725         for (i=0;i<tmp*st->channels;i++)
726             st->delay_buffer[i] = st->delay_buffer[i+frame_size*st->channels];
727         for (i=0;i<frame_size*st->channels;i++)
728             st->delay_buffer[tmp*st->channels+i] = pcm[i];
729     }
730
731     /* Signalling the mode in the first byte */
732     data--;
733     data[0] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, st->stream_channels);
734
735     st->rangeFinal = enc.rng ^ redundant_rng;
736
737     if (to_celt)
738         st->prev_mode = MODE_CELT_ONLY;
739     else
740         st->prev_mode = st->mode;
741     st->first = 0;
742     return ret+1+redundancy_bytes;
743 }
744
745 #ifdef FIXED_POINT
746
747 #ifndef DISABLE_FLOAT_API
748 int opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
749       unsigned char *data, int max_data_bytes)
750 {
751    int i, ret;
752    VARDECL(opus_int16, in);
753    ALLOC_STACK;
754
755    ALLOC(in, frame_size*st->channels, opus_int16);
756
757    for (i=0;i<frame_size*st->channels;i++)
758       in[i] = FLOAT2INT16(pcm[i]);
759    ret = opus_encode(st, in, frame_size, data, max_data_bytes);
760    RESTORE_STACK;
761    return ret;
762 }
763 #endif
764
765 #else
766 int opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
767       unsigned char *data, int max_data_bytes)
768 {
769    int i, ret;
770    VARDECL(float, in);
771    ALLOC_STACK;
772
773    ALLOC(in, frame_size*st->channels, float);
774
775    for (i=0;i<frame_size*st->channels;i++)
776       in[i] = (1./32768)*pcm[i];
777    ret = opus_encode_float(st, in, frame_size, data, max_data_bytes);
778    RESTORE_STACK;
779    return ret;
780 }
781 #endif
782
783
784 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
785 {
786     CELTEncoder *celt_enc;
787     va_list ap;
788
789     va_start(ap, request);
790
791     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
792
793     switch (request)
794     {
795         case OPUS_SET_APPLICATION_REQUEST:
796         {
797             int value = va_arg(ap, int);
798             st->application = value;
799         }
800         break;
801         case OPUS_GET_APPLICATION_REQUEST:
802         {
803             int *value = va_arg(ap, int*);
804             *value = st->mode;
805         }
806         break;
807         case OPUS_SET_BITRATE_REQUEST:
808         {
809             int value = va_arg(ap, int);
810             if (value != OPUS_BITRATE_AUTO)
811             {
812                 if (value <= 0)
813                     goto bad_arg;
814                 else if (value <= 500)
815                     value = 500;
816             }
817             st->user_bitrate_bps = value;
818         }
819         break;
820         case OPUS_GET_BITRATE_REQUEST:
821         {
822             int *value = va_arg(ap, int*);
823             *value = st->bitrate_bps;
824         }
825         break;
826         case OPUS_SET_FORCE_MONO_REQUEST:
827         {
828             int value = va_arg(ap, int);
829             st->force_mono = value;
830         }
831         break;
832         case OPUS_GET_FORCE_MONO_REQUEST:
833         {
834             int *value = va_arg(ap, int*);
835             *value = !!st->force_mono;
836         }
837         break;
838         case OPUS_SET_BANDWIDTH_REQUEST:
839         {
840             int value = va_arg(ap, int);
841             if (value < OPUS_BANDWIDTH_AUTO || value > OPUS_BANDWIDTH_FULLBAND)
842                 return OPUS_BAD_ARG;
843             st->user_bandwidth = value;
844             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
845                 st->silk_mode.maxInternalSampleRate = 8000;
846             } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
847                 st->silk_mode.maxInternalSampleRate = 12000;
848             } else {
849                 st->silk_mode.maxInternalSampleRate = 16000;
850             }
851         }
852         break;
853         case OPUS_GET_BANDWIDTH_REQUEST:
854         {
855             int *value = va_arg(ap, int*);
856             *value = st->bandwidth;
857         }
858         break;
859         case OPUS_SET_DTX_FLAG_REQUEST:
860         {
861             int value = va_arg(ap, int);
862             st->silk_mode.useDTX = value;
863         }
864         break;
865         case OPUS_GET_DTX_FLAG_REQUEST:
866         {
867             int *value = va_arg(ap, int*);
868             *value = st->silk_mode.useDTX;
869         }
870         break;
871         case OPUS_SET_COMPLEXITY_REQUEST:
872         {
873             int value = va_arg(ap, int);
874             st->silk_mode.complexity = value;
875             celt_encoder_ctl(celt_enc, CELT_SET_COMPLEXITY(value));
876         }
877         break;
878         case OPUS_GET_COMPLEXITY_REQUEST:
879         {
880             int *value = va_arg(ap, int*);
881             *value = st->silk_mode.complexity;
882         }
883         break;
884         case OPUS_SET_INBAND_FEC_FLAG_REQUEST:
885         {
886             int value = va_arg(ap, int);
887             st->silk_mode.useInBandFEC = value;
888         }
889         break;
890         case OPUS_GET_INBAND_FEC_FLAG_REQUEST:
891         {
892             int *value = va_arg(ap, int*);
893             *value = st->silk_mode.useInBandFEC;
894         }
895         break;
896         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
897         {
898             int value = va_arg(ap, int);
899             if (value < 0 || value > 100)
900                 return OPUS_BAD_ARG;
901             st->silk_mode.packetLossPercentage = value;
902             celt_encoder_ctl(celt_enc, CELT_SET_LOSS_PERC(value));
903         }
904         break;
905         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
906         {
907             int *value = va_arg(ap, int*);
908             *value = st->silk_mode.packetLossPercentage;
909         }
910         break;
911         case OPUS_SET_VBR_REQUEST:
912         {
913             int value = va_arg(ap, int);
914             st->use_vbr = value;
915             st->silk_mode.useCBR = 1-value;
916         }
917         break;
918         case OPUS_GET_VBR_REQUEST:
919         {
920             int *value = va_arg(ap, int*);
921             *value = st->use_vbr;
922         }
923         break;
924         case OPUS_SET_VOICE_RATIO_REQUEST:
925         {
926             int value = va_arg(ap, int);
927             if (value>100 || value<0)
928                 goto bad_arg;
929             st->voice_ratio = value;
930         }
931         break;
932         case OPUS_GET_VOICE_RATIO_REQUEST:
933         {
934             int *value = va_arg(ap, int*);
935             *value = st->voice_ratio;
936         }
937         break;
938         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
939         {
940             int value = va_arg(ap, int);
941             st->vbr_constraint = value;
942         }
943         break;
944         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
945         {
946             int *value = va_arg(ap, int*);
947             *value = st->vbr_constraint;
948         }
949         break;
950         case OPUS_SET_SIGNAL_REQUEST:
951         {
952             int value = va_arg(ap, int);
953             st->signal_type = value;
954         }
955         break;
956         case OPUS_GET_SIGNAL_REQUEST:
957         {
958             int *value = va_arg(ap, int*);
959             *value = st->signal_type;
960         }
961         break;
962         case OPUS_GET_LOOKAHEAD_REQUEST:
963         {
964             int *value = va_arg(ap, int*);
965             *value = st->delay_compensation+st->Fs/400;
966         }
967         break;
968         default:
969             fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);
970             break;
971     }
972     va_end(ap);
973     return OPUS_OK;
974 bad_arg:
975     va_end(ap);
976     return OPUS_BAD_ARG;
977 }
978
979 void opus_encoder_destroy(OpusEncoder *st)
980 {
981     free(st);
982 }
983
984 int opus_encoder_get_final_range(OpusEncoder *st)
985 {
986     return st->rangeFinal;
987 }