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