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