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