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