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