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