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