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