New bandwidth detection code
[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
547    if (celt_ret>=0)
548    {
549       if (OPUS_CHECK_ARRAY(pcm, audiosize*st->channels))
550          OPUS_PRINT_INT(audiosize);
551    }
552
553    RESTORE_STACK;
554    return celt_ret < 0 ? celt_ret : audiosize;
555
556 }
557
558 static int parse_size(const unsigned char *data, opus_int32 len, short *size)
559 {
560    if (len<1)
561    {
562       *size = -1;
563       return -1;
564    } else if (data[0]<252)
565    {
566       *size = data[0];
567       return 1;
568    } else if (len<2)
569    {
570       *size = -1;
571       return -1;
572    } else {
573       *size = 4*data[1] + data[0];
574       return 2;
575    }
576 }
577
578 static int opus_packet_parse_impl(const unsigned char *data, opus_int32 len,
579       int self_delimited, unsigned char *out_toc,
580       const unsigned char *frames[48], short size[48], int *payload_offset)
581 {
582    int i, bytes;
583    int count;
584    int cbr;
585    unsigned char ch, toc;
586    int framesize;
587    opus_int32 last_size;
588    const unsigned char *data0 = data;
589
590    if (size==NULL)
591       return OPUS_BAD_ARG;
592
593    framesize = opus_packet_get_samples_per_frame(data, 48000);
594
595    cbr = 0;
596    toc = *data++;
597    len--;
598    last_size = len;
599    switch (toc&0x3)
600    {
601    /* One frame */
602    case 0:
603       count=1;
604       break;
605    /* Two CBR frames */
606    case 1:
607       count=2;
608       cbr = 1;
609       if (!self_delimited)
610       {
611          if (len&0x1)
612             return OPUS_INVALID_PACKET;
613          last_size = len/2;
614          /* If last_size doesn't fit in size[0], we'll catch it later */
615          size[0] = (short)last_size;
616       }
617       break;
618    /* Two VBR frames */
619    case 2:
620       count = 2;
621       bytes = parse_size(data, len, size);
622       len -= bytes;
623       if (size[0]<0 || size[0] > len)
624          return OPUS_INVALID_PACKET;
625       data += bytes;
626       last_size = len-size[0];
627       break;
628    /* Multiple CBR/VBR frames (from 0 to 120 ms) */
629    default: /*case 3:*/
630       if (len<1)
631          return OPUS_INVALID_PACKET;
632       /* Number of frames encoded in bits 0 to 5 */
633       ch = *data++;
634       count = ch&0x3F;
635       if (count <= 0 || framesize*count > 5760)
636          return OPUS_INVALID_PACKET;
637       len--;
638       /* Padding flag is bit 6 */
639       if (ch&0x40)
640       {
641          int p;
642          do {
643             if (len<=0)
644                return OPUS_INVALID_PACKET;
645             p = *data++;
646             len--;
647             len -= p==255 ? 254: p;
648          } while (p==255);
649       }
650       if (len<0)
651          return OPUS_INVALID_PACKET;
652       /* VBR flag is bit 7 */
653       cbr = !(ch&0x80);
654       if (!cbr)
655       {
656          /* VBR case */
657          last_size = len;
658          for (i=0;i<count-1;i++)
659          {
660             bytes = parse_size(data, len, size+i);
661             len -= bytes;
662             if (size[i]<0 || size[i] > len)
663                return OPUS_INVALID_PACKET;
664             data += bytes;
665             last_size -= bytes+size[i];
666          }
667          if (last_size<0)
668             return OPUS_INVALID_PACKET;
669       } else if (!self_delimited)
670       {
671          /* CBR case */
672          last_size = len/count;
673          if (last_size*count!=len)
674             return OPUS_INVALID_PACKET;
675          for (i=0;i<count-1;i++)
676             size[i] = (short)last_size;
677       }
678       break;
679    }
680    /* Self-delimited framing has an extra size for the last frame. */
681    if (self_delimited)
682    {
683       bytes = parse_size(data, len, size+count-1);
684       len -= bytes;
685       if (size[count-1]<0 || size[count-1] > len)
686          return OPUS_INVALID_PACKET;
687       data += bytes;
688       /* For CBR packets, apply the size to all the frames. */
689       if (cbr)
690       {
691          if (size[count-1]*count > len)
692             return OPUS_INVALID_PACKET;
693          for (i=0;i<count-1;i++)
694             size[i] = size[count-1];
695       } else if(size[count-1] > last_size)
696          return OPUS_INVALID_PACKET;
697    } else
698    {
699       /* Because it's not encoded explicitly, it's possible the size of the
700          last packet (or all the packets, for the CBR case) is larger than
701          1275. Reject them here.*/
702       if (last_size > 1275)
703          return OPUS_INVALID_PACKET;
704       size[count-1] = (short)last_size;
705    }
706
707    if (frames)
708    {
709       for (i=0;i<count;i++)
710       {
711          frames[i] = data;
712          data += size[i];
713       }
714    }
715
716    if (out_toc)
717       *out_toc = toc;
718
719    if (payload_offset)
720       *payload_offset = (int)(data-data0);
721
722    return count;
723 }
724
725 int opus_packet_parse(const unsigned char *data, opus_int32 len,
726       unsigned char *out_toc, const unsigned char *frames[48],
727       short size[48], int *payload_offset)
728 {
729    return opus_packet_parse_impl(data, len, 0, out_toc,
730                                  frames, size, payload_offset);
731 }
732
733 int opus_decode_native(OpusDecoder *st, const unsigned char *data,
734       opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec,
735       int self_delimited, int *packet_offset)
736 {
737    int i, nb_samples;
738    int count, offset;
739    unsigned char toc;
740    int tot_offset;
741    int packet_frame_size, packet_bandwidth, packet_mode, packet_stream_channels;
742    /* 48 x 2.5 ms = 120 ms */
743    short size[48];
744    if (decode_fec<0 || decode_fec>1)
745       return OPUS_BAD_ARG;
746    /* For FEC/PLC, frame_size has to be to have a multiple of 2.5 ms */
747    if ((decode_fec || len==0 || data==NULL) && frame_size%(st->Fs/400)!=0)
748       return OPUS_BAD_ARG;
749    if (len==0 || data==NULL)
750    {
751       int pcm_count=0;
752       do {
753          int ret;
754          ret = opus_decode_frame(st, NULL, 0, pcm+pcm_count*st->channels, frame_size-pcm_count, 0);
755          if (ret<0)
756             return ret;
757          pcm_count += ret;
758       } while (pcm_count < frame_size);
759       celt_assert(pcm_count == frame_size);
760       if (OPUS_CHECK_ARRAY(pcm, pcm_count*st->channels))
761          OPUS_PRINT_INT(pcm_count);
762       st->last_packet_duration = pcm_count;
763       return pcm_count;
764    } else if (len<0)
765       return OPUS_BAD_ARG;
766
767    packet_mode = opus_packet_get_mode(data);
768    packet_bandwidth = opus_packet_get_bandwidth(data);
769    packet_frame_size = opus_packet_get_samples_per_frame(data, st->Fs);
770    packet_stream_channels = opus_packet_get_nb_channels(data);
771
772    count = opus_packet_parse_impl(data, len, self_delimited, &toc, NULL, size, &offset);
773
774    data += offset;
775
776    if (decode_fec)
777    {
778       int duration_copy;
779       int ret;
780       /* If no FEC can be present, run the PLC (recursive call) */
781       if (frame_size <= packet_frame_size || packet_mode == MODE_CELT_ONLY || st->mode == MODE_CELT_ONLY)
782          return opus_decode_native(st, NULL, 0, pcm, frame_size, 0, 0, NULL);
783       /* Otherwise, run the PLC on everything except the size for which we might have FEC */
784       duration_copy = st->last_packet_duration;
785       ret = opus_decode_native(st, NULL, 0, pcm, frame_size-packet_frame_size, 0, 0, NULL);
786       if (ret<0)
787       {
788          st->last_packet_duration = duration_copy;
789          return ret;
790       }
791       celt_assert(ret==frame_size-packet_frame_size);
792       /* Complete with FEC */
793       st->mode = packet_mode;
794       st->bandwidth = packet_bandwidth;
795       st->frame_size = packet_frame_size;
796       st->stream_channels = packet_stream_channels;
797       ret = opus_decode_frame(st, data, size[0], pcm+st->channels*(frame_size-packet_frame_size),
798             packet_frame_size, 1);
799       if (ret<0)
800          return ret;
801       else {
802          if (OPUS_CHECK_ARRAY(pcm, frame_size*st->channels))
803             OPUS_PRINT_INT(frame_size);
804          st->last_packet_duration = frame_size;
805          return frame_size;
806       }
807    }
808    tot_offset = 0;
809    if (count < 0)
810       return count;
811
812    tot_offset += offset;
813
814    if (count*packet_frame_size > frame_size)
815       return OPUS_BUFFER_TOO_SMALL;
816
817    /* Update the state as the last step to avoid updating it on an invalid packet */
818    st->mode = packet_mode;
819    st->bandwidth = packet_bandwidth;
820    st->frame_size = packet_frame_size;
821    st->stream_channels = packet_stream_channels;
822
823    nb_samples=0;
824    for (i=0;i<count;i++)
825    {
826       int ret;
827       ret = opus_decode_frame(st, data, size[i], pcm+nb_samples*st->channels, frame_size-nb_samples, 0);
828       if (ret<0)
829          return ret;
830       celt_assert(ret==packet_frame_size);
831       data += size[i];
832       tot_offset += size[i];
833       nb_samples += ret;
834    }
835    if (packet_offset != NULL)
836       *packet_offset = tot_offset;
837    st->last_packet_duration = nb_samples;
838    if (OPUS_CHECK_ARRAY(pcm, nb_samples*st->channels))
839       OPUS_PRINT_INT(nb_samples);
840    return nb_samples;
841 }
842
843 #ifdef FIXED_POINT
844
845 int opus_decode(OpusDecoder *st, const unsigned char *data,
846       opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec)
847 {
848    return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL);
849 }
850
851 #ifndef DISABLE_FLOAT_API
852 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
853       opus_int32 len, float *pcm, int frame_size, int decode_fec)
854 {
855    VARDECL(opus_int16, out);
856    int ret, i;
857    ALLOC_STACK;
858
859    ALLOC(out, frame_size*st->channels, opus_int16);
860
861    ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL);
862    if (ret > 0)
863    {
864       for (i=0;i<ret*st->channels;i++)
865          pcm[i] = (1.f/32768.f)*(out[i]);
866    }
867    RESTORE_STACK;
868    return ret;
869 }
870 #endif
871
872
873 #else
874 int opus_decode(OpusDecoder *st, const unsigned char *data,
875       opus_int32 len, opus_int16 *pcm, int frame_size, int decode_fec)
876 {
877    VARDECL(float, out);
878    int ret, i;
879    ALLOC_STACK;
880
881    if(frame_size<0)
882    {
883       RESTORE_STACK;
884       return OPUS_BAD_ARG;
885    }
886
887    ALLOC(out, frame_size*st->channels, float);
888
889    ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL);
890    if (ret > 0)
891    {
892       for (i=0;i<ret*st->channels;i++)
893          pcm[i] = FLOAT2INT16(out[i]);
894    }
895    RESTORE_STACK;
896    return ret;
897 }
898
899 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
900       opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec)
901 {
902    return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL);
903 }
904
905 #endif
906
907 int opus_decoder_ctl(OpusDecoder *st, int request, ...)
908 {
909    int ret = OPUS_OK;
910    va_list ap;
911    void *silk_dec;
912    CELTDecoder *celt_dec;
913
914    silk_dec = (char*)st+st->silk_dec_offset;
915    celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
916
917
918    va_start(ap, request);
919
920    switch (request)
921    {
922    case OPUS_GET_BANDWIDTH_REQUEST:
923    {
924       opus_int32 *value = va_arg(ap, opus_int32*);
925       *value = st->bandwidth;
926    }
927    break;
928    case OPUS_GET_FINAL_RANGE_REQUEST:
929    {
930       opus_uint32 *value = va_arg(ap, opus_uint32*);
931       *value = st->rangeFinal;
932    }
933    break;
934    case OPUS_RESET_STATE:
935    {
936       OPUS_CLEAR((char*)&st->OPUS_DECODER_RESET_START,
937             sizeof(OpusDecoder)-
938             ((char*)&st->OPUS_DECODER_RESET_START - (char*)st));
939
940       celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
941       silk_InitDecoder( silk_dec );
942       st->stream_channels = st->channels;
943       st->frame_size = st->Fs/400;
944    }
945    break;
946    case OPUS_GET_SAMPLE_RATE_REQUEST:
947    {
948       opus_int32 *value = va_arg(ap, opus_int32*);
949       if (value==NULL)
950       {
951          ret = OPUS_BAD_ARG;
952          break;
953       }
954       *value = st->Fs;
955    }
956    break;
957    case OPUS_GET_PITCH_REQUEST:
958    {
959       opus_int32 *value = va_arg(ap, opus_int32*);
960       if (value==NULL)
961       {
962          ret = OPUS_BAD_ARG;
963          break;
964       }
965       if (st->prev_mode == MODE_CELT_ONLY)
966          celt_decoder_ctl(celt_dec, OPUS_GET_PITCH(value));
967       else
968          *value = st->DecControl.prevPitchLag;
969    }
970    break;
971    case OPUS_GET_GAIN_REQUEST:
972    {
973       opus_int32 *value = va_arg(ap, opus_int32*);
974       if (value==NULL)
975       {
976          ret = OPUS_BAD_ARG;
977          break;
978       }
979       *value = st->decode_gain;
980    }
981    break;
982    case OPUS_SET_GAIN_REQUEST:
983    {
984        opus_int32 value = va_arg(ap, opus_int32);
985        if (value<-32768 || value>32767)
986        {
987           ret = OPUS_BAD_ARG;
988           break;
989        }
990        st->decode_gain = value;
991    }
992    break;
993    case OPUS_GET_LAST_PACKET_DURATION_REQUEST:
994    {
995       opus_uint32 *value = va_arg(ap, opus_uint32*);
996       *value = st->last_packet_duration;
997    }
998    break;
999    default:
1000       /*fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);*/
1001       ret = OPUS_UNIMPLEMENTED;
1002       break;
1003    }
1004
1005    va_end(ap);
1006    return ret;
1007 }
1008
1009 void opus_decoder_destroy(OpusDecoder *st)
1010 {
1011    opus_free(st);
1012 }
1013
1014
1015 int opus_packet_get_bandwidth(const unsigned char *data)
1016 {
1017    int bandwidth;
1018    if (data[0]&0x80)
1019    {
1020       bandwidth = OPUS_BANDWIDTH_MEDIUMBAND + ((data[0]>>5)&0x3);
1021       if (bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1022          bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1023    } else if ((data[0]&0x60) == 0x60)
1024    {
1025       bandwidth = (data[0]&0x10) ? OPUS_BANDWIDTH_FULLBAND :
1026                                    OPUS_BANDWIDTH_SUPERWIDEBAND;
1027    } else {
1028       bandwidth = OPUS_BANDWIDTH_NARROWBAND + ((data[0]>>5)&0x3);
1029    }
1030    return bandwidth;
1031 }
1032
1033 int opus_packet_get_samples_per_frame(const unsigned char *data,
1034       opus_int32 Fs)
1035 {
1036    int audiosize;
1037    if (data[0]&0x80)
1038    {
1039       audiosize = ((data[0]>>3)&0x3);
1040       audiosize = (Fs<<audiosize)/400;
1041    } else if ((data[0]&0x60) == 0x60)
1042    {
1043       audiosize = (data[0]&0x08) ? Fs/50 : Fs/100;
1044    } else {
1045       audiosize = ((data[0]>>3)&0x3);
1046       if (audiosize == 3)
1047          audiosize = Fs*60/1000;
1048       else
1049          audiosize = (Fs<<audiosize)/100;
1050    }
1051    return audiosize;
1052 }
1053
1054 int opus_packet_get_nb_channels(const unsigned char *data)
1055 {
1056    return (data[0]&0x4) ? 2 : 1;
1057 }
1058
1059 int opus_packet_get_nb_frames(const unsigned char packet[], opus_int32 len)
1060 {
1061    int count;
1062    if (len<1)
1063       return OPUS_BAD_ARG;
1064    count = packet[0]&0x3;
1065    if (count==0)
1066       return 1;
1067    else if (count!=3)
1068       return 2;
1069    else if (len<2)
1070       return OPUS_INVALID_PACKET;
1071    else
1072       return packet[1]&0x3F;
1073 }
1074
1075 int opus_packet_get_nb_samples(const unsigned char packet[], opus_int32 len,
1076       opus_int32 Fs)
1077 {
1078    int samples;
1079    int count = opus_packet_get_nb_frames(packet, len);
1080
1081    if (count<0)
1082       return count;
1083
1084    samples = count*opus_packet_get_samples_per_frame(packet, Fs);
1085    /* Can't have more than 120 ms */
1086    if (samples*25 > Fs*3)
1087       return OPUS_INVALID_PACKET;
1088    else
1089       return samples;
1090 }
1091
1092 int opus_decoder_get_nb_samples(const OpusDecoder *dec,
1093       const unsigned char packet[], opus_int32 len)
1094 {
1095    return opus_packet_get_nb_samples(packet, len, dec->Fs);
1096 }