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