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