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