624b7fe2309fc4a1078b799bd13026f4d2a345c7
[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         return st;
71 }
72
73 int opus_decode(OpusDecoder *st, const unsigned char *data,
74                 int len, short *pcm, int frame_size, int decode_fec)
75 {
76         int i, silk_ret=0, celt_ret=0;
77         ec_dec dec;
78     SKP_SILK_SDK_DecControlStruct DecControl;
79     SKP_int32 silk_frame_size;
80     short pcm_celt[960*2];
81     int audiosize;
82
83     /* Payloads of 1 (2 including ToC) or 0 trigger the PLC/DTX */
84     if (len<=2)
85         data = NULL;
86
87     if (data != NULL)
88     {
89         /* Decoding mode/bandwidth/framesize from first byte */
90         if (data[0]&0x80)
91         {
92             st->mode = MODE_CELT_ONLY;
93             st->bandwidth = BANDWIDTH_MEDIUMBAND + ((data[0]>>5)&0x3);
94             if (st->bandwidth == BANDWIDTH_MEDIUMBAND)
95                 st->bandwidth = BANDWIDTH_NARROWBAND;
96             audiosize = ((data[0]>>3)&0x3);
97             audiosize = (st->Fs<<audiosize)/400;
98         } else if ((data[0]&0x60) == 0x60)
99         {
100             st->mode = MODE_HYBRID;
101             st->bandwidth = (data[0]&0x10) ? BANDWIDTH_FULLBAND : BANDWIDTH_SUPERWIDEBAND;
102             audiosize = (data[0]&0x08) ? st->Fs/50 : st->Fs/100;
103         } else {
104
105             st->mode = MODE_SILK_ONLY;
106             st->bandwidth = BANDWIDTH_NARROWBAND + ((data[0]>>5)&0x3);
107             audiosize = ((data[0]>>3)&0x3);
108             if (audiosize == 3)
109                 audiosize = st->Fs*60/1000;
110             else
111                 audiosize = (st->Fs<<audiosize)/100;
112         }
113         st->stream_channels = (data[0]&0x4) ? 2 : 1;
114         /*printf ("%d %d %d\n", st->mode, st->bandwidth, audiosize);*/
115
116         len -= 1;
117         data += 1;
118         ec_dec_init(&dec,(unsigned char*)data,len);
119     } else {
120         audiosize = frame_size;
121     }
122
123     if (audiosize > frame_size)
124     {
125         fprintf(stderr, "PCM buffer too small");
126         return -1;
127     } else {
128         frame_size = audiosize;
129     }
130
131     /* SILK processing */
132     if (st->mode != MODE_CELT_ONLY)
133     {
134         int lost_flag, decoded_samples;
135         SKP_int16 *pcm_ptr = pcm;
136         DecControl.API_sampleRate = st->Fs;
137         DecControl.payloadSize_ms = 1000 * audiosize / st->Fs;
138         if( st->mode == MODE_SILK_ONLY ) {
139             if( st->bandwidth == BANDWIDTH_NARROWBAND ) {
140                 DecControl.internalSampleRate = 8000;
141             } else if( st->bandwidth == BANDWIDTH_MEDIUMBAND ) {
142                 DecControl.internalSampleRate = 12000;
143             } else if( st->bandwidth == BANDWIDTH_WIDEBAND ) {
144                 DecControl.internalSampleRate = 16000;
145             } else {
146                 SKP_assert( 0 );
147             }
148         } else {
149             /* Hybrid mode */
150             DecControl.internalSampleRate = 16000;
151         }
152
153         lost_flag = data == NULL ? 1 : 2 * decode_fec;
154         decoded_samples = 0;
155         do {
156             /* Call SILK decoder */
157             int first_frame = decoded_samples == 0;
158             silk_ret = SKP_Silk_SDK_Decode( st->silk_dec, &DecControl, 
159                 lost_flag, first_frame, &dec, len, pcm_ptr, &silk_frame_size );
160             if( silk_ret ) {
161                 fprintf (stderr, "SILK decode error\n");
162                 /* Handle error */
163             }
164             pcm_ptr += silk_frame_size;
165             decoded_samples += silk_frame_size;
166         } while( decoded_samples < frame_size );
167     } else {
168         for (i=0;i<frame_size*st->channels;i++)
169             pcm[i] = 0;
170     }
171
172     if (st->mode == MODE_HYBRID)
173     {
174         /* This should be adjusted based on the SILK bandwidth */
175         celt_decoder_ctl(st->celt_dec, CELT_SET_START_BAND(17));
176     } else {
177         celt_decoder_ctl(st->celt_dec, CELT_SET_START_BAND(0));
178     }
179
180     if (st->mode != MODE_SILK_ONLY)
181     {
182         int endband;
183
184             switch(st->bandwidth)
185             {
186             case BANDWIDTH_NARROWBAND:
187                 endband = 13;
188                 break;
189             case BANDWIDTH_WIDEBAND:
190                 endband = 17;
191                 break;
192             case BANDWIDTH_SUPERWIDEBAND:
193                 endband = 19;
194                 break;
195             case BANDWIDTH_FULLBAND:
196                 endband = 21;
197                 break;
198             }
199             celt_decoder_ctl(st->celt_dec, CELT_SET_END_BAND(endband));
200             celt_decoder_ctl(st->celt_dec, CELT_SET_CHANNELS(st->stream_channels));
201
202         /* Decode CELT */
203         celt_ret = celt_decode_with_ec(st->celt_dec, data, len, pcm_celt, frame_size, &dec);
204         for (i=0;i<frame_size*st->channels;i++)
205             pcm[i] = ADD_SAT16(pcm[i], pcm_celt[i]);
206     }
207
208 #if OPUS_TEST_RANGE_CODER_STATE
209     st->rangeFinal = dec.rng;
210 #endif
211
212         return celt_ret<0 ? celt_ret : audiosize;
213
214 }
215
216 void opus_decoder_ctl(OpusDecoder *st, int request, ...)
217 {
218     va_list ap;
219
220     va_start(ap, request);
221
222     switch (request)
223     {
224         case OPUS_SET_MODE_REQUEST:
225         {
226             int value = va_arg(ap, int);
227             st->mode = value;
228         }
229         break;
230         case OPUS_GET_MODE_REQUEST:
231         {
232             int *value = va_arg(ap, int*);
233             *value = st->mode;
234         }
235         break;
236         case OPUS_SET_BANDWIDTH_REQUEST:
237         {
238             int value = va_arg(ap, int);
239             st->bandwidth = value;
240         }
241         break;
242         case OPUS_GET_BANDWIDTH_REQUEST:
243         {
244             int *value = va_arg(ap, int*);
245             *value = st->bandwidth;
246         }
247         break;
248         default:
249             fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);
250             break;
251     }
252
253     va_end(ap);
254 }
255
256 void opus_decoder_destroy(OpusDecoder *st)
257 {
258         free(st);
259 }
260
261 #if OPUS_TEST_RANGE_CODER_STATE
262 int opus_decoder_get_final_range(OpusDecoder *st)
263 {
264     return st->rangeFinal;
265 }
266 #endif