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