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