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