Merged Koen's encoder changes
[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         if (st->mode == MODE_HYBRID)
179         {
180             int len;
181             celt_encoder_ctl(st->celt_enc, CELT_SET_START_BAND(17));
182
183             len = (ec_enc_tell(&enc, 0)+7)>>3;
184             if( st->use_vbr ) {
185                 nb_compr_bytes = len + (st->bitrate_bps - 12000) * frame_size / (2 * 8 * st->Fs);
186             } else {
187                 /* check if SILK used up too much */
188                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
189             }
190
191         } else {
192             celt_encoder_ctl(st->celt_enc, CELT_SET_START_BAND(0));
193             nb_compr_bytes = bytes_target;
194         }
195
196             for (i=0;i<ENCODER_DELAY_COMPENSATION*st->channels;i++)
197                 pcm_buf[i] = st->delay_buffer[i];
198         for (;i<frame_size*st->channels;i++)
199             pcm_buf[i] = pcm[i-ENCODER_DELAY_COMPENSATION*st->channels];
200
201         ec_byte_shrink(&buf, nb_compr_bytes);
202
203             /* Encode high band with CELT */
204             ret = celt_encode_with_ec(st->celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
205             for (i=0;i<ENCODER_DELAY_COMPENSATION*st->channels;i++)
206                 st->delay_buffer[i] = pcm[frame_size*st->channels-ENCODER_DELAY_COMPENSATION*st->channels+i];
207         } else {
208             ret = (ec_enc_tell(&enc, 0)+7)>>3;
209             ec_enc_done(&enc);
210         }
211
212         /* Signalling the mode in the first byte */
213         data--;
214         framerate = st->Fs/frame_size;
215         period = 0;
216         while (framerate < 400)
217         {
218             framerate <<= 1;
219             period++;
220         }
221     if (st->mode == MODE_SILK_ONLY)
222     {
223         data[0] = (silk_internal_bandwidth-BANDWIDTH_NARROWBAND)<<5;
224         data[0] |= (period-2)<<3;
225     } else if (st->mode == MODE_CELT_ONLY)
226     {
227         int tmp = st->bandwidth-BANDWIDTH_MEDIUMBAND;
228         if (tmp < 0)
229             tmp = 0;
230         data[0] = 0x80;
231         data[0] |= tmp << 5;
232         data[0] |= period<<3;
233     } else /* Hybrid */
234     {
235         data[0] = 0x60;
236         data[0] |= (st->bandwidth-BANDWIDTH_SUPERWIDEBAND)<<4;
237         data[0] |= (period-2)<<3;
238     }
239     data[0] |= (st->stream_channels==2)<<2;
240     /*printf ("%x\n", (int)data[0]);*/
241
242     return ret+1;
243 }
244
245 void opus_encoder_ctl(OpusEncoder *st, int request, ...)
246 {
247     va_list ap;
248
249     va_start(ap, request);
250
251     switch (request)
252     {
253         case OPUS_SET_MODE_REQUEST:
254         {
255             int value = va_arg(ap, int);
256             st->mode = value;
257         }
258         break;
259         case OPUS_GET_MODE_REQUEST:
260         {
261             int *value = va_arg(ap, int*);
262             *value = st->mode;
263         }
264         break;
265         case OPUS_SET_BITRATE_REQUEST:
266         {
267             int value = va_arg(ap, int);
268             st->bitrate_bps = value;
269         }
270         break;
271         case OPUS_GET_BITRATE_REQUEST:
272         {
273             int *value = va_arg(ap, int*);
274             *value = st->bitrate_bps;
275         }
276         break;
277         case OPUS_SET_BANDWIDTH_REQUEST:
278         {
279             int value = va_arg(ap, int);
280             st->bandwidth = value;
281             if (st->bandwidth == BANDWIDTH_NARROWBAND) {
282                 st->silk_mode.maxInternalSampleRate = 8000;
283             } else if (st->bandwidth == BANDWIDTH_MEDIUMBAND) {
284                 st->silk_mode.maxInternalSampleRate = 12000;
285             } else {
286                 st->silk_mode.maxInternalSampleRate = 16000;
287             }
288         }
289         break;
290         case OPUS_GET_BANDWIDTH_REQUEST:
291         {
292             int *value = va_arg(ap, int*);
293             *value = st->bandwidth;
294         }
295         break;
296         case OPUS_SET_DTX_FLAG_REQUEST:
297         {
298             int value = va_arg(ap, int);
299             st->silk_mode.useDTX = value;
300         }
301         break;
302         case OPUS_GET_DTX_FLAG_REQUEST:
303         {
304             int *value = va_arg(ap, int*);
305             *value = st->silk_mode.useDTX;
306         }
307         break;
308         case OPUS_SET_COMPLEXITY_REQUEST:
309         {
310             int value = va_arg(ap, int);
311             st->silk_mode.complexity = value;
312         }
313         break;
314         case OPUS_GET_COMPLEXITY_REQUEST:
315         {
316             int *value = va_arg(ap, int*);
317             *value = st->silk_mode.complexity;
318         }
319         break;
320         case OPUS_SET_INBAND_FEC_FLAG_REQUEST:
321         {
322             int value = va_arg(ap, int);
323             st->silk_mode.useInBandFEC = value;
324         }
325         break;
326         case OPUS_GET_INBAND_FEC_FLAG_REQUEST:
327         {
328             int *value = va_arg(ap, int*);
329             *value = st->silk_mode.useInBandFEC;
330         }
331         break;
332         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
333         {
334             int value = va_arg(ap, int);
335             st->silk_mode.packetLossPercentage = value;
336         }
337         break;
338         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
339         {
340             int *value = va_arg(ap, int*);
341             *value = st->silk_mode.packetLossPercentage;
342         }
343         break;
344         case OPUS_SET_VBR_FLAG_REQUEST:
345         {
346             int value = va_arg(ap, int);
347             st->use_vbr = value;
348             st->silk_mode.useCBR = 1-value;
349         }
350         break;
351         case OPUS_GET_VBR_FLAG_REQUEST:
352         {
353             int *value = va_arg(ap, int*);
354             *value = st->use_vbr;
355         }
356         break;
357         default:
358             fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);
359             break;
360     }
361
362     va_end(ap);
363 }
364
365 void opus_encoder_destroy(OpusEncoder *st)
366 {
367         free(st);
368 }
369