Makes the CELT init() functions behave just like the Opus ones.
[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 != CELT_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     /* SILK processing */
471     if (st->mode != MODE_CELT_ONLY)
472     {
473 #ifdef FIXED_POINT
474        const opus_int16 *pcm_silk;
475 #else
476        VARDECL(opus_int16, pcm_silk);
477        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
478 #endif
479         st->silk_mode.bitRate = st->bitrate_bps - 8*st->Fs/frame_size;
480         if( st->mode == MODE_HYBRID ) {
481             st->silk_mode.bitRate /= st->stream_channels;
482             if( st->bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
483                 if( st->Fs == 100 * frame_size ) {
484                     /* 24 kHz, 10 ms */
485                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 2000 + st->use_vbr * 1000 ) * 2 ) / 3;
486                 } else {
487                     /* 24 kHz, 20 ms */
488                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 1000 + st->use_vbr * 1000 ) * 2 ) / 3;
489                 }
490             } else {
491                 if( st->Fs == 100 * frame_size ) {
492                     /* 48 kHz, 10 ms */
493                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 8000 + st->use_vbr * 3000 ) / 2;
494                 } else {
495                     /* 48 kHz, 20 ms */
496                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 9000 + st->use_vbr * 1000 ) / 2;
497                 }
498             }
499             st->silk_mode.bitRate *= st->stream_channels;
500             /* don't let SILK use more than 80% */
501             if( st->silk_mode.bitRate > ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5 ) {
502                 st->silk_mode.bitRate = ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5;
503             }
504         }
505
506         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
507         st->silk_mode.nChannelsAPI = st->channels;
508         st->silk_mode.nChannelsInternal = st->stream_channels;
509         if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
510             st->silk_mode.desiredInternalSampleRate = 8000;
511         } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
512             st->silk_mode.desiredInternalSampleRate = 12000;
513         } else {
514             SKP_assert( st->mode == MODE_HYBRID || st->bandwidth == OPUS_BANDWIDTH_WIDEBAND );
515             st->silk_mode.desiredInternalSampleRate = 16000;
516         }
517         if( st->mode == MODE_HYBRID ) {
518             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
519             st->silk_mode.minInternalSampleRate = 16000;
520         } else {
521             st->silk_mode.minInternalSampleRate = 8000;
522         }
523         st->silk_mode.maxInternalSampleRate = 16000;
524
525         /* Call SILK encoder for the low band */
526         nBytes = IMIN(1275, max_data_bytes-1);
527         if (prefill)
528         {
529             int zero=0;
530 #ifdef FIXED_POINT
531             pcm_silk = st->delay_buffer;
532 #else
533             for (i=0;i<st->encoder_buffer*st->channels;i++)
534                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
535 #endif
536             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
537         }
538
539 #ifdef FIXED_POINT
540         pcm_silk = pcm;
541 #else
542         for (i=0;i<frame_size*st->channels;i++)
543             pcm_silk[i] = FLOAT2INT16(pcm[i]);
544 #endif
545         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
546         if( ret ) {
547             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
548             /* Handle error */
549            return OPUS_INTERNAL_ERROR;
550         }
551         if (nBytes==0)
552         {
553            data[-1] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, silk_internal_bandwidth, st->stream_channels);
554            RESTORE_STACK;
555            return 1;
556         }
557         /* Extract SILK internal bandwidth for signaling in first byte */
558         if( st->mode == MODE_SILK_ONLY ) {
559             if( st->silk_mode.internalSampleRate == 8000 ) {
560                 silk_internal_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
561             } else if( st->silk_mode.internalSampleRate == 12000 ) {
562                 silk_internal_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
563             } else if( st->silk_mode.internalSampleRate == 16000 ) {
564                 silk_internal_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
565             }
566         } else {
567             SKP_assert( st->silk_mode.internalSampleRate == 16000 );
568         }
569     }
570
571     /* CELT processing */
572     {
573         int endband=21;
574
575         switch(st->bandwidth)
576         {
577             case OPUS_BANDWIDTH_NARROWBAND:
578                 endband = 13;
579                 break;
580             case OPUS_BANDWIDTH_MEDIUMBAND:
581             case OPUS_BANDWIDTH_WIDEBAND:
582                 endband = 17;
583                 break;
584             case OPUS_BANDWIDTH_SUPERWIDEBAND:
585                 endband = 19;
586                 break;
587             case OPUS_BANDWIDTH_FULLBAND:
588                 endband = 21;
589                 break;
590         }
591         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
592         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
593     }
594     if (st->mode != MODE_SILK_ONLY)
595     {
596         celt_encoder_ctl(celt_enc, CELT_SET_VBR(0));
597         celt_encoder_ctl(celt_enc, CELT_SET_BITRATE(-1));
598         if (st->prev_mode == MODE_SILK_ONLY)
599         {
600             unsigned char dummy[10];
601             celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
602             celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
603             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
604             /* TODO: This wastes CPU a bit compared to just prefilling the buffer */
605             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);
606         } else {
607             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
608         }
609
610         if (st->mode == MODE_HYBRID)
611         {
612             int len;
613
614             len = (ec_tell(&enc)+7)>>3;
615             if( st->use_vbr ) {
616                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
617             } else {
618                 /* check if SILK used up too much */
619                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
620             }
621         } else {
622             if (st->use_vbr)
623             {
624                 celt_encoder_ctl(celt_enc, CELT_SET_VBR(1));
625                 celt_encoder_ctl(celt_enc, CELT_SET_VBR_CONSTRAINT(st->vbr_constraint));
626                 celt_encoder_ctl(celt_enc, CELT_SET_BITRATE(st->bitrate_bps));
627                 nb_compr_bytes = max_data_bytes-1;
628             } else {
629                 nb_compr_bytes = bytes_target;
630             }
631         }
632
633     } else {
634         nb_compr_bytes = 0;
635     }
636
637     ALLOC(pcm_buf, IMAX(frame_size, st->Fs/200)*st->channels, opus_val16);
638     for (i=0;i<IMIN(frame_size, st->delay_compensation)*st->channels;i++)
639         pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-st->delay_compensation)*st->channels+i];
640     for (;i<frame_size*st->channels;i++)
641         pcm_buf[i] = pcm[i-st->delay_compensation*st->channels];
642
643     if( st->mode == MODE_HYBRID && st->stream_channels == 2 ) {
644         /* Apply stereo width reduction (at low bitrates) */
645         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
646             int width_Q14, delta_Q14, nSamples_8ms, diff;
647             nSamples_8ms = ( st->Fs * 8 ) / 1000;
648             width_Q14 = (1 << 14 ) - st->hybrid_stereo_width_Q14;
649             delta_Q14 = ( st->hybrid_stereo_width_Q14 - st->silk_mode.stereoWidth_Q14 ) / nSamples_8ms;
650             for( i = 0; i < nSamples_8ms; i++ ) {
651                 width_Q14 += delta_Q14;
652                 diff = pcm_buf[ 2*i+1 ] - (opus_int32)pcm_buf[ 2*i ];
653                 diff = ( diff * width_Q14 ) >> 15;
654                 pcm_buf[ 2*i ]   = (opus_int16)( pcm_buf[ 2*i ]   + diff );
655                 pcm_buf[ 2*i+1 ] = (opus_int16)( pcm_buf[ 2*i+1 ] - diff );
656             }
657             for( ; i < frame_size; i++ ) {
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             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
664         }
665     }
666
667     if (st->mode != MODE_CELT_ONLY)
668     {
669         /* Check if we have a redundant 0-8 kHz band */
670         ec_enc_bit_logp(&enc, redundancy, 12);
671         if (redundancy)
672         {
673             /* Target the same bit-rate for redundancy as for the rest,
674                up to a max of 257 bytes */
675             redundancy_bytes = IMIN(257, st->bitrate_bps/1600);
676             ec_enc_bit_logp(&enc, celt_to_silk, 1);
677             if (st->mode == MODE_HYBRID)
678                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
679         }
680         start_band = 17;
681     }
682
683     if (st->mode == MODE_SILK_ONLY)
684     {
685         ret = (ec_tell(&enc)+7)>>3;
686         ec_enc_done(&enc);
687         /*When in LPC only mode it's perfectly
688           reasonable to strip off trailing zero bytes as
689           the required range decoder behavior is to
690           fill these in. This can't be done when the MDCT
691           modes are used because the decoder needs to know
692           the actual length for allocation purposes.*/
693         if(!redundancy)
694             while(ret>2&&data[ret-1]==0)ret--;
695         nb_compr_bytes = ret;
696     } else {
697        nb_compr_bytes = IMIN(1275-redundancy_bytes, nb_compr_bytes);
698        ec_enc_shrink(&enc, nb_compr_bytes);
699     }
700
701
702     /* 5 ms redundant frame for CELT->SILK */
703     if (redundancy && celt_to_silk)
704     {
705         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
706         celt_encoder_ctl(celt_enc, CELT_SET_VBR(0));
707         celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
708         celt_encoder_ctl(celt_enc, CELT_GET_RANGE(&redundant_rng));
709         celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
710     }
711
712     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
713
714     if (st->mode != MODE_SILK_ONLY)
715     {
716         ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
717     }
718
719     /* 5 ms redundant frame for SILK->CELT */
720     if (redundancy && !celt_to_silk)
721     {
722         int N2, N4;
723         N2 = st->Fs/200;
724         N4 = st->Fs/400;
725
726         celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
727         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
728         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
729
730         /* TODO: We could speed up prefilling here */
731         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, data+nb_compr_bytes, redundancy_bytes, NULL);
732
733         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
734         celt_encoder_ctl(celt_enc, CELT_GET_RANGE(&redundant_rng));
735     }
736
737
738     if (frame_size>st->encoder_buffer)
739     {
740         for (i=0;i<st->encoder_buffer*st->channels;i++)
741             st->delay_buffer[i] = pcm[(frame_size-st->encoder_buffer)*st->channels+i];
742     } else {
743         int tmp = st->encoder_buffer-frame_size;
744         for (i=0;i<tmp*st->channels;i++)
745             st->delay_buffer[i] = st->delay_buffer[i+frame_size*st->channels];
746         for (i=0;i<frame_size*st->channels;i++)
747             st->delay_buffer[tmp*st->channels+i] = pcm[i];
748     }
749
750     /* Signalling the mode in the first byte */
751     data--;
752     data[0] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, silk_internal_bandwidth, st->stream_channels);
753
754     st->rangeFinal = enc.rng ^ redundant_rng;
755
756     if (to_celt)
757         st->prev_mode = MODE_CELT_ONLY;
758     else
759         st->prev_mode = st->mode;
760     st->first = 0;
761     RESTORE_STACK;
762     return ret+1+redundancy_bytes;
763 }
764
765 #ifdef FIXED_POINT
766
767 #ifndef DISABLE_FLOAT_API
768 int opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
769       unsigned char *data, int max_data_bytes)
770 {
771    int i, ret;
772    VARDECL(opus_int16, in);
773    ALLOC_STACK;
774
775    ALLOC(in, frame_size*st->channels, opus_int16);
776
777    for (i=0;i<frame_size*st->channels;i++)
778       in[i] = FLOAT2INT16(pcm[i]);
779    ret = opus_encode(st, in, frame_size, data, max_data_bytes);
780    RESTORE_STACK;
781    return ret;
782 }
783 #endif
784
785 #else
786 int opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
787       unsigned char *data, int max_data_bytes)
788 {
789    int i, ret;
790    VARDECL(float, in);
791    ALLOC_STACK;
792
793    ALLOC(in, frame_size*st->channels, float);
794
795    for (i=0;i<frame_size*st->channels;i++)
796       in[i] = (1./32768)*pcm[i];
797    ret = opus_encode_float(st, in, frame_size, data, max_data_bytes);
798    RESTORE_STACK;
799    return ret;
800 }
801 #endif
802
803
804 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
805 {
806     int ret;
807     CELTEncoder *celt_enc;
808     va_list ap;
809
810     ret = OPUS_OK;
811     va_start(ap, request);
812
813     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
814
815     switch (request)
816     {
817         case OPUS_SET_APPLICATION_REQUEST:
818         {
819             opus_int32 value = va_arg(ap, opus_int32);
820             st->application = value;
821         }
822         break;
823         case OPUS_GET_APPLICATION_REQUEST:
824         {
825             opus_int32 *value = va_arg(ap, opus_int32*);
826             *value = st->mode;
827         }
828         break;
829         case OPUS_SET_BITRATE_REQUEST:
830         {
831             opus_int32 value = va_arg(ap, opus_int32);
832             if (value != OPUS_BITRATE_AUTO)
833             {
834                 if (value <= 0)
835                     goto bad_arg;
836                 else if (value <= 500)
837                     value = 500;
838             }
839             st->user_bitrate_bps = value;
840         }
841         break;
842         case OPUS_GET_BITRATE_REQUEST:
843         {
844             opus_int32 *value = va_arg(ap, opus_int32*);
845             *value = st->bitrate_bps;
846         }
847         break;
848         case OPUS_SET_FORCE_MONO_REQUEST:
849         {
850             opus_int32 value = va_arg(ap, opus_int32);
851             st->force_mono = value;
852         }
853         break;
854         case OPUS_GET_FORCE_MONO_REQUEST:
855         {
856             opus_int32 *value = va_arg(ap, opus_int32*);
857             *value = !!st->force_mono;
858         }
859         break;
860         case OPUS_SET_BANDWIDTH_REQUEST:
861         {
862             opus_int32 value = va_arg(ap, opus_int32);
863             if (value < OPUS_BANDWIDTH_AUTO || value > OPUS_BANDWIDTH_FULLBAND)
864                 return OPUS_BAD_ARG;
865             st->user_bandwidth = value;
866             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
867                 st->silk_mode.maxInternalSampleRate = 8000;
868             } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
869                 st->silk_mode.maxInternalSampleRate = 12000;
870             } else {
871                 st->silk_mode.maxInternalSampleRate = 16000;
872             }
873         }
874         break;
875         case OPUS_GET_BANDWIDTH_REQUEST:
876         {
877             opus_int32 *value = va_arg(ap, opus_int32*);
878             *value = st->bandwidth;
879         }
880         break;
881         case OPUS_SET_DTX_REQUEST:
882         {
883             opus_int32 value = va_arg(ap, opus_int32);
884             st->silk_mode.useDTX = value;
885         }
886         break;
887         case OPUS_GET_DTX_REQUEST:
888         {
889             opus_int32 *value = va_arg(ap, opus_int32*);
890             *value = st->silk_mode.useDTX;
891         }
892         break;
893         case OPUS_SET_COMPLEXITY_REQUEST:
894         {
895             opus_int32 value = va_arg(ap, opus_int32);
896             st->silk_mode.complexity = value;
897             celt_encoder_ctl(celt_enc, CELT_SET_COMPLEXITY(value));
898         }
899         break;
900         case OPUS_GET_COMPLEXITY_REQUEST:
901         {
902             opus_int32 *value = va_arg(ap, opus_int32*);
903             *value = st->silk_mode.complexity;
904         }
905         break;
906         case OPUS_SET_INBAND_FEC_REQUEST:
907         {
908             opus_int32 value = va_arg(ap, opus_int32);
909             st->silk_mode.useInBandFEC = value;
910         }
911         break;
912         case OPUS_GET_INBAND_FEC_REQUEST:
913         {
914             opus_int32 *value = va_arg(ap, opus_int32*);
915             *value = st->silk_mode.useInBandFEC;
916         }
917         break;
918         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
919         {
920             opus_int32 value = va_arg(ap, opus_int32);
921             if (value < 0 || value > 100)
922                 return OPUS_BAD_ARG;
923             st->silk_mode.packetLossPercentage = value;
924             celt_encoder_ctl(celt_enc, CELT_SET_LOSS_PERC(value));
925         }
926         break;
927         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
928         {
929             opus_int32 *value = va_arg(ap, opus_int32*);
930             *value = st->silk_mode.packetLossPercentage;
931         }
932         break;
933         case OPUS_SET_VBR_REQUEST:
934         {
935             opus_int32 value = va_arg(ap, opus_int32);
936             st->use_vbr = value;
937             st->silk_mode.useCBR = 1-value;
938         }
939         break;
940         case OPUS_GET_VBR_REQUEST:
941         {
942             opus_int32 *value = va_arg(ap, opus_int32*);
943             *value = st->use_vbr;
944         }
945         break;
946         case OPUS_SET_VOICE_RATIO_REQUEST:
947         {
948             opus_int32 value = va_arg(ap, opus_int32);
949             if (value>100 || value<0)
950                 goto bad_arg;
951             st->voice_ratio = value;
952         }
953         break;
954         case OPUS_GET_VOICE_RATIO_REQUEST:
955         {
956             opus_int32 *value = va_arg(ap, opus_int32*);
957             *value = st->voice_ratio;
958         }
959         break;
960         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
961         {
962             opus_int32 value = va_arg(ap, opus_int32);
963             st->vbr_constraint = value;
964         }
965         break;
966         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
967         {
968             opus_int32 *value = va_arg(ap, opus_int32*);
969             *value = st->vbr_constraint;
970         }
971         break;
972         case OPUS_SET_SIGNAL_REQUEST:
973         {
974             opus_int32 value = va_arg(ap, opus_int32);
975             st->signal_type = value;
976         }
977         break;
978         case OPUS_GET_SIGNAL_REQUEST:
979         {
980             opus_int32 *value = va_arg(ap, opus_int32*);
981             *value = st->signal_type;
982         }
983         break;
984         case OPUS_GET_LOOKAHEAD_REQUEST:
985         {
986             opus_int32 *value = va_arg(ap, opus_int32*);
987             *value = st->delay_compensation+st->Fs/400;
988         }
989         break;
990         case OPUS_GET_FINAL_RANGE_REQUEST:
991         {
992             opus_uint32 *value = va_arg(ap, opus_uint32*);
993             *value = st->rangeFinal;
994         }
995         break;
996         case OPUS_RESET_STATE:
997         {
998            void *silk_enc;
999            silk_EncControlStruct dummy;
1000            silk_enc = (char*)st+st->silk_enc_offset;
1001
1002            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
1003                  opus_encoder_get_size(st->channels)-
1004                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
1005
1006            celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
1007            silk_InitEncoder( silk_enc, &dummy );
1008            st->stream_channels = st->channels;
1009            st->hybrid_stereo_width_Q14             = 1 << 14;
1010            st->first = 1;
1011            st->mode = MODE_HYBRID;
1012            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
1013         }
1014         break;
1015         default:
1016             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
1017             ret = OPUS_BAD_ARG;
1018             break;
1019     }
1020     va_end(ap);
1021     return ret;
1022 bad_arg:
1023     va_end(ap);
1024     return OPUS_BAD_ARG;
1025 }
1026
1027 void opus_encoder_destroy(OpusEncoder *st)
1028 {
1029     opus_free(st);
1030 }