Fixes a few issues with PLC-based mode switching
[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         st->encoder_buffer = st->Fs/100;
85         st->delay_compensation = st->Fs/400;
86         if (st->Fs > 16000)
87                 st->delay_compensation += 10;
88         return st;
89 }
90
91 int opus_encode(OpusEncoder *st, const short *pcm, int frame_size,
92                 unsigned char *data, int max_data_bytes)
93 {
94     int i;
95         int ret=0;
96         SKP_int32 nBytes;
97         ec_enc enc;
98         int framerate, period;
99     int silk_internal_bandwidth;
100     int bytes_target;
101     int prefill=0;
102     int start_band = 0;
103     int redundancy = 0;
104     int redundancy_bytes = 0;
105     int celt_to_silk = 0;
106     short pcm_buf[960*2];
107     int nb_compr_bytes;
108     int to_celt = 0;
109
110         bytes_target = st->bitrate_bps * frame_size / (st->Fs * 8) - 1;
111
112         data += 1;
113         if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
114         {
115                 SKP_SILK_SDK_EncControlStruct dummy;
116                 SKP_Silk_SDK_InitEncoder( st->silk_enc, &dummy);
117                 prefill=1;
118         }
119         if (st->prev_mode >0 &&
120                 ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
121                 || (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
122         {
123             redundancy = 1;
124             celt_to_silk = (st->mode != MODE_CELT_ONLY);
125             if (!celt_to_silk)
126             {
127                 /* Switch to SILK/hybrid if frame size is 10 ms or more*/
128                 if (frame_size >= st->Fs/100)
129                 {
130                         st->mode = st->prev_mode;
131                         to_celt = 1;
132                 } else {
133                         redundancy=0;
134                 }
135             }
136         }
137
138         ec_enc_init(&enc, data, max_data_bytes-1);
139
140         /* SILK processing */
141     if (st->mode != MODE_CELT_ONLY)
142     {
143         st->silk_mode.bitRate = st->bitrate_bps - 8*st->Fs/frame_size;
144         if( st->mode == MODE_HYBRID ) {
145             if( st->bandwidth == BANDWIDTH_SUPERWIDEBAND ) {
146                 if( st->Fs == 100 * frame_size ) {
147                     /* 24 kHz, 10 ms */
148                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 2000 + st->use_vbr * 1000 ) * 2 ) / 3;
149                 } else {
150                     /* 24 kHz, 20 ms */
151                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 1000 + st->use_vbr * 1000 ) * 2 ) / 3;
152                 }
153             } else {
154                 if( st->Fs == 100 * frame_size ) {
155                     /* 48 kHz, 10 ms */
156                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 8000 + st->use_vbr * 3000 ) / 2;
157                 } else {
158                     /* 48 kHz, 20 ms */
159                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 9000 + st->use_vbr * 1000 ) / 2;
160                 }
161             }
162             /* don't let SILK use more than 80% */
163             if( st->silk_mode.bitRate > ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5 ) {
164                 st->silk_mode.bitRate = ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5;
165             }
166         }
167
168         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
169         if (st->bandwidth == BANDWIDTH_NARROWBAND) {
170             st->silk_mode.maxInternalSampleRate = 8000;
171         } else if (st->bandwidth == BANDWIDTH_MEDIUMBAND) {
172             st->silk_mode.maxInternalSampleRate = 12000;
173         } else {
174             SKP_assert( st->mode == MODE_HYBRID || st->bandwidth == BANDWIDTH_WIDEBAND );
175             st->silk_mode.maxInternalSampleRate = 16000;
176         }
177         if( st->mode == MODE_HYBRID ) {
178             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
179             st->silk_mode.minInternalSampleRate = 16000;
180         } else {
181             st->silk_mode.minInternalSampleRate = 8000;
182         }
183
184         /* Call SILK encoder for the low band */
185         nBytes = max_data_bytes-1;
186         if (prefill)
187         {
188             int zero=0;
189                 SKP_Silk_SDK_Encode( st->silk_enc, &st->silk_mode, st->delay_buffer, st->encoder_buffer, NULL, &zero, 1 );
190         }
191
192         ret = SKP_Silk_SDK_Encode( st->silk_enc, &st->silk_mode, pcm, frame_size, &enc, &nBytes, 0 );
193         if( ret ) {
194             fprintf (stderr, "SILK encode error: %d\n", ret);
195             /* Handle error */
196         }
197         /* Extract SILK internal bandwidth for signaling in first byte */
198         if( st->mode == MODE_SILK_ONLY ) {
199             if( st->silk_mode.internalSampleRate == 8000 ) {
200                 silk_internal_bandwidth = BANDWIDTH_NARROWBAND;
201             } else if( st->silk_mode.internalSampleRate == 12000 ) {
202                 silk_internal_bandwidth = BANDWIDTH_MEDIUMBAND;
203             } else if( st->silk_mode.internalSampleRate == 16000 ) {
204                 silk_internal_bandwidth = BANDWIDTH_WIDEBAND;
205             }
206         } else {
207             SKP_assert( st->silk_mode.internalSampleRate == 16000 );
208         }
209     }
210
211     /* CELT processing */
212         {
213             int endband=21;
214
215             switch(st->bandwidth)
216             {
217             case BANDWIDTH_NARROWBAND:
218                 endband = 13;
219                 break;
220             case BANDWIDTH_WIDEBAND:
221                 endband = 17;
222                 break;
223             case BANDWIDTH_SUPERWIDEBAND:
224                 endband = 19;
225                 break;
226             case BANDWIDTH_FULLBAND:
227                 endband = 21;
228                 break;
229             }
230             celt_encoder_ctl(st->celt_enc, CELT_SET_END_BAND(endband));
231             celt_encoder_ctl(st->celt_enc, CELT_SET_CHANNELS(st->stream_channels));
232         }
233         if (st->mode != MODE_SILK_ONLY)
234         {
235         celt_encoder_ctl(st->celt_enc, CELT_SET_VBR(0));
236         celt_encoder_ctl(st->celt_enc, CELT_SET_BITRATE(510000));
237         if (st->prev_mode == MODE_SILK_ONLY)
238         {
239                 unsigned char dummy[10];
240                 celt_encoder_ctl(st->celt_enc, CELT_RESET_STATE);
241                 celt_encoder_ctl(st->celt_enc, CELT_SET_START_BAND(0));
242                 celt_encoder_ctl(st->celt_enc, CELT_SET_PREDICTION(0));
243                 /* FIXME: This wastes CPU a bit compared to just prefilling the buffer */
244                 celt_encode(st->celt_enc, &st->delay_buffer[(st->encoder_buffer-st->delay_compensation-st->Fs/400)*st->channels], st->Fs/400, dummy, 10);
245         } else {
246                 celt_encoder_ctl(st->celt_enc, CELT_SET_PREDICTION(2));
247         }
248
249         if (st->mode == MODE_HYBRID)
250         {
251             int len;
252
253             len = (ec_tell(&enc)+7)>>3;
254             if( st->use_vbr ) {
255                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
256             } else {
257                 /* check if SILK used up too much */
258                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
259             }
260         } else {
261             if (st->use_vbr)
262             {
263                 celt_encoder_ctl(st->celt_enc, CELT_SET_VBR(1));
264                 celt_encoder_ctl(st->celt_enc, CELT_SET_BITRATE(st->bitrate_bps));
265                 nb_compr_bytes = max_data_bytes-1;
266             } else {
267                 nb_compr_bytes = bytes_target;
268             }
269         }
270
271
272         ec_enc_shrink(&enc, nb_compr_bytes);
273         } else {
274             nb_compr_bytes = 0;
275         }
276
277     for (i=0;i<IMIN(frame_size, st->delay_compensation)*st->channels;i++)
278         pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-st->delay_compensation)*st->channels+i];
279     for (;i<frame_size*st->channels;i++)
280         pcm_buf[i] = pcm[i-st->delay_compensation*st->channels];
281     if (st->mode != MODE_CELT_ONLY)
282     {
283         /* Check if we have a redundant 0-8 kHz band */
284         ec_enc_bit_logp(&enc, redundancy, 12);
285         if (redundancy)
286         {
287             redundancy_bytes = 40;
288             ec_enc_bit_logp(&enc, celt_to_silk, 1);
289             if (st->mode == MODE_HYBRID)
290                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
291         }
292         start_band = 17;
293     }
294
295     if (st->mode == MODE_SILK_ONLY)
296     {
297         ret = (ec_tell(&enc)+7)>>3;
298         ec_enc_done(&enc);
299         nb_compr_bytes = ret;
300     }
301
302     /* 5 ms redundant frame for CELT->SILK */
303     if (redundancy && celt_to_silk)
304     {
305         celt_encoder_ctl(st->celt_enc, CELT_SET_START_BAND(0));
306         /* FIXME: This is wrong -- we need to set the flags properly */
307         celt_encoder_ctl(st->celt_enc, CELT_SET_VBR(0));
308         /* FIXME: Make sure not to overflow here */
309         celt_encode(st->celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes);
310         celt_encoder_ctl(st->celt_enc, CELT_RESET_STATE);
311     }
312
313     celt_encoder_ctl(st->celt_enc, CELT_SET_START_BAND(start_band));
314
315     if (st->mode != MODE_SILK_ONLY)
316         {
317             /* Encode high band with CELT */
318             ret = celt_encode_with_ec(st->celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
319         }
320
321     /* 5 ms redundant frame for SILK->CELT */
322     if (redundancy && !celt_to_silk)
323     {
324         int N2, N4;
325         N2 = st->Fs/200;
326         N4 = st->Fs/400;
327
328         celt_encoder_ctl(st->celt_enc, CELT_RESET_STATE);
329         celt_encoder_ctl(st->celt_enc, CELT_SET_START_BAND(0));
330         celt_encoder_ctl(st->celt_enc, CELT_SET_PREDICTION(0));
331
332         /* FIXME: Do proper prefilling here */
333         celt_encode(st->celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, data+nb_compr_bytes, redundancy_bytes);
334
335         celt_encode(st->celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes);
336     }
337
338
339     if (frame_size>st->encoder_buffer)
340     {
341         for (i=0;i<st->encoder_buffer*st->channels;i++)
342                 st->delay_buffer[i] = pcm[(frame_size-st->encoder_buffer)*st->channels+i];
343     } else {
344         int tmp = st->encoder_buffer-frame_size;
345         for (i=0;i<tmp*st->channels;i++)
346                 st->delay_buffer[i] = st->delay_buffer[i+frame_size*st->channels];
347         for (i=0;i<frame_size*st->channels;i++)
348                 st->delay_buffer[tmp*st->channels+i] = pcm[i];
349     }
350
351         /* Signalling the mode in the first byte */
352         data--;
353         framerate = st->Fs/frame_size;
354         period = 0;
355         while (framerate < 400)
356         {
357             framerate <<= 1;
358             period++;
359         }
360     if (st->mode == MODE_SILK_ONLY)
361     {
362         data[0] = (silk_internal_bandwidth-BANDWIDTH_NARROWBAND)<<5;
363         data[0] |= (period-2)<<3;
364     } else if (st->mode == MODE_CELT_ONLY)
365     {
366         int tmp = st->bandwidth-BANDWIDTH_MEDIUMBAND;
367         if (tmp < 0)
368             tmp = 0;
369         data[0] = 0x80;
370         data[0] |= tmp << 5;
371         data[0] |= period<<3;
372     } else /* Hybrid */
373     {
374         data[0] = 0x60;
375         data[0] |= (st->bandwidth-BANDWIDTH_SUPERWIDEBAND)<<4;
376         data[0] |= (period-2)<<3;
377     }
378     data[0] |= (st->stream_channels==2)<<2;
379     /*printf ("%x\n", (int)data[0]);*/
380
381 #if OPUS_TEST_RANGE_CODER_STATE
382     st->rangeFinal = enc.rng;
383 #endif
384     if (to_celt)
385         st->prev_mode = MODE_CELT_ONLY;
386     else
387         st->prev_mode = st->mode;
388     return ret+1+redundancy_bytes;
389 }
390
391 void opus_encoder_ctl(OpusEncoder *st, int request, ...)
392 {
393     va_list ap;
394
395     va_start(ap, request);
396
397     switch (request)
398     {
399         case OPUS_SET_MODE_REQUEST:
400         {
401             int value = va_arg(ap, int);
402             st->mode = value;
403         }
404         break;
405         case OPUS_GET_MODE_REQUEST:
406         {
407             int *value = va_arg(ap, int*);
408             *value = st->mode;
409         }
410         break;
411         case OPUS_SET_BITRATE_REQUEST:
412         {
413             int value = va_arg(ap, int);
414             st->bitrate_bps = value;
415         }
416         break;
417         case OPUS_GET_BITRATE_REQUEST:
418         {
419             int *value = va_arg(ap, int*);
420             *value = st->bitrate_bps;
421         }
422         break;
423         case OPUS_SET_BANDWIDTH_REQUEST:
424         {
425             int value = va_arg(ap, int);
426             st->bandwidth = value;
427             if (st->bandwidth == BANDWIDTH_NARROWBAND) {
428                 st->silk_mode.maxInternalSampleRate = 8000;
429             } else if (st->bandwidth == BANDWIDTH_MEDIUMBAND) {
430                 st->silk_mode.maxInternalSampleRate = 12000;
431             } else {
432                 st->silk_mode.maxInternalSampleRate = 16000;
433             }
434         }
435         break;
436         case OPUS_GET_BANDWIDTH_REQUEST:
437         {
438             int *value = va_arg(ap, int*);
439             *value = st->bandwidth;
440         }
441         break;
442         case OPUS_SET_DTX_FLAG_REQUEST:
443         {
444             int value = va_arg(ap, int);
445             st->silk_mode.useDTX = value;
446         }
447         break;
448         case OPUS_GET_DTX_FLAG_REQUEST:
449         {
450             int *value = va_arg(ap, int*);
451             *value = st->silk_mode.useDTX;
452         }
453         break;
454         case OPUS_SET_COMPLEXITY_REQUEST:
455         {
456             int value = va_arg(ap, int);
457             st->silk_mode.complexity = value;
458             celt_encoder_ctl(st->celt_enc, CELT_SET_COMPLEXITY(value));
459         }
460         break;
461         case OPUS_GET_COMPLEXITY_REQUEST:
462         {
463             int *value = va_arg(ap, int*);
464             *value = st->silk_mode.complexity;
465         }
466         break;
467         case OPUS_SET_INBAND_FEC_FLAG_REQUEST:
468         {
469             int value = va_arg(ap, int);
470             st->silk_mode.useInBandFEC = value;
471         }
472         break;
473         case OPUS_GET_INBAND_FEC_FLAG_REQUEST:
474         {
475             int *value = va_arg(ap, int*);
476             *value = st->silk_mode.useInBandFEC;
477         }
478         break;
479         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
480         {
481             int value = va_arg(ap, int);
482             st->silk_mode.packetLossPercentage = value;
483         }
484         break;
485         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
486         {
487             int *value = va_arg(ap, int*);
488             *value = st->silk_mode.packetLossPercentage;
489         }
490         break;
491         case OPUS_SET_VBR_FLAG_REQUEST:
492         {
493             int value = va_arg(ap, int);
494             st->use_vbr = value;
495             st->silk_mode.useCBR = 1-value;
496         }
497         break;
498         case OPUS_GET_VBR_FLAG_REQUEST:
499         {
500             int *value = va_arg(ap, int*);
501             *value = st->use_vbr;
502         }
503         break;
504         default:
505             fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);
506             break;
507     }
508
509     va_end(ap);
510 }
511
512 void opus_encoder_destroy(OpusEncoder *st)
513 {
514         free(st);
515 }
516
517 #if OPUS_TEST_RANGE_CODER_STATE
518 int opus_encoder_get_final_range(OpusEncoder *st)
519 {
520     return st->rangeFinal;
521 }
522 #endif