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