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