384922d560d30e615dd9cc72e57e4acab9697146
[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 <stdlib.h>
33 #include <stdio.h>
34 #include <stdarg.h>
35 #include "opus_encoder.h"
36 #include "entenc.h"
37 #include "modes.h"
38 #include "SKP_Silk_SDK_API.h"
39
40 OpusEncoder *opus_encoder_create(int Fs, int channels)
41 {
42     int err;
43     char *raw_state;
44         OpusEncoder *st;
45         int ret, silkEncSizeBytes, celtEncSizeBytes;
46
47     /* Create SILK encoder */
48     ret = SKP_Silk_SDK_Get_Encoder_Size( &silkEncSizeBytes );
49     if( ret ) {
50         /* Handle error */
51     }
52     celtEncSizeBytes = celt_encoder_get_size(channels);
53     raw_state = calloc(sizeof(OpusEncoder)+silkEncSizeBytes+celtEncSizeBytes, 1);
54     st = (OpusEncoder*)raw_state;
55     st->silk_enc = (void*)(raw_state+sizeof(OpusEncoder));
56     st->celt_enc = (CELTEncoder*)(raw_state+sizeof(OpusEncoder)+silkEncSizeBytes);
57     st->stream_channels = st->channels = channels;
58
59     st->Fs = Fs;
60
61     ret = SKP_Silk_SDK_InitEncoder( st->silk_enc, &st->silk_mode );
62     if( ret ) {
63         /* Handle error */
64     }
65
66     /* default SILK parameters */
67     st->silk_mode.API_sampleRate        = st->Fs;
68     st->silk_mode.maxInternalSampleRate = 16000;
69     st->silk_mode.minInternalSampleRate = 8000;
70     st->silk_mode.payloadSize_ms        = 20;
71     st->silk_mode.packetLossPercentage  = 0;
72     st->silk_mode.useInBandFEC          = 0;
73     st->silk_mode.useDTX                = 0;
74     st->silk_mode.complexity            = 10;
75
76     /* Create CELT encoder */
77         /* Initialize CELT encoder */
78         st->celt_enc = celt_encoder_init(st->celt_enc, Fs, channels, &err);
79
80         st->mode = MODE_HYBRID;
81         st->bandwidth = BANDWIDTH_FULLBAND;
82         st->use_vbr = 0;
83         st->bitrate_bps = 32000;
84         st->user_mode = OPUS_MODE_AUTO;
85         st->user_bandwidth = BANDWIDTH_AUTO;
86         st->voice_ratio = 90;
87
88         st->encoder_buffer = st->Fs/100;
89         st->delay_compensation = st->Fs/400;
90         if (st->Fs > 16000)
91                 st->delay_compensation += 10;
92         return st;
93 }
94
95 int opus_encode(OpusEncoder *st, const short *pcm, int frame_size,
96                 unsigned char *data, int max_data_bytes)
97 {
98     int i;
99         int ret=0;
100         SKP_int32 nBytes;
101         ec_enc enc;
102         int framerate, period;
103     int silk_internal_bandwidth;
104     int bytes_target;
105     int prefill=0;
106     int start_band = 0;
107     int redundancy = 0;
108     int redundancy_bytes = 0;
109     int celt_to_silk = 0;
110     short pcm_buf[960*2];
111     int nb_compr_bytes;
112     int to_celt = 0;
113     celt_int32 mono_rate;
114
115     if (st->channels == 2)
116     {
117         celt_int32 decision_rate;
118         decision_rate = st->bitrate_bps + st->voice_ratio*st->voice_ratio;
119         if (st->stream_channels == 2)
120             decision_rate += 4000;
121         else
122             decision_rate -= 4000;
123         if (decision_rate>48000)
124             st->stream_channels = 2;
125         else
126             st->stream_channels = 1;
127     } else {
128         st->stream_channels = 1;
129     }
130     /* Equivalent bit-rate for mono */
131     mono_rate = st->bitrate_bps;
132     if (st->stream_channels==2)
133         mono_rate = (mono_rate+10000)/2;
134
135     /* Mode selection */
136     if (st->user_mode==OPUS_MODE_AUTO)
137     {
138         celt_int32 decision_rate;
139         decision_rate = mono_rate - 3*st->voice_ratio*st->voice_ratio;
140         if (st->prev_mode == MODE_CELT_ONLY)
141             decision_rate += 4000;
142         else if (st->prev_mode>0)
143             decision_rate -= 4000;
144         if (decision_rate>24000)
145             st->mode = MODE_CELT_ONLY;
146         else
147             st->mode = MODE_SILK_ONLY;
148     } else if (st->user_mode==OPUS_MODE_VOICE)
149     {
150         st->mode = MODE_SILK_ONLY;
151     } else {/* OPUS_AUDIO_MODE */
152         st->mode = MODE_CELT_ONLY;
153     }
154
155     /* FIXME: Remove this once SILK supports stereo */
156     if (st->channels == 2)
157         st->mode = MODE_CELT_ONLY;
158
159     /* Bandwidth selection */
160     if (st->mode == MODE_CELT_ONLY)
161     {
162         if (mono_rate>35000 || (mono_rate>28000 && st->bandwidth==BANDWIDTH_FULLBAND))
163             st->bandwidth = BANDWIDTH_FULLBAND;
164         else if (mono_rate>28000 || (mono_rate>24000 && st->bandwidth==BANDWIDTH_SUPERWIDEBAND))
165             st->bandwidth = BANDWIDTH_SUPERWIDEBAND;
166         else if (mono_rate>24000 || (mono_rate>18000 && st->bandwidth==BANDWIDTH_WIDEBAND))
167             st->bandwidth = BANDWIDTH_WIDEBAND;
168         else
169             st->bandwidth = BANDWIDTH_NARROWBAND;
170     } else {
171         if (mono_rate>28000 || (mono_rate>24000 && st->bandwidth==BANDWIDTH_FULLBAND))
172             st->bandwidth = BANDWIDTH_FULLBAND;
173         else if (mono_rate>24000 || (mono_rate>18000 && st->bandwidth==BANDWIDTH_SUPERWIDEBAND))
174             st->bandwidth = BANDWIDTH_SUPERWIDEBAND;
175         else if (mono_rate>18000 || (mono_rate>14000 && st->bandwidth==BANDWIDTH_WIDEBAND))
176             st->bandwidth = BANDWIDTH_WIDEBAND;
177         else if (mono_rate>14000 || (mono_rate>11000 && st->bandwidth==BANDWIDTH_MEDIUMBAND))
178             st->bandwidth = BANDWIDTH_MEDIUMBAND;
179         else
180             st->bandwidth = BANDWIDTH_NARROWBAND;
181     }
182
183     if (st->Fs <= 24000 && st->bandwidth > BANDWIDTH_SUPERWIDEBAND)
184         st->bandwidth = BANDWIDTH_SUPERWIDEBAND;
185     if (st->Fs <= 16000 && st->bandwidth > BANDWIDTH_WIDEBAND)
186         st->bandwidth = BANDWIDTH_WIDEBAND;
187     if (st->Fs <= 12000 && st->bandwidth > BANDWIDTH_MEDIUMBAND)
188         st->bandwidth = BANDWIDTH_MEDIUMBAND;
189     if (st->Fs <= 8000 && st->bandwidth > BANDWIDTH_NARROWBAND)
190         st->bandwidth = BANDWIDTH_NARROWBAND;
191
192     if (st->user_bandwidth != BANDWIDTH_AUTO)
193         st->bandwidth = st->user_bandwidth;
194
195     /* Preventing non-sensical configurations */
196     if (frame_size < st->Fs/100 && st->mode != MODE_CELT_ONLY)
197         st->mode = MODE_CELT_ONLY;
198     if (frame_size > st->Fs/50 && st->mode != MODE_SILK_ONLY)
199         st->mode = MODE_SILK_ONLY;
200     if (st->mode == MODE_CELT_ONLY && st->bandwidth == BANDWIDTH_MEDIUMBAND)
201         st->bandwidth = BANDWIDTH_WIDEBAND;
202     if (st->mode == MODE_SILK_ONLY && st->bandwidth > BANDWIDTH_WIDEBAND)
203         st->mode = MODE_HYBRID;
204     if (st->mode == MODE_HYBRID && st->bandwidth <= BANDWIDTH_WIDEBAND)
205         st->mode = MODE_SILK_ONLY;
206
207         bytes_target = st->bitrate_bps * frame_size / (st->Fs * 8) - 1;
208
209         data += 1;
210         if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
211         {
212                 SKP_SILK_SDK_EncControlStruct dummy;
213                 SKP_Silk_SDK_InitEncoder( st->silk_enc, &dummy);
214                 prefill=1;
215         }
216         if (st->prev_mode >0 &&
217                 ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
218                 || (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
219         {
220             redundancy = 1;
221             celt_to_silk = (st->mode != MODE_CELT_ONLY);
222             if (!celt_to_silk)
223             {
224                 /* Switch to SILK/hybrid if frame size is 10 ms or more*/
225                 if (frame_size >= st->Fs/100)
226                 {
227                         st->mode = st->prev_mode;
228                         to_celt = 1;
229                 } else {
230                         redundancy=0;
231                 }
232             }
233         }
234
235         ec_enc_init(&enc, data, max_data_bytes-1);
236
237         /* SILK processing */
238     if (st->mode != MODE_CELT_ONLY)
239     {
240         st->silk_mode.bitRate = st->bitrate_bps - 8*st->Fs/frame_size;
241         if( st->mode == MODE_HYBRID ) {
242             if( st->bandwidth == BANDWIDTH_SUPERWIDEBAND ) {
243                 if( st->Fs == 100 * frame_size ) {
244                     /* 24 kHz, 10 ms */
245                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 2000 + st->use_vbr * 1000 ) * 2 ) / 3;
246                 } else {
247                     /* 24 kHz, 20 ms */
248                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 1000 + st->use_vbr * 1000 ) * 2 ) / 3;
249                 }
250             } else {
251                 if( st->Fs == 100 * frame_size ) {
252                     /* 48 kHz, 10 ms */
253                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 8000 + st->use_vbr * 3000 ) / 2;
254                 } else {
255                     /* 48 kHz, 20 ms */
256                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 9000 + st->use_vbr * 1000 ) / 2;
257                 }
258             }
259             /* don't let SILK use more than 80% */
260             if( st->silk_mode.bitRate > ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5 ) {
261                 st->silk_mode.bitRate = ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5;
262             }
263         }
264
265         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
266         if (st->bandwidth == BANDWIDTH_NARROWBAND) {
267             st->silk_mode.maxInternalSampleRate = 8000;
268         } else if (st->bandwidth == BANDWIDTH_MEDIUMBAND) {
269             st->silk_mode.maxInternalSampleRate = 12000;
270         } else {
271             SKP_assert( st->mode == MODE_HYBRID || st->bandwidth == BANDWIDTH_WIDEBAND );
272             st->silk_mode.maxInternalSampleRate = 16000;
273         }
274         if( st->mode == MODE_HYBRID ) {
275             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
276             st->silk_mode.minInternalSampleRate = 16000;
277         } else {
278             st->silk_mode.minInternalSampleRate = 8000;
279         }
280
281         /* Call SILK encoder for the low band */
282         nBytes = max_data_bytes-1;
283         if (prefill)
284         {
285             int zero=0;
286                 SKP_Silk_SDK_Encode( st->silk_enc, &st->silk_mode, st->delay_buffer, st->encoder_buffer, NULL, &zero, 1 );
287         }
288
289         ret = SKP_Silk_SDK_Encode( st->silk_enc, &st->silk_mode, pcm, frame_size, &enc, &nBytes, 0 );
290         if( ret ) {
291             fprintf (stderr, "SILK encode error: %d\n", ret);
292             /* Handle error */
293         }
294         /* Extract SILK internal bandwidth for signaling in first byte */
295         if( st->mode == MODE_SILK_ONLY ) {
296             if( st->silk_mode.internalSampleRate == 8000 ) {
297                 silk_internal_bandwidth = BANDWIDTH_NARROWBAND;
298             } else if( st->silk_mode.internalSampleRate == 12000 ) {
299                 silk_internal_bandwidth = BANDWIDTH_MEDIUMBAND;
300             } else if( st->silk_mode.internalSampleRate == 16000 ) {
301                 silk_internal_bandwidth = BANDWIDTH_WIDEBAND;
302             }
303         } else {
304             SKP_assert( st->silk_mode.internalSampleRate == 16000 );
305         }
306     }
307
308     /* CELT processing */
309         {
310             int endband=21;
311
312             switch(st->bandwidth)
313             {
314             case BANDWIDTH_NARROWBAND:
315                 endband = 13;
316                 break;
317             case BANDWIDTH_WIDEBAND:
318                 endband = 17;
319                 break;
320             case BANDWIDTH_SUPERWIDEBAND:
321                 endband = 19;
322                 break;
323             case BANDWIDTH_FULLBAND:
324                 endband = 21;
325                 break;
326             }
327             celt_encoder_ctl(st->celt_enc, CELT_SET_END_BAND(endband));
328             celt_encoder_ctl(st->celt_enc, CELT_SET_CHANNELS(st->stream_channels));
329         }
330         if (st->mode != MODE_SILK_ONLY)
331         {
332         celt_encoder_ctl(st->celt_enc, CELT_SET_VBR(0));
333         celt_encoder_ctl(st->celt_enc, CELT_SET_BITRATE(510000));
334         if (st->prev_mode == MODE_SILK_ONLY)
335         {
336                 unsigned char dummy[10];
337                 celt_encoder_ctl(st->celt_enc, CELT_RESET_STATE);
338                 celt_encoder_ctl(st->celt_enc, CELT_SET_START_BAND(0));
339                 celt_encoder_ctl(st->celt_enc, CELT_SET_PREDICTION(0));
340                 /* FIXME: This wastes CPU a bit compared to just prefilling the buffer */
341                 celt_encode(st->celt_enc, &st->delay_buffer[(st->encoder_buffer-st->delay_compensation-st->Fs/400)*st->channels], st->Fs/400, dummy, 10);
342         } else {
343                 celt_encoder_ctl(st->celt_enc, CELT_SET_PREDICTION(2));
344         }
345
346         if (st->mode == MODE_HYBRID)
347         {
348             int len;
349
350             len = (ec_tell(&enc)+7)>>3;
351             if( st->use_vbr ) {
352                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
353             } else {
354                 /* check if SILK used up too much */
355                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
356             }
357         } else {
358             if (st->use_vbr)
359             {
360                 celt_encoder_ctl(st->celt_enc, CELT_SET_VBR(1));
361                 celt_encoder_ctl(st->celt_enc, CELT_SET_BITRATE(st->bitrate_bps));
362                 nb_compr_bytes = max_data_bytes-1;
363             } else {
364                 nb_compr_bytes = bytes_target;
365             }
366         }
367
368
369         ec_enc_shrink(&enc, nb_compr_bytes);
370         } else {
371             nb_compr_bytes = 0;
372         }
373
374     for (i=0;i<IMIN(frame_size, st->delay_compensation)*st->channels;i++)
375         pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-st->delay_compensation)*st->channels+i];
376     for (;i<frame_size*st->channels;i++)
377         pcm_buf[i] = pcm[i-st->delay_compensation*st->channels];
378     if (st->mode != MODE_CELT_ONLY)
379     {
380         /* Check if we have a redundant 0-8 kHz band */
381         ec_enc_bit_logp(&enc, redundancy, 12);
382         if (redundancy)
383         {
384             redundancy_bytes = 40;
385             ec_enc_bit_logp(&enc, celt_to_silk, 1);
386             if (st->mode == MODE_HYBRID)
387                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
388         }
389         start_band = 17;
390     }
391
392     if (st->mode == MODE_SILK_ONLY)
393     {
394         ret = (ec_tell(&enc)+7)>>3;
395         ec_enc_done(&enc);
396         nb_compr_bytes = ret;
397     }
398
399     /* 5 ms redundant frame for CELT->SILK */
400     if (redundancy && celt_to_silk)
401     {
402         celt_encoder_ctl(st->celt_enc, CELT_SET_START_BAND(0));
403         /* FIXME: This is wrong -- we need to set the flags properly */
404         celt_encoder_ctl(st->celt_enc, CELT_SET_VBR(0));
405         /* FIXME: Make sure not to overflow here */
406         celt_encode(st->celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes);
407         celt_encoder_ctl(st->celt_enc, CELT_RESET_STATE);
408     }
409
410     celt_encoder_ctl(st->celt_enc, CELT_SET_START_BAND(start_band));
411
412     if (st->mode != MODE_SILK_ONLY)
413         {
414             /* Encode high band with CELT */
415             ret = celt_encode_with_ec(st->celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
416         }
417
418     /* 5 ms redundant frame for SILK->CELT */
419     if (redundancy && !celt_to_silk)
420     {
421         int N2, N4;
422         N2 = st->Fs/200;
423         N4 = st->Fs/400;
424
425         celt_encoder_ctl(st->celt_enc, CELT_RESET_STATE);
426         celt_encoder_ctl(st->celt_enc, CELT_SET_START_BAND(0));
427         celt_encoder_ctl(st->celt_enc, CELT_SET_PREDICTION(0));
428
429         /* FIXME: Do proper prefilling here */
430         celt_encode(st->celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, data+nb_compr_bytes, redundancy_bytes);
431
432         celt_encode(st->celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes);
433     }
434
435
436     if (frame_size>st->encoder_buffer)
437     {
438         for (i=0;i<st->encoder_buffer*st->channels;i++)
439                 st->delay_buffer[i] = pcm[(frame_size-st->encoder_buffer)*st->channels+i];
440     } else {
441         int tmp = st->encoder_buffer-frame_size;
442         for (i=0;i<tmp*st->channels;i++)
443                 st->delay_buffer[i] = st->delay_buffer[i+frame_size*st->channels];
444         for (i=0;i<frame_size*st->channels;i++)
445                 st->delay_buffer[tmp*st->channels+i] = pcm[i];
446     }
447
448         /* Signalling the mode in the first byte */
449         data--;
450         framerate = st->Fs/frame_size;
451         period = 0;
452         while (framerate < 400)
453         {
454             framerate <<= 1;
455             period++;
456         }
457     if (st->mode == MODE_SILK_ONLY)
458     {
459         data[0] = (silk_internal_bandwidth-BANDWIDTH_NARROWBAND)<<5;
460         data[0] |= (period-2)<<3;
461     } else if (st->mode == MODE_CELT_ONLY)
462     {
463         int tmp = st->bandwidth-BANDWIDTH_MEDIUMBAND;
464         if (tmp < 0)
465             tmp = 0;
466         data[0] = 0x80;
467         data[0] |= tmp << 5;
468         data[0] |= period<<3;
469     } else /* Hybrid */
470     {
471         data[0] = 0x60;
472         data[0] |= (st->bandwidth-BANDWIDTH_SUPERWIDEBAND)<<4;
473         data[0] |= (period-2)<<3;
474     }
475     data[0] |= (st->stream_channels==2)<<2;
476     /*printf ("%x\n", (int)data[0]);*/
477
478 #if OPUS_TEST_RANGE_CODER_STATE
479     st->rangeFinal = enc.rng;
480 #endif
481     if (to_celt)
482         st->prev_mode = MODE_CELT_ONLY;
483     else
484         st->prev_mode = st->mode;
485     return ret+1+redundancy_bytes;
486 }
487
488 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
489 {
490     va_list ap;
491
492     va_start(ap, request);
493
494     switch (request)
495     {
496         case OPUS_SET_MODE_REQUEST:
497         {
498             int value = va_arg(ap, int);
499             st->user_mode = value;
500         }
501         break;
502         case OPUS_GET_MODE_REQUEST:
503         {
504             int *value = va_arg(ap, int*);
505             *value = st->mode;
506         }
507         break;
508         case OPUS_SET_BITRATE_REQUEST:
509         {
510             int value = va_arg(ap, int);
511             st->bitrate_bps = value;
512         }
513         break;
514         case OPUS_GET_BITRATE_REQUEST:
515         {
516             int *value = va_arg(ap, int*);
517             *value = st->bitrate_bps;
518         }
519         break;
520         case OPUS_SET_BANDWIDTH_REQUEST:
521         {
522             int value = va_arg(ap, int);
523             if (value < BANDWIDTH_AUTO || value > BANDWIDTH_FULLBAND)
524                 return OPUS_BAD_ARG;
525             st->user_bandwidth = value;
526             if (st->user_bandwidth == BANDWIDTH_NARROWBAND) {
527                 st->silk_mode.maxInternalSampleRate = 8000;
528             } else if (st->bandwidth == BANDWIDTH_MEDIUMBAND) {
529                 st->silk_mode.maxInternalSampleRate = 12000;
530             } else {
531                 st->silk_mode.maxInternalSampleRate = 16000;
532             }
533         }
534         break;
535         case OPUS_GET_BANDWIDTH_REQUEST:
536         {
537             int *value = va_arg(ap, int*);
538             *value = st->bandwidth;
539         }
540         break;
541         case OPUS_SET_DTX_FLAG_REQUEST:
542         {
543             int value = va_arg(ap, int);
544             st->silk_mode.useDTX = value;
545         }
546         break;
547         case OPUS_GET_DTX_FLAG_REQUEST:
548         {
549             int *value = va_arg(ap, int*);
550             *value = st->silk_mode.useDTX;
551         }
552         break;
553         case OPUS_SET_COMPLEXITY_REQUEST:
554         {
555             int value = va_arg(ap, int);
556             st->silk_mode.complexity = value;
557             celt_encoder_ctl(st->celt_enc, CELT_SET_COMPLEXITY(value));
558         }
559         break;
560         case OPUS_GET_COMPLEXITY_REQUEST:
561         {
562             int *value = va_arg(ap, int*);
563             *value = st->silk_mode.complexity;
564         }
565         break;
566         case OPUS_SET_INBAND_FEC_FLAG_REQUEST:
567         {
568             int value = va_arg(ap, int);
569             st->silk_mode.useInBandFEC = value;
570         }
571         break;
572         case OPUS_GET_INBAND_FEC_FLAG_REQUEST:
573         {
574             int *value = va_arg(ap, int*);
575             *value = st->silk_mode.useInBandFEC;
576         }
577         break;
578         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
579         {
580             int value = va_arg(ap, int);
581             st->silk_mode.packetLossPercentage = value;
582         }
583         break;
584         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
585         {
586             int *value = va_arg(ap, int*);
587             *value = st->silk_mode.packetLossPercentage;
588         }
589         break;
590         case OPUS_SET_VBR_FLAG_REQUEST:
591         {
592             int value = va_arg(ap, int);
593             st->use_vbr = value;
594             st->silk_mode.useCBR = 1-value;
595         }
596         break;
597         case OPUS_GET_VBR_FLAG_REQUEST:
598         {
599             int *value = va_arg(ap, int*);
600             *value = st->use_vbr;
601         }
602         break;
603         case OPUS_SET_VOICE_RATIO_REQUEST:
604         {
605             int value = va_arg(ap, int);
606             if (value>100 || value<0)
607                 return OPUS_BAD_ARG;
608             st->voice_ratio = value;
609         }
610         break;
611         case OPUS_GET_VOICE_RATIO_REQUEST:
612         {
613             int *value = va_arg(ap, int*);
614             *value = st->voice_ratio;
615         }
616         break;
617         default:
618             fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);
619             break;
620     }
621
622     va_end(ap);
623 }
624
625 void opus_encoder_destroy(OpusEncoder *st)
626 {
627         free(st);
628 }
629
630 #if OPUS_TEST_RANGE_CODER_STATE
631 int opus_encoder_get_final_range(OpusEncoder *st)
632 {
633     return st->rangeFinal;
634 }
635 #endif