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