Fixes buffering issues with CELT-only mode at 2.5 ms
[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    - Neither the name of the Xiph.org Foundation nor the names of its
16    contributors may be used to endorse or promote products derived from
17    this software without specific prior written permission.
18
19    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
23    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
26    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
27    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
28    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #ifdef HAVE_CONFIG_H
33 #include "config.h"
34 #endif
35
36 #include <stdlib.h>
37 #include <stdio.h>
38 #include <stdarg.h>
39 #include "opus_encoder.h"
40 #include "entenc.h"
41 #include "modes.h"
42 #include "SKP_Silk_SDK_API.h"
43
44 OpusEncoder *opus_encoder_create(int Fs, int channels)
45 {
46     char *raw_state;
47         OpusEncoder *st;
48         int ret, silkEncSizeBytes, celtEncSizeBytes;
49
50     /* Create SILK encoder */
51     ret = SKP_Silk_SDK_Get_Encoder_Size( &silkEncSizeBytes );
52     if( ret ) {
53         /* Handle error */
54     }
55     celtEncSizeBytes = celt_encoder_get_size(channels);
56     raw_state = calloc(sizeof(OpusEncoder)+silkEncSizeBytes+celtEncSizeBytes, 1);
57     st = (OpusEncoder*)raw_state;
58     st->silk_enc = (void*)(raw_state+sizeof(OpusEncoder));
59     st->celt_enc = (CELTEncoder*)(raw_state+sizeof(OpusEncoder)+silkEncSizeBytes);
60     st->stream_channels = st->channels = channels;
61
62     st->Fs = Fs;
63
64     ret = SKP_Silk_SDK_InitEncoder( st->silk_enc, &st->silk_mode );
65     if( ret ) {
66         /* Handle error */
67     }
68
69     /* default SILK parameters */
70     st->silk_mode.API_sampleRate        = st->Fs;
71     st->silk_mode.maxInternalSampleRate = 16000;
72     st->silk_mode.minInternalSampleRate = 8000;
73     st->silk_mode.payloadSize_ms        = 20;
74     st->silk_mode.packetLossPercentage  = 0;
75     st->silk_mode.useInBandFEC          = 0;
76     st->silk_mode.useDTX                = 0;
77     st->silk_mode.complexity            = 10;
78
79     /* Create CELT encoder */
80         /* Initialize CELT encoder */
81         st->celt_enc = celt_encoder_init(st->celt_enc, Fs, channels, NULL);
82
83         st->mode = MODE_HYBRID;
84         st->bandwidth = BANDWIDTH_FULLBAND;
85         st->use_vbr = 0;
86         st->bitrate_bps = 32000;
87
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
102         bytes_target = st->bitrate_bps * frame_size / (st->Fs * 8) - 1;
103
104         data += 1;
105         ec_enc_init(&enc, data, max_data_bytes-1);
106
107         /* SILK processing */
108     if (st->mode != MODE_CELT_ONLY) {
109         st->silk_mode.bitRate = st->bitrate_bps - 8*st->Fs/frame_size;
110         if( st->mode == MODE_HYBRID ) {
111             if( st->bandwidth == BANDWIDTH_SUPERWIDEBAND ) {
112                 if( st->Fs == 100 * frame_size ) {
113                     /* 24 kHz, 10 ms */
114                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 2000 + st->use_vbr * 1000 ) * 2 ) / 3;
115                 } else {
116                     /* 24 kHz, 20 ms */
117                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 1000 + st->use_vbr * 1000 ) * 2 ) / 3;
118                 }
119             } else {
120                 if( st->Fs == 100 * frame_size ) {
121                     /* 48 kHz, 10 ms */
122                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 8000 + st->use_vbr * 3000 ) / 2;
123                 } else {
124                     /* 48 kHz, 20 ms */
125                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 9000 + st->use_vbr * 1000 ) / 2;
126                 }
127             }
128         }
129
130         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
131         if (st->bandwidth == BANDWIDTH_NARROWBAND) {
132             st->silk_mode.maxInternalSampleRate = 8000;
133         } else if (st->bandwidth == BANDWIDTH_MEDIUMBAND) {
134             st->silk_mode.maxInternalSampleRate = 12000;
135         } else {
136             SKP_assert( st->mode == MODE_HYBRID || st->bandwidth == BANDWIDTH_WIDEBAND );
137             st->silk_mode.maxInternalSampleRate = 16000;
138         }
139         if( st->mode == MODE_HYBRID ) {
140             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
141             st->silk_mode.minInternalSampleRate = st->silk_mode.maxInternalSampleRate ;
142         }
143
144         /* Call SILK encoder for the low band */
145         nBytes = max_data_bytes-1;
146         ret = SKP_Silk_SDK_Encode( st->silk_enc, &st->silk_mode, pcm, frame_size, &enc, &nBytes );
147         if( ret ) {
148             fprintf (stderr, "SILK encode error: %d\n", ret);
149             /* Handle error */
150         }
151         /* Extract SILK internal bandwidth for signaling in first byte */
152         if( st->mode == MODE_SILK_ONLY ) {
153             if( st->silk_mode.internalSampleRate == 8000 ) {
154                 silk_internal_bandwidth = BANDWIDTH_NARROWBAND;
155             } else if( st->silk_mode.internalSampleRate == 12000 ) {
156                 silk_internal_bandwidth = BANDWIDTH_MEDIUMBAND;
157             } else if( st->silk_mode.internalSampleRate == 16000 ) {
158                 silk_internal_bandwidth = BANDWIDTH_WIDEBAND;
159             }
160         }
161     }
162
163     /* CELT processing */
164         if (st->mode != MODE_SILK_ONLY)
165         {
166                 int endband;
167             short pcm_buf[960*2];
168             int nb_compr_bytes;
169
170             switch(st->bandwidth)
171             {
172             case BANDWIDTH_NARROWBAND:
173                 endband = 13;
174                 break;
175             case BANDWIDTH_WIDEBAND:
176                 endband = 17;
177                 break;
178             case BANDWIDTH_SUPERWIDEBAND:
179                 endband = 19;
180                 break;
181             case BANDWIDTH_FULLBAND:
182                 endband = 21;
183                 break;
184             }
185             celt_encoder_ctl(st->celt_enc, CELT_SET_END_BAND(endband));
186             celt_encoder_ctl(st->celt_enc, CELT_SET_CHANNELS(st->stream_channels));
187
188         celt_encoder_ctl(st->celt_enc, CELT_SET_VBR(0));
189         celt_encoder_ctl(st->celt_enc, CELT_SET_BITRATE(510000));
190         if (st->mode == MODE_HYBRID)
191         {
192             int len;
193             celt_encoder_ctl(st->celt_enc, CELT_SET_START_BAND(17));
194
195             len = (ec_tell(&enc)+7)>>3;
196             if( st->use_vbr ) {
197                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
198             } else {
199                 /* check if SILK used up too much */
200                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
201             }
202         } else {
203             celt_encoder_ctl(st->celt_enc, CELT_SET_START_BAND(0));
204             if (st->use_vbr)
205             {
206                 celt_encoder_ctl(st->celt_enc, CELT_SET_VBR(1));
207                 celt_encoder_ctl(st->celt_enc, CELT_SET_BITRATE(st->bitrate_bps));
208                 nb_compr_bytes = max_data_bytes-1;
209             } else {
210                 nb_compr_bytes = bytes_target;
211             }
212         }
213
214         for (i=0;i<IMIN(frame_size, ENCODER_DELAY_COMPENSATION)*st->channels;i++)
215             pcm_buf[i] = st->delay_buffer[i];
216         for (;i<frame_size*st->channels;i++)
217             pcm_buf[i] = pcm[i-ENCODER_DELAY_COMPENSATION*st->channels];
218
219         ec_enc_shrink(&enc, nb_compr_bytes);
220
221             /* Encode high band with CELT */
222             ret = celt_encode_with_ec(st->celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
223
224             if (frame_size>ENCODER_DELAY_COMPENSATION)
225             {
226                 for (i=0;i<ENCODER_DELAY_COMPENSATION*st->channels;i++)
227                     st->delay_buffer[i] = pcm[(frame_size-ENCODER_DELAY_COMPENSATION)*st->channels+i];
228             } else {
229                 int tmp = ENCODER_DELAY_COMPENSATION-frame_size;
230                 for (i=0;i<tmp*st->channels;i++)
231                     st->delay_buffer[i] = st->delay_buffer[i+frame_size*st->channels];
232                 for (i=0;i<frame_size*st->channels;i++)
233                     st->delay_buffer[tmp*st->channels+i] = pcm[i];
234             }
235         } else {
236             ret = (ec_tell(&enc)+7)>>3;
237             ec_enc_done(&enc);
238         }
239
240         /* Signalling the mode in the first byte */
241         data--;
242         framerate = st->Fs/frame_size;
243         period = 0;
244         while (framerate < 400)
245         {
246             framerate <<= 1;
247             period++;
248         }
249     if (st->mode == MODE_SILK_ONLY)
250     {
251         data[0] = (silk_internal_bandwidth-BANDWIDTH_NARROWBAND)<<5;
252         data[0] |= (period-2)<<3;
253     } else if (st->mode == MODE_CELT_ONLY)
254     {
255         int tmp = st->bandwidth-BANDWIDTH_MEDIUMBAND;
256         if (tmp < 0)
257             tmp = 0;
258         data[0] = 0x80;
259         data[0] |= tmp << 5;
260         data[0] |= period<<3;
261     } else /* Hybrid */
262     {
263         data[0] = 0x60;
264         data[0] |= (st->bandwidth-BANDWIDTH_SUPERWIDEBAND)<<4;
265         data[0] |= (period-2)<<3;
266     }
267     data[0] |= (st->stream_channels==2)<<2;
268     /*printf ("%x\n", (int)data[0]);*/
269
270 #if OPUS_TEST_RANGE_CODER_STATE
271     st->rangeFinal = enc.rng;
272 #endif
273
274     return ret+1;
275 }
276
277 void opus_encoder_ctl(OpusEncoder *st, int request, ...)
278 {
279     va_list ap;
280
281     va_start(ap, request);
282
283     switch (request)
284     {
285         case OPUS_SET_MODE_REQUEST:
286         {
287             int value = va_arg(ap, int);
288             st->mode = value;
289         }
290         break;
291         case OPUS_GET_MODE_REQUEST:
292         {
293             int *value = va_arg(ap, int*);
294             *value = st->mode;
295         }
296         break;
297         case OPUS_SET_BITRATE_REQUEST:
298         {
299             int value = va_arg(ap, int);
300             st->bitrate_bps = value;
301         }
302         break;
303         case OPUS_GET_BITRATE_REQUEST:
304         {
305             int *value = va_arg(ap, int*);
306             *value = st->bitrate_bps;
307         }
308         break;
309         case OPUS_SET_BANDWIDTH_REQUEST:
310         {
311             int value = va_arg(ap, int);
312             st->bandwidth = value;
313             if (st->bandwidth == BANDWIDTH_NARROWBAND) {
314                 st->silk_mode.maxInternalSampleRate = 8000;
315             } else if (st->bandwidth == BANDWIDTH_MEDIUMBAND) {
316                 st->silk_mode.maxInternalSampleRate = 12000;
317             } else {
318                 st->silk_mode.maxInternalSampleRate = 16000;
319             }
320         }
321         break;
322         case OPUS_GET_BANDWIDTH_REQUEST:
323         {
324             int *value = va_arg(ap, int*);
325             *value = st->bandwidth;
326         }
327         break;
328         case OPUS_SET_DTX_FLAG_REQUEST:
329         {
330             int value = va_arg(ap, int);
331             st->silk_mode.useDTX = value;
332         }
333         break;
334         case OPUS_GET_DTX_FLAG_REQUEST:
335         {
336             int *value = va_arg(ap, int*);
337             *value = st->silk_mode.useDTX;
338         }
339         break;
340         case OPUS_SET_COMPLEXITY_REQUEST:
341         {
342             int value = va_arg(ap, int);
343             st->silk_mode.complexity = value;
344             celt_encoder_ctl(st->celt_enc, CELT_SET_COMPLEXITY(value));
345         }
346         break;
347         case OPUS_GET_COMPLEXITY_REQUEST:
348         {
349             int *value = va_arg(ap, int*);
350             *value = st->silk_mode.complexity;
351         }
352         break;
353         case OPUS_SET_INBAND_FEC_FLAG_REQUEST:
354         {
355             int value = va_arg(ap, int);
356             st->silk_mode.useInBandFEC = value;
357         }
358         break;
359         case OPUS_GET_INBAND_FEC_FLAG_REQUEST:
360         {
361             int *value = va_arg(ap, int*);
362             *value = st->silk_mode.useInBandFEC;
363         }
364         break;
365         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
366         {
367             int value = va_arg(ap, int);
368             st->silk_mode.packetLossPercentage = value;
369         }
370         break;
371         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
372         {
373             int *value = va_arg(ap, int*);
374             *value = st->silk_mode.packetLossPercentage;
375         }
376         break;
377         case OPUS_SET_VBR_FLAG_REQUEST:
378         {
379             int value = va_arg(ap, int);
380             st->use_vbr = value;
381             st->silk_mode.useCBR = 1-value;
382         }
383         break;
384         case OPUS_GET_VBR_FLAG_REQUEST:
385         {
386             int *value = va_arg(ap, int*);
387             *value = st->use_vbr;
388         }
389         break;
390         default:
391             fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);
392             break;
393     }
394
395     va_end(ap);
396 }
397
398 void opus_encoder_destroy(OpusEncoder *st)
399 {
400         free(st);
401 }
402
403 #if OPUS_TEST_RANGE_CODER_STATE
404 int opus_encoder_get_final_range(OpusEncoder *st)
405 {
406     return st->rangeFinal;
407 }
408 #endif