fbf857cba6a38b4cbc57ea72589d3e2f32fb4962
[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 #include "stack_alloc.h"
42 #include "float_cast.h"
43
44 #ifdef FIXED_POINT
45 #define celt_encode_native celt_encode
46 #else
47 #define celt_encode_native celt_encode_float
48 #endif
49
50 /* Transition tables for the voice and audio modes. First column is the
51    middle (memoriless) threshold. The second column is the hysteresis
52    (difference with the middle) */
53 static const int voice_bandwidth_thresholds[10] = {
54                 11000, 1000, /* NB<->MB */
55                 14000, 1000, /* MB<->WB */
56                 21000, 2000, /* WB<->SWB */
57                 29000, 2000, /* SWB<->FB */
58 };
59 static const int audio_bandwidth_thresholds[10] = {
60                 30000,    0, /* MB not allowed */
61                 20000, 2000, /* MB<->WB */
62                 26000, 2000, /* WB<->SWB */
63                 33000, 2000, /* SWB<->FB */
64 };
65
66 /* Make sure everything's aligned to 4 bytes (this may need to be increased
67    on really weird architectures) */
68 static inline int align(int i)
69 {
70     return (i+3)&-4;
71 }
72
73 int opus_encoder_get_size(int channels)
74 {
75     int silkEncSizeBytes, celtEncSizeBytes;
76     int ret;
77     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
78     if(ret)
79         return 0;
80     silkEncSizeBytes = align(silkEncSizeBytes);
81     celtEncSizeBytes = celt_encoder_get_size(channels);
82     return align(sizeof(OpusEncoder))+silkEncSizeBytes+celtEncSizeBytes;
83 }
84
85 OpusEncoder *opus_encoder_init(OpusEncoder* st, int Fs, int channels, int application)
86 {
87     void *silk_enc;
88     CELTEncoder *celt_enc;
89     int err;
90     int ret, silkEncSizeBytes;
91
92     if (channels > 2 || channels<1)
93         return NULL;
94     if (application < OPUS_APPLICATION_VOIP || application > OPUS_APPLICATION_AUDIO)
95         return NULL;
96     if (Fs != 8000 && Fs != 12000 && Fs != 16000 && Fs != 24000 && Fs != 48000)
97         return NULL;
98
99     memset(st, 0, opus_encoder_get_size(channels));
100     /* Create SILK encoder */
101     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
102     if( ret )
103         return NULL;
104         silkEncSizeBytes = align(silkEncSizeBytes);
105     st->silk_enc_offset = align(sizeof(OpusEncoder));
106     st->celt_enc_offset = st->silk_enc_offset+silkEncSizeBytes;
107     silk_enc = (char*)st+st->silk_enc_offset;
108     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
109
110     st->stream_channels = st->channels = channels;
111
112     st->Fs = Fs;
113
114     ret = silk_InitEncoder( silk_enc, &st->silk_mode );
115     if( ret )
116         goto failure;
117
118     /* default SILK parameters */
119     st->silk_mode.nChannelsAPI              = channels;
120     st->silk_mode.nChannelsInternal         = channels;
121     st->silk_mode.API_sampleRate            = st->Fs;
122     st->silk_mode.maxInternalSampleRate     = 16000;
123     st->silk_mode.minInternalSampleRate     = 8000;
124     st->silk_mode.desiredInternalSampleRate = 16000;
125     st->silk_mode.payloadSize_ms            = 20;
126     st->silk_mode.bitRate                   = 25000;
127     st->silk_mode.packetLossPercentage      = 0;
128     st->silk_mode.complexity                = 10;
129     st->silk_mode.useInBandFEC              = 0;
130     st->silk_mode.useDTX                    = 0;
131     st->silk_mode.useCBR                    = 0;
132     st->silk_mode.HP_cutoff_Hz              = 0;
133
134     st->hybrid_stereo_width_Q14             = 1 << 14;
135
136     /* Create CELT encoder */
137     /* Initialize CELT encoder */
138     celt_encoder_init(celt_enc, Fs, channels, &err);
139     if (err != CELT_OK)
140                 goto failure;
141     celt_encoder_ctl(celt_enc, CELT_SET_SIGNALLING(0));
142
143     st->mode = MODE_HYBRID;
144     st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
145     st->use_vbr = 0;
146     st->user_bitrate_bps = OPUS_BITRATE_AUTO;
147     st->bitrate_bps = 3000+Fs*channels;
148     st->user_mode = application;
149     st->signal_type = OPUS_SIGNAL_AUTO;
150     st->user_bandwidth = OPUS_BANDWIDTH_AUTO;
151     st->voice_ratio = 90;
152     st->first = 1;
153
154     st->encoder_buffer = st->Fs/100;
155     st->delay_compensation = st->Fs/400;
156     if (st->Fs > 16000)
157         st->delay_compensation += 10;
158     return st;
159
160 failure:
161     free(st);
162     return NULL;
163 }
164
165 OpusEncoder *opus_encoder_create(int Fs, int channels, int mode)
166 {
167     char *raw_state = (char *)malloc(opus_encoder_get_size(channels));
168     if (raw_state == NULL)
169         return NULL;
170     return opus_encoder_init((OpusEncoder*)raw_state, Fs, channels, mode);
171 }
172 #ifdef FIXED_POINT
173 int opus_encode(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
174                 unsigned char *data, int max_data_bytes)
175 #else
176 int opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
177       unsigned char *data, int max_data_bytes)
178 #endif
179 {
180     void *silk_enc;
181     CELTEncoder *celt_enc;
182     int i;
183     int ret=0;
184     int nBytes;
185     ec_enc enc;
186     int framerate, period;
187     int silk_internal_bandwidth=-1;
188     int bytes_target;
189     int prefill=0;
190     int start_band = 0;
191     int redundancy = 0;
192     int redundancy_bytes = 0;
193     int celt_to_silk = 0;
194     VARDECL(opus_val16, pcm_buf);
195     int nb_compr_bytes;
196     int to_celt = 0;
197     opus_int32 mono_rate;
198     ALLOC_STACK;
199
200     if (400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
201          50*frame_size != st->Fs &&  25*frame_size != st->Fs &&  50*frame_size != 3*st->Fs)
202         return OPUS_BAD_ARG;
203     silk_enc = (char*)st+st->silk_enc_offset;
204     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
205
206     if (st->user_bitrate_bps==OPUS_BITRATE_AUTO)
207         st->bitrate_bps = 60*st->Fs/frame_size + st->Fs*st->channels;
208     else
209         st->bitrate_bps = st->user_bitrate_bps;
210
211     /* Rate-dependent mono-stereo decision */
212     if (st->force_mono)
213     {
214         st->stream_channels = 1;
215     } else if (st->mode == MODE_CELT_ONLY && st->channels == 2)
216     {
217         opus_int32 decision_rate;
218         decision_rate = st->bitrate_bps + st->voice_ratio*st->voice_ratio;
219         /* Add some hysteresis */
220         if (st->stream_channels == 2)
221             decision_rate += 4000;
222         else
223             decision_rate -= 4000;
224         if (decision_rate>48000)
225             st->stream_channels = 2;
226         else
227             st->stream_channels = 1;
228     } else {
229             st->stream_channels = st->channels;
230     }
231
232 #ifdef FUZZING
233     if (st->channels == 2 && (rand()&0x1F)==0)
234        st->stream_channels = 3-st->stream_channels;
235 #endif
236
237     /* Equivalent bit-rate for mono */
238     mono_rate = st->bitrate_bps;
239     if (st->stream_channels==2)
240         mono_rate = 2*mono_rate/3;
241     /* Compensate for smaller frame sizes assuming an equivalent overhead
242        of 60 bits/frame */
243     mono_rate -= 60*(st->Fs/frame_size - 50);
244
245 #ifdef FUZZING
246     if ((rand()&0xF)==0)
247     {
248        if ((rand()&0x1)==0)
249           st->mode = MODE_CELT_ONLY;
250        else
251           st->mode = MODE_SILK_ONLY;
252     } else {
253        if (st->prev_mode==MODE_CELT_ONLY)
254           st->mode = MODE_CELT_ONLY;
255        else
256           st->mode = MODE_SILK_ONLY;
257     }
258 #else
259     /* Mode selection depending on application and signal type */
260     if (st->user_mode==OPUS_APPLICATION_VOIP)
261     {
262         opus_int32 threshold = 20000;
263         /* Hysteresis */
264         if (st->prev_mode == MODE_CELT_ONLY)
265             threshold -= 4000;
266         else if (st->prev_mode>0)
267             threshold += 4000;
268
269         /* OPUS_APPLICATION_VOIP defaults to MODE_SILK_ONLY */
270         if (st->signal_type == OPUS_SIGNAL_MUSIC && mono_rate > threshold)
271             st->mode = MODE_CELT_ONLY;
272         else
273             st->mode = MODE_SILK_ONLY;
274     } else {/* OPUS_APPLICATION_AUDIO */
275         opus_int32 threshold;
276         /* SILK/CELT threshold is higher for voice than for music */
277         threshold = 36000;
278         if (st->signal_type == OPUS_SIGNAL_MUSIC)
279             threshold -= 20000;
280         else if (st->signal_type == OPUS_SIGNAL_VOICE)
281             threshold += 8000;
282
283         /* Hysteresis */
284         if (st->prev_mode == MODE_CELT_ONLY)
285             threshold -= 4000;
286         else if (st->prev_mode>0)
287             threshold += 4000;
288
289         if (mono_rate>threshold)
290             st->mode = MODE_CELT_ONLY;
291         else
292             st->mode = MODE_SILK_ONLY;
293     }
294 #endif
295     /* Override the chosen mode to make sure we meet the requested frame size */
296     if (st->mode == MODE_CELT_ONLY && frame_size > st->Fs/50)
297        st->mode = MODE_SILK_ONLY;
298     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
299        st->mode = MODE_CELT_ONLY;
300
301     if (st->prev_mode > 0 &&
302         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
303     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
304     {
305         redundancy = 1;
306         celt_to_silk = (st->mode != MODE_CELT_ONLY);
307         if (!celt_to_silk)
308         {
309             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
310             if (frame_size >= st->Fs/100)
311             {
312                 st->mode = st->prev_mode;
313                 to_celt = 1;
314             } else {
315                 redundancy=0;
316             }
317         }
318     }
319     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
320     {
321         silk_EncControlStruct dummy;
322         silk_InitEncoder( silk_enc, &dummy);
323         prefill=1;
324     }
325
326     /* Automatic (rate-dependent) bandwidth selection */
327     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
328     {
329         const int *bandwidth_thresholds;
330         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
331
332         bandwidth_thresholds = st->mode == MODE_CELT_ONLY ? audio_bandwidth_thresholds : voice_bandwidth_thresholds;
333         do {
334             int threshold, hysteresis;
335             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
336             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
337             if (!st->first)
338             {
339                 if (st->bandwidth >= bandwidth)
340                     threshold -= hysteresis;
341                 else
342                     threshold += hysteresis;
343             }
344             if (mono_rate >= threshold)
345                 break;
346         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
347         st->bandwidth = bandwidth;
348         /* Prevents any transition to SWB/FB until the SILK layer has fully
349            switched to WB mode and turned the variable LP filter off */
350         if (st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
351             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
352     }
353
354     /* Prevents Opus from wasting bits on frequencies that are above
355        the Nyquist rate of the input signal */
356     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
357         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
358     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
359         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
360     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
361         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
362     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
363         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
364
365     if (st->user_bandwidth != OPUS_BANDWIDTH_AUTO)
366         st->bandwidth = st->user_bandwidth;
367
368     /* Can't support higher than wideband for >20 ms frames */
369     if (frame_size > st->Fs/50 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
370        st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
371
372     /* CELT mode doesn't support mediumband, use wideband instead */
373     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
374         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
375
376     /* Chooses the appropriate mode for speech
377        *NEVER* switch to/from CELT-only mode here as this will */
378     if (st->mode == MODE_SILK_ONLY && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
379         st->mode = MODE_HYBRID;
380     if (st->mode == MODE_HYBRID && st->bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
381         st->mode = MODE_SILK_ONLY;
382
383     bytes_target = st->bitrate_bps * frame_size / (st->Fs * 8) - 1;
384
385     data += 1;
386
387     ec_enc_init(&enc, data, max_data_bytes-1);
388
389     /* SILK processing */
390     if (st->mode != MODE_CELT_ONLY)
391     {
392 #ifdef FIXED_POINT
393        const opus_int16 *pcm_silk;
394 #else
395        VARDECL(opus_int16, pcm_silk);
396        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
397 #endif
398         st->silk_mode.bitRate = st->bitrate_bps - 8*st->Fs/frame_size;
399         if( st->mode == MODE_HYBRID ) {
400             st->silk_mode.bitRate /= st->stream_channels;
401             if( st->bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
402                 if( st->Fs == 100 * frame_size ) {
403                     /* 24 kHz, 10 ms */
404                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 2000 + st->use_vbr * 1000 ) * 2 ) / 3;
405                 } else {
406                     /* 24 kHz, 20 ms */
407                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 1000 + st->use_vbr * 1000 ) * 2 ) / 3;
408                 }
409             } else {
410                 if( st->Fs == 100 * frame_size ) {
411                     /* 48 kHz, 10 ms */
412                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 8000 + st->use_vbr * 3000 ) / 2;
413                 } else {
414                     /* 48 kHz, 20 ms */
415                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 9000 + st->use_vbr * 1000 ) / 2;
416                 }
417             }
418             st->silk_mode.bitRate *= st->stream_channels;
419             /* don't let SILK use more than 80% */
420             if( st->silk_mode.bitRate > ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5 ) {
421                 st->silk_mode.bitRate = ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5;
422             }
423         }
424
425         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
426         st->silk_mode.nChannelsAPI = st->channels;
427         st->silk_mode.nChannelsInternal = st->stream_channels;
428         if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
429             st->silk_mode.desiredInternalSampleRate = 8000;
430         } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
431             st->silk_mode.desiredInternalSampleRate = 12000;
432         } else {
433             SKP_assert( st->mode == MODE_HYBRID || st->bandwidth == OPUS_BANDWIDTH_WIDEBAND );
434             st->silk_mode.desiredInternalSampleRate = 16000;
435         }
436         if( st->mode == MODE_HYBRID ) {
437             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
438             st->silk_mode.minInternalSampleRate = 16000;
439         } else {
440             st->silk_mode.minInternalSampleRate = 8000;
441         }
442         st->silk_mode.maxInternalSampleRate = 16000;
443
444         /* Call SILK encoder for the low band */
445         nBytes = IMIN(1275, max_data_bytes-1);
446         if (prefill)
447         {
448             int zero=0;
449 #ifdef FIXED_POINT
450             pcm_silk = st->delay_buffer;
451 #else
452             for (i=0;i<st->encoder_buffer*st->channels;i++)
453                pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
454 #endif
455             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
456         }
457
458 #ifdef FIXED_POINT
459         pcm_silk = pcm;
460 #else
461         for (i=0;i<frame_size*st->channels;i++)
462            pcm_silk[i] = FLOAT2INT16(pcm[i]);
463 #endif
464         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
465         if( ret ) {
466             fprintf (stderr, "SILK encode error: %d\n", ret);
467             /* Handle error */
468         }
469         if (nBytes==0)
470             return 0;
471         /* Extract SILK internal bandwidth for signaling in first byte */
472         if( st->mode == MODE_SILK_ONLY ) {
473             if( st->silk_mode.internalSampleRate == 8000 ) {
474                 silk_internal_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
475             } else if( st->silk_mode.internalSampleRate == 12000 ) {
476                 silk_internal_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
477             } else if( st->silk_mode.internalSampleRate == 16000 ) {
478                 silk_internal_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
479             }
480         } else {
481             SKP_assert( st->silk_mode.internalSampleRate == 16000 );
482         }
483     }
484
485     /* CELT processing */
486     {
487         int endband=21;
488
489         switch(st->bandwidth)
490         {
491             case OPUS_BANDWIDTH_NARROWBAND:
492                 endband = 13;
493                 break;
494             case OPUS_BANDWIDTH_MEDIUMBAND:
495             case OPUS_BANDWIDTH_WIDEBAND:
496                 endband = 17;
497                 break;
498             case OPUS_BANDWIDTH_SUPERWIDEBAND:
499                 endband = 19;
500                 break;
501             case OPUS_BANDWIDTH_FULLBAND:
502                 endband = 21;
503                 break;
504         }
505         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
506         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
507     }
508     if (st->mode != MODE_SILK_ONLY)
509     {
510         celt_encoder_ctl(celt_enc, CELT_SET_VBR(0));
511         celt_encoder_ctl(celt_enc, CELT_SET_BITRATE(-1));
512         if (st->prev_mode == MODE_SILK_ONLY)
513         {
514             unsigned char dummy[10];
515             celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
516             celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
517             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
518             /* TODO: This wastes CPU a bit compared to just prefilling the buffer */
519             celt_encode_native(celt_enc, &st->delay_buffer[(st->encoder_buffer-st->delay_compensation-st->Fs/400)*st->channels], st->Fs/400, dummy, 10);
520         } else {
521             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
522         }
523
524         if (st->mode == MODE_HYBRID)
525         {
526             int len;
527
528             len = (ec_tell(&enc)+7)>>3;
529             if( st->use_vbr ) {
530                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
531             } else {
532                 /* check if SILK used up too much */
533                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
534             }
535         } else {
536             if (st->use_vbr)
537             {
538                 celt_encoder_ctl(celt_enc, CELT_SET_VBR(1));
539                 celt_encoder_ctl(celt_enc, CELT_SET_VBR_CONSTRAINT(st->vbr_constraint));
540                 celt_encoder_ctl(celt_enc, CELT_SET_BITRATE(st->bitrate_bps));
541                 nb_compr_bytes = max_data_bytes-1;
542             } else {
543                 nb_compr_bytes = bytes_target;
544             }
545         }
546
547     } else {
548         nb_compr_bytes = 0;
549     }
550
551     ALLOC(pcm_buf, IMAX(frame_size, st->Fs/200)*st->channels, opus_val16);
552     for (i=0;i<IMIN(frame_size, st->delay_compensation)*st->channels;i++)
553         pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-st->delay_compensation)*st->channels+i];
554     for (;i<frame_size*st->channels;i++)
555         pcm_buf[i] = pcm[i-st->delay_compensation*st->channels];
556
557     if( st->mode == MODE_HYBRID && st->stream_channels == 2 ) {
558         /* Apply stereo width reduction (at low bitrates) */
559         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
560             int width_Q14, delta_Q14, nSamples_8ms, diff;
561             nSamples_8ms = ( st->Fs * 8 ) / 1000;
562             width_Q14 = (1 << 14 ) - st->hybrid_stereo_width_Q14;
563             delta_Q14 = ( st->hybrid_stereo_width_Q14 - st->silk_mode.stereoWidth_Q14 ) / nSamples_8ms;
564             for( i = 0; i < nSamples_8ms; i++ ) {
565                 width_Q14 += delta_Q14;
566                 diff = pcm_buf[ 2*i+1 ] - (opus_int32)pcm_buf[ 2*i ];
567                 diff = ( diff * width_Q14 ) >> 15;
568                 pcm_buf[ 2*i ]   = (opus_int16)( pcm_buf[ 2*i ]   + diff );
569                 pcm_buf[ 2*i+1 ] = (opus_int16)( pcm_buf[ 2*i+1 ] - diff );
570             }
571             for( ; i < frame_size; i++ ) {
572                 diff = pcm_buf[ 2*i+1 ] - (opus_int32)pcm_buf[ 2*i ];
573                 diff = ( diff * width_Q14 ) >> 15;
574                 pcm_buf[ 2*i ]   = (opus_int16)( pcm_buf[ 2*i ]   + diff );
575                 pcm_buf[ 2*i+1 ] = (opus_int16)( pcm_buf[ 2*i+1 ] - diff );
576             }
577             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
578         }
579     }
580
581     if (st->mode != MODE_CELT_ONLY)
582     {
583         /* Check if we have a redundant 0-8 kHz band */
584         ec_enc_bit_logp(&enc, redundancy, 12);
585         if (redundancy)
586         {
587             /* Target the same bit-rate for redundancy as for the rest,
588                up to a max of 257 bytes */
589             redundancy_bytes = IMIN(257, st->bitrate_bps/1600);
590             ec_enc_bit_logp(&enc, celt_to_silk, 1);
591             if (st->mode == MODE_HYBRID)
592                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
593         }
594         start_band = 17;
595     }
596
597     if (st->mode == MODE_SILK_ONLY)
598     {
599         ret = (ec_tell(&enc)+7)>>3;
600         ec_enc_done(&enc);
601         /*When in LPC only mode it's perfectly
602           reasonable to strip off trailing zero bytes as
603           the required range decoder behavior is to
604           fill these in. This can't be done when the MDCT
605           modes are used because the decoder needs to know
606           the actual length for allocation purposes.*/
607         if(!redundancy)
608             while(ret>2&&data[ret-1]==0)ret--;
609         nb_compr_bytes = ret;
610     } else {
611        nb_compr_bytes = IMIN(1275-redundancy_bytes, nb_compr_bytes);
612        ec_enc_shrink(&enc, nb_compr_bytes);
613     }
614
615
616     /* 5 ms redundant frame for CELT->SILK */
617     if (redundancy && celt_to_silk)
618     {
619         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
620         celt_encoder_ctl(celt_enc, CELT_SET_VBR(0));
621         celt_encode_native(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes);
622         celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
623     }
624
625     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
626
627     if (st->mode != MODE_SILK_ONLY)
628     {
629         ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
630     }
631
632     /* 5 ms redundant frame for SILK->CELT */
633     if (redundancy && !celt_to_silk)
634     {
635         int N2, N4;
636         N2 = st->Fs/200;
637         N4 = st->Fs/400;
638
639         celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
640         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
641         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
642
643         /* TODO: We could speed up prefilling here */
644         celt_encode_native(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, data+nb_compr_bytes, redundancy_bytes);
645
646         celt_encode_native(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes);
647     }
648
649
650     if (frame_size>st->encoder_buffer)
651     {
652         for (i=0;i<st->encoder_buffer*st->channels;i++)
653                 st->delay_buffer[i] = pcm[(frame_size-st->encoder_buffer)*st->channels+i];
654     } else {
655         int tmp = st->encoder_buffer-frame_size;
656         for (i=0;i<tmp*st->channels;i++)
657             st->delay_buffer[i] = st->delay_buffer[i+frame_size*st->channels];
658         for (i=0;i<frame_size*st->channels;i++)
659             st->delay_buffer[tmp*st->channels+i] = pcm[i];
660     }
661
662     /* Signalling the mode in the first byte */
663     data--;
664     framerate = st->Fs/frame_size;
665     period = 0;
666     while (framerate < 400)
667     {
668         framerate <<= 1;
669         period++;
670     }
671     if (st->mode == MODE_SILK_ONLY)
672     {
673         data[0] = (silk_internal_bandwidth-OPUS_BANDWIDTH_NARROWBAND)<<5;
674         data[0] |= (period-2)<<3;
675     } else if (st->mode == MODE_CELT_ONLY)
676     {
677         int tmp = st->bandwidth-OPUS_BANDWIDTH_MEDIUMBAND;
678         if (tmp < 0)
679             tmp = 0;
680         data[0] = 0x80;
681         data[0] |= tmp << 5;
682         data[0] |= period<<3;
683     } else /* Hybrid */
684     {
685         data[0] = 0x60;
686         data[0] |= (st->bandwidth-OPUS_BANDWIDTH_SUPERWIDEBAND)<<4;
687         data[0] |= (period-2)<<3;
688     }
689     data[0] |= (st->stream_channels==2)<<2;
690     /*printf ("%x\n", (int)data[0]);*/
691
692     st->rangeFinal = enc.rng;
693
694     if (to_celt)
695         st->prev_mode = MODE_CELT_ONLY;
696     else
697         st->prev_mode = st->mode;
698     st->first = 0;
699     return ret+1+redundancy_bytes;
700 }
701
702 #ifdef FIXED_POINT
703
704 #ifndef DISABLE_FLOAT_API
705 int opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
706       unsigned char *data, int max_data_bytes)
707 {
708    int i, ret;
709    VARDECL(opus_int16, in);
710    ALLOC_STACK;
711
712    ALLOC(in, frame_size*st->channels, opus_int16);
713
714    for (i=0;i<frame_size*st->channels;i++)
715       in[i] = FLOAT2INT16(pcm[i]);
716    ret = opus_encode(st, in, frame_size, data, max_data_bytes);
717    RESTORE_STACK;
718    return ret;
719 }
720 #endif
721
722 #else
723 int opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
724       unsigned char *data, int max_data_bytes)
725 {
726    int i, ret;
727    VARDECL(float, in);
728    ALLOC_STACK;
729
730    ALLOC(in, frame_size*st->channels, float);
731
732    for (i=0;i<frame_size*st->channels;i++)
733       in[i] = (1./32768)*pcm[i];
734    ret = opus_encode_float(st, in, frame_size, data, max_data_bytes);
735    RESTORE_STACK;
736    return ret;
737 }
738 #endif
739
740
741 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
742 {
743     CELTEncoder *celt_enc;
744     va_list ap;
745
746     va_start(ap, request);
747
748     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
749
750     switch (request)
751     {
752         case OPUS_SET_MODE_REQUEST:
753         {
754             int value = va_arg(ap, int);
755             st->user_mode = value;
756         }
757         break;
758         case OPUS_GET_MODE_REQUEST:
759         {
760             int *value = va_arg(ap, int*);
761             *value = st->mode;
762         }
763         break;
764         case OPUS_SET_BITRATE_REQUEST:
765         {
766             int value = va_arg(ap, int);
767             if (value != OPUS_BITRATE_AUTO)
768             {
769                 if (value <= 0)
770                     goto bad_arg;
771                 else if (value <= 500)
772                     value = 500;
773             }
774             st->user_bitrate_bps = value;
775         }
776         break;
777         case OPUS_GET_BITRATE_REQUEST:
778         {
779             int *value = va_arg(ap, int*);
780             *value = st->bitrate_bps;
781         }
782         break;
783         case OPUS_SET_FORCE_MONO_REQUEST:
784         {
785             int value = va_arg(ap, int);
786             st->force_mono = value;
787         }
788         break;
789         case OPUS_GET_FORCE_MONO_REQUEST:
790         {
791             int *value = va_arg(ap, int*);
792             *value = !!st->force_mono;
793         }
794         break;
795         case OPUS_SET_BANDWIDTH_REQUEST:
796         {
797             int value = va_arg(ap, int);
798             if (value < OPUS_BANDWIDTH_AUTO || value > OPUS_BANDWIDTH_FULLBAND)
799                 return OPUS_BAD_ARG;
800             st->user_bandwidth = value;
801             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
802                 st->silk_mode.maxInternalSampleRate = 8000;
803             } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
804                 st->silk_mode.maxInternalSampleRate = 12000;
805             } else {
806                 st->silk_mode.maxInternalSampleRate = 16000;
807             }
808         }
809         break;
810         case OPUS_GET_BANDWIDTH_REQUEST:
811         {
812             int *value = va_arg(ap, int*);
813             *value = st->bandwidth;
814         }
815         break;
816         case OPUS_SET_DTX_FLAG_REQUEST:
817         {
818             int value = va_arg(ap, int);
819             st->silk_mode.useDTX = value;
820         }
821         break;
822         case OPUS_GET_DTX_FLAG_REQUEST:
823         {
824             int *value = va_arg(ap, int*);
825             *value = st->silk_mode.useDTX;
826         }
827         break;
828         case OPUS_SET_COMPLEXITY_REQUEST:
829         {
830             int value = va_arg(ap, int);
831             st->silk_mode.complexity = value;
832             celt_encoder_ctl(celt_enc, CELT_SET_COMPLEXITY(value));
833         }
834         break;
835         case OPUS_GET_COMPLEXITY_REQUEST:
836         {
837             int *value = va_arg(ap, int*);
838             *value = st->silk_mode.complexity;
839         }
840         break;
841         case OPUS_SET_INBAND_FEC_FLAG_REQUEST:
842         {
843             int value = va_arg(ap, int);
844             st->silk_mode.useInBandFEC = value;
845         }
846         break;
847         case OPUS_GET_INBAND_FEC_FLAG_REQUEST:
848         {
849             int *value = va_arg(ap, int*);
850             *value = st->silk_mode.useInBandFEC;
851         }
852         break;
853         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
854         {
855             int value = va_arg(ap, int);
856             if (value < 0 || value > 100)
857                 return OPUS_BAD_ARG;
858             st->silk_mode.packetLossPercentage = value;
859             celt_encoder_ctl(celt_enc, CELT_SET_LOSS_PERC(value));
860         }
861         break;
862         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
863         {
864             int *value = va_arg(ap, int*);
865             *value = st->silk_mode.packetLossPercentage;
866         }
867         break;
868         case OPUS_SET_VBR_FLAG_REQUEST:
869         {
870             int value = va_arg(ap, int);
871             st->use_vbr = value;
872             st->silk_mode.useCBR = 1-value;
873         }
874         break;
875         case OPUS_GET_VBR_FLAG_REQUEST:
876         {
877             int *value = va_arg(ap, int*);
878             *value = st->use_vbr;
879         }
880         break;
881         case OPUS_SET_VOICE_RATIO_REQUEST:
882         {
883             int value = va_arg(ap, int);
884             if (value>100 || value<0)
885                 goto bad_arg;
886             st->voice_ratio = value;
887         }
888         break;
889         case OPUS_GET_VOICE_RATIO_REQUEST:
890         {
891             int *value = va_arg(ap, int*);
892             *value = st->voice_ratio;
893         }
894         break;
895         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
896         {
897             int value = va_arg(ap, int);
898             st->vbr_constraint = value;
899         }
900         break;
901         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
902         {
903             int *value = va_arg(ap, int*);
904             *value = st->vbr_constraint;
905         }
906         break;
907         case OPUS_SET_SIGNAL_REQUEST:
908         {
909             int value = va_arg(ap, int);
910             st->signal_type = value;
911         }
912         break;
913         case OPUS_GET_SIGNAL_REQUEST:
914         {
915             int *value = va_arg(ap, int*);
916             *value = st->signal_type;
917         }
918         break;
919         case OPUS_GET_LOOKAHEAD_REQUEST:
920         {
921             int *value = va_arg(ap, int*);
922             *value = st->delay_compensation+st->Fs/400;
923         }
924         break;
925         default:
926             fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);
927             break;
928     }
929     va_end(ap);
930     return OPUS_OK;
931 bad_arg:
932     va_end(ap);
933     return OPUS_BAD_ARG;
934 }
935
936 void opus_encoder_destroy(OpusEncoder *st)
937 {
938     free(st);
939 }
940
941 int opus_encoder_get_final_range(OpusEncoder *st)
942 {
943     return st->rangeFinal;
944 }