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