Making sure redundant frames can never bust the buget
[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_CORRUPTED_DATA;
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                RESTORE_STACK;
328                return OPUS_CORRUPTED_DATA;
329             }
330             /* Shrink decoder because of raw bits */
331             dec.storage -= redundancy_bytes;
332         }
333     }
334     if (mode != MODE_CELT_ONLY)
335         start_band = 17;
336
337     {
338         int endband=21;
339
340         switch(st->bandwidth)
341         {
342         case OPUS_BANDWIDTH_NARROWBAND:
343             endband = 13;
344             break;
345         case OPUS_BANDWIDTH_MEDIUMBAND:
346         case OPUS_BANDWIDTH_WIDEBAND:
347             endband = 17;
348             break;
349         case OPUS_BANDWIDTH_SUPERWIDEBAND:
350             endband = 19;
351             break;
352         case OPUS_BANDWIDTH_FULLBAND:
353             endband = 21;
354             break;
355         }
356         celt_decoder_ctl(celt_dec, CELT_SET_END_BAND(endband));
357         celt_decoder_ctl(celt_dec, CELT_SET_CHANNELS(st->stream_channels));
358     }
359
360     if (redundancy)
361         transition = 0;
362
363     if (transition && mode != MODE_CELT_ONLY)
364         opus_decode_frame(st, NULL, 0, pcm_transition, IMIN(F5, audiosize), 0);
365
366     /* 5 ms redundant frame for CELT->SILK*/
367     if (redundancy && celt_to_silk)
368     {
369         celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
370         celt_decode_with_ec(celt_dec, data+len, redundancy_bytes, redundant_audio, F5, NULL);
371         celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_RANGE(&redundant_rng));
372         celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
373     }
374
375     /* MUST be after PLC */
376     celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(start_band));
377
378     if (transition)
379         celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
380
381     if (mode != MODE_SILK_ONLY)
382     {
383         int celt_frame_size = IMIN(F20, frame_size);
384         /* Decode CELT */
385         celt_ret = celt_decode_with_ec(celt_dec, decode_fec?NULL:data, len, pcm, celt_frame_size, &dec);
386     } else {
387        for (i=0;i<frame_size*st->channels;i++)
388           pcm[i] = 0;
389     }
390
391     if (mode != MODE_CELT_ONLY)
392     {
393 #ifdef FIXED_POINT
394         for (i=0;i<frame_size*st->channels;i++)
395             pcm[i] = SAT16(pcm[i] + pcm_silk[i]);
396 #else
397         for (i=0;i<frame_size*st->channels;i++)
398             pcm[i] = pcm[i] + (1./32768.)*pcm_silk[i];
399 #endif
400     }
401
402     {
403         const CELTMode *celt_mode;
404         celt_decoder_ctl(celt_dec, CELT_GET_MODE(&celt_mode));
405         window = celt_mode->window;
406     }
407
408     /* 5 ms redundant frame for SILK->CELT */
409     if (redundancy && !celt_to_silk)
410     {
411         celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
412         celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
413
414         celt_decode_with_ec(celt_dec, data+len, redundancy_bytes, redundant_audio, F5, NULL);
415         celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_RANGE(&redundant_rng));
416         smooth_fade(pcm+st->channels*(frame_size-F2_5), redundant_audio+st->channels*F2_5,
417                         pcm+st->channels*(frame_size-F2_5), F2_5, st->channels, window, st->Fs);
418     }
419     if (redundancy && celt_to_silk)
420     {
421         for (c=0;c<st->channels;c++)
422         {
423             for (i=0;i<F2_5;i++)
424                 pcm[st->channels*i+c] = redundant_audio[st->channels*i+c];
425         }
426         smooth_fade(redundant_audio+st->channels*F2_5, pcm+st->channels*F2_5,
427                 pcm+st->channels*F2_5, F2_5, st->channels, window, st->Fs);
428     }
429     if (transition)
430     {
431         for (i=0;i<st->channels*F2_5;i++)
432                 pcm[i] = pcm_transition[i];
433         if (audiosize >= F5)
434             smooth_fade(pcm_transition+st->channels*F2_5, pcm+st->channels*F2_5,
435                     pcm+st->channels*F2_5, F2_5,
436                     st->channels, window, st->Fs);
437     }
438
439     if (len <= 1)
440        st->rangeFinal = 0;
441     else
442        st->rangeFinal = dec.rng ^ redundant_rng;
443
444     st->prev_mode = mode;
445     st->prev_redundancy = redundancy;
446     RESTORE_STACK;
447         return celt_ret<0 ? celt_ret : audiosize;
448
449 }
450
451 static int parse_size(const unsigned char *data, int len, short *size)
452 {
453         if (len<1)
454         {
455                 *size = -1;
456                 return -1;
457         } else if (data[0]<252)
458         {
459                 *size = data[0];
460                 return 1;
461         } else if (len<2)
462         {
463                 *size = -1;
464                 return -1;
465         } else {
466                 *size = 4*data[1] + data[0];
467                 return 2;
468         }
469 }
470
471 static int opus_packet_parse_impl(const unsigned char *data, int len,
472       int self_delimited, unsigned char *out_toc,
473       const unsigned char *frames[48], short size[48], int *payload_offset)
474 {
475    int i, bytes;
476    int count;
477    int cbr;
478    unsigned char ch, toc;
479    int framesize;
480    int last_size;
481    const unsigned char *data0 = data;
482
483    if (size==NULL)
484       return OPUS_BAD_ARG;
485
486    framesize = opus_packet_get_samples_per_frame(data, 48000);
487
488    cbr = 0;
489    toc = *data++;
490    len--;
491    last_size = len;
492    switch (toc&0x3)
493    {
494    /* One frame */
495    case 0:
496       count=1;
497       break;
498       /* Two CBR frames */
499    case 1:
500       count=2;
501       cbr = 1;
502       if (!self_delimited)
503       {
504          if (len&0x1)
505             return OPUS_CORRUPTED_DATA;
506          size[0] = last_size = len/2;
507       }
508       break;
509       /* Two VBR frames */
510    case 2:
511       count = 2;
512       bytes = parse_size(data, len, size);
513       len -= bytes;
514       if (size[0]<0 || size[0] > len)
515          return OPUS_CORRUPTED_DATA;
516       data += bytes;
517       last_size = len-size[0];
518       break;
519       /* Multiple CBR/VBR frames (from 0 to 120 ms) */
520    case 3:
521       if (len<1)
522          return OPUS_CORRUPTED_DATA;
523       /* Number of frames encoded in bits 0 to 5 */
524       ch = *data++;
525       count = ch&0x3F;
526       if (count <= 0 || framesize*count > 5760)
527           return OPUS_CORRUPTED_DATA;
528       len--;
529       /* Padding flag is bit 6 */
530       if (ch&0x40)
531       {
532          int padding=0;
533          int p;
534          do {
535             if (len<=0)
536                return OPUS_CORRUPTED_DATA;
537             p = *data++;
538             len--;
539             padding += p==255 ? 254: p;
540          } while (p==255);
541          len -= padding;
542       }
543       if (len<0)
544          return OPUS_CORRUPTED_DATA;
545       /* VBR flag is bit 7 */
546       cbr = !(ch&0x80);
547       if (cbr)
548       {
549          /* VBR case */
550          last_size = len;
551          for (i=0;i<count-1;i++)
552          {
553             bytes = parse_size(data, len, size+i);
554             len -= bytes;
555             if (size[i]<0 || size[i] > len)
556                return OPUS_CORRUPTED_DATA;
557             data += bytes;
558             last_size -= bytes+size[i];
559          }
560          if (last_size<0)
561             return OPUS_CORRUPTED_DATA;
562       } else if (!self_delimited)
563       {
564          /* CBR case */
565          last_size = len/count;
566          if (last_size*count!=len)
567             return OPUS_CORRUPTED_DATA;
568          for (i=0;i<count-1;i++)
569             size[i] = last_size;
570       }
571       break;
572    }
573    /* Self-delimited framing has an extra size for the last frame. */
574    if (self_delimited)
575    {
576       bytes = parse_size(data, len, size+count-1);
577       len -= bytes;
578       if (size[count-1]<0 || size[count-1] > len)
579          return OPUS_CORRUPTED_DATA;
580       data += bytes;
581       /* For CBR packets, apply the size to all the frames. */
582       if (cbr)
583       {
584          if (size[count-1]*count > len)
585             return OPUS_CORRUPTED_DATA;
586          for (i=0;i<count-1;i++)
587             size[i] = size[count-1];
588       } else if(size[count-1] > last_size)
589          return OPUS_CORRUPTED_DATA;
590    } else
591    {
592       /* Because it's not encoded explicitly, it's possible the size of the
593           last packet (or all the packets, for the CBR case) is larger than
594           1275.
595          Reject them here.*/
596       if (last_size > 1275)
597         return OPUS_CORRUPTED_DATA;
598       size[count-1] = last_size;
599    }
600
601    if (frames)
602    {
603       for (i=0;i<count;i++)
604       {
605          frames[i] = data;
606          data += size[i];
607       }
608    }
609
610    if (out_toc)
611       *out_toc = toc;
612
613    if (payload_offset)
614       *payload_offset = data-data0;
615
616    return count;
617 }
618
619 int opus_packet_parse(const unsigned char *data, int len,
620       unsigned char *out_toc, const unsigned char *frames[48],
621       short size[48], int *payload_offset)
622 {
623    return opus_packet_parse_impl(data, len, 0,
624          out_toc, frames, size, payload_offset);
625 }
626
627 int opus_decode_native(OpusDecoder *st, const unsigned char *data,
628       int len, opus_val16 *pcm, int frame_size, int decode_fec, int self_delimited, int *packet_offset)
629 {
630         int i, nb_samples;
631         int count, offset;
632         unsigned char toc;
633         int tot_offset;
634         /* 48 x 2.5 ms = 120 ms */
635         short size[48];
636         if (decode_fec<0 || decode_fec>1)return OPUS_BAD_ARG;
637         if (len==0 || data==NULL)
638             return opus_decode_frame(st, NULL, 0, pcm, frame_size, 0);
639         else if (len<0)
640                 return OPUS_BAD_ARG;
641
642         tot_offset = 0;
643         st->mode = opus_packet_get_mode(data);
644         st->bandwidth = opus_packet_get_bandwidth(data);
645         st->frame_size = opus_packet_get_samples_per_frame(data, st->Fs);
646         st->stream_channels = opus_packet_get_nb_channels(data);
647
648         count = opus_packet_parse_impl(data, len, self_delimited, &toc, NULL, size, &offset);
649         if (count < 0)
650            return count;
651
652         data += offset;
653         tot_offset += offset;
654
655         if (count*st->frame_size > frame_size)
656                 return OPUS_BAD_ARG;
657         nb_samples=0;
658         for (i=0;i<count;i++)
659         {
660                 int ret;
661                 ret = opus_decode_frame(st, data, size[i], pcm, frame_size-nb_samples, decode_fec);
662                 if (ret<0)
663                         return ret;
664                 data += size[i];
665                 tot_offset += size[i];
666                 pcm += ret*st->channels;
667                 nb_samples += ret;
668         }
669         if (packet_offset != NULL)
670            *packet_offset = tot_offset;
671         return nb_samples;
672 }
673
674 #ifdef FIXED_POINT
675
676 int opus_decode(OpusDecoder *st, const unsigned char *data,
677       int len, opus_val16 *pcm, int frame_size, int decode_fec)
678 {
679    return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL);
680 }
681
682 #ifndef DISABLE_FLOAT_API
683 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
684       int len, float *pcm, int frame_size, int decode_fec)
685 {
686    VARDECL(opus_int16, out);
687    int ret, i;
688    ALLOC_STACK;
689
690    ALLOC(out, frame_size*st->channels, opus_int16);
691
692    ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL);
693    if (ret > 0)
694    {
695       for (i=0;i<ret*st->channels;i++)
696          pcm[i] = (1./32768.)*(out[i]);
697    }
698    RESTORE_STACK;
699    return ret;
700 }
701 #endif
702
703
704 #else
705 int opus_decode(OpusDecoder *st, const unsigned char *data,
706       int len, opus_int16 *pcm, int frame_size, int decode_fec)
707 {
708    VARDECL(float, out);
709    int ret, i;
710    ALLOC_STACK;
711
712    ALLOC(out, frame_size*st->channels, float);
713
714    ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL);
715    if (ret > 0)
716    {
717       for (i=0;i<ret*st->channels;i++)
718          pcm[i] = FLOAT2INT16(out[i]);
719    }
720    RESTORE_STACK;
721    return ret;
722 }
723
724 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
725         int len, opus_val16 *pcm, int frame_size, int decode_fec)
726 {
727    return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL);
728 }
729
730 #endif
731
732 int opus_decoder_ctl(OpusDecoder *st, int request, ...)
733 {
734    int ret = OPUS_OK;
735    va_list ap;
736
737    va_start(ap, request);
738
739    switch (request)
740    {
741    case OPUS_GET_BANDWIDTH_REQUEST:
742    {
743       opus_int32 *value = va_arg(ap, opus_int32*);
744       *value = st->bandwidth;
745    }
746    break;
747    case OPUS_GET_FINAL_RANGE_REQUEST:
748    {
749       opus_uint32 *value = va_arg(ap, opus_uint32*);
750       *value = st->rangeFinal;
751    }
752    break;
753    case OPUS_RESET_STATE:
754    {
755       void *silk_dec;
756       CELTDecoder *celt_dec;
757
758       silk_dec = (char*)st+st->silk_dec_offset;
759       celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
760
761       OPUS_CLEAR((char*)&st->OPUS_DECODER_RESET_START,
762             sizeof(OpusDecoder)-
763             ((char*)&st->OPUS_DECODER_RESET_START - (char*)st));
764
765       celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
766       silk_InitDecoder( silk_dec );
767       st->stream_channels = st->channels;
768       st->frame_size = st->Fs/400;
769    }
770    break;
771    default:
772       /*fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);*/
773       ret = OPUS_UNIMPLEMENTED;
774       break;
775    }
776
777    va_end(ap);
778    return ret;
779 }
780
781 void opus_decoder_destroy(OpusDecoder *st)
782 {
783         opus_free(st);
784 }
785
786
787 int opus_packet_get_bandwidth(const unsigned char *data)
788 {
789         int bandwidth;
790     if (data[0]&0x80)
791     {
792         bandwidth = OPUS_BANDWIDTH_MEDIUMBAND + ((data[0]>>5)&0x3);
793         if (bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
794             bandwidth = OPUS_BANDWIDTH_NARROWBAND;
795     } else if ((data[0]&0x60) == 0x60)
796     {
797         bandwidth = (data[0]&0x10) ? OPUS_BANDWIDTH_FULLBAND : OPUS_BANDWIDTH_SUPERWIDEBAND;
798     } else {
799
800         bandwidth = OPUS_BANDWIDTH_NARROWBAND + ((data[0]>>5)&0x3);
801     }
802     return bandwidth;
803 }
804
805 int opus_packet_get_samples_per_frame(const unsigned char *data, opus_int32 Fs)
806 {
807     int audiosize;
808     if (data[0]&0x80)
809     {
810         audiosize = ((data[0]>>3)&0x3);
811         audiosize = (Fs<<audiosize)/400;
812     } else if ((data[0]&0x60) == 0x60)
813     {
814         audiosize = (data[0]&0x08) ? Fs/50 : Fs/100;
815     } else {
816
817         audiosize = ((data[0]>>3)&0x3);
818         if (audiosize == 3)
819             audiosize = Fs*60/1000;
820         else
821             audiosize = (Fs<<audiosize)/100;
822     }
823     return audiosize;
824 }
825
826 int opus_packet_get_nb_channels(const unsigned char *data)
827 {
828     return (data[0]&0x4) ? 2 : 1;
829 }
830
831 int opus_packet_get_nb_frames(const unsigned char packet[], int len)
832 {
833         int count;
834         if (len<1)
835                 return OPUS_BAD_ARG;
836         count = packet[0]&0x3;
837         if (count==0)
838                 return 1;
839         else if (count!=3)
840                 return 2;
841         else if (len<2)
842                 return OPUS_CORRUPTED_DATA;
843         else
844                 return packet[1]&0x3F;
845 }
846
847 int opus_decoder_get_nb_samples(const OpusDecoder *dec, const unsigned char packet[], int len)
848 {
849         int samples;
850         int count = opus_packet_get_nb_frames(packet, len);
851         samples = count*opus_packet_get_samples_per_frame(packet, dec->Fs);
852         /* Can't have more than 120 ms */
853         if (samples*25 > dec->Fs*3)
854                 return OPUS_CORRUPTED_DATA;
855         else
856                 return samples;
857 }