Make opus_decoder_create set its error code.
[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 <stdarg.h>
33 #include "celt.h"
34 #include "opus.h"
35 #include "entdec.h"
36 #include "modes.h"
37 #include "silk_API.h"
38 #include "stack_alloc.h"
39 #include "float_cast.h"
40 #include "opus_private.h"
41 #include "os_support.h"
42
43 struct OpusDecoder {
44    int          celt_dec_offset;
45    int          silk_dec_offset;
46    int          channels;
47    opus_int32   Fs;          /** Sampling rate (at the API level) */
48
49    /* Everything beyond this point gets cleared on a reset */
50 #define OPUS_DECODER_RESET_START stream_channels
51    int          stream_channels;
52
53    int          bandwidth;
54    int          mode;
55    int          prev_mode;
56    int          frame_size;
57    int          prev_redundancy;
58
59    opus_uint32  rangeFinal;
60 };
61
62 #ifdef FIXED_POINT
63 static inline opus_int16 SAT16(opus_int32 x) {
64     return x > 32767 ? 32767 : x < -32768 ? -32768 : (opus_int16)x;
65 };
66 #endif
67
68
69 int opus_decoder_get_size(int channels)
70 {
71    int silkDecSizeBytes, celtDecSizeBytes;
72    int ret;
73    ret = silk_Get_Decoder_Size( &silkDecSizeBytes );
74    if(ret)
75       return 0;
76    silkDecSizeBytes = align(silkDecSizeBytes);
77    celtDecSizeBytes = celt_decoder_get_size(channels);
78    return align(sizeof(OpusDecoder))+silkDecSizeBytes+celtDecSizeBytes;
79 }
80
81 int opus_decoder_init(OpusDecoder *st, opus_int32 Fs, int channels)
82 {
83    void *silk_dec;
84    CELTDecoder *celt_dec;
85    int ret, silkDecSizeBytes;
86
87    if (channels<1 || channels > 2)
88       return OPUS_BAD_ARG;
89    OPUS_CLEAR((char*)st, opus_decoder_get_size(channels));
90    /* Initialize SILK encoder */
91    ret = silk_Get_Decoder_Size( &silkDecSizeBytes );
92    if( ret ) {
93       return OPUS_INTERNAL_ERROR;
94    }
95    silkDecSizeBytes = align(silkDecSizeBytes);
96    st->silk_dec_offset = align(sizeof(OpusDecoder));
97    st->celt_dec_offset = st->silk_dec_offset+silkDecSizeBytes;
98    silk_dec = (char*)st+st->silk_dec_offset;
99    celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
100    st->stream_channels = st->channels = channels;
101
102    st->Fs = Fs;
103
104    /* Reset decoder */
105    ret = silk_InitDecoder( silk_dec );
106    if( ret ) {
107       goto failure;
108    }
109
110    /* Initialize CELT decoder */
111    ret = celt_decoder_init(celt_dec, Fs, channels);
112    if (ret != OPUS_OK)
113       goto failure;
114    celt_decoder_ctl(celt_dec, CELT_SET_SIGNALLING(0));
115
116    st->prev_mode = 0;
117    st->frame_size = Fs/400;
118    return OPUS_OK;
119 failure:
120    opus_free(st);
121    return OPUS_INTERNAL_ERROR;
122 }
123
124 OpusDecoder *opus_decoder_create(opus_int32 Fs, int channels, int *error)
125 {
126    int ret;
127    OpusDecoder *st = (OpusDecoder *)opus_alloc(opus_decoder_get_size(channels));
128    if (st == NULL)
129    {
130       if (error)
131          *error = OPUS_ALLOC_FAIL;
132       return NULL;
133    }
134    ret = opus_decoder_init(st, Fs, channels);
135    if (error)
136       *error = ret;
137    if (ret != OPUS_OK)
138    {
139       opus_free(st);
140       st = NULL;
141    }
142    return st;
143 }
144
145 static void smooth_fade(const opus_val16 *in1, const opus_val16 *in2, opus_val16 *out,
146         int overlap, int channels, const opus_val16 *window, opus_int32 Fs)
147 {
148         int i, c;
149         int inc = 48000/Fs;
150         for (c=0;c<channels;c++)
151         {
152                 for (i=0;i<overlap;i++)
153                 {
154                     opus_val16 w = MULT16_16_Q15(window[i*inc], window[i*inc]);
155                     out[i*channels+c] = SHR32(MAC16_16(MULT16_16(w,in2[i*channels+c]),
156                             Q15ONE-w, in1[i*channels+c]), 15);
157                 }
158         }
159 }
160
161 static int opus_packet_get_mode(const unsigned char *data)
162 {
163         int mode;
164     if (data[0]&0x80)
165     {
166         mode = MODE_CELT_ONLY;
167     } else if ((data[0]&0x60) == 0x60)
168     {
169         mode = MODE_HYBRID;
170     } else {
171
172         mode = MODE_SILK_ONLY;
173     }
174     return mode;
175 }
176
177 static int opus_decode_frame(OpusDecoder *st, const unsigned char *data,
178                 int len, opus_val16 *pcm, int frame_size, int decode_fec)
179 {
180     void *silk_dec;
181     CELTDecoder *celt_dec;
182     int i, silk_ret=0, celt_ret=0;
183     ec_dec dec;
184     silk_DecControlStruct DecControl;
185     opus_int32 silk_frame_size;
186     VARDECL(opus_int16, pcm_silk);
187     VARDECL(opus_val16, pcm_transition);
188     VARDECL(opus_val16, redundant_audio);
189
190     int audiosize;
191     int mode;
192     int transition=0;
193     int start_band;
194     int redundancy=0;
195     int redundancy_bytes = 0;
196     int celt_to_silk=0;
197     int c;
198     int F2_5, F5, F10, F20;
199     const opus_val16 *window;
200     opus_uint32 redundant_rng = 0;
201     ALLOC_STACK;
202
203     silk_dec = (char*)st+st->silk_dec_offset;
204     celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
205     F20 = st->Fs/50;
206     F10 = F20>>1;
207     F5 = F10>>1;
208     F2_5 = F5>>1;
209     if (frame_size < F2_5)
210        return OPUS_BUFFER_TOO_SMALL;
211     /* Payloads of 1 (2 including ToC) or 0 trigger the PLC/DTX */
212     if (len<=1)
213     {
214         data = NULL;
215         /* In that case, don't conceal more than what the ToC says */
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_with_ec(celt_dec, data+len, redundancy_bytes, redundant_audio, F5, NULL);
377         celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_RANGE(&redundant_rng));
378         celt_decoder_ctl(celt_dec, OPUS_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, OPUS_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, OPUS_RESET_STATE);
418         celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
419
420         celt_decode_with_ec(celt_dec, data+len, redundancy_bytes, redundant_audio, F5, NULL);
421         celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_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 int opus_decode_native(OpusDecoder *st, const unsigned char *data,
634       int len, opus_val16 *pcm, int frame_size, int decode_fec, int self_delimited, int *packet_offset)
635 {
636         int i, nb_samples;
637         int count, offset;
638         unsigned char toc;
639         int tot_offset;
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
647         tot_offset = 0;
648         st->mode = opus_packet_get_mode(data);
649         st->bandwidth = opus_packet_get_bandwidth(data);
650         st->frame_size = opus_packet_get_samples_per_frame(data, st->Fs);
651         st->stream_channels = opus_packet_get_nb_channels(data);
652
653         count = opus_packet_parse_impl(data, len, self_delimited, &toc, NULL, size, &offset);
654         if (count < 0)
655            return count;
656
657         data += offset;
658         tot_offset += offset;
659
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                 tot_offset += size[i];
671                 pcm += ret*st->channels;
672                 nb_samples += ret;
673         }
674         if (packet_offset != NULL)
675            *packet_offset = tot_offset;
676         return nb_samples;
677 }
678
679 #ifdef FIXED_POINT
680
681 int opus_decode(OpusDecoder *st, const unsigned char *data,
682       int len, opus_val16 *pcm, int frame_size, int decode_fec)
683 {
684    return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL);
685 }
686
687 #ifndef DISABLE_FLOAT_API
688 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
689       int len, float *pcm, int frame_size, int decode_fec)
690 {
691    VARDECL(opus_int16, out);
692    int ret, i;
693    ALLOC_STACK;
694
695    ALLOC(out, frame_size*st->channels, opus_int16);
696
697    ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL);
698    if (ret > 0)
699    {
700       for (i=0;i<ret*st->channels;i++)
701          pcm[i] = (1./32768.)*(out[i]);
702    }
703    RESTORE_STACK;
704    return ret;
705 }
706 #endif
707
708
709 #else
710 int opus_decode(OpusDecoder *st, const unsigned char *data,
711       int len, opus_int16 *pcm, int frame_size, int decode_fec)
712 {
713    VARDECL(float, out);
714    int ret, i;
715    ALLOC_STACK;
716
717    ALLOC(out, frame_size*st->channels, float);
718
719    ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL);
720    if (ret > 0)
721    {
722       for (i=0;i<ret*st->channels;i++)
723          pcm[i] = FLOAT2INT16(out[i]);
724    }
725    RESTORE_STACK;
726    return ret;
727 }
728
729 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
730         int len, opus_val16 *pcm, int frame_size, int decode_fec)
731 {
732    return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL);
733 }
734
735 #endif
736
737 int opus_decoder_ctl(OpusDecoder *st, int request, ...)
738 {
739    int ret = OPUS_OK;
740    va_list ap;
741
742    va_start(ap, request);
743
744    switch (request)
745    {
746    case OPUS_GET_BANDWIDTH_REQUEST:
747    {
748       opus_int32 *value = va_arg(ap, opus_int32*);
749       *value = st->bandwidth;
750    }
751    break;
752    case OPUS_GET_FINAL_RANGE_REQUEST:
753    {
754       opus_uint32 *value = va_arg(ap, opus_uint32*);
755       *value = st->rangeFinal;
756    }
757    break;
758    case OPUS_RESET_STATE:
759    {
760       void *silk_dec;
761       CELTDecoder *celt_dec;
762
763       silk_dec = (char*)st+st->silk_dec_offset;
764       celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
765
766       OPUS_CLEAR((char*)&st->OPUS_DECODER_RESET_START,
767             opus_decoder_get_size(st->channels)-
768             ((char*)&st->OPUS_DECODER_RESET_START - (char*)st));
769
770       celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
771       silk_InitDecoder( silk_dec );
772       st->stream_channels = st->channels;
773       st->frame_size = st->Fs/400;
774    }
775    break;
776    default:
777       /*fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);*/
778       ret = OPUS_UNIMPLEMENTED;
779       break;
780    }
781
782    va_end(ap);
783    return ret;
784 }
785
786 void opus_decoder_destroy(OpusDecoder *st)
787 {
788         opus_free(st);
789 }
790
791
792 int opus_packet_get_bandwidth(const unsigned char *data)
793 {
794         int bandwidth;
795     if (data[0]&0x80)
796     {
797         bandwidth = OPUS_BANDWIDTH_MEDIUMBAND + ((data[0]>>5)&0x3);
798         if (bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
799             bandwidth = OPUS_BANDWIDTH_NARROWBAND;
800     } else if ((data[0]&0x60) == 0x60)
801     {
802         bandwidth = (data[0]&0x10) ? OPUS_BANDWIDTH_FULLBAND : OPUS_BANDWIDTH_SUPERWIDEBAND;
803     } else {
804
805         bandwidth = OPUS_BANDWIDTH_NARROWBAND + ((data[0]>>5)&0x3);
806     }
807     return bandwidth;
808 }
809
810 int opus_packet_get_samples_per_frame(const unsigned char *data, opus_int32 Fs)
811 {
812     int audiosize;
813     if (data[0]&0x80)
814     {
815         audiosize = ((data[0]>>3)&0x3);
816         audiosize = (Fs<<audiosize)/400;
817     } else if ((data[0]&0x60) == 0x60)
818     {
819         audiosize = (data[0]&0x08) ? Fs/50 : Fs/100;
820     } else {
821
822         audiosize = ((data[0]>>3)&0x3);
823         if (audiosize == 3)
824             audiosize = Fs*60/1000;
825         else
826             audiosize = (Fs<<audiosize)/100;
827     }
828     return audiosize;
829 }
830
831 int opus_packet_get_nb_channels(const unsigned char *data)
832 {
833     return (data[0]&0x4) ? 2 : 1;
834 }
835
836 int opus_packet_get_nb_frames(const unsigned char packet[], int len)
837 {
838         int count;
839         if (len<1)
840                 return OPUS_BAD_ARG;
841         count = packet[0]&0x3;
842         if (count==0)
843                 return 1;
844         else if (count!=3)
845                 return 2;
846         else if (len<2)
847                 return OPUS_CORRUPTED_DATA;
848         else
849                 return packet[1]&0x3F;
850 }
851
852 int opus_decoder_get_nb_samples(const OpusDecoder *dec, const unsigned char packet[], int len)
853 {
854         int samples;
855         int count = opus_packet_get_nb_frames(packet, len);
856         samples = count*opus_packet_get_samples_per_frame(packet, dec->Fs);
857         /* Can't have more than 120 ms */
858         if (samples*25 > dec->Fs*3)
859                 return OPUS_CORRUPTED_DATA;
860         else
861                 return samples;
862 }