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