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