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