Properly take into account the frame size to decide the mode
[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     /* Override the chosen mode to make sure we meet the requested frame size */
285     if (st->mode == MODE_CELT_ONLY && frame_size > st->Fs/50)
286        st->mode = MODE_SILK_ONLY;
287     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
288        st->mode = MODE_CELT_ONLY;
289
290     if (st->prev_mode > 0 &&
291         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
292     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
293     {
294         redundancy = 1;
295         celt_to_silk = (st->mode != MODE_CELT_ONLY);
296         if (!celt_to_silk)
297         {
298             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
299             if (frame_size >= st->Fs/100)
300             {
301                 st->mode = st->prev_mode;
302                 to_celt = 1;
303             } else {
304                 redundancy=0;
305             }
306         }
307     }
308     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
309     {
310         silk_EncControlStruct dummy;
311         silk_InitEncoder( silk_enc, &dummy);
312         prefill=1;
313     }
314
315     /* Automatic (rate-dependent) bandwidth selection */
316     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
317     {
318         const int *bandwidth_thresholds;
319         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
320
321         bandwidth_thresholds = st->mode == MODE_CELT_ONLY ? audio_bandwidth_thresholds : voice_bandwidth_thresholds;
322         do {
323             int threshold, hysteresis;
324             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
325             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
326             if (!st->first)
327             {
328                 if (st->bandwidth >= bandwidth)
329                     threshold -= hysteresis;
330                 else
331                     threshold += hysteresis;
332             }
333             if (mono_rate >= threshold)
334                 break;
335         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
336         st->bandwidth = bandwidth;
337         /* Prevents any transition to SWB/FB until the SILK layer has fully
338            switched to WB mode and turned the variable LP filter off */
339         if (st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
340             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
341     }
342
343     /* Prevents Opus from wasting bits on frequencies that are above
344        the Nyquist rate of the input signal */
345     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
346         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
347     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
348         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
349     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
350         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
351     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
352         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
353
354     if (st->user_bandwidth != OPUS_BANDWIDTH_AUTO)
355         st->bandwidth = st->user_bandwidth;
356
357     /* Can't support higher than wideband for >20 ms frames */
358     if (frame_size > st->Fs/50 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
359        st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
360
361     /* CELT mode doesn't support mediumband, use wideband instead */
362     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
363         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
364
365     /* Chooses the appropriate mode for speech
366        *NEVER* switch to/from CELT-only mode here as this will */
367     if (st->mode == MODE_SILK_ONLY && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
368         st->mode = MODE_HYBRID;
369     if (st->mode == MODE_HYBRID && st->bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
370         st->mode = MODE_SILK_ONLY;
371
372     bytes_target = st->bitrate_bps * frame_size / (st->Fs * 8) - 1;
373
374     data += 1;
375
376     ec_enc_init(&enc, data, max_data_bytes-1);
377
378     /* SILK processing */
379     if (st->mode != MODE_CELT_ONLY)
380     {
381         st->silk_mode.bitRate = st->bitrate_bps - 8*st->Fs/frame_size;
382         if( st->mode == MODE_HYBRID ) {
383             st->silk_mode.bitRate /= st->stream_channels;
384             if( st->bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
385                 if( st->Fs == 100 * frame_size ) {
386                     /* 24 kHz, 10 ms */
387                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 2000 + st->use_vbr * 1000 ) * 2 ) / 3;
388                 } else {
389                     /* 24 kHz, 20 ms */
390                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 1000 + st->use_vbr * 1000 ) * 2 ) / 3;
391                 }
392             } else {
393                 if( st->Fs == 100 * frame_size ) {
394                     /* 48 kHz, 10 ms */
395                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 8000 + st->use_vbr * 3000 ) / 2;
396                 } else {
397                     /* 48 kHz, 20 ms */
398                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 9000 + st->use_vbr * 1000 ) / 2;
399                 }
400             }
401             st->silk_mode.bitRate *= st->stream_channels;
402             /* don't let SILK use more than 80% */
403             if( st->silk_mode.bitRate > ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5 ) {
404                 st->silk_mode.bitRate = ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5;
405             }
406         }
407
408         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
409         st->silk_mode.nChannelsAPI = st->channels;
410         st->silk_mode.nChannelsInternal = st->stream_channels;
411         if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
412             st->silk_mode.desiredInternalSampleRate = 8000;
413         } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
414             st->silk_mode.desiredInternalSampleRate = 12000;
415         } else {
416             SKP_assert( st->mode == MODE_HYBRID || st->bandwidth == OPUS_BANDWIDTH_WIDEBAND );
417             st->silk_mode.desiredInternalSampleRate = 16000;
418         }
419         if( st->mode == MODE_HYBRID ) {
420             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
421             st->silk_mode.minInternalSampleRate = 16000;
422         } else {
423             st->silk_mode.minInternalSampleRate = 8000;
424         }
425         st->silk_mode.maxInternalSampleRate = 16000;
426
427         /* Call SILK encoder for the low band */
428         nBytes = max_data_bytes-1;
429         if (prefill)
430         {
431             int zero=0;
432             silk_Encode( silk_enc, &st->silk_mode, st->delay_buffer, st->encoder_buffer, NULL, &zero, 1 );
433         }
434
435         ret = silk_Encode( silk_enc, &st->silk_mode, pcm, frame_size, &enc, &nBytes, 0 );
436         if( ret ) {
437             fprintf (stderr, "SILK encode error: %d\n", ret);
438             /* Handle error */
439         }
440         if (nBytes==0)
441             return 0;
442         /* Extract SILK internal bandwidth for signaling in first byte */
443         if( st->mode == MODE_SILK_ONLY ) {
444             if( st->silk_mode.internalSampleRate == 8000 ) {
445                 silk_internal_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
446             } else if( st->silk_mode.internalSampleRate == 12000 ) {
447                 silk_internal_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
448             } else if( st->silk_mode.internalSampleRate == 16000 ) {
449                 silk_internal_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
450             }
451         } else {
452             SKP_assert( st->silk_mode.internalSampleRate == 16000 );
453         }
454     }
455
456     /* CELT processing */
457     {
458         int endband=21;
459
460         switch(st->bandwidth)
461         {
462             case OPUS_BANDWIDTH_NARROWBAND:
463                 endband = 13;
464                 break;
465             case OPUS_BANDWIDTH_MEDIUMBAND:
466             case OPUS_BANDWIDTH_WIDEBAND:
467                 endband = 17;
468                 break;
469             case OPUS_BANDWIDTH_SUPERWIDEBAND:
470                 endband = 19;
471                 break;
472             case OPUS_BANDWIDTH_FULLBAND:
473                 endband = 21;
474                 break;
475         }
476         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
477         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
478     }
479     if (st->mode != MODE_SILK_ONLY)
480     {
481         celt_encoder_ctl(celt_enc, CELT_SET_VBR(0));
482         celt_encoder_ctl(celt_enc, CELT_SET_BITRATE(510000));
483         if (st->prev_mode == MODE_SILK_ONLY)
484         {
485             unsigned char dummy[10];
486             celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
487             celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
488             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
489             /* TODO: This wastes CPU a bit compared to just prefilling the buffer */
490             celt_encode(celt_enc, &st->delay_buffer[(st->encoder_buffer-st->delay_compensation-st->Fs/400)*st->channels], st->Fs/400, dummy, 10);
491         } else {
492             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
493         }
494
495         if (st->mode == MODE_HYBRID)
496         {
497             int len;
498
499             len = (ec_tell(&enc)+7)>>3;
500             if( st->use_vbr ) {
501                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
502             } else {
503                 /* check if SILK used up too much */
504                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
505             }
506         } else {
507             if (st->use_vbr)
508             {
509                 celt_encoder_ctl(celt_enc, CELT_SET_VBR(1));
510                 celt_encoder_ctl(celt_enc, CELT_SET_VBR_CONSTRAINT(st->vbr_constraint));
511                 celt_encoder_ctl(celt_enc, CELT_SET_BITRATE(st->bitrate_bps));
512                 nb_compr_bytes = max_data_bytes-1;
513             } else {
514                 nb_compr_bytes = bytes_target;
515             }
516         }
517
518         ec_enc_shrink(&enc, nb_compr_bytes);
519     } else {
520         nb_compr_bytes = 0;
521     }
522
523     for (i=0;i<IMIN(frame_size, st->delay_compensation)*st->channels;i++)
524         pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-st->delay_compensation)*st->channels+i];
525     for (;i<frame_size*st->channels;i++)
526         pcm_buf[i] = pcm[i-st->delay_compensation*st->channels];
527
528     if( st->mode == MODE_HYBRID && st->stream_channels == 2 ) {
529         /* Apply stereo width reduction (at low bitrates) */
530         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
531             int width_Q14, delta_Q14, nSamples_8ms, diff;
532             nSamples_8ms = ( st->Fs * 8 ) / 1000;
533             width_Q14 = (1 << 14 ) - st->hybrid_stereo_width_Q14;
534             delta_Q14 = ( st->hybrid_stereo_width_Q14 - st->silk_mode.stereoWidth_Q14 ) / nSamples_8ms;
535             for( i = 0; i < nSamples_8ms; i++ ) {
536                 width_Q14 += delta_Q14;
537                 diff = pcm_buf[ 2*i+1 ] - (opus_int32)pcm_buf[ 2*i ];
538                 diff = ( diff * width_Q14 ) >> 15;
539                 pcm_buf[ 2*i ]   = (opus_int16)( pcm_buf[ 2*i ]   + diff );
540                 pcm_buf[ 2*i+1 ] = (opus_int16)( pcm_buf[ 2*i+1 ] - diff );
541             }
542             for( ; i < frame_size; i++ ) {
543                 diff = pcm_buf[ 2*i+1 ] - (opus_int32)pcm_buf[ 2*i ];
544                 diff = ( diff * width_Q14 ) >> 15;
545                 pcm_buf[ 2*i ]   = (opus_int16)( pcm_buf[ 2*i ]   + diff );
546                 pcm_buf[ 2*i+1 ] = (opus_int16)( pcm_buf[ 2*i+1 ] - diff );
547             }
548             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
549         }
550     }
551
552     if (st->mode != MODE_CELT_ONLY)
553     {
554         /* Check if we have a redundant 0-8 kHz band */
555         ec_enc_bit_logp(&enc, redundancy, 12);
556         if (redundancy)
557         {
558             redundancy_bytes = st->stream_channels*st->bitrate_bps/1600;
559             ec_enc_bit_logp(&enc, celt_to_silk, 1);
560             if (st->mode == MODE_HYBRID)
561                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
562         }
563         start_band = 17;
564     }
565
566     if (st->mode == MODE_SILK_ONLY)
567     {
568         ret = (ec_tell(&enc)+7)>>3;
569         ec_enc_done(&enc);
570         nb_compr_bytes = ret;
571     }
572
573     /* 5 ms redundant frame for CELT->SILK */
574     if (redundancy && celt_to_silk)
575     {
576         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
577         celt_encoder_ctl(celt_enc, CELT_SET_VBR(0));
578         celt_encode(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes);
579         celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
580     }
581
582     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
583
584     if (st->mode != MODE_SILK_ONLY)
585     {
586         ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
587     }
588
589     /* 5 ms redundant frame for SILK->CELT */
590     if (redundancy && !celt_to_silk)
591     {
592         int N2, N4;
593         N2 = st->Fs/200;
594         N4 = st->Fs/400;
595
596         celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
597         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
598         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
599
600         /* TODO: We could speed up prefilling here */
601         celt_encode(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, data+nb_compr_bytes, redundancy_bytes);
602
603         celt_encode(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes);
604     }
605
606
607     if (frame_size>st->encoder_buffer)
608     {
609         for (i=0;i<st->encoder_buffer*st->channels;i++)
610                 st->delay_buffer[i] = pcm[(frame_size-st->encoder_buffer)*st->channels+i];
611     } else {
612         int tmp = st->encoder_buffer-frame_size;
613         for (i=0;i<tmp*st->channels;i++)
614             st->delay_buffer[i] = st->delay_buffer[i+frame_size*st->channels];
615         for (i=0;i<frame_size*st->channels;i++)
616             st->delay_buffer[tmp*st->channels+i] = pcm[i];
617     }
618
619     /* Signalling the mode in the first byte */
620     data--;
621     framerate = st->Fs/frame_size;
622     period = 0;
623     while (framerate < 400)
624     {
625         framerate <<= 1;
626         period++;
627     }
628     if (st->mode == MODE_SILK_ONLY)
629     {
630         data[0] = (silk_internal_bandwidth-OPUS_BANDWIDTH_NARROWBAND)<<5;
631         data[0] |= (period-2)<<3;
632     } else if (st->mode == MODE_CELT_ONLY)
633     {
634         int tmp = st->bandwidth-OPUS_BANDWIDTH_MEDIUMBAND;
635         if (tmp < 0)
636             tmp = 0;
637         data[0] = 0x80;
638         data[0] |= tmp << 5;
639         data[0] |= period<<3;
640     } else /* Hybrid */
641     {
642         data[0] = 0x60;
643         data[0] |= (st->bandwidth-OPUS_BANDWIDTH_SUPERWIDEBAND)<<4;
644         data[0] |= (period-2)<<3;
645     }
646     data[0] |= (st->stream_channels==2)<<2;
647     /*printf ("%x\n", (int)data[0]);*/
648
649     st->rangeFinal = enc.rng;
650
651     if (to_celt)
652         st->prev_mode = MODE_CELT_ONLY;
653     else
654         st->prev_mode = st->mode;
655     st->first = 0;
656     return ret+1+redundancy_bytes;
657 }
658
659 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
660 {
661     CELTEncoder *celt_enc;
662     va_list ap;
663
664     va_start(ap, request);
665
666     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
667
668     switch (request)
669     {
670         case OPUS_SET_MODE_REQUEST:
671         {
672             int value = va_arg(ap, int);
673             st->user_mode = value;
674         }
675         break;
676         case OPUS_GET_MODE_REQUEST:
677         {
678             int *value = va_arg(ap, int*);
679             *value = st->mode;
680         }
681         break;
682         case OPUS_SET_BITRATE_REQUEST:
683         {
684             int value = va_arg(ap, int);
685             if (value != OPUS_BITRATE_AUTO)
686             {
687                 if (value <= 0)
688                     goto bad_arg;
689                 else if (value <= 500)
690                     value = 500;
691             }
692             st->user_bitrate_bps = value;
693         }
694         break;
695         case OPUS_GET_BITRATE_REQUEST:
696         {
697             int *value = va_arg(ap, int*);
698             *value = st->bitrate_bps;
699         }
700         break;
701         case OPUS_SET_FORCE_MONO_REQUEST:
702         {
703             int value = va_arg(ap, int);
704             st->force_mono = value;
705         }
706         break;
707         case OPUS_GET_FORCE_MONO_REQUEST:
708         {
709             int *value = va_arg(ap, int*);
710             *value = !!st->force_mono;
711         }
712         break;
713         case OPUS_SET_BANDWIDTH_REQUEST:
714         {
715             int value = va_arg(ap, int);
716             if (value < OPUS_BANDWIDTH_AUTO || value > OPUS_BANDWIDTH_FULLBAND)
717                 return OPUS_BAD_ARG;
718             st->user_bandwidth = value;
719             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
720                 st->silk_mode.maxInternalSampleRate = 8000;
721             } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
722                 st->silk_mode.maxInternalSampleRate = 12000;
723             } else {
724                 st->silk_mode.maxInternalSampleRate = 16000;
725             }
726         }
727         break;
728         case OPUS_GET_BANDWIDTH_REQUEST:
729         {
730             int *value = va_arg(ap, int*);
731             *value = st->bandwidth;
732         }
733         break;
734         case OPUS_SET_DTX_FLAG_REQUEST:
735         {
736             int value = va_arg(ap, int);
737             st->silk_mode.useDTX = value;
738         }
739         break;
740         case OPUS_GET_DTX_FLAG_REQUEST:
741         {
742             int *value = va_arg(ap, int*);
743             *value = st->silk_mode.useDTX;
744         }
745         break;
746         case OPUS_SET_COMPLEXITY_REQUEST:
747         {
748             int value = va_arg(ap, int);
749             st->silk_mode.complexity = value;
750             celt_encoder_ctl(celt_enc, CELT_SET_COMPLEXITY(value));
751         }
752         break;
753         case OPUS_GET_COMPLEXITY_REQUEST:
754         {
755             int *value = va_arg(ap, int*);
756             *value = st->silk_mode.complexity;
757         }
758         break;
759         case OPUS_SET_INBAND_FEC_FLAG_REQUEST:
760         {
761             int value = va_arg(ap, int);
762             st->silk_mode.useInBandFEC = value;
763         }
764         break;
765         case OPUS_GET_INBAND_FEC_FLAG_REQUEST:
766         {
767             int *value = va_arg(ap, int*);
768             *value = st->silk_mode.useInBandFEC;
769         }
770         break;
771         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
772         {
773             int value = va_arg(ap, int);
774             if (value < 0 || value > 100)
775                 return OPUS_BAD_ARG;
776             st->silk_mode.packetLossPercentage = value;
777             celt_encoder_ctl(celt_enc, CELT_SET_LOSS_PERC(value));
778         }
779         break;
780         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
781         {
782             int *value = va_arg(ap, int*);
783             *value = st->silk_mode.packetLossPercentage;
784         }
785         break;
786         case OPUS_SET_VBR_FLAG_REQUEST:
787         {
788             int value = va_arg(ap, int);
789             st->use_vbr = value;
790             st->silk_mode.useCBR = 1-value;
791         }
792         break;
793         case OPUS_GET_VBR_FLAG_REQUEST:
794         {
795             int *value = va_arg(ap, int*);
796             *value = st->use_vbr;
797         }
798         break;
799         case OPUS_SET_VOICE_RATIO_REQUEST:
800         {
801             int value = va_arg(ap, int);
802             if (value>100 || value<0)
803                 goto bad_arg;
804             st->voice_ratio = value;
805         }
806         break;
807         case OPUS_GET_VOICE_RATIO_REQUEST:
808         {
809             int *value = va_arg(ap, int*);
810             *value = st->voice_ratio;
811         }
812         break;
813         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
814         {
815             int value = va_arg(ap, int);
816             st->vbr_constraint = value;
817         }
818         break;
819         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
820         {
821             int *value = va_arg(ap, int*);
822             *value = st->vbr_constraint;
823         }
824         break;
825         case OPUS_SET_SIGNAL_REQUEST:
826         {
827             int value = va_arg(ap, int);
828             st->signal_type = value;
829         }
830         break;
831         case OPUS_GET_SIGNAL_REQUEST:
832         {
833             int *value = va_arg(ap, int*);
834             *value = st->signal_type;
835         }
836         break;
837         case OPUS_GET_LOOKAHEAD_REQUEST:
838         {
839             int *value = va_arg(ap, int*);
840             *value = st->delay_compensation+st->Fs/400;
841         }
842         break;
843         default:
844             fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);
845             break;
846     }
847     va_end(ap);
848     return OPUS_OK;
849 bad_arg:
850     va_end(ap);
851     return OPUS_BAD_ARG;
852 }
853
854 void opus_encoder_destroy(OpusEncoder *st)
855 {
856     free(st);
857 }
858
859 int opus_encoder_get_final_range(OpusEncoder *st)
860 {
861     return st->rangeFinal;
862 }