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