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