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