Squashed commit of the following:
[opus.git] / src / opus_encoder.c
1 /* Copyright (c) 2010 Xiph.Org Foundation, Skype Limited
2    Written by Jean-Marc Valin and Koen Vos */
3 /*
4    Redistribution and use in source and binary forms, with or without
5    modification, are permitted provided that the following conditions
6    are met:
7
8    - Redistributions of source code must retain the above copyright
9    notice, this list of conditions and the following disclaimer.
10
11    - Redistributions in binary form must reproduce the above copyright
12    notice, this list of conditions and the following disclaimer in the
13    documentation and/or other materials provided with the distribution.
14
15    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
18    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
19    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
23    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
24    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #ifdef HAVE_CONFIG_H
29 #include "config.h"
30 #endif
31
32 #include <string.h>
33 #include <stdlib.h>
34 #include <stdio.h>
35 #include <stdarg.h>
36 #include "celt.h"
37 #include "opus_encoder.h"
38 #include "entenc.h"
39 #include "modes.h"
40 #include "silk_API.h"
41
42 /* Transition tables for the voice and audio modes. First column is the
43    middle (memoriless) threshold. The second column is the hysteresis
44    (difference with the middle) */
45 static const int voice_bandwidth_thresholds[10] = {
46                 11000, 1000, /* NB<->MB */
47                 14000, 1000, /* MB<->WB */
48                 21000, 2000, /* WB<->SWB */
49                 29000, 2000, /* SWB<->FB */
50 };
51 static const int audio_bandwidth_thresholds[10] = {
52                 30000,    0, /* MB not allowed */
53                 20000, 2000, /* MB<->WB */
54                 26000, 2000, /* WB<->SWB */
55                 33000, 2000, /* SWB<->FB */
56 };
57
58 /* Make sure everything's aligned to 4 bytes (this may need to be increased
59    on really weird architectures) */
60 static inline int align(int i)
61 {
62         return (i+3)&-4;
63 }
64
65 int opus_encoder_get_size(int channels)
66 {
67         int silkEncSizeBytes, celtEncSizeBytes;
68         int ret;
69         ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
70         if(ret)
71                 return 0;
72         silkEncSizeBytes = align(silkEncSizeBytes);
73     celtEncSizeBytes = celt_encoder_get_size(channels);
74     return align(sizeof(OpusEncoder))+silkEncSizeBytes+celtEncSizeBytes;
75
76 }
77
78 OpusEncoder *opus_encoder_init(OpusEncoder* st, int Fs, int channels)
79 {
80         void *silk_enc;
81         CELTEncoder *celt_enc;
82     int err;
83         int ret, silkEncSizeBytes, celtEncSizeBytes;
84
85         memset(st, 0, sizeof(OpusEncoder));
86     /* Create SILK encoder */
87     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
88     if( ret )
89         return NULL;
90         silkEncSizeBytes = align(silkEncSizeBytes);
91     celtEncSizeBytes = celt_encoder_get_size(channels);
92     st->silk_enc_offset = align(sizeof(OpusEncoder));
93     st->celt_enc_offset = st->silk_enc_offset+silkEncSizeBytes;
94     silk_enc = (char*)st+st->silk_enc_offset;
95     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
96
97     st->stream_channels = st->channels = channels;
98
99     st->Fs = Fs;
100
101     ret = silk_InitEncoder( silk_enc, &st->silk_mode );
102     if( ret )
103         goto failure;
104
105     /* default SILK parameters */
106     st->silk_mode.nChannelsAPI              = channels;
107     st->silk_mode.nChannelsInternal         = channels;
108     st->silk_mode.API_sampleRate            = st->Fs;
109     st->silk_mode.maxInternalSampleRate     = 16000;
110     st->silk_mode.minInternalSampleRate     = 8000;
111     st->silk_mode.desiredInternalSampleRate = 16000;
112     st->silk_mode.payloadSize_ms            = 20;
113     st->silk_mode.bitRate                   = 25000;
114     st->silk_mode.packetLossPercentage      = 0;
115     st->silk_mode.complexity                = 10;
116     st->silk_mode.useInBandFEC              = 0;
117     st->silk_mode.useDTX                    = 0;
118     st->silk_mode.useCBR                    = 0;
119
120     st->hybrid_stereo_width_Q14             = 1 << 14;
121
122     /* Create CELT encoder */
123         /* Initialize CELT encoder */
124         celt_encoder_init(celt_enc, Fs, channels, &err);
125         if (err != CELT_OK)
126                 goto failure;
127     celt_encoder_ctl(celt_enc, CELT_SET_SIGNALLING(0));
128
129         st->mode = MODE_HYBRID;
130         st->bandwidth = BANDWIDTH_FULLBAND;
131         st->use_vbr = 0;
132     st->user_bitrate_bps = OPUS_BITRATE_AUTO;
133         st->bitrate_bps = 3000+Fs*channels;
134         st->user_mode = OPUS_MODE_AUTO;
135         st->user_bandwidth = BANDWIDTH_AUTO;
136         st->voice_ratio = 90;
137         st->first = 1;
138
139         st->encoder_buffer = st->Fs/100;
140         st->delay_compensation = st->Fs/400;
141         if (st->Fs > 16000)
142                 st->delay_compensation += 10;
143         return st;
144 failure:
145     free(st);
146     return NULL;
147 }
148
149 OpusEncoder *opus_encoder_create(int Fs, int channels)
150 {
151     char *raw_state = (char *)malloc(opus_encoder_get_size(channels));
152     if (raw_state == NULL)
153         return NULL;
154     return opus_encoder_init((OpusEncoder*)raw_state, Fs, channels);
155 }
156
157 int opus_encode(OpusEncoder *st, const short *pcm, int frame_size,
158                 unsigned char *data, int max_data_bytes)
159 {
160         void *silk_enc;
161         CELTEncoder *celt_enc;
162     int i;
163         int ret=0;
164         SKP_int32 nBytes;
165         ec_enc enc;
166         int framerate, period;
167     int silk_internal_bandwidth=-1;
168     int bytes_target;
169     int prefill=0;
170     int start_band = 0;
171     int redundancy = 0;
172     int redundancy_bytes = 0;
173     int celt_to_silk = 0;
174     /* TODO: This is 60 only so we can handle 60ms speech/audio switching 
175        it shouldn't be too hard to reduce to 20 ms if needed */
176     short pcm_buf[60*48*2];
177     int nb_compr_bytes;
178     int to_celt = 0;
179     celt_int32 mono_rate;
180
181     silk_enc = (char*)st+st->silk_enc_offset;
182     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
183
184     if (st->user_bitrate_bps==OPUS_BITRATE_AUTO)
185         st->bitrate_bps = 60*st->Fs/frame_size + st->Fs*st->channels;
186     else
187         st->bitrate_bps = st->user_bitrate_bps;
188
189     /* Rate-dependent mono-stereo decision */
190     if (st->force_mono)
191         st->stream_channels = 1;
192     if (st->mode == MODE_CELT_ONLY && st->channels == 2)
193     {
194         celt_int32 decision_rate;
195         decision_rate = st->bitrate_bps + st->voice_ratio*st->voice_ratio;
196         /* Add some hysteresis */
197         if (st->stream_channels == 2)
198             decision_rate += 4000;
199         else
200             decision_rate -= 4000;
201         if (decision_rate>48000)
202             st->stream_channels = 2;
203         else
204             st->stream_channels = 1;
205     } else {
206             st->stream_channels = st->channels;
207     }
208     /* Equivalent bit-rate for mono */
209     mono_rate = st->bitrate_bps;
210     if (st->stream_channels==2)
211         mono_rate = (mono_rate+10000)/2;
212     /* Compensate for smaller frame sizes assuming an equivalent overhead
213        of 60 bits/frame */
214     mono_rate -= 60*(st->Fs/frame_size - 50);
215
216     /* Mode selection */
217     if (st->user_mode==OPUS_MODE_AUTO)
218     {
219         celt_int32 decision_rate;
220         /* SILK/CELT threshold is higher for voice than for music */
221         decision_rate = mono_rate - 3*st->voice_ratio*st->voice_ratio;
222         /* Hysteresis */
223         if (st->prev_mode == MODE_CELT_ONLY)
224             decision_rate += 4000;
225         else if (st->prev_mode>0)
226             decision_rate -= 4000;
227         if (decision_rate>24000)
228             st->mode = MODE_CELT_ONLY;
229         else
230             st->mode = MODE_SILK_ONLY;
231     } else if (st->user_mode==OPUS_MODE_VOICE)
232     {
233         st->mode = MODE_SILK_ONLY;
234     } else {/* OPUS_AUDIO_MODE */
235         st->mode = MODE_CELT_ONLY;
236     }
237
238     /* Automatic (rate-dependent) bandwidth selection */
239     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
240     {
241         const int *bandwidth_thresholds;
242         int bandwidth = BANDWIDTH_FULLBAND;
243
244         bandwidth_thresholds = st->mode == MODE_CELT_ONLY ? audio_bandwidth_thresholds : voice_bandwidth_thresholds;
245         do {
246                 int threshold, hysteresis;
247                 threshold = bandwidth_thresholds[2*(bandwidth-BANDWIDTH_MEDIUMBAND)];
248                 hysteresis = bandwidth_thresholds[2*(bandwidth-BANDWIDTH_MEDIUMBAND)+1];
249                 if (!st->first)
250                 {
251                         if (st->bandwidth >= bandwidth)
252                                 threshold -= hysteresis;
253                         else
254                                 threshold += hysteresis;
255                 }
256                 if (mono_rate >= threshold)
257                         break;
258         } while (--bandwidth>BANDWIDTH_NARROWBAND);
259         st->bandwidth = bandwidth;
260         /* Prevents any transition to SWB/FB until the SILK layer has fully
261            switched to WB mode and turned the variable LP filter off */
262         if (st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > BANDWIDTH_WIDEBAND)
263                 st->bandwidth = BANDWIDTH_WIDEBAND;
264     }
265
266     /* Prevents Opus from wasting bits on frequencies that are above
267        the Nyquist rate of the input signal */
268     if (st->Fs <= 24000 && st->bandwidth > BANDWIDTH_SUPERWIDEBAND)
269         st->bandwidth = BANDWIDTH_SUPERWIDEBAND;
270     if (st->Fs <= 16000 && st->bandwidth > BANDWIDTH_WIDEBAND)
271         st->bandwidth = BANDWIDTH_WIDEBAND;
272     if (st->Fs <= 12000 && st->bandwidth > BANDWIDTH_MEDIUMBAND)
273         st->bandwidth = BANDWIDTH_MEDIUMBAND;
274     if (st->Fs <= 8000 && st->bandwidth > BANDWIDTH_NARROWBAND)
275         st->bandwidth = BANDWIDTH_NARROWBAND;
276
277     if (st->user_bandwidth != BANDWIDTH_AUTO)
278         st->bandwidth = st->user_bandwidth;
279
280     /* Prevents nonsensical configurations, i.e. modes that don't exist */
281     if (frame_size < st->Fs/100 && st->mode != MODE_CELT_ONLY)
282         st->mode = MODE_CELT_ONLY;
283     if (frame_size > st->Fs/50 && st->mode != MODE_SILK_ONLY)
284         st->mode = MODE_SILK_ONLY;
285     if (st->mode == MODE_CELT_ONLY && st->bandwidth == BANDWIDTH_MEDIUMBAND)
286         st->bandwidth = BANDWIDTH_WIDEBAND;
287     if (st->mode == MODE_SILK_ONLY && st->bandwidth > BANDWIDTH_WIDEBAND)
288         st->mode = MODE_HYBRID;
289     if (st->mode == MODE_HYBRID && st->bandwidth <= BANDWIDTH_WIDEBAND)
290         st->mode = MODE_SILK_ONLY;
291
292         bytes_target = st->bitrate_bps * frame_size / (st->Fs * 8) - 1;
293
294         data += 1;
295         if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
296         {
297                 silk_EncControlStruct dummy;
298                 silk_InitEncoder( silk_enc, &dummy);
299                 prefill=1;
300         }
301         if (st->prev_mode > 0 &&
302                ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
303                 (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
304         {
305             redundancy = 1;
306             celt_to_silk = (st->mode != MODE_CELT_ONLY);
307             if (!celt_to_silk)
308             {
309                 /* Switch to SILK/hybrid if frame size is 10 ms or more*/
310                 if (frame_size >= st->Fs/100)
311                 {
312                         st->mode = st->prev_mode;
313                         to_celt = 1;
314                 } else {
315                         redundancy=0;
316                 }
317             }
318         }
319
320         ec_enc_init(&enc, data, max_data_bytes-1);
321
322         /* SILK processing */
323     if (st->mode != MODE_CELT_ONLY)
324     {
325         st->silk_mode.bitRate = st->bitrate_bps - 8*st->Fs/frame_size;
326         if( st->mode == MODE_HYBRID ) {
327             st->silk_mode.bitRate /= st->stream_channels;
328             if( st->bandwidth == BANDWIDTH_SUPERWIDEBAND ) {
329                 if( st->Fs == 100 * frame_size ) {
330                     /* 24 kHz, 10 ms */
331                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 2000 + st->use_vbr * 1000 ) * 2 ) / 3;
332                 } else {
333                     /* 24 kHz, 20 ms */
334                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 1000 + st->use_vbr * 1000 ) * 2 ) / 3;
335                 }
336             } else {
337                 if( st->Fs == 100 * frame_size ) {
338                     /* 48 kHz, 10 ms */
339                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 8000 + st->use_vbr * 3000 ) / 2;
340                 } else {
341                     /* 48 kHz, 20 ms */
342                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 9000 + st->use_vbr * 1000 ) / 2;
343                 }
344             }
345             st->silk_mode.bitRate *= st->stream_channels;
346             /* don't let SILK use more than 80% */
347             if( st->silk_mode.bitRate > ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5 ) {
348                 st->silk_mode.bitRate = ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5;
349             }
350         }
351
352         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
353         st->silk_mode.nChannelsAPI = st->channels;
354         st->silk_mode.nChannelsInternal = st->stream_channels;
355         if (st->bandwidth == BANDWIDTH_NARROWBAND) {
356                 st->silk_mode.desiredInternalSampleRate = 8000;
357         } else if (st->bandwidth == BANDWIDTH_MEDIUMBAND) {
358                 st->silk_mode.desiredInternalSampleRate = 12000;
359         } else {
360             SKP_assert( st->mode == MODE_HYBRID || st->bandwidth == BANDWIDTH_WIDEBAND );
361             st->silk_mode.desiredInternalSampleRate = 16000;
362         }
363         if( st->mode == MODE_HYBRID ) {
364             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
365             st->silk_mode.minInternalSampleRate = 16000;
366         } else {
367             st->silk_mode.minInternalSampleRate = 8000;
368         }
369         st->silk_mode.maxInternalSampleRate = 16000;
370
371         /* Call SILK encoder for the low band */
372         nBytes = max_data_bytes-1;
373         if (prefill)
374         {
375             int zero=0;
376                 silk_Encode( silk_enc, &st->silk_mode, st->delay_buffer, st->encoder_buffer, NULL, &zero, 1 );
377         }
378
379         ret = silk_Encode( silk_enc, &st->silk_mode, pcm, frame_size, &enc, &nBytes, 0 );
380         if( ret ) {
381             fprintf (stderr, "SILK encode error: %d\n", ret);
382             /* Handle error */
383         }
384         if (nBytes==0)
385             return 0;
386         /* Extract SILK internal bandwidth for signaling in first byte */
387         if( st->mode == MODE_SILK_ONLY ) {
388             if( st->silk_mode.internalSampleRate == 8000 ) {
389                 silk_internal_bandwidth = BANDWIDTH_NARROWBAND;
390             } else if( st->silk_mode.internalSampleRate == 12000 ) {
391                 silk_internal_bandwidth = BANDWIDTH_MEDIUMBAND;
392             } else if( st->silk_mode.internalSampleRate == 16000 ) {
393                 silk_internal_bandwidth = BANDWIDTH_WIDEBAND;
394             }
395         } else {
396             SKP_assert( st->silk_mode.internalSampleRate == 16000 );
397         }
398     }
399
400     /* CELT processing */
401         {
402             int endband=21;
403
404             switch(st->bandwidth)
405             {
406             case BANDWIDTH_NARROWBAND:
407                 endband = 13;
408                 break;
409             case BANDWIDTH_WIDEBAND:
410                 endband = 17;
411                 break;
412             case BANDWIDTH_SUPERWIDEBAND:
413                 endband = 19;
414                 break;
415             case BANDWIDTH_FULLBAND:
416                 endband = 21;
417                 break;
418             }
419             celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
420             celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
421         }
422         if (st->mode != MODE_SILK_ONLY)
423         {
424         celt_encoder_ctl(celt_enc, CELT_SET_VBR(0));
425         celt_encoder_ctl(celt_enc, CELT_SET_BITRATE(510000));
426         if (st->prev_mode == MODE_SILK_ONLY)
427         {
428                 unsigned char dummy[10];
429                 celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
430                 celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
431                 celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
432                 /* TODO: This wastes CPU a bit compared to just prefilling the buffer */
433                 celt_encode(celt_enc, &st->delay_buffer[(st->encoder_buffer-st->delay_compensation-st->Fs/400)*st->channels], st->Fs/400, dummy, 10);
434         } else {
435                 celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
436         }
437
438         if (st->mode == MODE_HYBRID)
439         {
440             int len;
441
442             len = (ec_tell(&enc)+7)>>3;
443             if( st->use_vbr ) {
444                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
445             } else {
446                 /* check if SILK used up too much */
447                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
448             }
449         } else {
450             if (st->use_vbr)
451             {
452                 celt_encoder_ctl(celt_enc, CELT_SET_VBR(1));
453                 celt_encoder_ctl(celt_enc, CELT_SET_VBR_CONSTRAINT(st->vbr_constraint));
454                 celt_encoder_ctl(celt_enc, CELT_SET_BITRATE(st->bitrate_bps));
455                 nb_compr_bytes = max_data_bytes-1;
456             } else {
457                 nb_compr_bytes = bytes_target;
458             }
459         }
460
461         ec_enc_shrink(&enc, nb_compr_bytes);
462         } else {
463             nb_compr_bytes = 0;
464         }
465
466     for (i=0;i<IMIN(frame_size, st->delay_compensation)*st->channels;i++)
467         pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-st->delay_compensation)*st->channels+i];
468     for (;i<frame_size*st->channels;i++)
469         pcm_buf[i] = pcm[i-st->delay_compensation*st->channels];
470
471     if( st->mode == MODE_HYBRID && st->stream_channels == 2 ) {
472         /* Apply stereo width reduction (at low bitrates) */
473         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
474             int width_Q14, delta_Q14, nSamples_8ms, diff;
475             nSamples_8ms = ( st->Fs * 8 ) / 1000;
476             width_Q14 = (1 << 14 ) - st->hybrid_stereo_width_Q14;
477             delta_Q14 = ( st->hybrid_stereo_width_Q14 - st->silk_mode.stereoWidth_Q14 ) / nSamples_8ms;
478             for( i = 0; i < nSamples_8ms; i++ ) {
479                 width_Q14 += delta_Q14;
480                 diff = pcm_buf[ 2*i+1 ] - (int)pcm_buf[ 2*i ];
481                 diff = ( diff * width_Q14 ) >> 15;
482                 pcm_buf[ 2*i ]   = (short)( pcm_buf[ 2*i ]   + diff );
483                 pcm_buf[ 2*i+1 ] = (short)( pcm_buf[ 2*i+1 ] - diff );
484             }
485             for( ; i < frame_size; i++ ) {
486                 diff = pcm_buf[ 2*i+1 ] - (int)pcm_buf[ 2*i ];
487                 diff = ( diff * width_Q14 ) >> 15;
488                 pcm_buf[ 2*i ]   = (short)( pcm_buf[ 2*i ]   + diff );
489                 pcm_buf[ 2*i+1 ] = (short)( pcm_buf[ 2*i+1 ] - diff );
490             }
491             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
492         }
493     }
494
495     if (st->mode != MODE_CELT_ONLY)
496     {
497         /* Check if we have a redundant 0-8 kHz band */
498         ec_enc_bit_logp(&enc, redundancy, 12);
499         if (redundancy)
500         {
501             redundancy_bytes = st->stream_channels*st->bitrate_bps/1600;
502             ec_enc_bit_logp(&enc, celt_to_silk, 1);
503             if (st->mode == MODE_HYBRID)
504                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
505         }
506         start_band = 17;
507     }
508
509     if (st->mode == MODE_SILK_ONLY)
510     {
511         ret = (ec_tell(&enc)+7)>>3;
512         ec_enc_done(&enc);
513         nb_compr_bytes = ret;
514     }
515
516     /* 5 ms redundant frame for CELT->SILK */
517     if (redundancy && celt_to_silk)
518     {
519         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
520         celt_encoder_ctl(celt_enc, CELT_SET_VBR(0));
521         celt_encode(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes);
522         celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
523     }
524
525     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
526
527     if (st->mode != MODE_SILK_ONLY)
528         {
529             /* Encode high band with CELT */
530             ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
531         }
532
533     /* 5 ms redundant frame for SILK->CELT */
534     if (redundancy && !celt_to_silk)
535     {
536         int N2, N4;
537         N2 = st->Fs/200;
538         N4 = st->Fs/400;
539
540         celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
541         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
542         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
543
544         /* TODO: We could speed up prefilling here */
545         celt_encode(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, data+nb_compr_bytes, redundancy_bytes);
546
547         celt_encode(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes);
548     }
549
550
551     if (frame_size>st->encoder_buffer)
552     {
553         for (i=0;i<st->encoder_buffer*st->channels;i++)
554                 st->delay_buffer[i] = pcm[(frame_size-st->encoder_buffer)*st->channels+i];
555     } else {
556         int tmp = st->encoder_buffer-frame_size;
557         for (i=0;i<tmp*st->channels;i++)
558                 st->delay_buffer[i] = st->delay_buffer[i+frame_size*st->channels];
559         for (i=0;i<frame_size*st->channels;i++)
560                 st->delay_buffer[tmp*st->channels+i] = pcm[i];
561     }
562
563         /* Signalling the mode in the first byte */
564         data--;
565         framerate = st->Fs/frame_size;
566         period = 0;
567         while (framerate < 400)
568         {
569             framerate <<= 1;
570             period++;
571         }
572     if (st->mode == MODE_SILK_ONLY)
573     {
574         data[0] = (silk_internal_bandwidth-BANDWIDTH_NARROWBAND)<<5;
575         data[0] |= (period-2)<<3;
576     } else if (st->mode == MODE_CELT_ONLY)
577     {
578         int tmp = st->bandwidth-BANDWIDTH_MEDIUMBAND;
579         if (tmp < 0)
580             tmp = 0;
581         data[0] = 0x80;
582         data[0] |= tmp << 5;
583         data[0] |= period<<3;
584     } else /* Hybrid */
585     {
586         data[0] = 0x60;
587         data[0] |= (st->bandwidth-BANDWIDTH_SUPERWIDEBAND)<<4;
588         data[0] |= (period-2)<<3;
589     }
590     data[0] |= (st->stream_channels==2)<<2;
591     /*printf ("%x\n", (int)data[0]);*/
592
593 #if OPUS_TEST_RANGE_CODER_STATE
594     st->rangeFinal = enc.rng;
595 #endif
596     if (to_celt)
597         st->prev_mode = MODE_CELT_ONLY;
598     else
599         st->prev_mode = st->mode;
600     st->first = 0;
601     return ret+1+redundancy_bytes;
602 }
603
604 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
605 {
606         CELTEncoder *celt_enc;
607     va_list ap;
608
609     va_start(ap, request);
610
611     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
612
613     switch (request)
614     {
615         case OPUS_SET_MODE_REQUEST:
616         {
617             int value = va_arg(ap, int);
618             st->user_mode = value;
619         }
620         break;
621         case OPUS_GET_MODE_REQUEST:
622         {
623             int *value = va_arg(ap, int*);
624             *value = st->mode;
625         }
626         break;
627         case OPUS_SET_BITRATE_REQUEST:
628         {
629             int value = va_arg(ap, int);
630             if (value != OPUS_BITRATE_AUTO)
631             {
632                 if (value <= 0)
633                     goto bad_arg;
634                 else if (value <= 500)
635                     value = 500;
636             }
637             st->user_bitrate_bps = value;
638         }
639         break;
640         case OPUS_GET_BITRATE_REQUEST:
641         {
642             int *value = va_arg(ap, int*);
643             *value = st->bitrate_bps;
644         }
645         break;
646         case OPUS_SET_FORCE_MONO_REQUEST:
647         {
648             int value = va_arg(ap, int);
649             st->force_mono = value;
650         }
651         break;
652         case OPUS_GET_FORCE_MONO_REQUEST:
653         {
654             int *value = va_arg(ap, int*);
655             *value = !!st->force_mono;
656         }
657         break;
658         case OPUS_SET_BANDWIDTH_REQUEST:
659         {
660             int value = va_arg(ap, int);
661             if (value < BANDWIDTH_AUTO || value > BANDWIDTH_FULLBAND)
662                 return OPUS_BAD_ARG;
663             st->user_bandwidth = value;
664             if (st->user_bandwidth == BANDWIDTH_NARROWBAND) {
665                 st->silk_mode.maxInternalSampleRate = 8000;
666             } else if (st->bandwidth == BANDWIDTH_MEDIUMBAND) {
667                 st->silk_mode.maxInternalSampleRate = 12000;
668             } else {
669                 st->silk_mode.maxInternalSampleRate = 16000;
670             }
671         }
672         break;
673         case OPUS_GET_BANDWIDTH_REQUEST:
674         {
675             int *value = va_arg(ap, int*);
676             *value = st->bandwidth;
677         }
678         break;
679         case OPUS_SET_DTX_FLAG_REQUEST:
680         {
681             int value = va_arg(ap, int);
682             st->silk_mode.useDTX = value;
683         }
684         break;
685         case OPUS_GET_DTX_FLAG_REQUEST:
686         {
687             int *value = va_arg(ap, int*);
688             *value = st->silk_mode.useDTX;
689         }
690         break;
691         case OPUS_SET_COMPLEXITY_REQUEST:
692         {
693             int value = va_arg(ap, int);
694             st->silk_mode.complexity = value;
695             celt_encoder_ctl(celt_enc, CELT_SET_COMPLEXITY(value));
696         }
697         break;
698         case OPUS_GET_COMPLEXITY_REQUEST:
699         {
700             int *value = va_arg(ap, int*);
701             *value = st->silk_mode.complexity;
702         }
703         break;
704         case OPUS_SET_INBAND_FEC_FLAG_REQUEST:
705         {
706             int value = va_arg(ap, int);
707             st->silk_mode.useInBandFEC = value;
708         }
709         break;
710         case OPUS_GET_INBAND_FEC_FLAG_REQUEST:
711         {
712             int *value = va_arg(ap, int*);
713             *value = st->silk_mode.useInBandFEC;
714         }
715         break;
716         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
717         {
718             int value = va_arg(ap, int);
719             if (value < 0 || value > 100)
720                 return OPUS_BAD_ARG;
721             st->silk_mode.packetLossPercentage = value;
722             celt_encoder_ctl(celt_enc, CELT_SET_LOSS_PERC(value));
723         }
724         break;
725         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
726         {
727             int *value = va_arg(ap, int*);
728             *value = st->silk_mode.packetLossPercentage;
729         }
730         break;
731         case OPUS_SET_VBR_FLAG_REQUEST:
732         {
733             int value = va_arg(ap, int);
734             st->use_vbr = value;
735             st->silk_mode.useCBR = 1-value;
736         }
737         break;
738         case OPUS_GET_VBR_FLAG_REQUEST:
739         {
740             int *value = va_arg(ap, int*);
741             *value = st->use_vbr;
742         }
743         break;
744         case OPUS_SET_VOICE_RATIO_REQUEST:
745         {
746             int value = va_arg(ap, int);
747             if (value>100 || value<0)
748                 goto bad_arg;
749             st->voice_ratio = value;
750         }
751         break;
752         case OPUS_GET_VOICE_RATIO_REQUEST:
753         {
754             int *value = va_arg(ap, int*);
755             *value = st->voice_ratio;
756         }
757         break;
758         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
759         {
760             int value = va_arg(ap, int);
761             st->vbr_constraint = value;
762         }
763         break;
764         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
765         {
766             int *value = va_arg(ap, int*);
767             *value = st->vbr_constraint;
768         }
769         break;
770         default:
771             fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);
772             break;
773     }
774     va_end(ap);
775     return OPUS_OK;
776 bad_arg:
777     va_end(ap);
778     return OPUS_BAD_ARG;
779 }
780
781 void opus_encoder_destroy(OpusEncoder *st)
782 {
783         free(st);
784 }
785
786 #if OPUS_TEST_RANGE_CODER_STATE
787 int opus_encoder_get_final_range(OpusEncoder *st)
788 {
789     return st->rangeFinal;
790 }
791 #endif