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