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