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