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