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