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