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