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