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