1ebc3ea2e5a37eec30a1fefb615d5558fd1ef0ab
[opus.git] / src / opus_decoder.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_decoder.h"
36 #include "entdec.h"
37 #include "modes.h"
38 #include "SKP_Silk_SDK_API.h"
39
40
41 OpusDecoder *opus_decoder_create(int Fs, int channels)
42 {
43     char *raw_state;
44         int ret, silkDecSizeBytes, celtDecSizeBytes;
45         OpusDecoder *st;
46
47         /* Initialize SILK encoder */
48     ret = SKP_Silk_SDK_Get_Decoder_Size( &silkDecSizeBytes );
49     if( ret ) {
50         /* Handle error */
51     }
52     celtDecSizeBytes = celt_decoder_get_size(channels);
53     raw_state = calloc(sizeof(OpusDecoder)+silkDecSizeBytes+celtDecSizeBytes, 1);
54     st = (OpusDecoder*)raw_state;
55     st->silk_dec = (void*)(raw_state+sizeof(OpusDecoder));
56     st->celt_dec = (CELTDecoder*)(raw_state+sizeof(OpusDecoder)+silkDecSizeBytes);
57     st->stream_channels = st->channels = channels;
58
59     st->Fs = Fs;
60
61     /* Reset decoder */
62     ret = SKP_Silk_SDK_InitDecoder( st->silk_dec );
63     if( ret ) {
64         /* Handle error */
65     }
66
67         /* Initialize CELT decoder */
68         st->celt_dec = celt_decoder_init(st->celt_dec, Fs, channels, NULL);
69
70         st->prev_mode = 0;
71         return st;
72 }
73
74 int opus_decode(OpusDecoder *st, const unsigned char *data,
75                 int len, short *pcm, int frame_size, int decode_fec)
76 {
77         int i, silk_ret=0, celt_ret=0;
78         ec_dec dec;
79     SKP_SILK_SDK_DecControlStruct DecControl;
80     SKP_int32 silk_frame_size;
81     short pcm_celt[960*2];
82     short pcm_transition[960*2];
83     int audiosize;
84     int mode;
85     int transition=0;
86     int start_band;
87     int redundancy;
88
89     /* Payloads of 1 (2 including ToC) or 0 trigger the PLC/DTX */
90     if (len<=2)
91         data = NULL;
92
93     if (data != NULL)
94     {
95         /* Decoding mode/bandwidth/framesize from first byte */
96         if (data[0]&0x80)
97         {
98             mode = MODE_CELT_ONLY;
99             st->bandwidth = BANDWIDTH_MEDIUMBAND + ((data[0]>>5)&0x3);
100             if (st->bandwidth == BANDWIDTH_MEDIUMBAND)
101                 st->bandwidth = BANDWIDTH_NARROWBAND;
102             audiosize = ((data[0]>>3)&0x3);
103             audiosize = (st->Fs<<audiosize)/400;
104         } else if ((data[0]&0x60) == 0x60)
105         {
106             mode = MODE_HYBRID;
107             st->bandwidth = (data[0]&0x10) ? BANDWIDTH_FULLBAND : BANDWIDTH_SUPERWIDEBAND;
108             audiosize = (data[0]&0x08) ? st->Fs/50 : st->Fs/100;
109         } else {
110
111             mode = MODE_SILK_ONLY;
112             st->bandwidth = BANDWIDTH_NARROWBAND + ((data[0]>>5)&0x3);
113             audiosize = ((data[0]>>3)&0x3);
114             if (audiosize == 3)
115                 audiosize = st->Fs*60/1000;
116             else
117                 audiosize = (st->Fs<<audiosize)/100;
118         }
119         st->stream_channels = (data[0]&0x4) ? 2 : 1;
120         /*printf ("%d %d %d\n", st->mode, st->bandwidth, audiosize);*/
121
122         len -= 1;
123         data += 1;
124         ec_dec_init(&dec,(unsigned char*)data,len);
125     } else {
126         audiosize = frame_size;
127         mode = st->prev_mode;
128     }
129
130     if (mode != st->prev_mode && st->prev_mode > 0
131                 && !(mode == MODE_SILK_ONLY && st->prev_mode == MODE_HYBRID)
132                 && !(mode == MODE_HYBRID && st->prev_mode == MODE_SILK_ONLY))
133     {
134         transition = 1;
135         if (mode == MODE_CELT_ONLY && !st->prev_redundancy)
136             opus_decode(st, NULL, 0, pcm_transition, IMAX(480, audiosize), 0);
137     }
138     if (audiosize > frame_size)
139     {
140         fprintf(stderr, "PCM buffer too small");
141         return -1;
142     } else {
143         frame_size = audiosize;
144     }
145
146     /* SILK processing */
147     if (mode != MODE_CELT_ONLY)
148     {
149         int lost_flag, decoded_samples;
150         SKP_int16 *pcm_ptr = pcm;
151
152         if (st->prev_mode==MODE_CELT_ONLY)
153                 SKP_Silk_SDK_InitDecoder( st->silk_dec );
154
155         DecControl.API_sampleRate = st->Fs;
156         DecControl.payloadSize_ms = 1000 * audiosize / st->Fs;
157         if( mode == MODE_SILK_ONLY ) {
158             if( st->bandwidth == BANDWIDTH_NARROWBAND ) {
159                 DecControl.internalSampleRate = 8000;
160             } else if( st->bandwidth == BANDWIDTH_MEDIUMBAND ) {
161                 DecControl.internalSampleRate = 12000;
162             } else if( st->bandwidth == BANDWIDTH_WIDEBAND ) {
163                 DecControl.internalSampleRate = 16000;
164             } else {
165                 SKP_assert( 0 );
166             }
167         } else {
168             /* Hybrid mode */
169             DecControl.internalSampleRate = 16000;
170         }
171
172         lost_flag = data == NULL ? 1 : 2 * decode_fec;
173         decoded_samples = 0;
174         do {
175             /* Call SILK decoder */
176             int first_frame = decoded_samples == 0;
177             silk_ret = SKP_Silk_SDK_Decode( st->silk_dec, &DecControl, 
178                 lost_flag, first_frame, &dec, len, pcm_ptr, &silk_frame_size );
179             if( silk_ret ) {
180                 fprintf (stderr, "SILK decode error\n");
181                 /* Handle error */
182             }
183             pcm_ptr += silk_frame_size;
184             decoded_samples += silk_frame_size;
185         } while( decoded_samples < frame_size );
186     } else {
187         for (i=0;i<frame_size*st->channels;i++)
188             pcm[i] = 0;
189     }
190
191     start_band = 0;
192     if (mode == MODE_HYBRID)
193     {
194         /* Check if we have a redundant 0-8 kHz band */
195         redundancy = ec_dec_bit_logp(&dec, 12);
196         if (!redundancy)
197             start_band = 17;
198     }
199     celt_decoder_ctl(st->celt_dec, CELT_SET_START_BAND(start_band));
200
201     if (redundancy)
202         transition = 0;
203
204     if (transition && mode != MODE_CELT_ONLY)
205         opus_decode(st, NULL, 0, pcm_transition, IMAX(480, audiosize), 0);
206
207     if (mode != MODE_SILK_ONLY)
208     {
209         int endband;
210
211             switch(st->bandwidth)
212             {
213             case BANDWIDTH_NARROWBAND:
214                 endband = 13;
215                 break;
216             case BANDWIDTH_WIDEBAND:
217                 endband = 17;
218                 break;
219             case BANDWIDTH_SUPERWIDEBAND:
220                 endband = 19;
221                 break;
222             case BANDWIDTH_FULLBAND:
223                 endband = 21;
224                 break;
225             }
226             celt_decoder_ctl(st->celt_dec, CELT_SET_END_BAND(endband));
227             celt_decoder_ctl(st->celt_dec, CELT_SET_CHANNELS(st->stream_channels));
228
229             if (st->prev_mode == MODE_SILK_ONLY)
230                 celt_decoder_ctl(st->celt_dec, CELT_RESET_STATE);
231         /* Decode CELT */
232         celt_ret = celt_decode_with_ec(st->celt_dec, decode_fec?NULL:data, len, pcm_celt, frame_size, &dec);
233         for (i=0;i<frame_size*st->channels;i++)
234             pcm[i] = ADD_SAT16(pcm[i], pcm_celt[i]);
235     }
236
237     if (transition)
238     {
239         int plc_length, overlap;
240         if (mode == MODE_CELT_ONLY)
241                 plc_length = IMIN(audiosize, 10+st->Fs/200);
242         else
243                 plc_length = IMIN(audiosize, 10+st->Fs/400);
244         for (i=0;i<plc_length;i++)
245                 pcm[i] = pcm_transition[i];
246
247         overlap = IMIN(480, IMAX(0, audiosize-plc_length));
248         for (i=0;i<overlap;i++)
249                 pcm[plc_length+i] = (i*pcm[plc_length+i] + (overlap-i)*pcm_transition[plc_length+i])/overlap;
250     }
251 #if OPUS_TEST_RANGE_CODER_STATE
252     st->rangeFinal = dec.rng;
253 #endif
254
255     st->prev_mode = mode;
256     st->prev_redundancy = redundancy;
257         return celt_ret<0 ? celt_ret : audiosize;
258
259 }
260
261 void opus_decoder_ctl(OpusDecoder *st, int request, ...)
262 {
263     va_list ap;
264
265     va_start(ap, request);
266
267     switch (request)
268     {
269         case OPUS_GET_MODE_REQUEST:
270         {
271             int *value = va_arg(ap, int*);
272             *value = st->prev_mode;
273         }
274         break;
275         case OPUS_SET_BANDWIDTH_REQUEST:
276         {
277             int value = va_arg(ap, int);
278             st->bandwidth = value;
279         }
280         break;
281         case OPUS_GET_BANDWIDTH_REQUEST:
282         {
283             int *value = va_arg(ap, int*);
284             *value = st->bandwidth;
285         }
286         break;
287         default:
288             fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);
289             break;
290     }
291
292     va_end(ap);
293 }
294
295 void opus_decoder_destroy(OpusDecoder *st)
296 {
297         free(st);
298 }
299
300 #if OPUS_TEST_RANGE_CODER_STATE
301 int opus_decoder_get_final_range(OpusDecoder *st)
302 {
303     return st->rangeFinal;
304 }
305 #endif