Making sure the decoder always outputs at least 2.5 ms
[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 #include "stack_alloc.h"
42 #include "float_cast.h"
43
44 #ifdef FIXED_POINT
45 #define celt_decode_native celt_decode
46 #else
47 #define celt_decode_native celt_decode_float
48 #endif
49
50 /* Make sure everything's aligned to 4 bytes (this may need to be increased
51    on really weird architectures) */
52 static inline int align(int i)
53 {
54         return (i+3)&-4;
55 }
56
57 int opus_decoder_get_size(int channels)
58 {
59         int silkDecSizeBytes, celtDecSizeBytes;
60         int ret;
61     ret = silk_Get_Decoder_Size( &silkDecSizeBytes );
62         if(ret)
63                 return 0;
64         silkDecSizeBytes = align(silkDecSizeBytes);
65     celtDecSizeBytes = celt_decoder_get_size(channels);
66     return align(sizeof(OpusDecoder))+silkDecSizeBytes+celtDecSizeBytes;
67
68 }
69
70 OpusDecoder *opus_decoder_init(OpusDecoder *st, int Fs, int channels)
71 {
72         void *silk_dec;
73         CELTDecoder *celt_dec;
74         int ret, silkDecSizeBytes;
75
76         if (channels<1 || channels > 2)
77             return NULL;
78         memset(st, 0, opus_decoder_get_size(channels));
79         /* Initialize SILK encoder */
80     ret = silk_Get_Decoder_Size( &silkDecSizeBytes );
81     if( ret ) {
82         return NULL;
83     }
84     silkDecSizeBytes = align(silkDecSizeBytes);
85     st->silk_dec_offset = align(sizeof(OpusDecoder));
86     st->celt_dec_offset = st->silk_dec_offset+silkDecSizeBytes;
87     silk_dec = (char*)st+st->silk_dec_offset;
88     celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
89     st->stream_channels = st->channels = channels;
90
91     st->Fs = Fs;
92
93     /* Reset decoder */
94     ret = silk_InitDecoder( silk_dec );
95     if( ret ) {
96         goto failure;
97     }
98
99         /* Initialize CELT decoder */
100         celt_decoder_init(celt_dec, Fs, channels, &ret);
101         if (ret != CELT_OK)
102                 goto failure;
103     celt_decoder_ctl(celt_dec, CELT_SET_SIGNALLING(0));
104
105         st->prev_mode = 0;
106         st->frame_size = Fs/400;
107         return st;
108 failure:
109     free(st);
110     return NULL;
111 }
112
113 OpusDecoder *opus_decoder_create(int Fs, int channels)
114 {
115     char *raw_state = (char*)malloc(opus_decoder_get_size(channels));
116     if (raw_state == NULL)
117         return NULL;
118     return opus_decoder_init((OpusDecoder*)raw_state, Fs, channels);
119 }
120
121 static void smooth_fade(const opus_val16 *in1, const opus_val16 *in2, opus_val16 *out,
122         int overlap, int channels, const opus_val16 *window, int Fs)
123 {
124         int i, c;
125         int inc = 48000/Fs;
126         for (c=0;c<channels;c++)
127         {
128                 for (i=0;i<overlap;i++)
129                 {
130                     opus_val16 w = MULT16_16_Q15(window[i*inc], window[i*inc]);
131                     out[i*channels+c] = SHR32(MAC16_16(MULT16_16(w,in2[i*channels+c]),
132                             Q15ONE-w, in1[i*channels+c]), 15);
133                 }
134         }
135 }
136
137 static int opus_packet_get_mode(const unsigned char *data)
138 {
139         int mode;
140     if (data[0]&0x80)
141     {
142         mode = MODE_CELT_ONLY;
143     } else if ((data[0]&0x60) == 0x60)
144     {
145         mode = MODE_HYBRID;
146     } else {
147
148         mode = MODE_SILK_ONLY;
149     }
150     return mode;
151 }
152
153 static int opus_decode_frame(OpusDecoder *st, const unsigned char *data,
154                 int len, opus_val16 *pcm, int frame_size, int decode_fec)
155 {
156         void *silk_dec;
157         CELTDecoder *celt_dec;
158         int i, silk_ret=0, celt_ret=0;
159         ec_dec dec;
160     silk_DecControlStruct DecControl;
161     opus_int32 silk_frame_size;
162     VARDECL(opus_int16, pcm_silk);
163     VARDECL(opus_val16, pcm_transition);
164
165     int audiosize;
166     int mode;
167     int transition=0;
168     int start_band;
169     int redundancy=0;
170     int redundancy_bytes = 0;
171     int celt_to_silk=0;
172     int c;
173     int F2_5, F5, F10, F20;
174     const opus_val16 *window;
175     ALLOC_STACK;
176
177     silk_dec = (char*)st+st->silk_dec_offset;
178     celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
179     F20 = st->Fs/50;
180     F10 = F20>>1;
181     F5 = F10>>1;
182     F2_5 = F5>>1;
183     if (frame_size < F2_5)
184        return OPUS_BUFFER_TOO_SMALL;
185     /* Payloads of 1 (2 including ToC) or 0 trigger the PLC/DTX */
186     if (len<=1)
187     {
188         data = NULL;
189         /* In that case, don't conceal more than what the ToC says */
190         /* FIXME: What if st->frame_size has never been set? */
191         frame_size = IMIN(frame_size, st->frame_size);
192     }
193     if (data != NULL)
194     {
195         audiosize = st->frame_size;
196         mode = st->mode;
197         ec_dec_init(&dec,(unsigned char*)data,len);
198     } else {
199         audiosize = frame_size;
200
201         if (st->prev_mode == 0)
202         {
203                 /* If we haven't got any packet yet, all we can do is return zeros */
204                 for (i=0;i<audiosize*st->channels;i++)
205                         pcm[i] = 0;
206                 RESTORE_STACK;
207                 return audiosize;
208         } else {
209                 mode = st->prev_mode;
210         }
211     }
212
213     ALLOC(pcm_transition, F5*st->channels, opus_val16);
214
215     if (data!=NULL && !st->prev_redundancy && mode != st->prev_mode && st->prev_mode > 0
216                 && !(mode == MODE_SILK_ONLY && st->prev_mode == MODE_HYBRID)
217                 && !(mode == MODE_HYBRID && st->prev_mode == MODE_SILK_ONLY))
218     {
219         transition = 1;
220         if (mode == MODE_CELT_ONLY)
221             opus_decode_frame(st, NULL, 0, pcm_transition, IMIN(F5, audiosize), 0);
222     }
223     if (audiosize > frame_size)
224     {
225         fprintf(stderr, "PCM buffer too small: %d vs %d (mode = %d)\n", audiosize, frame_size, mode);
226         RESTORE_STACK;
227         return OPUS_BAD_ARG;
228     } else {
229         frame_size = audiosize;
230     }
231
232     ALLOC(pcm_silk, frame_size*st->channels, opus_int16);
233     ALLOC(redundant_audio, F5*st->channels, opus_val16);
234
235     /* SILK processing */
236     if (mode != MODE_CELT_ONLY)
237     {
238         int lost_flag, decoded_samples;
239         opus_int16 *pcm_ptr = pcm_silk;
240
241         if (st->prev_mode==MODE_CELT_ONLY)
242                 silk_InitDecoder( silk_dec );
243
244         DecControl.API_sampleRate = st->Fs;
245         DecControl.nChannelsAPI      = st->channels;
246         DecControl.nChannelsInternal = st->stream_channels;
247         DecControl.payloadSize_ms = 1000 * audiosize / st->Fs;
248         if( mode == MODE_SILK_ONLY ) {
249             if( st->bandwidth == OPUS_BANDWIDTH_NARROWBAND ) {
250                 DecControl.internalSampleRate = 8000;
251             } else if( st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND ) {
252                 DecControl.internalSampleRate = 12000;
253             } else if( st->bandwidth == OPUS_BANDWIDTH_WIDEBAND ) {
254                 DecControl.internalSampleRate = 16000;
255             } else {
256                 DecControl.internalSampleRate = 16000;
257                 SKP_assert( 0 );
258             }
259         } else {
260             /* Hybrid mode */
261             DecControl.internalSampleRate = 16000;
262         }
263
264         lost_flag = data == NULL ? 1 : 2 * decode_fec;
265         decoded_samples = 0;
266         do {
267             /* Call SILK decoder */
268             int first_frame = decoded_samples == 0;
269             silk_ret = silk_Decode( silk_dec, &DecControl,
270                 lost_flag, first_frame, &dec, pcm_ptr, &silk_frame_size );
271             if( silk_ret ) {
272                 if (lost_flag) {
273                         /* PLC failure should not be fatal */
274                         silk_frame_size = frame_size;
275                         for (i=0;i<frame_size*st->channels;i++)
276                                 pcm_ptr[i] = 0;
277                 } else {
278                    RESTORE_STACK;
279                    return OPUS_CORRUPTED_DATA;
280                 }
281             }
282             pcm_ptr += silk_frame_size * st->channels;
283             decoded_samples += silk_frame_size;
284         } while( decoded_samples < frame_size );
285     }
286
287     start_band = 0;
288     if (mode != MODE_CELT_ONLY && data != NULL)
289     {
290         /* Check if we have a redundant 0-8 kHz band */
291         redundancy = ec_dec_bit_logp(&dec, 12);
292         if (redundancy)
293         {
294             celt_to_silk = ec_dec_bit_logp(&dec, 1);
295             if (mode == MODE_HYBRID)
296                 redundancy_bytes = 2 + ec_dec_uint(&dec, 256);
297             else {
298                 redundancy_bytes = len - ((ec_tell(&dec)+7)>>3);
299                 /* Can only happen on an invalid packet */
300                 if (redundancy_bytes<0)
301                 {
302                         redundancy_bytes = 0;
303                         redundancy = 0;
304                 }
305             }
306             len -= redundancy_bytes;
307             if (len<0) {
308                RESTORE_STACK;
309                return OPUS_CORRUPTED_DATA;
310             }
311             /* Shrink decoder because of raw bits */
312             dec.storage -= redundancy_bytes;
313         }
314     }
315     if (mode != MODE_CELT_ONLY)
316         start_band = 17;
317
318     {
319         int endband=21;
320
321         switch(st->bandwidth)
322         {
323         case OPUS_BANDWIDTH_NARROWBAND:
324             endband = 13;
325             break;
326         case OPUS_BANDWIDTH_MEDIUMBAND:
327         case OPUS_BANDWIDTH_WIDEBAND:
328             endband = 17;
329             break;
330         case OPUS_BANDWIDTH_SUPERWIDEBAND:
331             endband = 19;
332             break;
333         case OPUS_BANDWIDTH_FULLBAND:
334             endband = 21;
335             break;
336         }
337         celt_decoder_ctl(celt_dec, CELT_SET_END_BAND(endband));
338         celt_decoder_ctl(celt_dec, CELT_SET_CHANNELS(st->stream_channels));
339     }
340
341     if (redundancy)
342         transition = 0;
343
344     if (transition && mode != MODE_CELT_ONLY)
345         opus_decode_frame(st, NULL, 0, pcm_transition, IMIN(F5, audiosize), 0);
346
347     /* 5 ms redundant frame for CELT->SILK*/
348     if (redundancy && celt_to_silk)
349     {
350         celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
351         celt_decode_native(celt_dec, data+len, redundancy_bytes, redundant_audio, F5);
352         celt_decoder_ctl(celt_dec, CELT_RESET_STATE);
353     }
354
355     /* MUST be after PLC */
356     celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(start_band));
357
358     if (transition)
359         celt_decoder_ctl(celt_dec, CELT_RESET_STATE);
360
361     if (mode != MODE_SILK_ONLY)
362     {
363         int celt_frame_size = IMIN(F20, frame_size);
364         /* Decode CELT */
365         celt_ret = celt_decode_with_ec(celt_dec, decode_fec?NULL:data, len, pcm, celt_frame_size, &dec);
366     } else {
367        for (i=0;i<frame_size*st->channels;i++)
368           pcm[i] = 0;
369     }
370
371     if (mode != MODE_CELT_ONLY)
372     {
373 #ifdef FIXED_POINT
374         for (i=0;i<frame_size*st->channels;i++)
375             pcm[i] = SAT16(pcm[i] + pcm_silk[i]);
376 #else
377         for (i=0;i<frame_size*st->channels;i++)
378             pcm[i] = pcm[i] + (1./32768.)*pcm_silk[i];
379 #endif
380     }
381
382     {
383         const CELTMode *celt_mode;
384         celt_decoder_ctl(celt_dec, CELT_GET_MODE(&celt_mode));
385         window = celt_mode->window;
386     }
387
388     /* 5 ms redundant frame for SILK->CELT */
389     if (redundancy && !celt_to_silk)
390     {
391         celt_decoder_ctl(celt_dec, CELT_RESET_STATE);
392         celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
393
394         celt_decode_native(celt_dec, data+len, redundancy_bytes, redundant_audio, F5);
395         smooth_fade(pcm+st->channels*(frame_size-F2_5), redundant_audio+st->channels*F2_5,
396                         pcm+st->channels*(frame_size-F2_5), F2_5, st->channels, window, st->Fs);
397     }
398     if (redundancy && celt_to_silk)
399     {
400         for (c=0;c<st->channels;c++)
401         {
402             for (i=0;i<F2_5;i++)
403                 pcm[st->channels*i+c] = redundant_audio[st->channels*i+c];
404         }
405         smooth_fade(redundant_audio+st->channels*F2_5, pcm+st->channels*F2_5,
406                 pcm+st->channels*F2_5, F2_5, st->channels, window, st->Fs);
407     }
408     if (transition)
409     {
410         for (i=0;i<st->channels*F2_5;i++)
411                 pcm[i] = pcm_transition[i];
412         if (audiosize >= F5)
413             smooth_fade(pcm_transition+st->channels*F2_5, pcm+st->channels*F2_5,
414                     pcm+st->channels*F2_5, F2_5,
415                     st->channels, window, st->Fs);
416     }
417
418     st->rangeFinal = dec.rng;
419
420     st->prev_mode = mode;
421     st->prev_redundancy = redundancy;
422     RESTORE_STACK;
423         return celt_ret<0 ? celt_ret : audiosize;
424
425 }
426
427 static int parse_size(const unsigned char *data, int len, short *size)
428 {
429         if (len<1)
430         {
431                 *size = -1;
432                 return -1;
433         } else if (data[0]<252)
434         {
435                 *size = data[0];
436                 return 1;
437         } else if (len<2)
438         {
439                 *size = -1;
440                 return -1;
441         } else {
442                 *size = 4*data[1] + data[0];
443                 return 2;
444         }
445 }
446
447 int opus_packet_parse(const unsigned char *data, int len,
448       unsigned char *out_toc, const unsigned char *frames[48],
449       short size[48], const unsigned char **payload)
450 {
451    int i, bytes;
452    int count;
453    unsigned char ch, toc;
454    int framesize;
455
456    if (size==NULL)
457       return OPUS_BAD_ARG;
458
459    framesize = opus_packet_get_samples_per_frame(data, 48000);
460
461    toc = *data++;
462    len--;
463    switch (toc&0x3)
464    {
465    /* One frame */
466    case 0:
467       count=1;
468       size[0] = len;
469       break;
470       /* Two CBR frames */
471    case 1:
472       count=2;
473       if (len&0x1)
474          return OPUS_CORRUPTED_DATA;
475       size[0] = size[1] = len/2;
476       break;
477       /* Two VBR frames */
478    case 2:
479       count = 2;
480       bytes = parse_size(data, len, size);
481       len -= bytes;
482       if (size[0]<0 || size[0] > len)
483          return OPUS_CORRUPTED_DATA;
484       data += bytes;
485       size[1] = len-size[0];
486       break;
487       /* Multiple CBR/VBR frames (from 0 to 120 ms) */
488    case 3:
489       if (len<1)
490          return OPUS_CORRUPTED_DATA;
491       /* Number of frames encoded in bits 0 to 5 */
492       ch = *data++;
493       count = ch&0x3F;
494       if (count <= 0 || framesize*count > 5760)
495           return OPUS_CORRUPTED_DATA;
496       len--;
497       /* Padding flag is bit 6 */
498       if (ch&0x40)
499       {
500          int padding=0;
501          int p;
502          do {
503             if (len<=0)
504                return OPUS_CORRUPTED_DATA;
505             p = *data++;
506             len--;
507             padding += p==255 ? 254: p;
508          } while (p==255);
509          len -= padding;
510       }
511       if (len<0)
512          return OPUS_CORRUPTED_DATA;
513       /* VBR flag is bit 7 */
514       if (ch&0x80)
515       {
516          /* VBR case */
517          int last_size=len;
518          for (i=0;i<count-1;i++)
519          {
520             bytes = parse_size(data, len, size+i);
521             len -= bytes;
522             if (size[i]<0 || size[i] > len)
523                return OPUS_CORRUPTED_DATA;
524             data += bytes;
525             last_size -= bytes+size[i];
526          }
527          if (last_size<0)
528             return OPUS_CORRUPTED_DATA;
529          size[count-1]=last_size;
530       } else {
531          /* CBR case */
532          int sz = len/count;
533          if (sz*count!=len)
534             return OPUS_CORRUPTED_DATA;
535          for (i=0;i<count;i++)
536             size[i] = sz;
537       }
538       break;
539    }
540    /* Because it's not encoded explicitly, it's possible the size of the
541        last packet (or all the packets, for the CBR case) is larger than
542        1275.
543       Reject them here.*/
544    if (size[count-1] > 1275)
545       return OPUS_CORRUPTED_DATA;
546
547    if (frames)
548    {
549       for (i=0;i<count;i++)
550       {
551          frames[i] = data;
552          data += size[i];
553       }
554    }
555
556    if (out_toc)
557       *out_toc = toc;
558
559    if (payload)
560       *payload = data;
561
562    return count;
563 }
564
565 #ifdef FIXED_POINT
566 int opus_decode(OpusDecoder *st, const unsigned char *data,
567       int len, opus_val16 *pcm, int frame_size, int decode_fec)
568 #else
569 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
570                 int len, opus_val16 *pcm, int frame_size, int decode_fec)
571 #endif
572 {
573         int i, nb_samples;
574         int count;
575         unsigned char toc;
576         /* 48 x 2.5 ms = 120 ms */
577         short size[48];
578         if (len==0 || data==NULL)
579             return opus_decode_frame(st, NULL, 0, pcm, frame_size, 0);
580         else if (len<0)
581                 return OPUS_BAD_ARG;
582         st->mode = opus_packet_get_mode(data);
583         st->bandwidth = opus_packet_get_bandwidth(data);
584         st->frame_size = opus_packet_get_samples_per_frame(data, st->Fs);
585         st->stream_channels = opus_packet_get_nb_channels(data);
586
587         count = opus_packet_parse(data, len, &toc, NULL, size, &data);
588         if (count < 0)
589            return count;
590
591         if (count*st->frame_size > frame_size)
592                 return OPUS_BAD_ARG;
593         nb_samples=0;
594         for (i=0;i<count;i++)
595         {
596                 int ret;
597                 ret = opus_decode_frame(st, data, size[i], pcm, frame_size-nb_samples, decode_fec);
598                 if (ret<0)
599                         return ret;
600                 data += size[i];
601                 pcm += ret*st->channels;
602                 nb_samples += ret;
603         }
604         return nb_samples;
605 }
606
607 #ifdef FIXED_POINT
608
609 #ifndef DISABLE_FLOAT_API
610 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
611       int len, float *pcm, int frame_size, int decode_fec)
612 {
613    VARDECL(opus_int16, out);
614    int ret, i;
615    ALLOC_STACK;
616
617    ALLOC(out, frame_size*st->channels, opus_int16);
618
619    ret = opus_decode(st, data, len, out, frame_size, decode_fec);
620    if (ret > 0)
621    {
622       for (i=0;i<ret*st->channels;i++)
623          pcm[i] = (1./32768.)*(out[i]);
624    }
625    RESTORE_STACK;
626    return ret;
627 }
628 #endif
629
630 #else
631 int opus_decode(OpusDecoder *st, const unsigned char *data,
632       int len, opus_int16 *pcm, int frame_size, int decode_fec)
633 {
634    VARDECL(float, out);
635    int ret, i;
636    ALLOC_STACK;
637
638    ALLOC(out, frame_size*st->channels, float);
639
640    ret = opus_decode_float(st, data, len, out, frame_size, decode_fec);
641    if (ret > 0)
642    {
643       for (i=0;i<ret*st->channels;i++)
644          pcm[i] = FLOAT2INT16(out[i]);
645    }
646    RESTORE_STACK;
647    return ret;
648 }
649 #endif
650
651 int opus_decoder_ctl(OpusDecoder *st, int request, ...)
652 {
653     va_list ap;
654
655     va_start(ap, request);
656
657     switch (request)
658     {
659         case OPUS_GET_MODE_REQUEST:
660         {
661             int *value = va_arg(ap, int*);
662             *value = st->prev_mode;
663         }
664         break;
665         case OPUS_SET_BANDWIDTH_REQUEST:
666         {
667             int value = va_arg(ap, int);
668             st->bandwidth = value;
669         }
670         break;
671         case OPUS_GET_BANDWIDTH_REQUEST:
672         {
673             int *value = va_arg(ap, int*);
674             *value = st->bandwidth;
675         }
676         break;
677         default:
678             fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);
679             break;
680     }
681
682     va_end(ap);
683     return OPUS_OK;
684 }
685
686 void opus_decoder_destroy(OpusDecoder *st)
687 {
688         free(st);
689 }
690
691 int opus_decoder_get_final_range(OpusDecoder *st)
692 {
693     return st->rangeFinal;
694 }
695
696 int opus_packet_get_bandwidth(const unsigned char *data)
697 {
698         int bandwidth;
699     if (data[0]&0x80)
700     {
701         bandwidth = OPUS_BANDWIDTH_MEDIUMBAND + ((data[0]>>5)&0x3);
702         if (bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
703             bandwidth = OPUS_BANDWIDTH_NARROWBAND;
704     } else if ((data[0]&0x60) == 0x60)
705     {
706         bandwidth = (data[0]&0x10) ? OPUS_BANDWIDTH_FULLBAND : OPUS_BANDWIDTH_SUPERWIDEBAND;
707     } else {
708
709         bandwidth = OPUS_BANDWIDTH_NARROWBAND + ((data[0]>>5)&0x3);
710     }
711     return bandwidth;
712 }
713
714 int opus_packet_get_samples_per_frame(const unsigned char *data, int Fs)
715 {
716         int audiosize;
717     if (data[0]&0x80)
718     {
719         audiosize = ((data[0]>>3)&0x3);
720         audiosize = (Fs<<audiosize)/400;
721     } else if ((data[0]&0x60) == 0x60)
722     {
723         audiosize = (data[0]&0x08) ? Fs/50 : Fs/100;
724     } else {
725
726         audiosize = ((data[0]>>3)&0x3);
727         if (audiosize == 3)
728             audiosize = Fs*60/1000;
729         else
730             audiosize = (Fs<<audiosize)/100;
731     }
732     return audiosize;
733 }
734
735 int opus_packet_get_nb_channels(const unsigned char *data)
736 {
737     return (data[0]&0x4) ? 2 : 1;
738 }
739
740 int opus_packet_get_nb_frames(const unsigned char packet[], int len)
741 {
742         int count;
743         if (len<1)
744                 return OPUS_BAD_ARG;
745         count = packet[0]&0x3;
746         if (count==0)
747                 return 1;
748         else if (count!=3)
749                 return 2;
750         else if (len<2)
751                 return OPUS_CORRUPTED_DATA;
752         else
753                 return packet[1]&0x3F;
754 }
755
756 int opus_decoder_get_nb_samples(const OpusDecoder *dec, const unsigned char packet[], int len)
757 {
758         int samples;
759         int count = opus_packet_get_nb_frames(packet, len);
760         samples = count*opus_packet_get_samples_per_frame(packet, dec->Fs);
761         /* Can't have more than 120 ms */
762         if (samples*25 > dec->Fs*3)
763                 return OPUS_CORRUPTED_DATA;
764         else
765                 return samples;
766 }
767