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