dd7487ce382f3cec531dbca5adc892cb8b9e4aa6
[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 int 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 OPUS_BAD_ARG;
122     if (application < OPUS_APPLICATION_VOIP || application > OPUS_APPLICATION_AUDIO)
123         return OPUS_BAD_ARG;
124     if (Fs != 8000 && Fs != 12000 && Fs != 16000 && Fs != 24000 && Fs != 48000)
125         return OPUS_BAD_ARG;
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 OPUS_BAD_ARG;
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     /* This part is meant to compensate for the resampler delay as a function
185        of the API sampling rate */
186     if (st->Fs == 48000)
187         st->delay_compensation += 23;
188     else if (st->Fs == 24000)
189        st->delay_compensation += 15;
190     else
191        st->delay_compensation += 2;
192
193     return OPUS_OK;
194
195 failure:
196     free(st);
197     return OPUS_INTERNAL_ERROR;
198 }
199
200 static unsigned char gen_toc(int mode, int framerate, int bandwidth, int channels)
201 {
202    int period;
203    unsigned char toc;
204    period = 0;
205    while (framerate < 400)
206    {
207        framerate <<= 1;
208        period++;
209    }
210    if (mode == MODE_SILK_ONLY)
211    {
212        toc = (bandwidth-OPUS_BANDWIDTH_NARROWBAND)<<5;
213        toc |= (period-2)<<3;
214    } else if (mode == MODE_CELT_ONLY)
215    {
216        int tmp = bandwidth-OPUS_BANDWIDTH_MEDIUMBAND;
217        if (tmp < 0)
218            tmp = 0;
219        toc = 0x80;
220        toc |= tmp << 5;
221        toc |= period<<3;
222    } else /* Hybrid */
223    {
224        toc = 0x60;
225        toc |= (bandwidth-OPUS_BANDWIDTH_SUPERWIDEBAND)<<4;
226        toc |= (period-2)<<3;
227    }
228    toc |= (channels==2)<<2;
229    return toc;
230 }
231 OpusEncoder *opus_encoder_create(int Fs, int channels, int mode, int *error)
232 {
233    int ret;
234    char *raw_state = (char *)malloc(opus_encoder_get_size(channels));
235    if (raw_state == NULL)
236    {
237       if (error)
238          *error = OPUS_ALLOC_FAIL;
239       return NULL;
240    }
241    ret = opus_encoder_init((OpusEncoder*)raw_state, Fs, channels, mode);
242    if (error)
243       *error = ret;
244    if (ret != OPUS_OK)
245    {
246       free(raw_state);
247       raw_state = NULL;
248    }
249    return (OpusEncoder*)raw_state;
250 }
251 #ifdef FIXED_POINT
252 int opus_encode(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
253                 unsigned char *data, int max_data_bytes)
254 #else
255 int opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
256                       unsigned char *data, int max_data_bytes)
257 #endif
258 {
259     void *silk_enc;
260     CELTEncoder *celt_enc;
261     int i;
262     int ret=0;
263     int nBytes;
264     ec_enc enc;
265     int silk_internal_bandwidth=-1;
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         /* Extract SILK internal bandwidth for signaling in first byte */
560         if( st->mode == MODE_SILK_ONLY ) {
561             if( st->silk_mode.internalSampleRate == 8000 ) {
562                 silk_internal_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
563             } else if( st->silk_mode.internalSampleRate == 12000 ) {
564                 silk_internal_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
565             } else if( st->silk_mode.internalSampleRate == 16000 ) {
566                 silk_internal_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
567             }
568         } else {
569             SKP_assert( st->silk_mode.internalSampleRate == 16000 );
570         }
571     }
572
573     /* CELT processing */
574     {
575         int endband=21;
576
577         switch(st->bandwidth)
578         {
579             case OPUS_BANDWIDTH_NARROWBAND:
580                 endband = 13;
581                 break;
582             case OPUS_BANDWIDTH_MEDIUMBAND:
583             case OPUS_BANDWIDTH_WIDEBAND:
584                 endband = 17;
585                 break;
586             case OPUS_BANDWIDTH_SUPERWIDEBAND:
587                 endband = 19;
588                 break;
589             case OPUS_BANDWIDTH_FULLBAND:
590                 endband = 21;
591                 break;
592         }
593         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
594         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
595     }
596     if (st->mode != MODE_SILK_ONLY)
597     {
598         celt_encoder_ctl(celt_enc, CELT_SET_VBR(0));
599         celt_encoder_ctl(celt_enc, CELT_SET_BITRATE(-1));
600         if (st->prev_mode == MODE_SILK_ONLY)
601         {
602             unsigned char dummy[10];
603             celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
604             celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
605             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
606             /* TODO: This wastes CPU a bit compared to just prefilling the buffer */
607             celt_encode_native(celt_enc, &st->delay_buffer[(st->encoder_buffer-st->delay_compensation-st->Fs/400)*st->channels], st->Fs/400, dummy, 10);
608         } else {
609             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
610         }
611
612         if (st->mode == MODE_HYBRID)
613         {
614             int len;
615
616             len = (ec_tell(&enc)+7)>>3;
617             if( st->use_vbr ) {
618                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
619             } else {
620                 /* check if SILK used up too much */
621                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
622             }
623         } else {
624             if (st->use_vbr)
625             {
626                 celt_encoder_ctl(celt_enc, CELT_SET_VBR(1));
627                 celt_encoder_ctl(celt_enc, CELT_SET_VBR_CONSTRAINT(st->vbr_constraint));
628                 celt_encoder_ctl(celt_enc, CELT_SET_BITRATE(st->bitrate_bps));
629                 nb_compr_bytes = max_data_bytes-1;
630             } else {
631                 nb_compr_bytes = bytes_target;
632             }
633         }
634
635     } else {
636         nb_compr_bytes = 0;
637     }
638
639     ALLOC(pcm_buf, IMAX(frame_size, st->Fs/200)*st->channels, opus_val16);
640     for (i=0;i<IMIN(frame_size, st->delay_compensation)*st->channels;i++)
641         pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-st->delay_compensation)*st->channels+i];
642     for (;i<frame_size*st->channels;i++)
643         pcm_buf[i] = pcm[i-st->delay_compensation*st->channels];
644
645     if( st->mode == MODE_HYBRID && st->stream_channels == 2 ) {
646         /* Apply stereo width reduction (at low bitrates) */
647         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
648             int width_Q14, delta_Q14, nSamples_8ms, diff;
649             nSamples_8ms = ( st->Fs * 8 ) / 1000;
650             width_Q14 = (1 << 14 ) - st->hybrid_stereo_width_Q14;
651             delta_Q14 = ( st->hybrid_stereo_width_Q14 - st->silk_mode.stereoWidth_Q14 ) / nSamples_8ms;
652             for( i = 0; i < nSamples_8ms; i++ ) {
653                 width_Q14 += delta_Q14;
654                 diff = pcm_buf[ 2*i+1 ] - (opus_int32)pcm_buf[ 2*i ];
655                 diff = ( diff * width_Q14 ) >> 15;
656                 pcm_buf[ 2*i ]   = (opus_int16)( pcm_buf[ 2*i ]   + diff );
657                 pcm_buf[ 2*i+1 ] = (opus_int16)( pcm_buf[ 2*i+1 ] - diff );
658             }
659             for( ; i < frame_size; i++ ) {
660                 diff = pcm_buf[ 2*i+1 ] - (opus_int32)pcm_buf[ 2*i ];
661                 diff = ( diff * width_Q14 ) >> 15;
662                 pcm_buf[ 2*i ]   = (opus_int16)( pcm_buf[ 2*i ]   + diff );
663                 pcm_buf[ 2*i+1 ] = (opus_int16)( pcm_buf[ 2*i+1 ] - diff );
664             }
665             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
666         }
667     }
668
669     if (st->mode != MODE_CELT_ONLY)
670     {
671         /* Check if we have a redundant 0-8 kHz band */
672         ec_enc_bit_logp(&enc, redundancy, 12);
673         if (redundancy)
674         {
675             /* Target the same bit-rate for redundancy as for the rest,
676                up to a max of 257 bytes */
677             redundancy_bytes = IMIN(257, st->bitrate_bps/1600);
678             ec_enc_bit_logp(&enc, celt_to_silk, 1);
679             if (st->mode == MODE_HYBRID)
680                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
681         }
682         start_band = 17;
683     }
684
685     if (st->mode == MODE_SILK_ONLY)
686     {
687         ret = (ec_tell(&enc)+7)>>3;
688         ec_enc_done(&enc);
689         /*When in LPC only mode it's perfectly
690           reasonable to strip off trailing zero bytes as
691           the required range decoder behavior is to
692           fill these in. This can't be done when the MDCT
693           modes are used because the decoder needs to know
694           the actual length for allocation purposes.*/
695         if(!redundancy)
696             while(ret>2&&data[ret-1]==0)ret--;
697         nb_compr_bytes = ret;
698     } else {
699        nb_compr_bytes = IMIN(1275-redundancy_bytes, nb_compr_bytes);
700        ec_enc_shrink(&enc, nb_compr_bytes);
701     }
702
703
704     /* 5 ms redundant frame for CELT->SILK */
705     if (redundancy && celt_to_silk)
706     {
707         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
708         celt_encoder_ctl(celt_enc, CELT_SET_VBR(0));
709         celt_encode_native(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes);
710         celt_encoder_ctl(celt_enc, CELT_GET_RANGE(&redundant_rng));
711         celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
712     }
713
714     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
715
716     if (st->mode != MODE_SILK_ONLY)
717     {
718         ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
719     }
720
721     /* 5 ms redundant frame for SILK->CELT */
722     if (redundancy && !celt_to_silk)
723     {
724         int N2, N4;
725         N2 = st->Fs/200;
726         N4 = st->Fs/400;
727
728         celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
729         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
730         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
731
732         /* TODO: We could speed up prefilling here */
733         celt_encode_native(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, data+nb_compr_bytes, redundancy_bytes);
734
735         celt_encode_native(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes);
736         celt_encoder_ctl(celt_enc, CELT_GET_RANGE(&redundant_rng));
737     }
738
739
740     if (frame_size>st->encoder_buffer)
741     {
742         for (i=0;i<st->encoder_buffer*st->channels;i++)
743             st->delay_buffer[i] = pcm[(frame_size-st->encoder_buffer)*st->channels+i];
744     } else {
745         int tmp = st->encoder_buffer-frame_size;
746         for (i=0;i<tmp*st->channels;i++)
747             st->delay_buffer[i] = st->delay_buffer[i+frame_size*st->channels];
748         for (i=0;i<frame_size*st->channels;i++)
749             st->delay_buffer[tmp*st->channels+i] = pcm[i];
750     }
751
752     /* Signalling the mode in the first byte */
753     data--;
754     data[0] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, st->stream_channels);
755
756     st->rangeFinal = enc.rng ^ redundant_rng;
757
758     if (to_celt)
759         st->prev_mode = MODE_CELT_ONLY;
760     else
761         st->prev_mode = st->mode;
762     st->first = 0;
763     return ret+1+redundancy_bytes;
764 }
765
766 #ifdef FIXED_POINT
767
768 #ifndef DISABLE_FLOAT_API
769 int opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
770       unsigned char *data, int max_data_bytes)
771 {
772    int i, ret;
773    VARDECL(opus_int16, in);
774    ALLOC_STACK;
775
776    ALLOC(in, frame_size*st->channels, opus_int16);
777
778    for (i=0;i<frame_size*st->channels;i++)
779       in[i] = FLOAT2INT16(pcm[i]);
780    ret = opus_encode(st, in, frame_size, data, max_data_bytes);
781    RESTORE_STACK;
782    return ret;
783 }
784 #endif
785
786 #else
787 int opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
788       unsigned char *data, int max_data_bytes)
789 {
790    int i, ret;
791    VARDECL(float, in);
792    ALLOC_STACK;
793
794    ALLOC(in, frame_size*st->channels, float);
795
796    for (i=0;i<frame_size*st->channels;i++)
797       in[i] = (1./32768)*pcm[i];
798    ret = opus_encode_float(st, in, frame_size, data, max_data_bytes);
799    RESTORE_STACK;
800    return ret;
801 }
802 #endif
803
804
805 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
806 {
807     CELTEncoder *celt_enc;
808     va_list ap;
809
810     va_start(ap, request);
811
812     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
813
814     switch (request)
815     {
816         case OPUS_SET_APPLICATION_REQUEST:
817         {
818             opus_int32 value = va_arg(ap, opus_int32);
819             st->application = value;
820         }
821         break;
822         case OPUS_GET_APPLICATION_REQUEST:
823         {
824             opus_int32 *value = va_arg(ap, opus_int32*);
825             *value = st->mode;
826         }
827         break;
828         case OPUS_SET_BITRATE_REQUEST:
829         {
830             opus_int32 value = va_arg(ap, opus_int32);
831             if (value != OPUS_BITRATE_AUTO)
832             {
833                 if (value <= 0)
834                     goto bad_arg;
835                 else if (value <= 500)
836                     value = 500;
837             }
838             st->user_bitrate_bps = value;
839         }
840         break;
841         case OPUS_GET_BITRATE_REQUEST:
842         {
843             opus_int32 *value = va_arg(ap, opus_int32*);
844             *value = st->bitrate_bps;
845         }
846         break;
847         case OPUS_SET_FORCE_MONO_REQUEST:
848         {
849             opus_int32 value = va_arg(ap, opus_int32);
850             st->force_mono = value;
851         }
852         break;
853         case OPUS_GET_FORCE_MONO_REQUEST:
854         {
855             opus_int32 *value = va_arg(ap, opus_int32*);
856             *value = !!st->force_mono;
857         }
858         break;
859         case OPUS_SET_BANDWIDTH_REQUEST:
860         {
861             opus_int32 value = va_arg(ap, opus_int32);
862             if (value < OPUS_BANDWIDTH_AUTO || value > OPUS_BANDWIDTH_FULLBAND)
863                 return OPUS_BAD_ARG;
864             st->user_bandwidth = value;
865             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
866                 st->silk_mode.maxInternalSampleRate = 8000;
867             } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
868                 st->silk_mode.maxInternalSampleRate = 12000;
869             } else {
870                 st->silk_mode.maxInternalSampleRate = 16000;
871             }
872         }
873         break;
874         case OPUS_GET_BANDWIDTH_REQUEST:
875         {
876             opus_int32 *value = va_arg(ap, opus_int32*);
877             *value = st->bandwidth;
878         }
879         break;
880         case OPUS_SET_DTX_REQUEST:
881         {
882             opus_int32 value = va_arg(ap, opus_int32);
883             st->silk_mode.useDTX = value;
884         }
885         break;
886         case OPUS_GET_DTX_REQUEST:
887         {
888             opus_int32 *value = va_arg(ap, opus_int32*);
889             *value = st->silk_mode.useDTX;
890         }
891         break;
892         case OPUS_SET_COMPLEXITY_REQUEST:
893         {
894             opus_int32 value = va_arg(ap, opus_int32);
895             st->silk_mode.complexity = value;
896             celt_encoder_ctl(celt_enc, CELT_SET_COMPLEXITY(value));
897         }
898         break;
899         case OPUS_GET_COMPLEXITY_REQUEST:
900         {
901             opus_int32 *value = va_arg(ap, opus_int32*);
902             *value = st->silk_mode.complexity;
903         }
904         break;
905         case OPUS_SET_INBAND_FEC_REQUEST:
906         {
907             opus_int32 value = va_arg(ap, opus_int32);
908             st->silk_mode.useInBandFEC = value;
909         }
910         break;
911         case OPUS_GET_INBAND_FEC_REQUEST:
912         {
913             opus_int32 *value = va_arg(ap, opus_int32*);
914             *value = st->silk_mode.useInBandFEC;
915         }
916         break;
917         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
918         {
919             opus_int32 value = va_arg(ap, opus_int32);
920             if (value < 0 || value > 100)
921                 return OPUS_BAD_ARG;
922             st->silk_mode.packetLossPercentage = value;
923             celt_encoder_ctl(celt_enc, CELT_SET_LOSS_PERC(value));
924         }
925         break;
926         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
927         {
928             opus_int32 *value = va_arg(ap, opus_int32*);
929             *value = st->silk_mode.packetLossPercentage;
930         }
931         break;
932         case OPUS_SET_VBR_REQUEST:
933         {
934             opus_int32 value = va_arg(ap, opus_int32);
935             st->use_vbr = value;
936             st->silk_mode.useCBR = 1-value;
937         }
938         break;
939         case OPUS_GET_VBR_REQUEST:
940         {
941             opus_int32 *value = va_arg(ap, opus_int32*);
942             *value = st->use_vbr;
943         }
944         break;
945         case OPUS_SET_VOICE_RATIO_REQUEST:
946         {
947             opus_int32 value = va_arg(ap, opus_int32);
948             if (value>100 || value<0)
949                 goto bad_arg;
950             st->voice_ratio = value;
951         }
952         break;
953         case OPUS_GET_VOICE_RATIO_REQUEST:
954         {
955             opus_int32 *value = va_arg(ap, opus_int32*);
956             *value = st->voice_ratio;
957         }
958         break;
959         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
960         {
961             opus_int32 value = va_arg(ap, opus_int32);
962             st->vbr_constraint = value;
963         }
964         break;
965         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
966         {
967             opus_int32 *value = va_arg(ap, opus_int32*);
968             *value = st->vbr_constraint;
969         }
970         break;
971         case OPUS_SET_SIGNAL_REQUEST:
972         {
973             opus_int32 value = va_arg(ap, opus_int32);
974             st->signal_type = value;
975         }
976         break;
977         case OPUS_GET_SIGNAL_REQUEST:
978         {
979             opus_int32 *value = va_arg(ap, opus_int32*);
980             *value = st->signal_type;
981         }
982         break;
983         case OPUS_GET_LOOKAHEAD_REQUEST:
984         {
985             opus_int32 *value = va_arg(ap, opus_int32*);
986             *value = st->delay_compensation+st->Fs/400;
987         }
988         break;
989         case OPUS_GET_FINAL_RANGE_REQUEST:
990         {
991             opus_uint32 *value = va_arg(ap, opus_uint32*);
992             *value = st->rangeFinal;
993         }
994         break;
995         default:
996             fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);
997             break;
998     }
999     va_end(ap);
1000     return OPUS_OK;
1001 bad_arg:
1002     va_end(ap);
1003     return OPUS_BAD_ARG;
1004 }
1005
1006 void opus_encoder_destroy(OpusEncoder *st)
1007 {
1008     free(st);
1009 }