7d45cc25fa81392afdb19b433785761972264632
[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;
330         threshold = 20000;
331         /* OPUS_APPLICATION_VOIP default to auto high-pass */
332         st->silk_mode.HP_cutoff_Hz=0;
333         /* Hysteresis */
334         if (st->prev_mode == MODE_CELT_ONLY)
335             threshold -= 4000;
336         else if (st->prev_mode>0)
337             threshold += 4000;
338
339         /* OPUS_APPLICATION_VOIP defaults to MODE_SILK_ONLY */
340         if (st->signal_type == OPUS_SIGNAL_MUSIC && mono_rate > threshold)
341             st->mode = MODE_CELT_ONLY;
342         else
343             st->mode = MODE_SILK_ONLY;
344     } else {/* OPUS_APPLICATION_AUDIO */
345         opus_int32 threshold;
346         /* SILK/CELT threshold is higher for voice than for music */
347         threshold = 36000;
348         /* OPUS_APPLICATION_AUDIO disables the high-pass */
349         st->silk_mode.HP_cutoff_Hz=-1;
350         if (st->signal_type == OPUS_SIGNAL_MUSIC)
351             threshold -= 20000;
352         else if (st->signal_type == OPUS_SIGNAL_VOICE)
353             threshold += 8000;
354
355         /* Hysteresis */
356         if (st->prev_mode == MODE_CELT_ONLY)
357             threshold -= 4000;
358         else if (st->prev_mode>0)
359             threshold += 4000;
360
361         if (mono_rate>threshold)
362             st->mode = MODE_CELT_ONLY;
363         else
364             st->mode = MODE_SILK_ONLY;
365     }
366 #endif
367     /* Override the chosen mode to make sure we meet the requested frame size */
368     if (st->mode == MODE_CELT_ONLY && frame_size > st->Fs/50)
369        st->mode = MODE_SILK_ONLY;
370     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
371        st->mode = MODE_CELT_ONLY;
372
373     if (st->prev_mode > 0 &&
374         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
375     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
376     {
377         redundancy = 1;
378         celt_to_silk = (st->mode != MODE_CELT_ONLY);
379         if (!celt_to_silk)
380         {
381             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
382             if (frame_size >= st->Fs/100)
383             {
384                 st->mode = st->prev_mode;
385                 to_celt = 1;
386             } else {
387                 redundancy=0;
388             }
389         }
390     }
391     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
392     {
393         silk_EncControlStruct dummy;
394         silk_InitEncoder( silk_enc, &dummy);
395         prefill=1;
396     }
397
398     /* Automatic (rate-dependent) bandwidth selection */
399     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
400     {
401         const int *bandwidth_thresholds;
402         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
403
404         bandwidth_thresholds = st->mode == MODE_CELT_ONLY ? audio_bandwidth_thresholds : voice_bandwidth_thresholds;
405         do {
406             int threshold, hysteresis;
407             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
408             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
409             if (!st->first)
410             {
411                 if (st->bandwidth >= bandwidth)
412                     threshold -= hysteresis;
413                 else
414                     threshold += hysteresis;
415             }
416             if (mono_rate >= threshold)
417                 break;
418         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
419         st->bandwidth = bandwidth;
420         /* Prevents any transition to SWB/FB until the SILK layer has fully
421            switched to WB mode and turned the variable LP filter off */
422         if (st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
423             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
424     }
425
426     /* Prevents Opus from wasting bits on frequencies that are above
427        the Nyquist rate of the input signal */
428     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
429         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
430     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
431         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
432     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
433         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
434     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
435         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
436
437     if (st->user_bandwidth != OPUS_BANDWIDTH_AUTO)
438         st->bandwidth = st->user_bandwidth;
439
440     /* Can't support higher than wideband for >20 ms frames */
441     if (frame_size > st->Fs/50 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
442        st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
443
444     /* CELT mode doesn't support mediumband, use wideband instead */
445     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
446         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
447
448     /* Chooses the appropriate mode for speech
449        *NEVER* switch to/from CELT-only mode here as this will */
450     if (st->mode == MODE_SILK_ONLY && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
451         st->mode = MODE_HYBRID;
452     if (st->mode == MODE_HYBRID && st->bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
453         st->mode = MODE_SILK_ONLY;
454
455     bytes_target = st->bitrate_bps * frame_size / (st->Fs * 8) - 1;
456
457     data += 1;
458
459     ec_enc_init(&enc, data, max_data_bytes-1);
460
461     /* SILK processing */
462     if (st->mode != MODE_CELT_ONLY)
463     {
464 #ifdef FIXED_POINT
465        const opus_int16 *pcm_silk;
466 #else
467        VARDECL(opus_int16, pcm_silk);
468        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
469 #endif
470         st->silk_mode.bitRate = st->bitrate_bps - 8*st->Fs/frame_size;
471         if( st->mode == MODE_HYBRID ) {
472             st->silk_mode.bitRate /= st->stream_channels;
473             if( st->bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
474                 if( st->Fs == 100 * frame_size ) {
475                     /* 24 kHz, 10 ms */
476                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 2000 + st->use_vbr * 1000 ) * 2 ) / 3;
477                 } else {
478                     /* 24 kHz, 20 ms */
479                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 1000 + st->use_vbr * 1000 ) * 2 ) / 3;
480                 }
481             } else {
482                 if( st->Fs == 100 * frame_size ) {
483                     /* 48 kHz, 10 ms */
484                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 8000 + st->use_vbr * 3000 ) / 2;
485                 } else {
486                     /* 48 kHz, 20 ms */
487                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 9000 + st->use_vbr * 1000 ) / 2;
488                 }
489             }
490             st->silk_mode.bitRate *= st->stream_channels;
491             /* don't let SILK use more than 80% */
492             if( st->silk_mode.bitRate > ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5 ) {
493                 st->silk_mode.bitRate = ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5;
494             }
495         }
496
497         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
498         st->silk_mode.nChannelsAPI = st->channels;
499         st->silk_mode.nChannelsInternal = st->stream_channels;
500         if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
501             st->silk_mode.desiredInternalSampleRate = 8000;
502         } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
503             st->silk_mode.desiredInternalSampleRate = 12000;
504         } else {
505             SKP_assert( st->mode == MODE_HYBRID || st->bandwidth == OPUS_BANDWIDTH_WIDEBAND );
506             st->silk_mode.desiredInternalSampleRate = 16000;
507         }
508         if( st->mode == MODE_HYBRID ) {
509             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
510             st->silk_mode.minInternalSampleRate = 16000;
511         } else {
512             st->silk_mode.minInternalSampleRate = 8000;
513         }
514         st->silk_mode.maxInternalSampleRate = 16000;
515
516         /* Call SILK encoder for the low band */
517         nBytes = IMIN(1275, max_data_bytes-1);
518         if (prefill)
519         {
520             int zero=0;
521 #ifdef FIXED_POINT
522             pcm_silk = st->delay_buffer;
523 #else
524             for (i=0;i<st->encoder_buffer*st->channels;i++)
525                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
526 #endif
527             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
528         }
529
530 #ifdef FIXED_POINT
531         pcm_silk = pcm;
532 #else
533         for (i=0;i<frame_size*st->channels;i++)
534             pcm_silk[i] = FLOAT2INT16(pcm[i]);
535 #endif
536         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
537         if( ret ) {
538             fprintf (stderr, "SILK encode error: %d\n", ret);
539             /* Handle error */
540         }
541         if (nBytes==0)
542         {
543            data[-1] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, st->stream_channels);
544            return 1;
545         }
546         /* Extract SILK internal bandwidth for signaling in first byte */
547         if( st->mode == MODE_SILK_ONLY ) {
548             if( st->silk_mode.internalSampleRate == 8000 ) {
549                 silk_internal_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
550             } else if( st->silk_mode.internalSampleRate == 12000 ) {
551                 silk_internal_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
552             } else if( st->silk_mode.internalSampleRate == 16000 ) {
553                 silk_internal_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
554             }
555         } else {
556             SKP_assert( st->silk_mode.internalSampleRate == 16000 );
557         }
558     }
559
560     /* CELT processing */
561     {
562         int endband=21;
563
564         switch(st->bandwidth)
565         {
566             case OPUS_BANDWIDTH_NARROWBAND:
567                 endband = 13;
568                 break;
569             case OPUS_BANDWIDTH_MEDIUMBAND:
570             case OPUS_BANDWIDTH_WIDEBAND:
571                 endband = 17;
572                 break;
573             case OPUS_BANDWIDTH_SUPERWIDEBAND:
574                 endband = 19;
575                 break;
576             case OPUS_BANDWIDTH_FULLBAND:
577                 endband = 21;
578                 break;
579         }
580         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
581         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
582     }
583     if (st->mode != MODE_SILK_ONLY)
584     {
585         celt_encoder_ctl(celt_enc, CELT_SET_VBR(0));
586         celt_encoder_ctl(celt_enc, CELT_SET_BITRATE(-1));
587         if (st->prev_mode == MODE_SILK_ONLY)
588         {
589             unsigned char dummy[10];
590             celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
591             celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
592             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
593             /* TODO: This wastes CPU a bit compared to just prefilling the buffer */
594             celt_encode_native(celt_enc, &st->delay_buffer[(st->encoder_buffer-st->delay_compensation-st->Fs/400)*st->channels], st->Fs/400, dummy, 10);
595         } else {
596             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
597         }
598
599         if (st->mode == MODE_HYBRID)
600         {
601             int len;
602
603             len = (ec_tell(&enc)+7)>>3;
604             if( st->use_vbr ) {
605                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
606             } else {
607                 /* check if SILK used up too much */
608                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
609             }
610         } else {
611             if (st->use_vbr)
612             {
613                 celt_encoder_ctl(celt_enc, CELT_SET_VBR(1));
614                 celt_encoder_ctl(celt_enc, CELT_SET_VBR_CONSTRAINT(st->vbr_constraint));
615                 celt_encoder_ctl(celt_enc, CELT_SET_BITRATE(st->bitrate_bps));
616                 nb_compr_bytes = max_data_bytes-1;
617             } else {
618                 nb_compr_bytes = bytes_target;
619             }
620         }
621
622     } else {
623         nb_compr_bytes = 0;
624     }
625
626     ALLOC(pcm_buf, IMAX(frame_size, st->Fs/200)*st->channels, opus_val16);
627     for (i=0;i<IMIN(frame_size, st->delay_compensation)*st->channels;i++)
628         pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-st->delay_compensation)*st->channels+i];
629     for (;i<frame_size*st->channels;i++)
630         pcm_buf[i] = pcm[i-st->delay_compensation*st->channels];
631
632     if( st->mode == MODE_HYBRID && st->stream_channels == 2 ) {
633         /* Apply stereo width reduction (at low bitrates) */
634         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
635             int width_Q14, delta_Q14, nSamples_8ms, diff;
636             nSamples_8ms = ( st->Fs * 8 ) / 1000;
637             width_Q14 = (1 << 14 ) - st->hybrid_stereo_width_Q14;
638             delta_Q14 = ( st->hybrid_stereo_width_Q14 - st->silk_mode.stereoWidth_Q14 ) / nSamples_8ms;
639             for( i = 0; i < nSamples_8ms; i++ ) {
640                 width_Q14 += delta_Q14;
641                 diff = pcm_buf[ 2*i+1 ] - (opus_int32)pcm_buf[ 2*i ];
642                 diff = ( diff * width_Q14 ) >> 15;
643                 pcm_buf[ 2*i ]   = (opus_int16)( pcm_buf[ 2*i ]   + diff );
644                 pcm_buf[ 2*i+1 ] = (opus_int16)( pcm_buf[ 2*i+1 ] - diff );
645             }
646             for( ; i < frame_size; i++ ) {
647                 diff = pcm_buf[ 2*i+1 ] - (opus_int32)pcm_buf[ 2*i ];
648                 diff = ( diff * width_Q14 ) >> 15;
649                 pcm_buf[ 2*i ]   = (opus_int16)( pcm_buf[ 2*i ]   + diff );
650                 pcm_buf[ 2*i+1 ] = (opus_int16)( pcm_buf[ 2*i+1 ] - diff );
651             }
652             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
653         }
654     }
655
656     if (st->mode != MODE_CELT_ONLY)
657     {
658         /* Check if we have a redundant 0-8 kHz band */
659         ec_enc_bit_logp(&enc, redundancy, 12);
660         if (redundancy)
661         {
662             /* Target the same bit-rate for redundancy as for the rest,
663                up to a max of 257 bytes */
664             redundancy_bytes = IMIN(257, st->bitrate_bps/1600);
665             ec_enc_bit_logp(&enc, celt_to_silk, 1);
666             if (st->mode == MODE_HYBRID)
667                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
668         }
669         start_band = 17;
670     }
671
672     if (st->mode == MODE_SILK_ONLY)
673     {
674         ret = (ec_tell(&enc)+7)>>3;
675         ec_enc_done(&enc);
676         /*When in LPC only mode it's perfectly
677           reasonable to strip off trailing zero bytes as
678           the required range decoder behavior is to
679           fill these in. This can't be done when the MDCT
680           modes are used because the decoder needs to know
681           the actual length for allocation purposes.*/
682         if(!redundancy)
683             while(ret>2&&data[ret-1]==0)ret--;
684         nb_compr_bytes = ret;
685     } else {
686        nb_compr_bytes = IMIN(1275-redundancy_bytes, nb_compr_bytes);
687        ec_enc_shrink(&enc, nb_compr_bytes);
688     }
689
690
691     /* 5 ms redundant frame for CELT->SILK */
692     if (redundancy && celt_to_silk)
693     {
694         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
695         celt_encoder_ctl(celt_enc, CELT_SET_VBR(0));
696         celt_encode_native(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes);
697         celt_encoder_ctl(celt_enc, CELT_GET_RANGE(&redundant_rng));
698         celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
699     }
700
701     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
702
703     if (st->mode != MODE_SILK_ONLY)
704     {
705         ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
706     }
707
708     /* 5 ms redundant frame for SILK->CELT */
709     if (redundancy && !celt_to_silk)
710     {
711         int N2, N4;
712         N2 = st->Fs/200;
713         N4 = st->Fs/400;
714
715         celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
716         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
717         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
718
719         /* TODO: We could speed up prefilling here */
720         celt_encode_native(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, data+nb_compr_bytes, redundancy_bytes);
721
722         celt_encode_native(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes);
723         celt_encoder_ctl(celt_enc, CELT_GET_RANGE(&redundant_rng));
724     }
725
726
727     if (frame_size>st->encoder_buffer)
728     {
729         for (i=0;i<st->encoder_buffer*st->channels;i++)
730             st->delay_buffer[i] = pcm[(frame_size-st->encoder_buffer)*st->channels+i];
731     } else {
732         int tmp = st->encoder_buffer-frame_size;
733         for (i=0;i<tmp*st->channels;i++)
734             st->delay_buffer[i] = st->delay_buffer[i+frame_size*st->channels];
735         for (i=0;i<frame_size*st->channels;i++)
736             st->delay_buffer[tmp*st->channels+i] = pcm[i];
737     }
738
739     /* Signalling the mode in the first byte */
740     data--;
741     data[0] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, st->stream_channels);
742
743     st->rangeFinal = enc.rng ^ redundant_rng;
744
745     if (to_celt)
746         st->prev_mode = MODE_CELT_ONLY;
747     else
748         st->prev_mode = st->mode;
749     st->first = 0;
750     return ret+1+redundancy_bytes;
751 }
752
753 #ifdef FIXED_POINT
754
755 #ifndef DISABLE_FLOAT_API
756 int opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
757       unsigned char *data, int max_data_bytes)
758 {
759    int i, ret;
760    VARDECL(opus_int16, in);
761    ALLOC_STACK;
762
763    ALLOC(in, frame_size*st->channels, opus_int16);
764
765    for (i=0;i<frame_size*st->channels;i++)
766       in[i] = FLOAT2INT16(pcm[i]);
767    ret = opus_encode(st, in, frame_size, data, max_data_bytes);
768    RESTORE_STACK;
769    return ret;
770 }
771 #endif
772
773 #else
774 int opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
775       unsigned char *data, int max_data_bytes)
776 {
777    int i, ret;
778    VARDECL(float, in);
779    ALLOC_STACK;
780
781    ALLOC(in, frame_size*st->channels, float);
782
783    for (i=0;i<frame_size*st->channels;i++)
784       in[i] = (1./32768)*pcm[i];
785    ret = opus_encode_float(st, in, frame_size, data, max_data_bytes);
786    RESTORE_STACK;
787    return ret;
788 }
789 #endif
790
791
792 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
793 {
794     CELTEncoder *celt_enc;
795     va_list ap;
796
797     va_start(ap, request);
798
799     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
800
801     switch (request)
802     {
803         case OPUS_SET_APPLICATION_REQUEST:
804         {
805             opus_int32 value = va_arg(ap, opus_int32);
806             st->application = value;
807         }
808         break;
809         case OPUS_GET_APPLICATION_REQUEST:
810         {
811             opus_int32 *value = va_arg(ap, opus_int32*);
812             *value = st->mode;
813         }
814         break;
815         case OPUS_SET_BITRATE_REQUEST:
816         {
817             opus_int32 value = va_arg(ap, opus_int32);
818             if (value != OPUS_BITRATE_AUTO)
819             {
820                 if (value <= 0)
821                     goto bad_arg;
822                 else if (value <= 500)
823                     value = 500;
824             }
825             st->user_bitrate_bps = value;
826         }
827         break;
828         case OPUS_GET_BITRATE_REQUEST:
829         {
830             opus_int32 *value = va_arg(ap, opus_int32*);
831             *value = st->bitrate_bps;
832         }
833         break;
834         case OPUS_SET_FORCE_MONO_REQUEST:
835         {
836             opus_int32 value = va_arg(ap, opus_int32);
837             st->force_mono = value;
838         }
839         break;
840         case OPUS_GET_FORCE_MONO_REQUEST:
841         {
842             opus_int32 *value = va_arg(ap, opus_int32*);
843             *value = !!st->force_mono;
844         }
845         break;
846         case OPUS_SET_BANDWIDTH_REQUEST:
847         {
848             opus_int32 value = va_arg(ap, opus_int32);
849             if (value < OPUS_BANDWIDTH_AUTO || value > OPUS_BANDWIDTH_FULLBAND)
850                 return OPUS_BAD_ARG;
851             st->user_bandwidth = value;
852             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
853                 st->silk_mode.maxInternalSampleRate = 8000;
854             } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
855                 st->silk_mode.maxInternalSampleRate = 12000;
856             } else {
857                 st->silk_mode.maxInternalSampleRate = 16000;
858             }
859         }
860         break;
861         case OPUS_GET_BANDWIDTH_REQUEST:
862         {
863             opus_int32 *value = va_arg(ap, opus_int32*);
864             *value = st->bandwidth;
865         }
866         break;
867         case OPUS_SET_DTX_REQUEST:
868         {
869             opus_int32 value = va_arg(ap, opus_int32);
870             st->silk_mode.useDTX = value;
871         }
872         break;
873         case OPUS_GET_DTX_REQUEST:
874         {
875             opus_int32 *value = va_arg(ap, opus_int32*);
876             *value = st->silk_mode.useDTX;
877         }
878         break;
879         case OPUS_SET_COMPLEXITY_REQUEST:
880         {
881             opus_int32 value = va_arg(ap, opus_int32);
882             st->silk_mode.complexity = value;
883             celt_encoder_ctl(celt_enc, CELT_SET_COMPLEXITY(value));
884         }
885         break;
886         case OPUS_GET_COMPLEXITY_REQUEST:
887         {
888             opus_int32 *value = va_arg(ap, opus_int32*);
889             *value = st->silk_mode.complexity;
890         }
891         break;
892         case OPUS_SET_INBAND_FEC_REQUEST:
893         {
894             opus_int32 value = va_arg(ap, opus_int32);
895             st->silk_mode.useInBandFEC = value;
896         }
897         break;
898         case OPUS_GET_INBAND_FEC_REQUEST:
899         {
900             opus_int32 *value = va_arg(ap, opus_int32*);
901             *value = st->silk_mode.useInBandFEC;
902         }
903         break;
904         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
905         {
906             opus_int32 value = va_arg(ap, opus_int32);
907             if (value < 0 || value > 100)
908                 return OPUS_BAD_ARG;
909             st->silk_mode.packetLossPercentage = value;
910             celt_encoder_ctl(celt_enc, CELT_SET_LOSS_PERC(value));
911         }
912         break;
913         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
914         {
915             opus_int32 *value = va_arg(ap, opus_int32*);
916             *value = st->silk_mode.packetLossPercentage;
917         }
918         break;
919         case OPUS_SET_VBR_REQUEST:
920         {
921             opus_int32 value = va_arg(ap, opus_int32);
922             st->use_vbr = value;
923             st->silk_mode.useCBR = 1-value;
924         }
925         break;
926         case OPUS_GET_VBR_REQUEST:
927         {
928             opus_int32 *value = va_arg(ap, opus_int32*);
929             *value = st->use_vbr;
930         }
931         break;
932         case OPUS_SET_VOICE_RATIO_REQUEST:
933         {
934             opus_int32 value = va_arg(ap, opus_int32);
935             if (value>100 || value<0)
936                 goto bad_arg;
937             st->voice_ratio = value;
938         }
939         break;
940         case OPUS_GET_VOICE_RATIO_REQUEST:
941         {
942             opus_int32 *value = va_arg(ap, opus_int32*);
943             *value = st->voice_ratio;
944         }
945         break;
946         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
947         {
948             opus_int32 value = va_arg(ap, opus_int32);
949             st->vbr_constraint = value;
950         }
951         break;
952         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
953         {
954             opus_int32 *value = va_arg(ap, opus_int32*);
955             *value = st->vbr_constraint;
956         }
957         break;
958         case OPUS_SET_SIGNAL_REQUEST:
959         {
960             opus_int32 value = va_arg(ap, opus_int32);
961             st->signal_type = value;
962         }
963         break;
964         case OPUS_GET_SIGNAL_REQUEST:
965         {
966             opus_int32 *value = va_arg(ap, opus_int32*);
967             *value = st->signal_type;
968         }
969         break;
970         case OPUS_GET_LOOKAHEAD_REQUEST:
971         {
972             opus_int32 *value = va_arg(ap, opus_int32*);
973             *value = st->delay_compensation+st->Fs/400;
974         }
975         break;
976         case OPUS_GET_FINAL_RANGE_REQUEST:
977         {
978             opus_uint32 *value = va_arg(ap, opus_uint32*);
979             *value = st->rangeFinal;
980         }
981         break;
982         default:
983             fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);
984             break;
985     }
986     va_end(ap);
987     return OPUS_OK;
988 bad_arg:
989     va_end(ap);
990     return OPUS_BAD_ARG;
991 }
992
993 void opus_encoder_destroy(OpusEncoder *st)
994 {
995     free(st);
996 }