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