PLC fix
[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 int opus_decode(OpusDecoder *st, const unsigned char *data,
77                 int len, short *pcm, int frame_size)
78 {
79         int i, silk_ret=0, celt_ret=0;
80         ec_dec dec;
81         ec_byte_buffer buf;
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_byte_readinit(&buf,(unsigned char*)data,len);
119         ec_dec_init(&dec,&buf);
120     } else {
121         audiosize = frame_size;
122     }
123
124     if (audiosize > frame_size)
125     {
126         fprintf(stderr, "PCM buffer too small");
127         return -1;
128     } else {
129         frame_size = audiosize;
130     }
131
132     /* SILK processing */
133     if (st->mode != MODE_CELT_ONLY)
134     {
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         do {
154             /* Call SILK decoder */
155             silk_ret = SKP_Silk_SDK_Decode( st->silk_dec, &DecControl, data == NULL, &dec, len, pcm_ptr, &silk_frame_size );
156             if( silk_ret ) {
157                 fprintf (stderr, "SILK decode error\n");
158                 /* Handle error */
159             }
160             pcm_ptr += silk_frame_size;
161         } while( DecControl.moreInternalDecoderFrames );
162     } else {
163         for (i=0;i<frame_size*st->channels;i++)
164             pcm[i] = 0;
165     }
166
167     if (st->mode == MODE_HYBRID)
168     {
169         /* This should be adjusted based on the SILK bandwidth */
170         celt_decoder_ctl(st->celt_dec, CELT_SET_START_BAND(17));
171     } else {
172         celt_decoder_ctl(st->celt_dec, CELT_SET_START_BAND(0));
173     }
174
175     if (st->mode != MODE_SILK_ONLY)
176     {
177         int endband;
178
179             switch(st->bandwidth)
180             {
181             case BANDWIDTH_NARROWBAND:
182                 endband = 13;
183                 break;
184             case BANDWIDTH_WIDEBAND:
185                 endband = 17;
186                 break;
187             case BANDWIDTH_SUPERWIDEBAND:
188                 endband = 19;
189                 break;
190             case BANDWIDTH_FULLBAND:
191                 endband = 21;
192                 break;
193             }
194             celt_decoder_ctl(st->celt_dec, CELT_SET_END_BAND(endband));
195             celt_decoder_ctl(st->celt_dec, CELT_SET_CHANNELS(st->stream_channels));
196
197         /* Decode CELT */
198         celt_ret = celt_decode_with_ec(st->celt_dec, data, len, pcm_celt, frame_size, &dec);
199         for (i=0;i<frame_size*st->channels;i++)
200             pcm[i] = ADD_SAT16(pcm[i], pcm_celt[i]);
201     }
202         return celt_ret<0 ? celt_ret : audiosize;
203
204 }
205
206 void opus_decoder_ctl(OpusDecoder *st, int request, ...)
207 {
208     va_list ap;
209
210     va_start(ap, request);
211
212     switch (request)
213     {
214         case OPUS_SET_MODE_REQUEST:
215         {
216             int value = va_arg(ap, int);
217             st->mode = value;
218         }
219         break;
220         case OPUS_GET_MODE_REQUEST:
221         {
222             int *value = va_arg(ap, int*);
223             *value = st->mode;
224         }
225         break;
226         case OPUS_SET_BANDWIDTH_REQUEST:
227         {
228             int value = va_arg(ap, int);
229             st->bandwidth = value;
230         }
231         break;
232         case OPUS_GET_BANDWIDTH_REQUEST:
233         {
234             int *value = va_arg(ap, int*);
235             *value = st->bandwidth;
236         }
237         break;
238         default:
239             fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);
240             break;
241     }
242
243     va_end(ap);
244 }
245
246 void opus_decoder_destroy(OpusDecoder *st)
247 {
248         free(st);
249 }