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