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