Strip off trailing zero bytes when in LPC 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 = 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         /*When in LPC only mode it's perfectly
572           reasonable to strip off trailing zero bytes as
573           the required range decoder behavior is to
574           fill these in. This can't be done when the MDCT
575           modes are used because the decoder needs to know
576           the actual length for allocation purposes.*/
577         if(!redundancy)
578             while(ret>2&&data[ret-1]==0)ret--;
579         nb_compr_bytes = ret;
580     }
581
582     /* 5 ms redundant frame for CELT->SILK */
583     if (redundancy && celt_to_silk)
584     {
585         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
586         celt_encoder_ctl(celt_enc, CELT_SET_VBR(0));
587         celt_encode(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes);
588         celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
589     }
590
591     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
592
593     if (st->mode != MODE_SILK_ONLY)
594     {
595         ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
596     }
597
598     /* 5 ms redundant frame for SILK->CELT */
599     if (redundancy && !celt_to_silk)
600     {
601         int N2, N4;
602         N2 = st->Fs/200;
603         N4 = st->Fs/400;
604
605         celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
606         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
607         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
608
609         /* TODO: We could speed up prefilling here */
610         celt_encode(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, data+nb_compr_bytes, redundancy_bytes);
611
612         celt_encode(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes);
613     }
614
615
616     if (frame_size>st->encoder_buffer)
617     {
618         for (i=0;i<st->encoder_buffer*st->channels;i++)
619                 st->delay_buffer[i] = pcm[(frame_size-st->encoder_buffer)*st->channels+i];
620     } else {
621         int tmp = st->encoder_buffer-frame_size;
622         for (i=0;i<tmp*st->channels;i++)
623             st->delay_buffer[i] = st->delay_buffer[i+frame_size*st->channels];
624         for (i=0;i<frame_size*st->channels;i++)
625             st->delay_buffer[tmp*st->channels+i] = pcm[i];
626     }
627
628     /* Signalling the mode in the first byte */
629     data--;
630     framerate = st->Fs/frame_size;
631     period = 0;
632     while (framerate < 400)
633     {
634         framerate <<= 1;
635         period++;
636     }
637     if (st->mode == MODE_SILK_ONLY)
638     {
639         data[0] = (silk_internal_bandwidth-OPUS_BANDWIDTH_NARROWBAND)<<5;
640         data[0] |= (period-2)<<3;
641     } else if (st->mode == MODE_CELT_ONLY)
642     {
643         int tmp = st->bandwidth-OPUS_BANDWIDTH_MEDIUMBAND;
644         if (tmp < 0)
645             tmp = 0;
646         data[0] = 0x80;
647         data[0] |= tmp << 5;
648         data[0] |= period<<3;
649     } else /* Hybrid */
650     {
651         data[0] = 0x60;
652         data[0] |= (st->bandwidth-OPUS_BANDWIDTH_SUPERWIDEBAND)<<4;
653         data[0] |= (period-2)<<3;
654     }
655     data[0] |= (st->stream_channels==2)<<2;
656     /*printf ("%x\n", (int)data[0]);*/
657
658     st->rangeFinal = enc.rng;
659
660     if (to_celt)
661         st->prev_mode = MODE_CELT_ONLY;
662     else
663         st->prev_mode = st->mode;
664     st->first = 0;
665     return ret+1+redundancy_bytes;
666 }
667
668 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
669 {
670     CELTEncoder *celt_enc;
671     va_list ap;
672
673     va_start(ap, request);
674
675     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
676
677     switch (request)
678     {
679         case OPUS_SET_MODE_REQUEST:
680         {
681             int value = va_arg(ap, int);
682             st->user_mode = value;
683         }
684         break;
685         case OPUS_GET_MODE_REQUEST:
686         {
687             int *value = va_arg(ap, int*);
688             *value = st->mode;
689         }
690         break;
691         case OPUS_SET_BITRATE_REQUEST:
692         {
693             int value = va_arg(ap, int);
694             if (value != OPUS_BITRATE_AUTO)
695             {
696                 if (value <= 0)
697                     goto bad_arg;
698                 else if (value <= 500)
699                     value = 500;
700             }
701             st->user_bitrate_bps = value;
702         }
703         break;
704         case OPUS_GET_BITRATE_REQUEST:
705         {
706             int *value = va_arg(ap, int*);
707             *value = st->bitrate_bps;
708         }
709         break;
710         case OPUS_SET_FORCE_MONO_REQUEST:
711         {
712             int value = va_arg(ap, int);
713             st->force_mono = value;
714         }
715         break;
716         case OPUS_GET_FORCE_MONO_REQUEST:
717         {
718             int *value = va_arg(ap, int*);
719             *value = !!st->force_mono;
720         }
721         break;
722         case OPUS_SET_BANDWIDTH_REQUEST:
723         {
724             int value = va_arg(ap, int);
725             if (value < OPUS_BANDWIDTH_AUTO || value > OPUS_BANDWIDTH_FULLBAND)
726                 return OPUS_BAD_ARG;
727             st->user_bandwidth = value;
728             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
729                 st->silk_mode.maxInternalSampleRate = 8000;
730             } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
731                 st->silk_mode.maxInternalSampleRate = 12000;
732             } else {
733                 st->silk_mode.maxInternalSampleRate = 16000;
734             }
735         }
736         break;
737         case OPUS_GET_BANDWIDTH_REQUEST:
738         {
739             int *value = va_arg(ap, int*);
740             *value = st->bandwidth;
741         }
742         break;
743         case OPUS_SET_DTX_FLAG_REQUEST:
744         {
745             int value = va_arg(ap, int);
746             st->silk_mode.useDTX = value;
747         }
748         break;
749         case OPUS_GET_DTX_FLAG_REQUEST:
750         {
751             int *value = va_arg(ap, int*);
752             *value = st->silk_mode.useDTX;
753         }
754         break;
755         case OPUS_SET_COMPLEXITY_REQUEST:
756         {
757             int value = va_arg(ap, int);
758             st->silk_mode.complexity = value;
759             celt_encoder_ctl(celt_enc, CELT_SET_COMPLEXITY(value));
760         }
761         break;
762         case OPUS_GET_COMPLEXITY_REQUEST:
763         {
764             int *value = va_arg(ap, int*);
765             *value = st->silk_mode.complexity;
766         }
767         break;
768         case OPUS_SET_INBAND_FEC_FLAG_REQUEST:
769         {
770             int value = va_arg(ap, int);
771             st->silk_mode.useInBandFEC = value;
772         }
773         break;
774         case OPUS_GET_INBAND_FEC_FLAG_REQUEST:
775         {
776             int *value = va_arg(ap, int*);
777             *value = st->silk_mode.useInBandFEC;
778         }
779         break;
780         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
781         {
782             int value = va_arg(ap, int);
783             if (value < 0 || value > 100)
784                 return OPUS_BAD_ARG;
785             st->silk_mode.packetLossPercentage = value;
786             celt_encoder_ctl(celt_enc, CELT_SET_LOSS_PERC(value));
787         }
788         break;
789         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
790         {
791             int *value = va_arg(ap, int*);
792             *value = st->silk_mode.packetLossPercentage;
793         }
794         break;
795         case OPUS_SET_VBR_FLAG_REQUEST:
796         {
797             int value = va_arg(ap, int);
798             st->use_vbr = value;
799             st->silk_mode.useCBR = 1-value;
800         }
801         break;
802         case OPUS_GET_VBR_FLAG_REQUEST:
803         {
804             int *value = va_arg(ap, int*);
805             *value = st->use_vbr;
806         }
807         break;
808         case OPUS_SET_VOICE_RATIO_REQUEST:
809         {
810             int value = va_arg(ap, int);
811             if (value>100 || value<0)
812                 goto bad_arg;
813             st->voice_ratio = value;
814         }
815         break;
816         case OPUS_GET_VOICE_RATIO_REQUEST:
817         {
818             int *value = va_arg(ap, int*);
819             *value = st->voice_ratio;
820         }
821         break;
822         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
823         {
824             int value = va_arg(ap, int);
825             st->vbr_constraint = value;
826         }
827         break;
828         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
829         {
830             int *value = va_arg(ap, int*);
831             *value = st->vbr_constraint;
832         }
833         break;
834         case OPUS_SET_SIGNAL_REQUEST:
835         {
836             int value = va_arg(ap, int);
837             st->signal_type = value;
838         }
839         break;
840         case OPUS_GET_SIGNAL_REQUEST:
841         {
842             int *value = va_arg(ap, int*);
843             *value = st->signal_type;
844         }
845         break;
846         case OPUS_GET_LOOKAHEAD_REQUEST:
847         {
848             int *value = va_arg(ap, int*);
849             *value = st->delay_compensation+st->Fs/400;
850         }
851         break;
852         default:
853             fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);
854             break;
855     }
856     va_end(ap);
857     return OPUS_OK;
858 bad_arg:
859     va_end(ap);
860     return OPUS_BAD_ARG;
861 }
862
863 void opus_encoder_destroy(OpusEncoder *st)
864 {
865     free(st);
866 }
867
868 int opus_encoder_get_final_range(OpusEncoder *st)
869 {
870     return st->rangeFinal;
871 }