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