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