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