Improved transitions between the different modes
[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 <stdlib.h>
33 #include <stdio.h>
34 #include <stdarg.h>
35 #include "opus_encoder.h"
36 #include "entenc.h"
37 #include "modes.h"
38 #include "SKP_Silk_SDK_API.h"
39
40 OpusEncoder *opus_encoder_create(int Fs, int channels)
41 {
42     char *raw_state;
43         OpusEncoder *st;
44         int ret, silkEncSizeBytes, celtEncSizeBytes;
45
46     /* Create SILK encoder */
47     ret = SKP_Silk_SDK_Get_Encoder_Size( &silkEncSizeBytes );
48     if( ret ) {
49         /* Handle error */
50     }
51     celtEncSizeBytes = celt_encoder_get_size(channels);
52     raw_state = calloc(sizeof(OpusEncoder)+silkEncSizeBytes+celtEncSizeBytes, 1);
53     st = (OpusEncoder*)raw_state;
54     st->silk_enc = (void*)(raw_state+sizeof(OpusEncoder));
55     st->celt_enc = (CELTEncoder*)(raw_state+sizeof(OpusEncoder)+silkEncSizeBytes);
56     st->stream_channels = st->channels = channels;
57
58     st->Fs = Fs;
59
60     ret = SKP_Silk_SDK_InitEncoder( st->silk_enc, &st->silk_mode );
61     if( ret ) {
62         /* Handle error */
63     }
64
65     /* default SILK parameters */
66     st->silk_mode.API_sampleRate        = st->Fs;
67     st->silk_mode.maxInternalSampleRate = 16000;
68     st->silk_mode.minInternalSampleRate = 8000;
69     st->silk_mode.payloadSize_ms        = 20;
70     st->silk_mode.packetLossPercentage  = 0;
71     st->silk_mode.useInBandFEC          = 0;
72     st->silk_mode.useDTX                = 0;
73     st->silk_mode.complexity            = 10;
74
75     /* Create CELT encoder */
76         /* Initialize CELT encoder */
77         st->celt_enc = celt_encoder_init(st->celt_enc, Fs, channels, NULL);
78
79         st->mode = MODE_HYBRID;
80         st->bandwidth = BANDWIDTH_FULLBAND;
81         st->use_vbr = 0;
82         st->bitrate_bps = 32000;
83
84         return st;
85 }
86
87 int opus_encode(OpusEncoder *st, const short *pcm, int frame_size,
88                 unsigned char *data, int max_data_bytes)
89 {
90     int i;
91         int ret=0;
92         SKP_int32 nBytes;
93         ec_enc enc;
94         int framerate, period;
95     int silk_internal_bandwidth;
96     int bytes_target;
97
98         bytes_target = st->bitrate_bps * frame_size / (st->Fs * 8) - 1;
99
100         data += 1;
101         if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
102         {
103                 SKP_SILK_SDK_EncControlStruct dummy;
104                 SKP_Silk_SDK_InitEncoder( st->silk_enc, &dummy);
105         }
106
107         ec_enc_init(&enc, data, max_data_bytes-1);
108
109         /* SILK processing */
110     if (st->mode != MODE_CELT_ONLY)
111     {
112         st->silk_mode.bitRate = st->bitrate_bps - 8*st->Fs/frame_size;
113         if( st->mode == MODE_HYBRID ) {
114             if( st->bandwidth == BANDWIDTH_SUPERWIDEBAND ) {
115                 if( st->Fs == 100 * frame_size ) {
116                     /* 24 kHz, 10 ms */
117                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 2000 + st->use_vbr * 1000 ) * 2 ) / 3;
118                 } else {
119                     /* 24 kHz, 20 ms */
120                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 1000 + st->use_vbr * 1000 ) * 2 ) / 3;
121                 }
122             } else {
123                 if( st->Fs == 100 * frame_size ) {
124                     /* 48 kHz, 10 ms */
125                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 8000 + st->use_vbr * 3000 ) / 2;
126                 } else {
127                     /* 48 kHz, 20 ms */
128                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 9000 + st->use_vbr * 1000 ) / 2;
129                 }
130             }
131         }
132
133         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
134         if (st->bandwidth == BANDWIDTH_NARROWBAND) {
135             st->silk_mode.maxInternalSampleRate = 8000;
136         } else if (st->bandwidth == BANDWIDTH_MEDIUMBAND) {
137             st->silk_mode.maxInternalSampleRate = 12000;
138         } else {
139             SKP_assert( st->mode == MODE_HYBRID || st->bandwidth == BANDWIDTH_WIDEBAND );
140             st->silk_mode.maxInternalSampleRate = 16000;
141         }
142         if( st->mode == MODE_HYBRID ) {
143             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
144             st->silk_mode.minInternalSampleRate = 16000;
145         } else {
146             st->silk_mode.minInternalSampleRate = 8000;
147         }
148
149         /* Call SILK encoder for the low band */
150         nBytes = max_data_bytes-1;
151         ret = SKP_Silk_SDK_Encode( st->silk_enc, &st->silk_mode, pcm, frame_size, &enc, &nBytes );
152         if( ret ) {
153             fprintf (stderr, "SILK encode error: %d\n", ret);
154             /* Handle error */
155         }
156         /* Extract SILK internal bandwidth for signaling in first byte */
157         if( st->mode == MODE_SILK_ONLY ) {
158             if( st->silk_mode.internalSampleRate == 8000 ) {
159                 silk_internal_bandwidth = BANDWIDTH_NARROWBAND;
160             } else if( st->silk_mode.internalSampleRate == 12000 ) {
161                 silk_internal_bandwidth = BANDWIDTH_MEDIUMBAND;
162             } else if( st->silk_mode.internalSampleRate == 16000 ) {
163                 silk_internal_bandwidth = BANDWIDTH_WIDEBAND;
164             }
165         }
166     }
167
168     /* CELT processing */
169         if (st->mode != MODE_SILK_ONLY)
170         {
171                 int endband;
172             short pcm_buf[960*2];
173             int nb_compr_bytes;
174
175             switch(st->bandwidth)
176             {
177             case BANDWIDTH_NARROWBAND:
178                 endband = 13;
179                 break;
180             case BANDWIDTH_WIDEBAND:
181                 endband = 17;
182                 break;
183             case BANDWIDTH_SUPERWIDEBAND:
184                 endband = 19;
185                 break;
186             case BANDWIDTH_FULLBAND:
187                 endband = 21;
188                 break;
189             }
190             celt_encoder_ctl(st->celt_enc, CELT_SET_END_BAND(endband));
191             celt_encoder_ctl(st->celt_enc, CELT_SET_CHANNELS(st->stream_channels));
192
193         celt_encoder_ctl(st->celt_enc, CELT_SET_VBR(0));
194         celt_encoder_ctl(st->celt_enc, CELT_SET_BITRATE(510000));
195         if (st->prev_mode == MODE_SILK_ONLY)
196         {
197                 celt_encoder_ctl(st->celt_enc, CELT_RESET_STATE);
198                 celt_encoder_ctl(st->celt_enc, CELT_SET_PREDICTION(0));
199         } else {
200                 celt_encoder_ctl(st->celt_enc, CELT_SET_PREDICTION(2));
201         }
202         if (st->mode == MODE_HYBRID)
203         {
204             int len;
205             celt_encoder_ctl(st->celt_enc, CELT_SET_START_BAND(17));
206
207             len = (ec_tell(&enc)+7)>>3;
208             if( st->use_vbr ) {
209                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
210             } else {
211                 /* check if SILK used up too much */
212                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
213             }
214         } else {
215             celt_encoder_ctl(st->celt_enc, CELT_SET_START_BAND(0));
216             if (st->use_vbr)
217             {
218                 celt_encoder_ctl(st->celt_enc, CELT_SET_VBR(1));
219                 celt_encoder_ctl(st->celt_enc, CELT_SET_BITRATE(st->bitrate_bps));
220                 nb_compr_bytes = max_data_bytes-1;
221             } else {
222                 nb_compr_bytes = bytes_target;
223             }
224         }
225
226         for (i=0;i<IMIN(frame_size, ENCODER_DELAY_COMPENSATION)*st->channels;i++)
227             pcm_buf[i] = st->delay_buffer[i];
228         for (;i<frame_size*st->channels;i++)
229             pcm_buf[i] = pcm[i-ENCODER_DELAY_COMPENSATION*st->channels];
230
231         ec_enc_shrink(&enc, nb_compr_bytes);
232
233             /* Encode high band with CELT */
234             ret = celt_encode_with_ec(st->celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
235
236             if (frame_size>ENCODER_DELAY_COMPENSATION)
237             {
238                 for (i=0;i<ENCODER_DELAY_COMPENSATION*st->channels;i++)
239                     st->delay_buffer[i] = pcm[(frame_size-ENCODER_DELAY_COMPENSATION)*st->channels+i];
240             } else {
241                 int tmp = ENCODER_DELAY_COMPENSATION-frame_size;
242                 for (i=0;i<tmp*st->channels;i++)
243                     st->delay_buffer[i] = st->delay_buffer[i+frame_size*st->channels];
244                 for (i=0;i<frame_size*st->channels;i++)
245                     st->delay_buffer[tmp*st->channels+i] = pcm[i];
246             }
247         } else {
248             ret = (ec_tell(&enc)+7)>>3;
249             ec_enc_done(&enc);
250         }
251
252         /* Signalling the mode in the first byte */
253         data--;
254         framerate = st->Fs/frame_size;
255         period = 0;
256         while (framerate < 400)
257         {
258             framerate <<= 1;
259             period++;
260         }
261     if (st->mode == MODE_SILK_ONLY)
262     {
263         data[0] = (silk_internal_bandwidth-BANDWIDTH_NARROWBAND)<<5;
264         data[0] |= (period-2)<<3;
265     } else if (st->mode == MODE_CELT_ONLY)
266     {
267         int tmp = st->bandwidth-BANDWIDTH_MEDIUMBAND;
268         if (tmp < 0)
269             tmp = 0;
270         data[0] = 0x80;
271         data[0] |= tmp << 5;
272         data[0] |= period<<3;
273     } else /* Hybrid */
274     {
275         data[0] = 0x60;
276         data[0] |= (st->bandwidth-BANDWIDTH_SUPERWIDEBAND)<<4;
277         data[0] |= (period-2)<<3;
278     }
279     data[0] |= (st->stream_channels==2)<<2;
280     /*printf ("%x\n", (int)data[0]);*/
281
282 #if OPUS_TEST_RANGE_CODER_STATE
283     st->rangeFinal = enc.rng;
284 #endif
285     st->prev_mode = st->mode;
286     return ret+1;
287 }
288
289 void opus_encoder_ctl(OpusEncoder *st, int request, ...)
290 {
291     va_list ap;
292
293     va_start(ap, request);
294
295     switch (request)
296     {
297         case OPUS_SET_MODE_REQUEST:
298         {
299             int value = va_arg(ap, int);
300             st->mode = value;
301         }
302         break;
303         case OPUS_GET_MODE_REQUEST:
304         {
305             int *value = va_arg(ap, int*);
306             *value = st->mode;
307         }
308         break;
309         case OPUS_SET_BITRATE_REQUEST:
310         {
311             int value = va_arg(ap, int);
312             st->bitrate_bps = value;
313         }
314         break;
315         case OPUS_GET_BITRATE_REQUEST:
316         {
317             int *value = va_arg(ap, int*);
318             *value = st->bitrate_bps;
319         }
320         break;
321         case OPUS_SET_BANDWIDTH_REQUEST:
322         {
323             int value = va_arg(ap, int);
324             st->bandwidth = value;
325             if (st->bandwidth == BANDWIDTH_NARROWBAND) {
326                 st->silk_mode.maxInternalSampleRate = 8000;
327             } else if (st->bandwidth == BANDWIDTH_MEDIUMBAND) {
328                 st->silk_mode.maxInternalSampleRate = 12000;
329             } else {
330                 st->silk_mode.maxInternalSampleRate = 16000;
331             }
332         }
333         break;
334         case OPUS_GET_BANDWIDTH_REQUEST:
335         {
336             int *value = va_arg(ap, int*);
337             *value = st->bandwidth;
338         }
339         break;
340         case OPUS_SET_DTX_FLAG_REQUEST:
341         {
342             int value = va_arg(ap, int);
343             st->silk_mode.useDTX = value;
344         }
345         break;
346         case OPUS_GET_DTX_FLAG_REQUEST:
347         {
348             int *value = va_arg(ap, int*);
349             *value = st->silk_mode.useDTX;
350         }
351         break;
352         case OPUS_SET_COMPLEXITY_REQUEST:
353         {
354             int value = va_arg(ap, int);
355             st->silk_mode.complexity = value;
356             celt_encoder_ctl(st->celt_enc, CELT_SET_COMPLEXITY(value));
357         }
358         break;
359         case OPUS_GET_COMPLEXITY_REQUEST:
360         {
361             int *value = va_arg(ap, int*);
362             *value = st->silk_mode.complexity;
363         }
364         break;
365         case OPUS_SET_INBAND_FEC_FLAG_REQUEST:
366         {
367             int value = va_arg(ap, int);
368             st->silk_mode.useInBandFEC = value;
369         }
370         break;
371         case OPUS_GET_INBAND_FEC_FLAG_REQUEST:
372         {
373             int *value = va_arg(ap, int*);
374             *value = st->silk_mode.useInBandFEC;
375         }
376         break;
377         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
378         {
379             int value = va_arg(ap, int);
380             st->silk_mode.packetLossPercentage = value;
381         }
382         break;
383         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
384         {
385             int *value = va_arg(ap, int*);
386             *value = st->silk_mode.packetLossPercentage;
387         }
388         break;
389         case OPUS_SET_VBR_FLAG_REQUEST:
390         {
391             int value = va_arg(ap, int);
392             st->use_vbr = value;
393             st->silk_mode.useCBR = 1-value;
394         }
395         break;
396         case OPUS_GET_VBR_FLAG_REQUEST:
397         {
398             int *value = va_arg(ap, int*);
399             *value = st->use_vbr;
400         }
401         break;
402         default:
403             fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);
404             break;
405     }
406
407     va_end(ap);
408 }
409
410 void opus_encoder_destroy(OpusEncoder *st)
411 {
412         free(st);
413 }
414
415 #if OPUS_TEST_RANGE_CODER_STATE
416 int opus_encoder_get_final_range(OpusEncoder *st)
417 {
418     return st->rangeFinal;
419 }
420 #endif