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