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