Removes pointers from the Opus state
[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 "celt.h"
36 #include "opus_decoder.h"
37 #include "entdec.h"
38 #include "modes.h"
39 #include "SKP_Silk_SDK_API.h"
40
41
42 OpusDecoder *opus_decoder_create(int Fs, int channels)
43 {
44         void *silk_dec;
45         CELTDecoder *celt_dec;
46     char *raw_state;
47         int ret, silkDecSizeBytes, celtDecSizeBytes;
48         OpusDecoder *st;
49
50         /* Initialize SILK encoder */
51     ret = SKP_Silk_SDK_Get_Decoder_Size( &silkDecSizeBytes );
52     if( ret ) {
53         /* Handle error */
54     }
55     celtDecSizeBytes = celt_decoder_get_size(channels);
56     raw_state = calloc(sizeof(OpusDecoder)+silkDecSizeBytes+celtDecSizeBytes, 1);
57     st = (OpusDecoder*)raw_state;
58     st->silk_dec_offset = sizeof(OpusDecoder);
59     st->celt_dec_offset = sizeof(OpusDecoder)+silkDecSizeBytes;
60     silk_dec = raw_state+st->silk_dec_offset;
61     celt_dec = (CELTDecoder*)(raw_state+st->celt_dec_offset);
62     st->stream_channels = st->channels = channels;
63
64     st->Fs = Fs;
65
66     /* Reset decoder */
67     ret = SKP_Silk_SDK_InitDecoder( silk_dec );
68     if( ret ) {
69         /* Handle error */
70     }
71
72         /* Initialize CELT decoder */
73         celt_decoder_init(celt_dec, Fs, channels, NULL);
74     celt_decoder_ctl(celt_dec, CELT_SET_SIGNALLING(0));
75
76         st->prev_mode = 0;
77         return st;
78 }
79
80 static void smooth_fade(const short *in1, const short *in2, short *out,
81         int overlap, int channels, const celt_word16 *window, int Fs)
82 {
83         int i, c;
84         int inc = 48000/Fs;
85         for (c=0;c<channels;c++)
86         {
87                 for (i=0;i<overlap;i++)
88                 {
89                     celt_word16 w = MULT16_16_Q15(window[i*inc], window[i*inc]);
90                     out[i*channels+c] = SHR32(MAC16_16(MULT16_16(w,in2[i*channels+c]),
91                             Q15ONE-w, in1[i*channels+c]), 15);
92                 }
93         }
94 }
95
96 static int opus_packet_get_mode(const unsigned char *data)
97 {
98         int mode;
99     if (data[0]&0x80)
100     {
101         mode = MODE_CELT_ONLY;
102     } else if ((data[0]&0x60) == 0x60)
103     {
104         mode = MODE_HYBRID;
105     } else {
106
107         mode = MODE_SILK_ONLY;
108     }
109     return mode;
110 }
111
112 static int opus_decode_frame(OpusDecoder *st, const unsigned char *data,
113                 int len, short *pcm, int frame_size, int decode_fec)
114 {
115         void *silk_dec;
116         CELTDecoder *celt_dec;
117         int i, silk_ret=0, celt_ret=0;
118         ec_dec dec;
119     SKP_SILK_SDK_DecControlStruct DecControl;
120     SKP_int32 silk_frame_size;
121     short pcm_celt[960*2];
122     short pcm_transition[960*2];
123     int audiosize;
124     int mode;
125     int transition=0;
126     int start_band;
127     int redundancy=0;
128     int redundancy_bytes = 0;
129     int celt_to_silk=0;
130     short redundant_audio[240*2];
131     int c;
132     int F2_5, F5, F10;
133     const celt_word16 *window;
134
135     silk_dec = (char*)st+st->silk_dec_offset;
136     celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
137     F10 = st->Fs/100;
138     F5 = F10>>1;
139     F2_5 = F5>>1;
140     /* Payloads of 1 (2 including ToC) or 0 trigger the PLC/DTX */
141     if (len<=1)
142         data = NULL;
143
144         audiosize = st->frame_size;
145     if (data != NULL)
146     {
147         mode = st->mode;
148         ec_dec_init(&dec,(unsigned char*)data,len);
149     } else {
150         mode = st->prev_mode;
151     }
152
153     if (st->stream_channels > st->channels)
154         return OPUS_CORRUPTED_DATA;
155
156     if (data!=NULL && !st->prev_redundancy && mode != st->prev_mode && st->prev_mode > 0
157                 && !(mode == MODE_SILK_ONLY && st->prev_mode == MODE_HYBRID)
158                 && !(mode == MODE_HYBRID && st->prev_mode == MODE_SILK_ONLY))
159     {
160         transition = 1;
161         if (mode == MODE_CELT_ONLY)
162             opus_decode_frame(st, NULL, 0, pcm_transition, IMAX(F10, audiosize), 0);
163     }
164     if (audiosize > frame_size)
165     {
166         fprintf(stderr, "PCM buffer too small: %d vs %d (mode = %d)\n", audiosize, frame_size, mode);
167         return OPUS_BAD_ARG;
168     } else {
169         frame_size = audiosize;
170     }
171
172     /* SILK processing */
173     if (mode != MODE_CELT_ONLY)
174     {
175         int lost_flag, decoded_samples;
176         SKP_int16 *pcm_ptr = pcm;
177
178         if (st->prev_mode==MODE_CELT_ONLY)
179                 SKP_Silk_SDK_InitDecoder( silk_dec );
180
181         DecControl.API_sampleRate = st->Fs;
182         DecControl.payloadSize_ms = 1000 * audiosize / st->Fs;
183         if( mode == MODE_SILK_ONLY ) {
184             if( st->bandwidth == BANDWIDTH_NARROWBAND ) {
185                 DecControl.internalSampleRate = 8000;
186             } else if( st->bandwidth == BANDWIDTH_MEDIUMBAND ) {
187                 DecControl.internalSampleRate = 12000;
188             } else if( st->bandwidth == BANDWIDTH_WIDEBAND ) {
189                 DecControl.internalSampleRate = 16000;
190             } else {
191                 DecControl.internalSampleRate = 16000;
192                 SKP_assert( 0 );
193             }
194         } else {
195             /* Hybrid mode */
196             DecControl.internalSampleRate = 16000;
197         }
198         DecControl.nChannels = st->channels;
199
200         lost_flag = data == NULL ? 1 : 2 * decode_fec;
201         decoded_samples = 0;
202         do {
203             /* Call SILK decoder */
204             int first_frame = decoded_samples == 0;
205             silk_ret = SKP_Silk_SDK_Decode( silk_dec, &DecControl,
206                 lost_flag, first_frame, &dec, pcm_ptr, &silk_frame_size );
207             if( silk_ret ) {
208                 fprintf (stderr, "SILK decode error\n");
209                 /* Handle error */
210             }
211             pcm_ptr += silk_frame_size * st->channels;
212             decoded_samples += silk_frame_size;
213         } while( decoded_samples < frame_size );
214     } else {
215         for (i=0;i<frame_size*st->channels;i++)
216             pcm[i] = 0;
217     }
218
219     start_band = 0;
220     if (mode != MODE_CELT_ONLY && data != NULL)
221     {
222         /* Check if we have a redundant 0-8 kHz band */
223         redundancy = ec_dec_bit_logp(&dec, 12);
224         if (redundancy)
225         {
226             celt_to_silk = ec_dec_bit_logp(&dec, 1);
227             if (mode == MODE_HYBRID)
228                 redundancy_bytes = 2 + ec_dec_uint(&dec, 256);
229             else
230                 redundancy_bytes = len - ((ec_tell(&dec)+7)>>3);
231             len -= redundancy_bytes;
232             if (len<0)
233                 return CELT_CORRUPTED_DATA;
234             /* Shrink decoder because of raw bits */
235             dec.storage -= redundancy_bytes;
236         }
237     }
238     if (mode != MODE_CELT_ONLY)
239         start_band = 17;
240
241     if (mode != MODE_SILK_ONLY)
242     {
243         int endband=21;
244
245         switch(st->bandwidth)
246         {
247         case BANDWIDTH_NARROWBAND:
248             endband = 13;
249             break;
250         case BANDWIDTH_WIDEBAND:
251             endband = 17;
252             break;
253         case BANDWIDTH_SUPERWIDEBAND:
254             endband = 19;
255             break;
256         case BANDWIDTH_FULLBAND:
257             endband = 21;
258             break;
259         }
260         celt_decoder_ctl(celt_dec, CELT_SET_END_BAND(endband));
261         celt_decoder_ctl(celt_dec, CELT_SET_CHANNELS(st->stream_channels));
262     }
263
264     if (redundancy)
265         transition = 0;
266
267     if (transition && mode != MODE_CELT_ONLY)
268         opus_decode_frame(st, NULL, 0, pcm_transition, IMAX(F10, audiosize), 0);
269
270     /* 5 ms redundant frame for CELT->SILK*/
271     if (redundancy && celt_to_silk)
272     {
273         celt_decode(celt_dec, data+len, redundancy_bytes, redundant_audio, F5);
274         celt_decoder_ctl(celt_dec, CELT_RESET_STATE);
275     }
276
277     /* MUST be after PLC */
278     celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(start_band));
279
280     if (transition)
281         celt_decoder_ctl(celt_dec, CELT_RESET_STATE);
282
283     if (mode != MODE_SILK_ONLY)
284     {
285         /* Decode CELT */
286         celt_ret = celt_decode_with_ec(celt_dec, decode_fec?NULL:data, len, pcm_celt, frame_size, &dec);
287         for (i=0;i<frame_size*st->channels;i++)
288             pcm[i] = ADD_SAT16(pcm[i], pcm_celt[i]);
289     }
290
291
292     {
293         const CELTMode *celt_mode;
294         celt_decoder_ctl(celt_dec, CELT_GET_MODE(&celt_mode));
295         window = celt_mode->window;
296     }
297
298     /* 5 ms redundant frame for SILK->CELT */
299     if (redundancy && !celt_to_silk)
300     {
301         celt_decoder_ctl(celt_dec, CELT_RESET_STATE);
302         celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
303
304         celt_decode(celt_dec, data+len, redundancy_bytes, redundant_audio, F5);
305         smooth_fade(pcm+st->channels*(frame_size-F2_5), redundant_audio+st->channels*F2_5,
306                         pcm+st->channels*(frame_size-F2_5), F2_5, st->channels, window, st->Fs);
307     }
308     if (redundancy && celt_to_silk)
309     {
310         for (c=0;c<st->channels;c++)
311         {
312             for (i=0;i<F2_5;i++)
313                 pcm[st->channels*i+c] = redundant_audio[st->channels*i];
314         }
315         smooth_fade(redundant_audio+st->channels*F2_5, pcm+st->channels*F2_5,
316                 pcm+st->channels*F2_5, F2_5, st->channels, window, st->Fs);
317     }
318     if (transition)
319     {
320         for (i=0;i<F2_5;i++)
321                 pcm[i] = pcm_transition[i];
322         if (audiosize >= F5)
323             smooth_fade(pcm_transition+F2_5, pcm+F2_5, pcm+F2_5, F2_5,
324                     st->channels, window, st->Fs);
325     }
326 #if OPUS_TEST_RANGE_CODER_STATE
327     st->rangeFinal = dec.rng;
328 #endif
329
330     st->prev_mode = mode;
331     st->prev_redundancy = redundancy;
332         return celt_ret<0 ? celt_ret : audiosize;
333
334 }
335
336 static int parse_size(const unsigned char *data, int len, short *size)
337 {
338         if (len<1)
339         {
340                 *size = -1;
341                 return -1;
342         } else if (data[0]<252)
343         {
344                 *size = data[0];
345                 return 1;
346         } else if (len<2)
347         {
348                 *size = -1;
349                 return -1;
350         } else {
351                 *size = 4*data[1] + data[0];
352                 return 2;
353         }
354 }
355
356 int opus_decode(OpusDecoder *st, const unsigned char *data,
357                 int len, short *pcm, int frame_size, int decode_fec)
358 {
359         int i, bytes, nb_samples;
360         int count;
361         unsigned char ch, toc;
362         /* 48 x 2.5 ms = 120 ms */
363         short size[48];
364         if (len==0 || data==NULL)
365             return opus_decode_frame(st, NULL, 0, pcm, frame_size, 0);
366         else if (len<0)
367                 return CELT_BAD_ARG;
368         st->mode = opus_packet_get_mode(data);
369         st->bandwidth = opus_packet_get_bandwidth(data);
370         st->frame_size = opus_packet_get_samples_per_frame(data, st->Fs);
371         st->stream_channels = opus_packet_get_nb_channels(data);
372         toc = *data++;
373         len--;
374         switch (toc&0x3)
375         {
376         /* One frame */
377         case 0:
378                 count=1;
379                 size[0] = len;
380                 break;
381                 /* Two CBR frames */
382         case 1:
383                 count=2;
384                 if (len&0x1)
385                         return OPUS_CORRUPTED_DATA;
386                 size[0] = size[1] = len/2;
387                 break;
388                 /* Two VBR frames */
389         case 2:
390                 count = 2;
391                 bytes = parse_size(data, len, size);
392                 len -= bytes;
393                 if (size[0]<0 || size[0] > len)
394                         return OPUS_CORRUPTED_DATA;
395                 data += bytes;
396                 size[1] = len-size[0];
397                 break;
398                 /* Multiple CBR/VBR frames (from 0 to 120 ms) */
399         case 3:
400                 if (len<1)
401                         return OPUS_CORRUPTED_DATA;
402                 /* Number of frames encoded in bits 0 to 5 */
403                 ch = *data++;
404                 count = ch&0x3F;
405                 if (st->frame_size*count*25 > 3*st->Fs)
406                     return OPUS_CORRUPTED_DATA;
407                 len--;
408                 /* Padding bit */
409                 if (ch&0x40)
410                 {
411                         int padding=0;
412                         int p;
413                         do {
414                                 if (len<=0)
415                                         return OPUS_CORRUPTED_DATA;
416                                 p = *data++;
417                                 len--;
418                                 padding += p==255 ? 254: p;
419                         } while (p==255);
420                         len -= padding;
421                 }
422                 if (len<0)
423                         return OPUS_CORRUPTED_DATA;
424                 /* Bit 7 is VBR flag (bit 6 is ignored) */
425                 if (ch&0x80)
426                 {
427                         /* VBR case */
428                         int last_size=len;
429                         for (i=0;i<count-1;i++)
430                         {
431                                 bytes = parse_size(data, len, size+i);
432                                 len -= bytes;
433                                 if (size[i]<0 || size[i] > len)
434                                         return OPUS_CORRUPTED_DATA;
435                                 data += bytes;
436                                 last_size -= bytes+size[i];
437                         }
438                         if (last_size<0)
439                                 return OPUS_CORRUPTED_DATA;
440                         if (count)
441                                 size[count-1]=last_size;
442                 } else {
443                         /* CBR case */
444                         int sz = count != 0 ? len/count : 0;
445                         if (sz*count!=len)
446                                 return OPUS_CORRUPTED_DATA;
447                         for (i=0;i<count;i++)
448                                 size[i] = sz;
449                 }
450                 break;
451         }
452         if (count*st->frame_size > frame_size)
453                 return OPUS_BAD_ARG;
454         nb_samples=0;
455         for (i=0;i<count;i++)
456         {
457                 int ret;
458                 ret = opus_decode_frame(st, data, len, pcm, frame_size-nb_samples, decode_fec);
459                 if (ret<0)
460                         return ret;
461                 data += size[i];
462                 pcm += ret;
463                 nb_samples += ret;
464         }
465         return nb_samples;
466 }
467 int opus_decoder_ctl(OpusDecoder *st, int request, ...)
468 {
469     va_list ap;
470
471     va_start(ap, request);
472
473     switch (request)
474     {
475         case OPUS_GET_MODE_REQUEST:
476         {
477             int *value = va_arg(ap, int*);
478             *value = st->prev_mode;
479         }
480         break;
481         case OPUS_SET_BANDWIDTH_REQUEST:
482         {
483             int value = va_arg(ap, int);
484             st->bandwidth = value;
485         }
486         break;
487         case OPUS_GET_BANDWIDTH_REQUEST:
488         {
489             int *value = va_arg(ap, int*);
490             *value = st->bandwidth;
491         }
492         break;
493         default:
494             fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);
495             break;
496     }
497
498     va_end(ap);
499     return OPUS_OK;
500 }
501
502 void opus_decoder_destroy(OpusDecoder *st)
503 {
504         free(st);
505 }
506
507 #if OPUS_TEST_RANGE_CODER_STATE
508 int opus_decoder_get_final_range(OpusDecoder *st)
509 {
510     return st->rangeFinal;
511 }
512 #endif
513
514
515 int opus_packet_get_bandwidth(const unsigned char *data)
516 {
517         int bandwidth;
518     if (data[0]&0x80)
519     {
520         bandwidth = BANDWIDTH_MEDIUMBAND + ((data[0]>>5)&0x3);
521         if (bandwidth == BANDWIDTH_MEDIUMBAND)
522             bandwidth = BANDWIDTH_NARROWBAND;
523     } else if ((data[0]&0x60) == 0x60)
524     {
525         bandwidth = (data[0]&0x10) ? BANDWIDTH_FULLBAND : BANDWIDTH_SUPERWIDEBAND;
526     } else {
527
528         bandwidth = BANDWIDTH_NARROWBAND + ((data[0]>>5)&0x3);
529     }
530     return bandwidth;
531 }
532
533 int opus_packet_get_samples_per_frame(const unsigned char *data, int Fs)
534 {
535         int audiosize;
536     if (data[0]&0x80)
537     {
538         audiosize = ((data[0]>>3)&0x3);
539         audiosize = (Fs<<audiosize)/400;
540     } else if ((data[0]&0x60) == 0x60)
541     {
542         audiosize = (data[0]&0x08) ? Fs/50 : Fs/100;
543     } else {
544
545         audiosize = ((data[0]>>3)&0x3);
546         if (audiosize == 3)
547             audiosize = Fs*60/1000;
548         else
549             audiosize = (Fs<<audiosize)/100;
550     }
551     return audiosize;
552 }
553
554 int opus_packet_get_nb_channels(const unsigned char *data)
555 {
556     return (data[0]&0x4) ? 2 : 1;
557 }
558
559 int opus_packet_get_nb_frames(const unsigned char packet[], int len)
560 {
561         int count;
562         if (len<1)
563                 return OPUS_BAD_ARG;
564         count = packet[0]&0x3;
565         if (count==0)
566                 return 1;
567         else if (count!=3)
568                 return 2;
569         else if (len<2)
570                 return OPUS_CORRUPTED_DATA;
571         else
572                 return packet[1]&0x3F;
573 }
574
575 int opus_decoder_get_nb_samples(const OpusDecoder *dec, const unsigned char packet[], int len)
576 {
577         int samples;
578         int count = opus_packet_get_nb_frames(packet, len);
579         samples = count*opus_packet_get_samples_per_frame(packet, dec->Fs);
580         /* Can't have more than 120 ms */
581         if (samples*25 > dec->Fs*3)
582                 return OPUS_CORRUPTED_DATA;
583         else
584                 return samples;
585 }
586