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