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