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