opus_packet_parse() now returns the payload offset rather than the pointer
[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], int *payload_offset)
450 {
451    int i, bytes;
452    int count;
453    unsigned char ch, toc;
454    int framesize;
455    const unsigned char *data0 = data;
456
457    if (size==NULL)
458       return OPUS_BAD_ARG;
459
460    framesize = opus_packet_get_samples_per_frame(data, 48000);
461
462    toc = *data++;
463    len--;
464    switch (toc&0x3)
465    {
466    /* One frame */
467    case 0:
468       count=1;
469       size[0] = len;
470       break;
471       /* Two CBR frames */
472    case 1:
473       count=2;
474       if (len&0x1)
475          return OPUS_CORRUPTED_DATA;
476       size[0] = size[1] = len/2;
477       break;
478       /* Two VBR frames */
479    case 2:
480       count = 2;
481       bytes = parse_size(data, len, size);
482       len -= bytes;
483       if (size[0]<0 || size[0] > len)
484          return OPUS_CORRUPTED_DATA;
485       data += bytes;
486       size[1] = len-size[0];
487       break;
488       /* Multiple CBR/VBR frames (from 0 to 120 ms) */
489    case 3:
490       if (len<1)
491          return OPUS_CORRUPTED_DATA;
492       /* Number of frames encoded in bits 0 to 5 */
493       ch = *data++;
494       count = ch&0x3F;
495       if (count <= 0 || framesize*count > 5760)
496           return OPUS_CORRUPTED_DATA;
497       len--;
498       /* Padding flag is bit 6 */
499       if (ch&0x40)
500       {
501          int padding=0;
502          int p;
503          do {
504             if (len<=0)
505                return OPUS_CORRUPTED_DATA;
506             p = *data++;
507             len--;
508             padding += p==255 ? 254: p;
509          } while (p==255);
510          len -= padding;
511       }
512       if (len<0)
513          return OPUS_CORRUPTED_DATA;
514       /* VBR flag is bit 7 */
515       if (ch&0x80)
516       {
517          /* VBR case */
518          int last_size=len;
519          for (i=0;i<count-1;i++)
520          {
521             bytes = parse_size(data, len, size+i);
522             len -= bytes;
523             if (size[i]<0 || size[i] > len)
524                return OPUS_CORRUPTED_DATA;
525             data += bytes;
526             last_size -= bytes+size[i];
527          }
528          if (last_size<0)
529             return OPUS_CORRUPTED_DATA;
530          size[count-1]=last_size;
531       } else {
532          /* CBR case */
533          int sz = len/count;
534          if (sz*count!=len)
535             return OPUS_CORRUPTED_DATA;
536          for (i=0;i<count;i++)
537             size[i] = sz;
538       }
539       break;
540    }
541    /* Because it's not encoded explicitly, it's possible the size of the
542        last packet (or all the packets, for the CBR case) is larger than
543        1275.
544       Reject them here.*/
545    if (size[count-1] > 1275)
546       return OPUS_CORRUPTED_DATA;
547
548    if (frames)
549    {
550       for (i=0;i<count;i++)
551       {
552          frames[i] = data;
553          data += size[i];
554       }
555    }
556
557    if (out_toc)
558       *out_toc = toc;
559
560    if (payload_offset)
561       *payload_offset = data-data0;
562
563    return count;
564 }
565
566 #ifdef FIXED_POINT
567 int opus_decode(OpusDecoder *st, const unsigned char *data,
568       int len, opus_val16 *pcm, int frame_size, int decode_fec)
569 #else
570 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
571                 int len, opus_val16 *pcm, int frame_size, int decode_fec)
572 #endif
573 {
574         int i, nb_samples;
575         int count, offset;
576         unsigned char toc;
577         /* 48 x 2.5 ms = 120 ms */
578         short size[48];
579         if (len==0 || data==NULL)
580             return opus_decode_frame(st, NULL, 0, pcm, frame_size, 0);
581         else if (len<0)
582                 return OPUS_BAD_ARG;
583         st->mode = opus_packet_get_mode(data);
584         st->bandwidth = opus_packet_get_bandwidth(data);
585         st->frame_size = opus_packet_get_samples_per_frame(data, st->Fs);
586         st->stream_channels = opus_packet_get_nb_channels(data);
587
588         count = opus_packet_parse(data, len, &toc, NULL, size, &offset);
589         if (count < 0)
590            return count;
591
592         data += offset;
593         if (count*st->frame_size > frame_size)
594                 return OPUS_BAD_ARG;
595         nb_samples=0;
596         for (i=0;i<count;i++)
597         {
598                 int ret;
599                 ret = opus_decode_frame(st, data, size[i], pcm, frame_size-nb_samples, decode_fec);
600                 if (ret<0)
601                         return ret;
602                 data += size[i];
603                 pcm += ret*st->channels;
604                 nb_samples += ret;
605         }
606         return nb_samples;
607 }
608
609 #ifdef FIXED_POINT
610
611 #ifndef DISABLE_FLOAT_API
612 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
613       int len, float *pcm, int frame_size, int decode_fec)
614 {
615    VARDECL(opus_int16, out);
616    int ret, i;
617    ALLOC_STACK;
618
619    ALLOC(out, frame_size*st->channels, opus_int16);
620
621    ret = opus_decode(st, data, len, out, frame_size, decode_fec);
622    if (ret > 0)
623    {
624       for (i=0;i<ret*st->channels;i++)
625          pcm[i] = (1./32768.)*(out[i]);
626    }
627    RESTORE_STACK;
628    return ret;
629 }
630 #endif
631
632 #else
633 int opus_decode(OpusDecoder *st, const unsigned char *data,
634       int len, opus_int16 *pcm, int frame_size, int decode_fec)
635 {
636    VARDECL(float, out);
637    int ret, i;
638    ALLOC_STACK;
639
640    ALLOC(out, frame_size*st->channels, float);
641
642    ret = opus_decode_float(st, data, len, out, frame_size, decode_fec);
643    if (ret > 0)
644    {
645       for (i=0;i<ret*st->channels;i++)
646          pcm[i] = FLOAT2INT16(out[i]);
647    }
648    RESTORE_STACK;
649    return ret;
650 }
651 #endif
652
653 int opus_decoder_ctl(OpusDecoder *st, int request, ...)
654 {
655     va_list ap;
656
657     va_start(ap, request);
658
659     switch (request)
660     {
661         case OPUS_GET_MODE_REQUEST:
662         {
663             int *value = va_arg(ap, int*);
664             *value = st->prev_mode;
665         }
666         break;
667         case OPUS_SET_BANDWIDTH_REQUEST:
668         {
669             int value = va_arg(ap, int);
670             st->bandwidth = value;
671         }
672         break;
673         case OPUS_GET_BANDWIDTH_REQUEST:
674         {
675             int *value = va_arg(ap, int*);
676             *value = st->bandwidth;
677         }
678         break;
679         default:
680             fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);
681             break;
682     }
683
684     va_end(ap);
685     return OPUS_OK;
686 }
687
688 void opus_decoder_destroy(OpusDecoder *st)
689 {
690         free(st);
691 }
692
693 int opus_decoder_get_final_range(OpusDecoder *st)
694 {
695     return st->rangeFinal;
696 }
697
698 int opus_packet_get_bandwidth(const unsigned char *data)
699 {
700         int bandwidth;
701     if (data[0]&0x80)
702     {
703         bandwidth = OPUS_BANDWIDTH_MEDIUMBAND + ((data[0]>>5)&0x3);
704         if (bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
705             bandwidth = OPUS_BANDWIDTH_NARROWBAND;
706     } else if ((data[0]&0x60) == 0x60)
707     {
708         bandwidth = (data[0]&0x10) ? OPUS_BANDWIDTH_FULLBAND : OPUS_BANDWIDTH_SUPERWIDEBAND;
709     } else {
710
711         bandwidth = OPUS_BANDWIDTH_NARROWBAND + ((data[0]>>5)&0x3);
712     }
713     return bandwidth;
714 }
715
716 int opus_packet_get_samples_per_frame(const unsigned char *data, int Fs)
717 {
718         int audiosize;
719     if (data[0]&0x80)
720     {
721         audiosize = ((data[0]>>3)&0x3);
722         audiosize = (Fs<<audiosize)/400;
723     } else if ((data[0]&0x60) == 0x60)
724     {
725         audiosize = (data[0]&0x08) ? Fs/50 : Fs/100;
726     } else {
727
728         audiosize = ((data[0]>>3)&0x3);
729         if (audiosize == 3)
730             audiosize = Fs*60/1000;
731         else
732             audiosize = (Fs<<audiosize)/100;
733     }
734     return audiosize;
735 }
736
737 int opus_packet_get_nb_channels(const unsigned char *data)
738 {
739     return (data[0]&0x4) ? 2 : 1;
740 }
741
742 int opus_packet_get_nb_frames(const unsigned char packet[], int len)
743 {
744         int count;
745         if (len<1)
746                 return OPUS_BAD_ARG;
747         count = packet[0]&0x3;
748         if (count==0)
749                 return 1;
750         else if (count!=3)
751                 return 2;
752         else if (len<2)
753                 return OPUS_CORRUPTED_DATA;
754         else
755                 return packet[1]&0x3F;
756 }
757
758 int opus_decoder_get_nb_samples(const OpusDecoder *dec, const unsigned char packet[], int len)
759 {
760         int samples;
761         int count = opus_packet_get_nb_frames(packet, len);
762         samples = count*opus_packet_get_samples_per_frame(packet, dec->Fs);
763         /* Can't have more than 120 ms */
764         if (samples*25 > dec->Fs*3)
765                 return OPUS_CORRUPTED_DATA;
766         else
767                 return samples;
768 }
769