Update Opus range coder due to CELT refactoring.
[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     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         SKP_int16 *pcm_ptr = pcm;
135         DecControl.API_sampleRate = st->Fs;
136         DecControl.payloadSize_ms = 1000 * audiosize / st->Fs;
137         if( st->mode == MODE_SILK_ONLY ) {
138             if( st->bandwidth == BANDWIDTH_NARROWBAND ) {
139                 DecControl.internalSampleRate = 8000;
140             } else if( st->bandwidth == BANDWIDTH_MEDIUMBAND ) {
141                 DecControl.internalSampleRate = 12000;
142             } else if( st->bandwidth == BANDWIDTH_WIDEBAND ) {
143                 DecControl.internalSampleRate = 16000;
144             } else {
145                 SKP_assert( 0 );
146             }
147         } else {
148             /* Hybrid mode */
149             DecControl.internalSampleRate = 16000;
150         }
151
152         do {
153             /* Call SILK decoder */
154             silk_ret = SKP_Silk_SDK_Decode( st->silk_dec, &DecControl, data == NULL, &dec, len, pcm_ptr, &silk_frame_size );
155             if( silk_ret ) {
156                 fprintf (stderr, "SILK decode error\n");
157                 /* Handle error */
158             }
159             pcm_ptr += silk_frame_size;
160         } while( DecControl.moreInternalDecoderFrames );
161     } else {
162         for (i=0;i<frame_size*st->channels;i++)
163             pcm[i] = 0;
164     }
165
166     if (st->mode == MODE_HYBRID)
167     {
168         /* This should be adjusted based on the SILK bandwidth */
169         celt_decoder_ctl(st->celt_dec, CELT_SET_START_BAND(17));
170     } else {
171         celt_decoder_ctl(st->celt_dec, CELT_SET_START_BAND(0));
172     }
173
174     if (st->mode != MODE_SILK_ONLY)
175     {
176         int endband;
177
178             switch(st->bandwidth)
179             {
180             case BANDWIDTH_NARROWBAND:
181                 endband = 13;
182                 break;
183             case BANDWIDTH_WIDEBAND:
184                 endband = 17;
185                 break;
186             case BANDWIDTH_SUPERWIDEBAND:
187                 endband = 19;
188                 break;
189             case BANDWIDTH_FULLBAND:
190                 endband = 21;
191                 break;
192             }
193             celt_decoder_ctl(st->celt_dec, CELT_SET_END_BAND(endband));
194             celt_decoder_ctl(st->celt_dec, CELT_SET_CHANNELS(st->stream_channels));
195
196         /* Decode CELT */
197         celt_ret = celt_decode_with_ec(st->celt_dec, data, len, pcm_celt, frame_size, &dec);
198         for (i=0;i<frame_size*st->channels;i++)
199             pcm[i] = ADD_SAT16(pcm[i], pcm_celt[i]);
200     }
201
202 #if OPUS_TEST_RANGE_CODER_STATE
203     st->rangeFinal = dec.rng;
204 #endif
205
206         return celt_ret<0 ? celt_ret : audiosize;
207
208 }
209
210 void opus_decoder_ctl(OpusDecoder *st, int request, ...)
211 {
212     va_list ap;
213
214     va_start(ap, request);
215
216     switch (request)
217     {
218         case OPUS_SET_MODE_REQUEST:
219         {
220             int value = va_arg(ap, int);
221             st->mode = value;
222         }
223         break;
224         case OPUS_GET_MODE_REQUEST:
225         {
226             int *value = va_arg(ap, int*);
227             *value = st->mode;
228         }
229         break;
230         case OPUS_SET_BANDWIDTH_REQUEST:
231         {
232             int value = va_arg(ap, int);
233             st->bandwidth = value;
234         }
235         break;
236         case OPUS_GET_BANDWIDTH_REQUEST:
237         {
238             int *value = va_arg(ap, int*);
239             *value = st->bandwidth;
240         }
241         break;
242         default:
243             fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);
244             break;
245     }
246
247     va_end(ap);
248 }
249
250 void opus_decoder_destroy(OpusDecoder *st)
251 {
252         free(st);
253 }
254
255 #if OPUS_TEST_RANGE_CODER_STATE
256 int opus_decoder_get_final_range(OpusDecoder *st)
257 {
258     return st->rangeFinal;
259 }
260 #endif