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