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