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