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