dc8c85f5442be87b6c6393d742907990ecfb5159
[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 = IMIN(1275, 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         nb_compr_bytes = IMIN(1275, nb_compr_bytes);
519         ec_enc_shrink(&enc, nb_compr_bytes);
520     } else {
521         nb_compr_bytes = 0;
522     }
523
524     for (i=0;i<IMIN(frame_size, st->delay_compensation)*st->channels;i++)
525         pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-st->delay_compensation)*st->channels+i];
526     for (;i<frame_size*st->channels;i++)
527         pcm_buf[i] = pcm[i-st->delay_compensation*st->channels];
528
529     if( st->mode == MODE_HYBRID && st->stream_channels == 2 ) {
530         /* Apply stereo width reduction (at low bitrates) */
531         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
532             int width_Q14, delta_Q14, nSamples_8ms, diff;
533             nSamples_8ms = ( st->Fs * 8 ) / 1000;
534             width_Q14 = (1 << 14 ) - st->hybrid_stereo_width_Q14;
535             delta_Q14 = ( st->hybrid_stereo_width_Q14 - st->silk_mode.stereoWidth_Q14 ) / nSamples_8ms;
536             for( i = 0; i < nSamples_8ms; i++ ) {
537                 width_Q14 += delta_Q14;
538                 diff = pcm_buf[ 2*i+1 ] - (opus_int32)pcm_buf[ 2*i ];
539                 diff = ( diff * width_Q14 ) >> 15;
540                 pcm_buf[ 2*i ]   = (opus_int16)( pcm_buf[ 2*i ]   + diff );
541                 pcm_buf[ 2*i+1 ] = (opus_int16)( pcm_buf[ 2*i+1 ] - diff );
542             }
543             for( ; i < frame_size; i++ ) {
544                 diff = pcm_buf[ 2*i+1 ] - (opus_int32)pcm_buf[ 2*i ];
545                 diff = ( diff * width_Q14 ) >> 15;
546                 pcm_buf[ 2*i ]   = (opus_int16)( pcm_buf[ 2*i ]   + diff );
547                 pcm_buf[ 2*i+1 ] = (opus_int16)( pcm_buf[ 2*i+1 ] - diff );
548             }
549             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
550         }
551     }
552
553     if (st->mode != MODE_CELT_ONLY)
554     {
555         /* Check if we have a redundant 0-8 kHz band */
556         ec_enc_bit_logp(&enc, redundancy, 12);
557         if (redundancy)
558         {
559             redundancy_bytes = st->stream_channels*st->bitrate_bps/1600;
560             ec_enc_bit_logp(&enc, celt_to_silk, 1);
561             if (st->mode == MODE_HYBRID)
562                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
563         }
564         start_band = 17;
565     }
566
567     if (st->mode == MODE_SILK_ONLY)
568     {
569         ret = (ec_tell(&enc)+7)>>3;
570         ec_enc_done(&enc);
571         nb_compr_bytes = ret;
572     }
573
574     /* 5 ms redundant frame for CELT->SILK */
575     if (redundancy && celt_to_silk)
576     {
577         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
578         celt_encoder_ctl(celt_enc, CELT_SET_VBR(0));
579         celt_encode(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes);
580         celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
581     }
582
583     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
584
585     if (st->mode != MODE_SILK_ONLY)
586     {
587         ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
588     }
589
590     /* 5 ms redundant frame for SILK->CELT */
591     if (redundancy && !celt_to_silk)
592     {
593         int N2, N4;
594         N2 = st->Fs/200;
595         N4 = st->Fs/400;
596
597         celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
598         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
599         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
600
601         /* TODO: We could speed up prefilling here */
602         celt_encode(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, data+nb_compr_bytes, redundancy_bytes);
603
604         celt_encode(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes);
605     }
606
607
608     if (frame_size>st->encoder_buffer)
609     {
610         for (i=0;i<st->encoder_buffer*st->channels;i++)
611                 st->delay_buffer[i] = pcm[(frame_size-st->encoder_buffer)*st->channels+i];
612     } else {
613         int tmp = st->encoder_buffer-frame_size;
614         for (i=0;i<tmp*st->channels;i++)
615             st->delay_buffer[i] = st->delay_buffer[i+frame_size*st->channels];
616         for (i=0;i<frame_size*st->channels;i++)
617             st->delay_buffer[tmp*st->channels+i] = pcm[i];
618     }
619
620     /* Signalling the mode in the first byte */
621     data--;
622     framerate = st->Fs/frame_size;
623     period = 0;
624     while (framerate < 400)
625     {
626         framerate <<= 1;
627         period++;
628     }
629     if (st->mode == MODE_SILK_ONLY)
630     {
631         data[0] = (silk_internal_bandwidth-OPUS_BANDWIDTH_NARROWBAND)<<5;
632         data[0] |= (period-2)<<3;
633     } else if (st->mode == MODE_CELT_ONLY)
634     {
635         int tmp = st->bandwidth-OPUS_BANDWIDTH_MEDIUMBAND;
636         if (tmp < 0)
637             tmp = 0;
638         data[0] = 0x80;
639         data[0] |= tmp << 5;
640         data[0] |= period<<3;
641     } else /* Hybrid */
642     {
643         data[0] = 0x60;
644         data[0] |= (st->bandwidth-OPUS_BANDWIDTH_SUPERWIDEBAND)<<4;
645         data[0] |= (period-2)<<3;
646     }
647     data[0] |= (st->stream_channels==2)<<2;
648     /*printf ("%x\n", (int)data[0]);*/
649
650     st->rangeFinal = enc.rng;
651
652     if (to_celt)
653         st->prev_mode = MODE_CELT_ONLY;
654     else
655         st->prev_mode = st->mode;
656     st->first = 0;
657     return ret+1+redundancy_bytes;
658 }
659
660 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
661 {
662     CELTEncoder *celt_enc;
663     va_list ap;
664
665     va_start(ap, request);
666
667     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
668
669     switch (request)
670     {
671         case OPUS_SET_MODE_REQUEST:
672         {
673             int value = va_arg(ap, int);
674             st->user_mode = value;
675         }
676         break;
677         case OPUS_GET_MODE_REQUEST:
678         {
679             int *value = va_arg(ap, int*);
680             *value = st->mode;
681         }
682         break;
683         case OPUS_SET_BITRATE_REQUEST:
684         {
685             int value = va_arg(ap, int);
686             if (value != OPUS_BITRATE_AUTO)
687             {
688                 if (value <= 0)
689                     goto bad_arg;
690                 else if (value <= 500)
691                     value = 500;
692             }
693             st->user_bitrate_bps = value;
694         }
695         break;
696         case OPUS_GET_BITRATE_REQUEST:
697         {
698             int *value = va_arg(ap, int*);
699             *value = st->bitrate_bps;
700         }
701         break;
702         case OPUS_SET_FORCE_MONO_REQUEST:
703         {
704             int value = va_arg(ap, int);
705             st->force_mono = value;
706         }
707         break;
708         case OPUS_GET_FORCE_MONO_REQUEST:
709         {
710             int *value = va_arg(ap, int*);
711             *value = !!st->force_mono;
712         }
713         break;
714         case OPUS_SET_BANDWIDTH_REQUEST:
715         {
716             int value = va_arg(ap, int);
717             if (value < OPUS_BANDWIDTH_AUTO || value > OPUS_BANDWIDTH_FULLBAND)
718                 return OPUS_BAD_ARG;
719             st->user_bandwidth = value;
720             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
721                 st->silk_mode.maxInternalSampleRate = 8000;
722             } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
723                 st->silk_mode.maxInternalSampleRate = 12000;
724             } else {
725                 st->silk_mode.maxInternalSampleRate = 16000;
726             }
727         }
728         break;
729         case OPUS_GET_BANDWIDTH_REQUEST:
730         {
731             int *value = va_arg(ap, int*);
732             *value = st->bandwidth;
733         }
734         break;
735         case OPUS_SET_DTX_FLAG_REQUEST:
736         {
737             int value = va_arg(ap, int);
738             st->silk_mode.useDTX = value;
739         }
740         break;
741         case OPUS_GET_DTX_FLAG_REQUEST:
742         {
743             int *value = va_arg(ap, int*);
744             *value = st->silk_mode.useDTX;
745         }
746         break;
747         case OPUS_SET_COMPLEXITY_REQUEST:
748         {
749             int value = va_arg(ap, int);
750             st->silk_mode.complexity = value;
751             celt_encoder_ctl(celt_enc, CELT_SET_COMPLEXITY(value));
752         }
753         break;
754         case OPUS_GET_COMPLEXITY_REQUEST:
755         {
756             int *value = va_arg(ap, int*);
757             *value = st->silk_mode.complexity;
758         }
759         break;
760         case OPUS_SET_INBAND_FEC_FLAG_REQUEST:
761         {
762             int value = va_arg(ap, int);
763             st->silk_mode.useInBandFEC = value;
764         }
765         break;
766         case OPUS_GET_INBAND_FEC_FLAG_REQUEST:
767         {
768             int *value = va_arg(ap, int*);
769             *value = st->silk_mode.useInBandFEC;
770         }
771         break;
772         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
773         {
774             int value = va_arg(ap, int);
775             if (value < 0 || value > 100)
776                 return OPUS_BAD_ARG;
777             st->silk_mode.packetLossPercentage = value;
778             celt_encoder_ctl(celt_enc, CELT_SET_LOSS_PERC(value));
779         }
780         break;
781         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
782         {
783             int *value = va_arg(ap, int*);
784             *value = st->silk_mode.packetLossPercentage;
785         }
786         break;
787         case OPUS_SET_VBR_FLAG_REQUEST:
788         {
789             int value = va_arg(ap, int);
790             st->use_vbr = value;
791             st->silk_mode.useCBR = 1-value;
792         }
793         break;
794         case OPUS_GET_VBR_FLAG_REQUEST:
795         {
796             int *value = va_arg(ap, int*);
797             *value = st->use_vbr;
798         }
799         break;
800         case OPUS_SET_VOICE_RATIO_REQUEST:
801         {
802             int value = va_arg(ap, int);
803             if (value>100 || value<0)
804                 goto bad_arg;
805             st->voice_ratio = value;
806         }
807         break;
808         case OPUS_GET_VOICE_RATIO_REQUEST:
809         {
810             int *value = va_arg(ap, int*);
811             *value = st->voice_ratio;
812         }
813         break;
814         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
815         {
816             int value = va_arg(ap, int);
817             st->vbr_constraint = value;
818         }
819         break;
820         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
821         {
822             int *value = va_arg(ap, int*);
823             *value = st->vbr_constraint;
824         }
825         break;
826         case OPUS_SET_SIGNAL_REQUEST:
827         {
828             int value = va_arg(ap, int);
829             st->signal_type = value;
830         }
831         break;
832         case OPUS_GET_SIGNAL_REQUEST:
833         {
834             int *value = va_arg(ap, int*);
835             *value = st->signal_type;
836         }
837         break;
838         case OPUS_GET_LOOKAHEAD_REQUEST:
839         {
840             int *value = va_arg(ap, int*);
841             *value = st->delay_compensation+st->Fs/400;
842         }
843         break;
844         default:
845             fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);
846             break;
847     }
848     va_end(ap);
849     return OPUS_OK;
850 bad_arg:
851     va_end(ap);
852     return OPUS_BAD_ARG;
853 }
854
855 void opus_encoder_destroy(OpusEncoder *st)
856 {
857     free(st);
858 }
859
860 int opus_encoder_get_final_range(OpusEncoder *st)
861 {
862     return st->rangeFinal;
863 }