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