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