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