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