splitting encoder config in terms of application and signal type
[opus.git] / src / opus_encoder.c
1 /* Copyright (c) 2010 Xiph.Org Foundation, Skype Limited
2    Written by Jean-Marc Valin and Koen Vos */
3 /*
4    Redistribution and use in source and binary forms, with or without
5    modification, are permitted provided that the following conditions
6    are met:
7
8    - Redistributions of source code must retain the above copyright
9    notice, this list of conditions and the following disclaimer.
10
11    - Redistributions in binary form must reproduce the above copyright
12    notice, this list of conditions and the following disclaimer in the
13    documentation and/or other materials provided with the distribution.
14
15    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
18    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
19    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
23    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
24    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #ifdef HAVE_CONFIG_H
29 #include "config.h"
30 #endif
31
32 #include <string.h>
33 #include <stdlib.h>
34 #include <stdio.h>
35 #include <stdarg.h>
36 #include "celt.h"
37 #include "opus_encoder.h"
38 #include "entenc.h"
39 #include "modes.h"
40 #include "silk_API.h"
41
42 /* Transition tables for the voice and audio modes. First column is the
43    middle (memoriless) threshold. The second column is the hysteresis
44    (difference with the middle) */
45 static const int voice_bandwidth_thresholds[10] = {
46                 11000, 1000, /* NB<->MB */
47                 14000, 1000, /* MB<->WB */
48                 21000, 2000, /* WB<->SWB */
49                 29000, 2000, /* SWB<->FB */
50 };
51 static const int audio_bandwidth_thresholds[10] = {
52                 30000,    0, /* MB not allowed */
53                 20000, 2000, /* MB<->WB */
54                 26000, 2000, /* WB<->SWB */
55                 33000, 2000, /* SWB<->FB */
56 };
57
58 /* Make sure everything's aligned to 4 bytes (this may need to be increased
59    on really weird architectures) */
60 static inline int align(int i)
61 {
62         return (i+3)&-4;
63 }
64
65 int opus_encoder_get_size(int channels)
66 {
67         int silkEncSizeBytes, celtEncSizeBytes;
68         int ret;
69         ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
70         if(ret)
71                 return 0;
72         silkEncSizeBytes = align(silkEncSizeBytes);
73     celtEncSizeBytes = celt_encoder_get_size(channels);
74     return align(sizeof(OpusEncoder))+silkEncSizeBytes+celtEncSizeBytes;
75
76 }
77
78 OpusEncoder *opus_encoder_init(OpusEncoder* st, int Fs, int channels, int application)
79 {
80         void *silk_enc;
81         CELTEncoder *celt_enc;
82     int err;
83         int ret, silkEncSizeBytes;
84
85         memset(st, 0, opus_encoder_get_size(channels));
86     /* Create SILK encoder */
87     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
88     if( ret )
89         return NULL;
90         silkEncSizeBytes = align(silkEncSizeBytes);
91     st->silk_enc_offset = align(sizeof(OpusEncoder));
92     st->celt_enc_offset = st->silk_enc_offset+silkEncSizeBytes;
93     silk_enc = (char*)st+st->silk_enc_offset;
94     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
95
96     st->stream_channels = st->channels = channels;
97
98     st->Fs = Fs;
99
100     ret = silk_InitEncoder( silk_enc, &st->silk_mode );
101     if( ret )
102         goto failure;
103
104     /* default SILK parameters */
105     st->silk_mode.nChannelsAPI              = channels;
106     st->silk_mode.nChannelsInternal         = channels;
107     st->silk_mode.API_sampleRate            = st->Fs;
108     st->silk_mode.maxInternalSampleRate     = 16000;
109     st->silk_mode.minInternalSampleRate     = 8000;
110     st->silk_mode.desiredInternalSampleRate = 16000;
111     st->silk_mode.payloadSize_ms            = 20;
112     st->silk_mode.bitRate                   = 25000;
113     st->silk_mode.packetLossPercentage      = 0;
114     st->silk_mode.complexity                = 10;
115     st->silk_mode.useInBandFEC              = 0;
116     st->silk_mode.useDTX                    = 0;
117     st->silk_mode.useCBR                    = 0;
118     st->silk_mode.HP_cutoff_Hz              = 0;
119
120     st->hybrid_stereo_width_Q14             = 1 << 14;
121
122     /* Create CELT encoder */
123         /* Initialize CELT encoder */
124         celt_encoder_init(celt_enc, Fs, channels, &err);
125         if (err != CELT_OK)
126                 goto failure;
127     celt_encoder_ctl(celt_enc, CELT_SET_SIGNALLING(0));
128
129         st->mode = MODE_HYBRID;
130         st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
131         st->use_vbr = 0;
132     st->user_bitrate_bps = OPUS_BITRATE_AUTO;
133         st->bitrate_bps = 3000+Fs*channels;
134         st->user_mode = application;
135         st->signal_type = OPUS_SIGNAL_AUTO;
136         st->user_bandwidth = OPUS_BANDWIDTH_AUTO;
137         st->voice_ratio = 90;
138         st->first = 1;
139
140         st->encoder_buffer = st->Fs/100;
141         st->delay_compensation = st->Fs/400;
142         if (st->Fs > 16000)
143                 st->delay_compensation += 10;
144         return st;
145 failure:
146     free(st);
147     return NULL;
148 }
149
150 OpusEncoder *opus_encoder_create(int Fs, int channels, int mode)
151 {
152     char *raw_state = (char *)malloc(opus_encoder_get_size(channels));
153     if (raw_state == NULL)
154         return NULL;
155     return opus_encoder_init((OpusEncoder*)raw_state, Fs, channels, mode);
156 }
157
158 int opus_encode(OpusEncoder *st, const short *pcm, int frame_size,
159                 unsigned char *data, int max_data_bytes)
160 {
161         void *silk_enc;
162         CELTEncoder *celt_enc;
163     int i;
164         int ret=0;
165         int nBytes;
166         ec_enc enc;
167         int framerate, period;
168     int silk_internal_bandwidth=-1;
169     int bytes_target;
170     int prefill=0;
171     int start_band = 0;
172     int redundancy = 0;
173     int redundancy_bytes = 0;
174     int celt_to_silk = 0;
175     /* TODO: This is 60 only so we can handle 60ms speech/audio switching 
176        it shouldn't be too hard to reduce to 20 ms if needed */
177     short pcm_buf[60*48*2];
178     int nb_compr_bytes;
179     int to_celt = 0;
180     celt_int32 mono_rate;
181
182     silk_enc = (char*)st+st->silk_enc_offset;
183     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
184
185     if (st->user_bitrate_bps==OPUS_BITRATE_AUTO)
186         st->bitrate_bps = 60*st->Fs/frame_size + st->Fs*st->channels;
187     else
188         st->bitrate_bps = st->user_bitrate_bps;
189
190     /* Rate-dependent mono-stereo decision */
191     if (st->force_mono)
192     {
193         st->stream_channels = 1;
194     } else if (st->mode == MODE_CELT_ONLY && st->channels == 2)
195     {
196         celt_int32 decision_rate;
197         decision_rate = st->bitrate_bps + st->voice_ratio*st->voice_ratio;
198         /* Add some hysteresis */
199         if (st->stream_channels == 2)
200             decision_rate += 4000;
201         else
202             decision_rate -= 4000;
203         if (decision_rate>48000)
204             st->stream_channels = 2;
205         else
206             st->stream_channels = 1;
207     } else {
208             st->stream_channels = st->channels;
209     }
210     /* Equivalent bit-rate for mono */
211     mono_rate = st->bitrate_bps;
212     if (st->stream_channels==2)
213         mono_rate = 2*mono_rate/3;
214     /* Compensate for smaller frame sizes assuming an equivalent overhead
215        of 60 bits/frame */
216     mono_rate -= 60*(st->Fs/frame_size - 50);
217
218     /* Mode selection depending on application and signal type */
219     if (st->user_mode==OPUS_APPLICATION_VOIP)
220     {
221         celt_int32 threshold = 20000;
222         /* Hysteresis */
223         if (st->prev_mode == MODE_CELT_ONLY)
224             threshold -= 4000;
225         else if (st->prev_mode>0)
226             threshold += 4000;
227
228         /* OPUS_APPLICATION_VOIP defaults to MODE_SILK_ONLY */
229         if (st->signal_type == OPUS_SIGNAL_MUSIC && mono_rate > threshold)
230             st->mode = MODE_CELT_ONLY;
231         else
232             st->mode = MODE_SILK_ONLY;
233     } else {/* OPUS_APPLICATION_AUDIO */
234         celt_int32 threshold;
235         /* SILK/CELT threshold is higher for voice than for music */
236         threshold = 36000;
237         if (st->signal_type == OPUS_SIGNAL_MUSIC)
238             threshold -= 20000;
239         else if (st->signal_type == OPUS_SIGNAL_VOICE)
240             threshold += 8000;
241
242         /* Hysteresis */
243         if (st->prev_mode == MODE_CELT_ONLY)
244             threshold -= 4000;
245         else if (st->prev_mode>0)
246             threshold += 4000;
247
248         if (mono_rate>threshold)
249             st->mode = MODE_CELT_ONLY;
250         else
251             st->mode = MODE_SILK_ONLY;
252     }
253     /* Automatic (rate-dependent) bandwidth selection */
254     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
255     {
256         const int *bandwidth_thresholds;
257         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
258
259         bandwidth_thresholds = st->mode == MODE_CELT_ONLY ? audio_bandwidth_thresholds : voice_bandwidth_thresholds;
260         do {
261                 int threshold, hysteresis;
262                 threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
263                 hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
264                 if (!st->first)
265                 {
266                         if (st->bandwidth >= bandwidth)
267                                 threshold -= hysteresis;
268                         else
269                                 threshold += hysteresis;
270                 }
271                 if (mono_rate >= threshold)
272                         break;
273         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
274         st->bandwidth = bandwidth;
275         /* Prevents any transition to SWB/FB until the SILK layer has fully
276            switched to WB mode and turned the variable LP filter off */
277         if (st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
278                 st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
279     }
280
281     /* Prevents Opus from wasting bits on frequencies that are above
282        the Nyquist rate of the input signal */
283     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
284         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
285     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
286         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
287     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
288         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
289     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
290         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
291
292     if (st->user_bandwidth != OPUS_BANDWIDTH_AUTO)
293         st->bandwidth = st->user_bandwidth;
294
295     /* Prevents nonsensical configurations, i.e. modes that don't exist */
296     if (frame_size < st->Fs/100 && st->mode != MODE_CELT_ONLY)
297         st->mode = MODE_CELT_ONLY;
298     if (frame_size > st->Fs/50 && st->mode != MODE_SILK_ONLY)
299         st->mode = MODE_SILK_ONLY;
300     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
301         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
302     if (st->mode == MODE_SILK_ONLY && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
303         st->mode = MODE_HYBRID;
304     if (st->mode == MODE_HYBRID && st->bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
305         st->mode = MODE_SILK_ONLY;
306
307         bytes_target = st->bitrate_bps * frame_size / (st->Fs * 8) - 1;
308
309         data += 1;
310         if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
311         {
312                 silk_EncControlStruct dummy;
313                 silk_InitEncoder( silk_enc, &dummy);
314                 prefill=1;
315         }
316         if (st->prev_mode > 0 &&
317                ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
318                 (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
319         {
320             redundancy = 1;
321             celt_to_silk = (st->mode != MODE_CELT_ONLY);
322             if (!celt_to_silk)
323             {
324                 /* Switch to SILK/hybrid if frame size is 10 ms or more*/
325                 if (frame_size >= st->Fs/100)
326                 {
327                         st->mode = st->prev_mode;
328                         to_celt = 1;
329                 } else {
330                         redundancy=0;
331                 }
332             }
333         }
334
335         ec_enc_init(&enc, data, max_data_bytes-1);
336
337         /* SILK processing */
338     if (st->mode != MODE_CELT_ONLY)
339     {
340         st->silk_mode.bitRate = st->bitrate_bps - 8*st->Fs/frame_size;
341         if( st->mode == MODE_HYBRID ) {
342             st->silk_mode.bitRate /= st->stream_channels;
343             if( st->bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
344                 if( st->Fs == 100 * frame_size ) {
345                     /* 24 kHz, 10 ms */
346                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 2000 + st->use_vbr * 1000 ) * 2 ) / 3;
347                 } else {
348                     /* 24 kHz, 20 ms */
349                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 1000 + st->use_vbr * 1000 ) * 2 ) / 3;
350                 }
351             } else {
352                 if( st->Fs == 100 * frame_size ) {
353                     /* 48 kHz, 10 ms */
354                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 8000 + st->use_vbr * 3000 ) / 2;
355                 } else {
356                     /* 48 kHz, 20 ms */
357                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 9000 + st->use_vbr * 1000 ) / 2;
358                 }
359             }
360             st->silk_mode.bitRate *= st->stream_channels;
361             /* don't let SILK use more than 80% */
362             if( st->silk_mode.bitRate > ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5 ) {
363                 st->silk_mode.bitRate = ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5;
364             }
365         }
366
367         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
368         st->silk_mode.nChannelsAPI = st->channels;
369         st->silk_mode.nChannelsInternal = st->stream_channels;
370         if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
371                 st->silk_mode.desiredInternalSampleRate = 8000;
372         } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
373                 st->silk_mode.desiredInternalSampleRate = 12000;
374         } else {
375             SKP_assert( st->mode == MODE_HYBRID || st->bandwidth == OPUS_BANDWIDTH_WIDEBAND );
376             st->silk_mode.desiredInternalSampleRate = 16000;
377         }
378         if( st->mode == MODE_HYBRID ) {
379             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
380             st->silk_mode.minInternalSampleRate = 16000;
381         } else {
382             st->silk_mode.minInternalSampleRate = 8000;
383         }
384         st->silk_mode.maxInternalSampleRate = 16000;
385
386         /* Call SILK encoder for the low band */
387         nBytes = max_data_bytes-1;
388         if (prefill)
389         {
390             int zero=0;
391                 silk_Encode( silk_enc, &st->silk_mode, st->delay_buffer, st->encoder_buffer, NULL, &zero, 1 );
392         }
393
394         ret = silk_Encode( silk_enc, &st->silk_mode, pcm, frame_size, &enc, &nBytes, 0 );
395         if( ret ) {
396             fprintf (stderr, "SILK encode error: %d\n", ret);
397             /* Handle error */
398         }
399         if (nBytes==0)
400             return 0;
401         /* Extract SILK internal bandwidth for signaling in first byte */
402         if( st->mode == MODE_SILK_ONLY ) {
403             if( st->silk_mode.internalSampleRate == 8000 ) {
404                 silk_internal_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
405             } else if( st->silk_mode.internalSampleRate == 12000 ) {
406                 silk_internal_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
407             } else if( st->silk_mode.internalSampleRate == 16000 ) {
408                 silk_internal_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
409             }
410         } else {
411             SKP_assert( st->silk_mode.internalSampleRate == 16000 );
412         }
413     }
414
415     /* CELT processing */
416         {
417             int endband=21;
418
419             switch(st->bandwidth)
420             {
421             case OPUS_BANDWIDTH_NARROWBAND:
422                 endband = 13;
423                 break;
424             case OPUS_BANDWIDTH_WIDEBAND:
425                 endband = 17;
426                 break;
427             case OPUS_BANDWIDTH_SUPERWIDEBAND:
428                 endband = 19;
429                 break;
430             case OPUS_BANDWIDTH_FULLBAND:
431                 endband = 21;
432                 break;
433             }
434             celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
435             celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
436         }
437         if (st->mode != MODE_SILK_ONLY)
438         {
439         celt_encoder_ctl(celt_enc, CELT_SET_VBR(0));
440         celt_encoder_ctl(celt_enc, CELT_SET_BITRATE(510000));
441         if (st->prev_mode == MODE_SILK_ONLY)
442         {
443                 unsigned char dummy[10];
444                 celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
445                 celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
446                 celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
447                 /* TODO: This wastes CPU a bit compared to just prefilling the buffer */
448                 celt_encode(celt_enc, &st->delay_buffer[(st->encoder_buffer-st->delay_compensation-st->Fs/400)*st->channels], st->Fs/400, dummy, 10);
449         } else {
450                 celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
451         }
452
453         if (st->mode == MODE_HYBRID)
454         {
455             int len;
456
457             len = (ec_tell(&enc)+7)>>3;
458             if( st->use_vbr ) {
459                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
460             } else {
461                 /* check if SILK used up too much */
462                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
463             }
464         } else {
465             if (st->use_vbr)
466             {
467                 celt_encoder_ctl(celt_enc, CELT_SET_VBR(1));
468                 celt_encoder_ctl(celt_enc, CELT_SET_VBR_CONSTRAINT(st->vbr_constraint));
469                 celt_encoder_ctl(celt_enc, CELT_SET_BITRATE(st->bitrate_bps));
470                 nb_compr_bytes = max_data_bytes-1;
471             } else {
472                 nb_compr_bytes = bytes_target;
473             }
474         }
475
476         ec_enc_shrink(&enc, nb_compr_bytes);
477         } else {
478             nb_compr_bytes = 0;
479         }
480
481     for (i=0;i<IMIN(frame_size, st->delay_compensation)*st->channels;i++)
482         pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-st->delay_compensation)*st->channels+i];
483     for (;i<frame_size*st->channels;i++)
484         pcm_buf[i] = pcm[i-st->delay_compensation*st->channels];
485
486     if( st->mode == MODE_HYBRID && st->stream_channels == 2 ) {
487         /* Apply stereo width reduction (at low bitrates) */
488         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
489             int width_Q14, delta_Q14, nSamples_8ms, diff;
490             nSamples_8ms = ( st->Fs * 8 ) / 1000;
491             width_Q14 = (1 << 14 ) - st->hybrid_stereo_width_Q14;
492             delta_Q14 = ( st->hybrid_stereo_width_Q14 - st->silk_mode.stereoWidth_Q14 ) / nSamples_8ms;
493             for( i = 0; i < nSamples_8ms; i++ ) {
494                 width_Q14 += delta_Q14;
495                 diff = pcm_buf[ 2*i+1 ] - (int)pcm_buf[ 2*i ];
496                 diff = ( diff * width_Q14 ) >> 15;
497                 pcm_buf[ 2*i ]   = (short)( pcm_buf[ 2*i ]   + diff );
498                 pcm_buf[ 2*i+1 ] = (short)( pcm_buf[ 2*i+1 ] - diff );
499             }
500             for( ; i < frame_size; i++ ) {
501                 diff = pcm_buf[ 2*i+1 ] - (int)pcm_buf[ 2*i ];
502                 diff = ( diff * width_Q14 ) >> 15;
503                 pcm_buf[ 2*i ]   = (short)( pcm_buf[ 2*i ]   + diff );
504                 pcm_buf[ 2*i+1 ] = (short)( pcm_buf[ 2*i+1 ] - diff );
505             }
506             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
507         }
508     }
509
510     if (st->mode != MODE_CELT_ONLY)
511     {
512         /* Check if we have a redundant 0-8 kHz band */
513         ec_enc_bit_logp(&enc, redundancy, 12);
514         if (redundancy)
515         {
516             redundancy_bytes = st->stream_channels*st->bitrate_bps/1600;
517             ec_enc_bit_logp(&enc, celt_to_silk, 1);
518             if (st->mode == MODE_HYBRID)
519                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
520         }
521         start_band = 17;
522     }
523
524     if (st->mode == MODE_SILK_ONLY)
525     {
526         ret = (ec_tell(&enc)+7)>>3;
527         ec_enc_done(&enc);
528         nb_compr_bytes = ret;
529     }
530
531     /* 5 ms redundant frame for CELT->SILK */
532     if (redundancy && celt_to_silk)
533     {
534         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
535         celt_encoder_ctl(celt_enc, CELT_SET_VBR(0));
536         celt_encode(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes);
537         celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
538     }
539
540     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
541
542     if (st->mode != MODE_SILK_ONLY)
543         {
544             ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
545         }
546
547     /* 5 ms redundant frame for SILK->CELT */
548     if (redundancy && !celt_to_silk)
549     {
550         int N2, N4;
551         N2 = st->Fs/200;
552         N4 = st->Fs/400;
553
554         celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
555         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
556         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
557
558         /* TODO: We could speed up prefilling here */
559         celt_encode(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, data+nb_compr_bytes, redundancy_bytes);
560
561         celt_encode(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes);
562     }
563
564
565     if (frame_size>st->encoder_buffer)
566     {
567         for (i=0;i<st->encoder_buffer*st->channels;i++)
568                 st->delay_buffer[i] = pcm[(frame_size-st->encoder_buffer)*st->channels+i];
569     } else {
570         int tmp = st->encoder_buffer-frame_size;
571         for (i=0;i<tmp*st->channels;i++)
572                 st->delay_buffer[i] = st->delay_buffer[i+frame_size*st->channels];
573         for (i=0;i<frame_size*st->channels;i++)
574                 st->delay_buffer[tmp*st->channels+i] = pcm[i];
575     }
576
577         /* Signalling the mode in the first byte */
578         data--;
579         framerate = st->Fs/frame_size;
580         period = 0;
581         while (framerate < 400)
582         {
583             framerate <<= 1;
584             period++;
585         }
586     if (st->mode == MODE_SILK_ONLY)
587     {
588         data[0] = (silk_internal_bandwidth-OPUS_BANDWIDTH_NARROWBAND)<<5;
589         data[0] |= (period-2)<<3;
590     } else if (st->mode == MODE_CELT_ONLY)
591     {
592         int tmp = st->bandwidth-OPUS_BANDWIDTH_MEDIUMBAND;
593         if (tmp < 0)
594             tmp = 0;
595         data[0] = 0x80;
596         data[0] |= tmp << 5;
597         data[0] |= period<<3;
598     } else /* Hybrid */
599     {
600         data[0] = 0x60;
601         data[0] |= (st->bandwidth-OPUS_BANDWIDTH_SUPERWIDEBAND)<<4;
602         data[0] |= (period-2)<<3;
603     }
604     data[0] |= (st->stream_channels==2)<<2;
605     /*printf ("%x\n", (int)data[0]);*/
606
607 #if OPUS_TEST_RANGE_CODER_STATE
608     st->rangeFinal = enc.rng;
609 #endif
610     if (to_celt)
611         st->prev_mode = MODE_CELT_ONLY;
612     else
613         st->prev_mode = st->mode;
614     st->first = 0;
615     return ret+1+redundancy_bytes;
616 }
617
618 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
619 {
620         CELTEncoder *celt_enc;
621     va_list ap;
622
623     va_start(ap, request);
624
625     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
626
627     switch (request)
628     {
629         case OPUS_SET_MODE_REQUEST:
630         {
631             int value = va_arg(ap, int);
632             st->user_mode = value;
633         }
634         break;
635         case OPUS_GET_MODE_REQUEST:
636         {
637             int *value = va_arg(ap, int*);
638             *value = st->mode;
639         }
640         break;
641         case OPUS_SET_BITRATE_REQUEST:
642         {
643             int value = va_arg(ap, int);
644             if (value != OPUS_BITRATE_AUTO)
645             {
646                 if (value <= 0)
647                     goto bad_arg;
648                 else if (value <= 500)
649                     value = 500;
650             }
651             st->user_bitrate_bps = value;
652         }
653         break;
654         case OPUS_GET_BITRATE_REQUEST:
655         {
656             int *value = va_arg(ap, int*);
657             *value = st->bitrate_bps;
658         }
659         break;
660         case OPUS_SET_FORCE_MONO_REQUEST:
661         {
662             int value = va_arg(ap, int);
663             st->force_mono = value;
664         }
665         break;
666         case OPUS_GET_FORCE_MONO_REQUEST:
667         {
668             int *value = va_arg(ap, int*);
669             *value = !!st->force_mono;
670         }
671         break;
672         case OPUS_SET_BANDWIDTH_REQUEST:
673         {
674             int value = va_arg(ap, int);
675             if (value < OPUS_BANDWIDTH_AUTO || value > OPUS_BANDWIDTH_FULLBAND)
676                 return OPUS_BAD_ARG;
677             st->user_bandwidth = value;
678             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
679                 st->silk_mode.maxInternalSampleRate = 8000;
680             } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
681                 st->silk_mode.maxInternalSampleRate = 12000;
682             } else {
683                 st->silk_mode.maxInternalSampleRate = 16000;
684             }
685         }
686         break;
687         case OPUS_GET_BANDWIDTH_REQUEST:
688         {
689             int *value = va_arg(ap, int*);
690             *value = st->bandwidth;
691         }
692         break;
693         case OPUS_SET_DTX_FLAG_REQUEST:
694         {
695             int value = va_arg(ap, int);
696             st->silk_mode.useDTX = value;
697         }
698         break;
699         case OPUS_GET_DTX_FLAG_REQUEST:
700         {
701             int *value = va_arg(ap, int*);
702             *value = st->silk_mode.useDTX;
703         }
704         break;
705         case OPUS_SET_COMPLEXITY_REQUEST:
706         {
707             int value = va_arg(ap, int);
708             st->silk_mode.complexity = value;
709             celt_encoder_ctl(celt_enc, CELT_SET_COMPLEXITY(value));
710         }
711         break;
712         case OPUS_GET_COMPLEXITY_REQUEST:
713         {
714             int *value = va_arg(ap, int*);
715             *value = st->silk_mode.complexity;
716         }
717         break;
718         case OPUS_SET_INBAND_FEC_FLAG_REQUEST:
719         {
720             int value = va_arg(ap, int);
721             st->silk_mode.useInBandFEC = value;
722         }
723         break;
724         case OPUS_GET_INBAND_FEC_FLAG_REQUEST:
725         {
726             int *value = va_arg(ap, int*);
727             *value = st->silk_mode.useInBandFEC;
728         }
729         break;
730         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
731         {
732             int value = va_arg(ap, int);
733             if (value < 0 || value > 100)
734                 return OPUS_BAD_ARG;
735             st->silk_mode.packetLossPercentage = value;
736             celt_encoder_ctl(celt_enc, CELT_SET_LOSS_PERC(value));
737         }
738         break;
739         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
740         {
741             int *value = va_arg(ap, int*);
742             *value = st->silk_mode.packetLossPercentage;
743         }
744         break;
745         case OPUS_SET_VBR_FLAG_REQUEST:
746         {
747             int value = va_arg(ap, int);
748             st->use_vbr = value;
749             st->silk_mode.useCBR = 1-value;
750         }
751         break;
752         case OPUS_GET_VBR_FLAG_REQUEST:
753         {
754             int *value = va_arg(ap, int*);
755             *value = st->use_vbr;
756         }
757         break;
758         case OPUS_SET_VOICE_RATIO_REQUEST:
759         {
760             int value = va_arg(ap, int);
761             if (value>100 || value<0)
762                 goto bad_arg;
763             st->voice_ratio = value;
764         }
765         break;
766         case OPUS_GET_VOICE_RATIO_REQUEST:
767         {
768             int *value = va_arg(ap, int*);
769             *value = st->voice_ratio;
770         }
771         break;
772         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
773         {
774             int value = va_arg(ap, int);
775             st->vbr_constraint = value;
776         }
777         break;
778         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
779         {
780             int *value = va_arg(ap, int*);
781             *value = st->vbr_constraint;
782         }
783         break;
784         case OPUS_SET_SIGNAL_REQUEST:
785         {
786             int value = va_arg(ap, int);
787             st->signal_type = value;
788         }
789         break;
790         case OPUS_GET_SIGNAL_REQUEST:
791         {
792             int *value = va_arg(ap, int*);
793             *value = st->signal_type;
794         }
795         break;
796         default:
797             fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);
798             break;
799     }
800     va_end(ap);
801     return OPUS_OK;
802 bad_arg:
803     va_end(ap);
804     return OPUS_BAD_ARG;
805 }
806
807 void opus_encoder_destroy(OpusEncoder *st)
808 {
809         free(st);
810 }
811
812 #if OPUS_TEST_RANGE_CODER_STATE
813 int opus_encoder_get_final_range(OpusEncoder *st)
814 {
815     return st->rangeFinal;
816 }
817 #endif