Applies soft-clipping to the int decoder API.
[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       ret = opus_decode_native(st, NULL, 0, pcm, frame_size-packet_frame_size, 0, 0, NULL, soft_clip);
789       if (ret<0)
790       {
791          st->last_packet_duration = duration_copy;
792          return ret;
793       }
794       celt_assert(ret==frame_size-packet_frame_size);
795       /* Complete with FEC */
796       st->mode = packet_mode;
797       st->bandwidth = packet_bandwidth;
798       st->frame_size = packet_frame_size;
799       st->stream_channels = packet_stream_channels;
800       ret = opus_decode_frame(st, data, size[0], pcm+st->channels*(frame_size-packet_frame_size),
801             packet_frame_size, 1);
802       if (ret<0)
803          return ret;
804       else {
805          if (OPUS_CHECK_ARRAY(pcm, frame_size*st->channels))
806             OPUS_PRINT_INT(frame_size);
807          st->last_packet_duration = frame_size;
808          return frame_size;
809       }
810    }
811    tot_offset = 0;
812    if (count < 0)
813       return count;
814
815    tot_offset += offset;
816
817    if (count*packet_frame_size > frame_size)
818       return OPUS_BUFFER_TOO_SMALL;
819
820    /* Update the state as the last step to avoid updating it on an invalid packet */
821    st->mode = packet_mode;
822    st->bandwidth = packet_bandwidth;
823    st->frame_size = packet_frame_size;
824    st->stream_channels = packet_stream_channels;
825
826    nb_samples=0;
827    for (i=0;i<count;i++)
828    {
829       int ret;
830       ret = opus_decode_frame(st, data, size[i], pcm+nb_samples*st->channels, frame_size-nb_samples, 0);
831       if (ret<0)
832          return ret;
833       celt_assert(ret==packet_frame_size);
834       data += size[i];
835       tot_offset += size[i];
836       nb_samples += ret;
837    }
838    if (packet_offset != NULL)
839       *packet_offset = tot_offset;
840    st->last_packet_duration = nb_samples;
841    if (OPUS_CHECK_ARRAY(pcm, nb_samples*st->channels))
842       OPUS_PRINT_INT(nb_samples);
843 #ifndef FIXED_POINT
844    if (soft_clip)
845       opus_pcm_soft_clip(pcm, nb_samples, st->channels, st->softclip_mem);
846    else
847       st->softclip_mem[0]=st->softclip_mem[1]=0;
848 #endif
849    return nb_samples;
850 }
851
852 #ifdef FIXED_POINT
853
854 int opus_decode(OpusDecoder *st, const unsigned char *data,
855       opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec)
856 {
857    return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL, 0);
858 }
859
860 #ifndef DISABLE_FLOAT_API
861 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
862       opus_int32 len, float *pcm, int frame_size, int decode_fec)
863 {
864    VARDECL(opus_int16, out);
865    int ret, i;
866    ALLOC_STACK;
867
868    ALLOC(out, frame_size*st->channels, opus_int16);
869
870    ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL, 0);
871    if (ret > 0)
872    {
873       for (i=0;i<ret*st->channels;i++)
874          pcm[i] = (1.f/32768.f)*(out[i]);
875    }
876    RESTORE_STACK;
877    return ret;
878 }
879 #endif
880
881
882 #else
883 int opus_decode(OpusDecoder *st, const unsigned char *data,
884       opus_int32 len, opus_int16 *pcm, int frame_size, int decode_fec)
885 {
886    VARDECL(float, out);
887    int ret, i;
888    ALLOC_STACK;
889
890    if(frame_size<0)
891    {
892       RESTORE_STACK;
893       return OPUS_BAD_ARG;
894    }
895
896    ALLOC(out, frame_size*st->channels, float);
897
898    ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL, 1);
899    if (ret > 0)
900    {
901       for (i=0;i<ret*st->channels;i++)
902          pcm[i] = FLOAT2INT16(out[i]);
903    }
904    RESTORE_STACK;
905    return ret;
906 }
907
908 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
909       opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec)
910 {
911    return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL, 0);
912 }
913
914 #endif
915
916 int opus_decoder_ctl(OpusDecoder *st, int request, ...)
917 {
918    int ret = OPUS_OK;
919    va_list ap;
920    void *silk_dec;
921    CELTDecoder *celt_dec;
922
923    silk_dec = (char*)st+st->silk_dec_offset;
924    celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
925
926
927    va_start(ap, request);
928
929    switch (request)
930    {
931    case OPUS_GET_BANDWIDTH_REQUEST:
932    {
933       opus_int32 *value = va_arg(ap, opus_int32*);
934       *value = st->bandwidth;
935    }
936    break;
937    case OPUS_GET_FINAL_RANGE_REQUEST:
938    {
939       opus_uint32 *value = va_arg(ap, opus_uint32*);
940       *value = st->rangeFinal;
941    }
942    break;
943    case OPUS_RESET_STATE:
944    {
945       OPUS_CLEAR((char*)&st->OPUS_DECODER_RESET_START,
946             sizeof(OpusDecoder)-
947             ((char*)&st->OPUS_DECODER_RESET_START - (char*)st));
948
949       celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
950       silk_InitDecoder( silk_dec );
951       st->stream_channels = st->channels;
952       st->frame_size = st->Fs/400;
953    }
954    break;
955    case OPUS_GET_SAMPLE_RATE_REQUEST:
956    {
957       opus_int32 *value = va_arg(ap, opus_int32*);
958       if (value==NULL)
959       {
960          ret = OPUS_BAD_ARG;
961          break;
962       }
963       *value = st->Fs;
964    }
965    break;
966    case OPUS_GET_PITCH_REQUEST:
967    {
968       opus_int32 *value = va_arg(ap, opus_int32*);
969       if (value==NULL)
970       {
971          ret = OPUS_BAD_ARG;
972          break;
973       }
974       if (st->prev_mode == MODE_CELT_ONLY)
975          celt_decoder_ctl(celt_dec, OPUS_GET_PITCH(value));
976       else
977          *value = st->DecControl.prevPitchLag;
978    }
979    break;
980    case OPUS_GET_GAIN_REQUEST:
981    {
982       opus_int32 *value = va_arg(ap, opus_int32*);
983       if (value==NULL)
984       {
985          ret = OPUS_BAD_ARG;
986          break;
987       }
988       *value = st->decode_gain;
989    }
990    break;
991    case OPUS_SET_GAIN_REQUEST:
992    {
993        opus_int32 value = va_arg(ap, opus_int32);
994        if (value<-32768 || value>32767)
995        {
996           ret = OPUS_BAD_ARG;
997           break;
998        }
999        st->decode_gain = value;
1000    }
1001    break;
1002    case OPUS_GET_LAST_PACKET_DURATION_REQUEST:
1003    {
1004       opus_uint32 *value = va_arg(ap, opus_uint32*);
1005       *value = st->last_packet_duration;
1006    }
1007    break;
1008    default:
1009       /*fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);*/
1010       ret = OPUS_UNIMPLEMENTED;
1011       break;
1012    }
1013
1014    va_end(ap);
1015    return ret;
1016 }
1017
1018 void opus_decoder_destroy(OpusDecoder *st)
1019 {
1020    opus_free(st);
1021 }
1022
1023
1024 int opus_packet_get_bandwidth(const unsigned char *data)
1025 {
1026    int bandwidth;
1027    if (data[0]&0x80)
1028    {
1029       bandwidth = OPUS_BANDWIDTH_MEDIUMBAND + ((data[0]>>5)&0x3);
1030       if (bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1031          bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1032    } else if ((data[0]&0x60) == 0x60)
1033    {
1034       bandwidth = (data[0]&0x10) ? OPUS_BANDWIDTH_FULLBAND :
1035                                    OPUS_BANDWIDTH_SUPERWIDEBAND;
1036    } else {
1037       bandwidth = OPUS_BANDWIDTH_NARROWBAND + ((data[0]>>5)&0x3);
1038    }
1039    return bandwidth;
1040 }
1041
1042 int opus_packet_get_samples_per_frame(const unsigned char *data,
1043       opus_int32 Fs)
1044 {
1045    int audiosize;
1046    if (data[0]&0x80)
1047    {
1048       audiosize = ((data[0]>>3)&0x3);
1049       audiosize = (Fs<<audiosize)/400;
1050    } else if ((data[0]&0x60) == 0x60)
1051    {
1052       audiosize = (data[0]&0x08) ? Fs/50 : Fs/100;
1053    } else {
1054       audiosize = ((data[0]>>3)&0x3);
1055       if (audiosize == 3)
1056          audiosize = Fs*60/1000;
1057       else
1058          audiosize = (Fs<<audiosize)/100;
1059    }
1060    return audiosize;
1061 }
1062
1063 int opus_packet_get_nb_channels(const unsigned char *data)
1064 {
1065    return (data[0]&0x4) ? 2 : 1;
1066 }
1067
1068 int opus_packet_get_nb_frames(const unsigned char packet[], opus_int32 len)
1069 {
1070    int count;
1071    if (len<1)
1072       return OPUS_BAD_ARG;
1073    count = packet[0]&0x3;
1074    if (count==0)
1075       return 1;
1076    else if (count!=3)
1077       return 2;
1078    else if (len<2)
1079       return OPUS_INVALID_PACKET;
1080    else
1081       return packet[1]&0x3F;
1082 }
1083
1084 int opus_packet_get_nb_samples(const unsigned char packet[], opus_int32 len,
1085       opus_int32 Fs)
1086 {
1087    int samples;
1088    int count = opus_packet_get_nb_frames(packet, len);
1089
1090    if (count<0)
1091       return count;
1092
1093    samples = count*opus_packet_get_samples_per_frame(packet, Fs);
1094    /* Can't have more than 120 ms */
1095    if (samples*25 > Fs*3)
1096       return OPUS_INVALID_PACKET;
1097    else
1098       return samples;
1099 }
1100
1101 int opus_decoder_get_nb_samples(const OpusDecoder *dec,
1102       const unsigned char packet[], opus_int32 len)
1103 {
1104    return opus_packet_get_nb_samples(packet, len, dec->Fs);
1105 }