Fixes PLC for sizes that don't match basic Opus frame sizes.
[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       /* 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], int *payload_offset)
605 {
606    int i, bytes;
607    int count;
608    int cbr;
609    unsigned char ch, toc;
610    int framesize;
611    opus_int32 last_size;
612    const unsigned char *data0 = data;
613
614    if (size==NULL)
615       return OPUS_BAD_ARG;
616
617    framesize = opus_packet_get_samples_per_frame(data, 48000);
618
619    cbr = 0;
620    toc = *data++;
621    len--;
622    last_size = len;
623    switch (toc&0x3)
624    {
625    /* One frame */
626    case 0:
627       count=1;
628       break;
629    /* Two CBR frames */
630    case 1:
631       count=2;
632       cbr = 1;
633       if (!self_delimited)
634       {
635          if (len&0x1)
636             return OPUS_INVALID_PACKET;
637          last_size = len/2;
638          /* If last_size doesn't fit in size[0], we'll catch it later */
639          size[0] = (opus_int16)last_size;
640       }
641       break;
642    /* Two VBR frames */
643    case 2:
644       count = 2;
645       bytes = parse_size(data, len, size);
646       len -= bytes;
647       if (size[0]<0 || size[0] > len)
648          return OPUS_INVALID_PACKET;
649       data += bytes;
650       last_size = len-size[0];
651       break;
652    /* Multiple CBR/VBR frames (from 0 to 120 ms) */
653    default: /*case 3:*/
654       if (len<1)
655          return OPUS_INVALID_PACKET;
656       /* Number of frames encoded in bits 0 to 5 */
657       ch = *data++;
658       count = ch&0x3F;
659       if (count <= 0 || framesize*count > 5760)
660          return OPUS_INVALID_PACKET;
661       len--;
662       /* Padding flag is bit 6 */
663       if (ch&0x40)
664       {
665          int p;
666          do {
667             if (len<=0)
668                return OPUS_INVALID_PACKET;
669             p = *data++;
670             len--;
671             len -= p==255 ? 254: p;
672          } while (p==255);
673       }
674       if (len<0)
675          return OPUS_INVALID_PACKET;
676       /* VBR flag is bit 7 */
677       cbr = !(ch&0x80);
678       if (!cbr)
679       {
680          /* VBR case */
681          last_size = len;
682          for (i=0;i<count-1;i++)
683          {
684             bytes = parse_size(data, len, size+i);
685             len -= bytes;
686             if (size[i]<0 || size[i] > len)
687                return OPUS_INVALID_PACKET;
688             data += bytes;
689             last_size -= bytes+size[i];
690          }
691          if (last_size<0)
692             return OPUS_INVALID_PACKET;
693       } else if (!self_delimited)
694       {
695          /* CBR case */
696          last_size = len/count;
697          if (last_size*count!=len)
698             return OPUS_INVALID_PACKET;
699          for (i=0;i<count-1;i++)
700             size[i] = (opus_int16)last_size;
701       }
702       break;
703    }
704    /* Self-delimited framing has an extra size for the last frame. */
705    if (self_delimited)
706    {
707       bytes = parse_size(data, len, size+count-1);
708       len -= bytes;
709       if (size[count-1]<0 || size[count-1] > len)
710          return OPUS_INVALID_PACKET;
711       data += bytes;
712       /* For CBR packets, apply the size to all the frames. */
713       if (cbr)
714       {
715          if (size[count-1]*count > len)
716             return OPUS_INVALID_PACKET;
717          for (i=0;i<count-1;i++)
718             size[i] = size[count-1];
719       } else if(size[count-1] > last_size)
720          return OPUS_INVALID_PACKET;
721    } else
722    {
723       /* Because it's not encoded explicitly, it's possible the size of the
724          last packet (or all the packets, for the CBR case) is larger than
725          1275. Reject them here.*/
726       if (last_size > 1275)
727          return OPUS_INVALID_PACKET;
728       size[count-1] = (opus_int16)last_size;
729    }
730
731    if (payload_offset)
732       *payload_offset = (int)(data-data0);
733
734    if (frames)
735    {
736       for (i=0;i<count;i++)
737       {
738          frames[i] = data;
739          data += size[i];
740       }
741    }
742
743    if (out_toc)
744       *out_toc = toc;
745
746    return count;
747 }
748
749 int opus_packet_parse(const unsigned char *data, opus_int32 len,
750       unsigned char *out_toc, const unsigned char *frames[48],
751       opus_int16 size[48], int *payload_offset)
752 {
753    return opus_packet_parse_impl(data, len, 0, out_toc,
754                                  frames, size, payload_offset);
755 }
756
757 int opus_decode_native(OpusDecoder *st, const unsigned char *data,
758       opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec,
759       int self_delimited, int *packet_offset, int soft_clip)
760 {
761    int i, nb_samples;
762    int count, offset;
763    unsigned char toc;
764    int tot_offset;
765    int packet_frame_size, packet_bandwidth, packet_mode, packet_stream_channels;
766    /* 48 x 2.5 ms = 120 ms */
767    opus_int16 size[48];
768    if (decode_fec<0 || decode_fec>1)
769       return OPUS_BAD_ARG;
770    /* For FEC/PLC, frame_size has to be to have a multiple of 2.5 ms */
771    if ((decode_fec || len==0 || data==NULL) && frame_size%(st->Fs/400)!=0)
772       return OPUS_BAD_ARG;
773    if (len==0 || data==NULL)
774    {
775       int pcm_count=0;
776       do {
777          int ret;
778          ret = opus_decode_frame(st, NULL, 0, pcm+pcm_count*st->channels, frame_size-pcm_count, 0);
779          if (ret<0)
780             return ret;
781          pcm_count += ret;
782       } while (pcm_count < frame_size);
783       celt_assert(pcm_count == frame_size);
784       if (OPUS_CHECK_ARRAY(pcm, pcm_count*st->channels))
785          OPUS_PRINT_INT(pcm_count);
786       st->last_packet_duration = pcm_count;
787       return pcm_count;
788    } else if (len<0)
789       return OPUS_BAD_ARG;
790
791    packet_mode = opus_packet_get_mode(data);
792    packet_bandwidth = opus_packet_get_bandwidth(data);
793    packet_frame_size = opus_packet_get_samples_per_frame(data, st->Fs);
794    packet_stream_channels = opus_packet_get_nb_channels(data);
795
796    count = opus_packet_parse_impl(data, len, self_delimited, &toc, NULL, size, &offset);
797
798    if (count<0)
799       return count;
800
801    data += offset;
802
803    if (decode_fec)
804    {
805       int duration_copy;
806       int ret;
807       /* If no FEC can be present, run the PLC (recursive call) */
808       if (frame_size < packet_frame_size || packet_mode == MODE_CELT_ONLY || st->mode == MODE_CELT_ONLY)
809          return opus_decode_native(st, NULL, 0, pcm, frame_size, 0, 0, NULL, soft_clip);
810       /* Otherwise, run the PLC on everything except the size for which we might have FEC */
811       duration_copy = st->last_packet_duration;
812       if (frame_size-packet_frame_size!=0)
813       {
814          ret = opus_decode_native(st, NULL, 0, pcm, frame_size-packet_frame_size, 0, 0, NULL, soft_clip);
815          if (ret<0)
816          {
817             st->last_packet_duration = duration_copy;
818             return ret;
819          }
820          celt_assert(ret==frame_size-packet_frame_size);
821       }
822       /* Complete with FEC */
823       st->mode = packet_mode;
824       st->bandwidth = packet_bandwidth;
825       st->frame_size = packet_frame_size;
826       st->stream_channels = packet_stream_channels;
827       ret = opus_decode_frame(st, data, size[0], pcm+st->channels*(frame_size-packet_frame_size),
828             packet_frame_size, 1);
829       if (ret<0)
830          return ret;
831       else {
832          if (OPUS_CHECK_ARRAY(pcm, frame_size*st->channels))
833             OPUS_PRINT_INT(frame_size);
834          st->last_packet_duration = frame_size;
835          return frame_size;
836       }
837    }
838    tot_offset = offset;
839
840    if (count*packet_frame_size > frame_size)
841       return OPUS_BUFFER_TOO_SMALL;
842
843    /* Update the state as the last step to avoid updating it on an invalid packet */
844    st->mode = packet_mode;
845    st->bandwidth = packet_bandwidth;
846    st->frame_size = packet_frame_size;
847    st->stream_channels = packet_stream_channels;
848
849    nb_samples=0;
850    for (i=0;i<count;i++)
851    {
852       int ret;
853       ret = opus_decode_frame(st, data, size[i], pcm+nb_samples*st->channels, frame_size-nb_samples, 0);
854       if (ret<0)
855          return ret;
856       celt_assert(ret==packet_frame_size);
857       data += size[i];
858       tot_offset += size[i];
859       nb_samples += ret;
860    }
861    if (packet_offset != NULL)
862       *packet_offset = tot_offset;
863    st->last_packet_duration = nb_samples;
864    if (OPUS_CHECK_ARRAY(pcm, nb_samples*st->channels))
865       OPUS_PRINT_INT(nb_samples);
866 #ifndef FIXED_POINT
867    if (soft_clip)
868       opus_pcm_soft_clip(pcm, nb_samples, st->channels, st->softclip_mem);
869    else
870       st->softclip_mem[0]=st->softclip_mem[1]=0;
871 #endif
872    return nb_samples;
873 }
874
875 #ifdef FIXED_POINT
876
877 int opus_decode(OpusDecoder *st, const unsigned char *data,
878       opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec)
879 {
880    return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL, 0);
881 }
882
883 #ifndef DISABLE_FLOAT_API
884 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
885       opus_int32 len, float *pcm, int frame_size, int decode_fec)
886 {
887    VARDECL(opus_int16, out);
888    int ret, i;
889    ALLOC_STACK;
890
891    ALLOC(out, frame_size*st->channels, opus_int16);
892
893    ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL, 0);
894    if (ret > 0)
895    {
896       for (i=0;i<ret*st->channels;i++)
897          pcm[i] = (1.f/32768.f)*(out[i]);
898    }
899    RESTORE_STACK;
900    return ret;
901 }
902 #endif
903
904
905 #else
906 int opus_decode(OpusDecoder *st, const unsigned char *data,
907       opus_int32 len, opus_int16 *pcm, int frame_size, int decode_fec)
908 {
909    VARDECL(float, out);
910    int ret, i;
911    ALLOC_STACK;
912
913    if(frame_size<0)
914    {
915       RESTORE_STACK;
916       return OPUS_BAD_ARG;
917    }
918
919    ALLOC(out, frame_size*st->channels, float);
920
921    ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL, 1);
922    if (ret > 0)
923    {
924       for (i=0;i<ret*st->channels;i++)
925          pcm[i] = FLOAT2INT16(out[i]);
926    }
927    RESTORE_STACK;
928    return ret;
929 }
930
931 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
932       opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec)
933 {
934    return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL, 0);
935 }
936
937 #endif
938
939 int opus_decoder_ctl(OpusDecoder *st, int request, ...)
940 {
941    int ret = OPUS_OK;
942    va_list ap;
943    void *silk_dec;
944    CELTDecoder *celt_dec;
945
946    silk_dec = (char*)st+st->silk_dec_offset;
947    celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
948
949
950    va_start(ap, request);
951
952    switch (request)
953    {
954    case OPUS_GET_BANDWIDTH_REQUEST:
955    {
956       opus_int32 *value = va_arg(ap, opus_int32*);
957       if (!value)
958       {
959          goto bad_arg;
960       }
961       *value = st->bandwidth;
962    }
963    break;
964    case OPUS_GET_FINAL_RANGE_REQUEST:
965    {
966       opus_uint32 *value = va_arg(ap, opus_uint32*);
967       if (!value)
968       {
969          goto bad_arg;
970       }
971       *value = st->rangeFinal;
972    }
973    break;
974    case OPUS_RESET_STATE:
975    {
976       OPUS_CLEAR((char*)&st->OPUS_DECODER_RESET_START,
977             sizeof(OpusDecoder)-
978             ((char*)&st->OPUS_DECODER_RESET_START - (char*)st));
979
980       celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
981       silk_InitDecoder( silk_dec );
982       st->stream_channels = st->channels;
983       st->frame_size = st->Fs/400;
984    }
985    break;
986    case OPUS_GET_SAMPLE_RATE_REQUEST:
987    {
988       opus_int32 *value = va_arg(ap, opus_int32*);
989       if (!value)
990       {
991          goto bad_arg;
992       }
993       *value = st->Fs;
994    }
995    break;
996    case OPUS_GET_PITCH_REQUEST:
997    {
998       opus_int32 *value = va_arg(ap, opus_int32*);
999       if (!value)
1000       {
1001          goto bad_arg;
1002       }
1003       if (st->prev_mode == MODE_CELT_ONLY)
1004          celt_decoder_ctl(celt_dec, OPUS_GET_PITCH(value));
1005       else
1006          *value = st->DecControl.prevPitchLag;
1007    }
1008    break;
1009    case OPUS_GET_GAIN_REQUEST:
1010    {
1011       opus_int32 *value = va_arg(ap, opus_int32*);
1012       if (!value)
1013       {
1014          goto bad_arg;
1015       }
1016       *value = st->decode_gain;
1017    }
1018    break;
1019    case OPUS_SET_GAIN_REQUEST:
1020    {
1021        opus_int32 value = va_arg(ap, opus_int32);
1022        if (value<-32768 || value>32767)
1023        {
1024           goto bad_arg;
1025        }
1026        st->decode_gain = value;
1027    }
1028    break;
1029    case OPUS_GET_LAST_PACKET_DURATION_REQUEST:
1030    {
1031       opus_uint32 *value = va_arg(ap, opus_uint32*);
1032       if (!value)
1033       {
1034          goto bad_arg;
1035       }
1036       *value = st->last_packet_duration;
1037    }
1038    break;
1039    default:
1040       /*fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);*/
1041       ret = OPUS_UNIMPLEMENTED;
1042       break;
1043    }
1044
1045    va_end(ap);
1046    return ret;
1047 bad_arg:
1048    va_end(ap);
1049    return OPUS_BAD_ARG;
1050 }
1051
1052 void opus_decoder_destroy(OpusDecoder *st)
1053 {
1054    opus_free(st);
1055 }
1056
1057
1058 int opus_packet_get_bandwidth(const unsigned char *data)
1059 {
1060    int bandwidth;
1061    if (data[0]&0x80)
1062    {
1063       bandwidth = OPUS_BANDWIDTH_MEDIUMBAND + ((data[0]>>5)&0x3);
1064       if (bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1065          bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1066    } else if ((data[0]&0x60) == 0x60)
1067    {
1068       bandwidth = (data[0]&0x10) ? OPUS_BANDWIDTH_FULLBAND :
1069                                    OPUS_BANDWIDTH_SUPERWIDEBAND;
1070    } else {
1071       bandwidth = OPUS_BANDWIDTH_NARROWBAND + ((data[0]>>5)&0x3);
1072    }
1073    return bandwidth;
1074 }
1075
1076 int opus_packet_get_samples_per_frame(const unsigned char *data,
1077       opus_int32 Fs)
1078 {
1079    int audiosize;
1080    if (data[0]&0x80)
1081    {
1082       audiosize = ((data[0]>>3)&0x3);
1083       audiosize = (Fs<<audiosize)/400;
1084    } else if ((data[0]&0x60) == 0x60)
1085    {
1086       audiosize = (data[0]&0x08) ? Fs/50 : Fs/100;
1087    } else {
1088       audiosize = ((data[0]>>3)&0x3);
1089       if (audiosize == 3)
1090          audiosize = Fs*60/1000;
1091       else
1092          audiosize = (Fs<<audiosize)/100;
1093    }
1094    return audiosize;
1095 }
1096
1097 int opus_packet_get_nb_channels(const unsigned char *data)
1098 {
1099    return (data[0]&0x4) ? 2 : 1;
1100 }
1101
1102 int opus_packet_get_nb_frames(const unsigned char packet[], opus_int32 len)
1103 {
1104    int count;
1105    if (len<1)
1106       return OPUS_BAD_ARG;
1107    count = packet[0]&0x3;
1108    if (count==0)
1109       return 1;
1110    else if (count!=3)
1111       return 2;
1112    else if (len<2)
1113       return OPUS_INVALID_PACKET;
1114    else
1115       return packet[1]&0x3F;
1116 }
1117
1118 int opus_packet_get_nb_samples(const unsigned char packet[], opus_int32 len,
1119       opus_int32 Fs)
1120 {
1121    int samples;
1122    int count = opus_packet_get_nb_frames(packet, len);
1123
1124    if (count<0)
1125       return count;
1126
1127    samples = count*opus_packet_get_samples_per_frame(packet, Fs);
1128    /* Can't have more than 120 ms */
1129    if (samples*25 > Fs*3)
1130       return OPUS_INVALID_PACKET;
1131    else
1132       return samples;
1133 }
1134
1135 int opus_decoder_get_nb_samples(const OpusDecoder *dec,
1136       const unsigned char packet[], opus_int32 len)
1137 {
1138    return opus_packet_get_nb_samples(packet, len, dec->Fs);
1139 }