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