Fixes glithes when switching between SILK-only and hybrid
[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 FOUNDATION OR
19    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 #include <stdarg.h>
33 #include "celt.h"
34 #include "opus.h"
35 #include "entdec.h"
36 #include "modes.h"
37 #include "API.h"
38 #include "stack_alloc.h"
39 #include "float_cast.h"
40 #include "opus_private.h"
41 #include "os_support.h"
42 #include "structs.h"
43 #include "define.h"
44
45 struct OpusDecoder {
46    int          celt_dec_offset;
47    int          silk_dec_offset;
48    int          channels;
49    opus_int32   Fs;          /** Sampling rate (at the API level) */
50    silk_DecControlStruct DecControl;
51
52    /* Everything beyond this point gets cleared on a reset */
53 #define OPUS_DECODER_RESET_START stream_channels
54    int          stream_channels;
55
56    int          bandwidth;
57    int          mode;
58    int          prev_mode;
59    int          frame_size;
60    int          prev_redundancy;
61
62    opus_uint32  rangeFinal;
63 };
64
65 #ifdef FIXED_POINT
66 static inline opus_int16 SAT16(opus_int32 x) {
67     return x > 32767 ? 32767 : x < -32768 ? -32768 : (opus_int16)x;
68 };
69 #endif
70
71
72 int opus_decoder_get_size(int channels)
73 {
74    int silkDecSizeBytes, celtDecSizeBytes;
75    int ret;
76    if (channels<1 || channels > 2)
77       return 0;
78    ret = silk_Get_Decoder_Size( &silkDecSizeBytes );
79    if(ret)
80       return 0;
81    silkDecSizeBytes = align(silkDecSizeBytes);
82    celtDecSizeBytes = celt_decoder_get_size(channels);
83    return align(sizeof(OpusDecoder))+silkDecSizeBytes+celtDecSizeBytes;
84 }
85
86 int opus_decoder_init(OpusDecoder *st, opus_int32 Fs, int channels)
87 {
88    void *silk_dec;
89    CELTDecoder *celt_dec;
90    int ret, silkDecSizeBytes;
91
92    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2))
93       return OPUS_BAD_ARG;
94
95    OPUS_CLEAR((char*)st, opus_decoder_get_size(channels));
96    /* Initialize SILK encoder */
97    ret = silk_Get_Decoder_Size(&silkDecSizeBytes);
98    if(ret)return OPUS_INTERNAL_ERROR;
99
100    silkDecSizeBytes = align(silkDecSizeBytes);
101    st->silk_dec_offset = align(sizeof(OpusDecoder));
102    st->celt_dec_offset = st->silk_dec_offset+silkDecSizeBytes;
103    silk_dec = (char*)st+st->silk_dec_offset;
104    celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
105    st->stream_channels = st->channels = channels;
106
107    st->Fs = Fs;
108    st->DecControl.API_sampleRate = st->Fs;
109    st->DecControl.nChannelsAPI      = st->channels;
110
111    /* Reset decoder */
112    ret = silk_InitDecoder( silk_dec );
113    if(ret)return OPUS_INTERNAL_ERROR;
114
115    /* Initialize CELT decoder */
116    ret = celt_decoder_init(celt_dec, Fs, channels);
117    if(ret!=OPUS_OK)return OPUS_INTERNAL_ERROR;
118
119    celt_decoder_ctl(celt_dec, CELT_SET_SIGNALLING(0));
120
121    st->prev_mode = 0;
122    st->frame_size = Fs/400;
123    return OPUS_OK;
124 }
125
126 OpusDecoder *opus_decoder_create(opus_int32 Fs, int channels, int *error)
127 {
128    int ret;
129    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2))
130    {
131       if (error)
132          *error = OPUS_BAD_ARG;
133       return NULL;
134    }
135    OpusDecoder *st = (OpusDecoder *)opus_alloc(opus_decoder_get_size(channels));
136    if (st == NULL)
137    {
138       if (error)
139          *error = OPUS_ALLOC_FAIL;
140       return NULL;
141    }
142    ret = opus_decoder_init(st, Fs, channels);
143    if (error)
144       *error = ret;
145    if (ret != OPUS_OK)
146    {
147       opus_free(st);
148       st = NULL;
149    }
150    return st;
151 }
152
153 static void smooth_fade(const opus_val16 *in1, const opus_val16 *in2, opus_val16 *out,
154         int overlap, int channels, const opus_val16 *window, opus_int32 Fs)
155 {
156         int i, c;
157         int inc = 48000/Fs;
158         for (c=0;c<channels;c++)
159         {
160                 for (i=0;i<overlap;i++)
161                 {
162                     opus_val16 w = MULT16_16_Q15(window[i*inc], window[i*inc]);
163                     out[i*channels+c] = SHR32(MAC16_16(MULT16_16(w,in2[i*channels+c]),
164                             Q15ONE-w, in1[i*channels+c]), 15);
165                 }
166         }
167 }
168
169 static int opus_packet_get_mode(const unsigned char *data)
170 {
171         int mode;
172     if (data[0]&0x80)
173     {
174         mode = MODE_CELT_ONLY;
175     } else if ((data[0]&0x60) == 0x60)
176     {
177         mode = MODE_HYBRID;
178     } else {
179
180         mode = MODE_SILK_ONLY;
181     }
182     return mode;
183 }
184
185 static int opus_decode_frame(OpusDecoder *st, const unsigned char *data,
186                 int len, opus_val16 *pcm, int frame_size, int decode_fec)
187 {
188     void *silk_dec;
189     CELTDecoder *celt_dec;
190     int i, silk_ret=0, celt_ret=0;
191     ec_dec dec;
192     opus_int32 silk_frame_size;
193     VARDECL(opus_int16, pcm_silk);
194     VARDECL(opus_val16, pcm_transition);
195     VARDECL(opus_val16, redundant_audio);
196
197     int audiosize;
198     int mode;
199     int transition=0;
200     int start_band;
201     int redundancy=0;
202     int redundancy_bytes = 0;
203     int celt_to_silk=0;
204     int c;
205     int F2_5, F5, F10, F20;
206     const opus_val16 *window;
207     opus_uint32 redundant_rng = 0;
208     ALLOC_STACK;
209
210     silk_dec = (char*)st+st->silk_dec_offset;
211     celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
212     F20 = st->Fs/50;
213     F10 = F20>>1;
214     F5 = F10>>1;
215     F2_5 = F5>>1;
216     if (frame_size < F2_5)
217        return OPUS_BUFFER_TOO_SMALL;
218     /* Payloads of 1 (2 including ToC) or 0 trigger the PLC/DTX */
219     if (len<=1)
220     {
221         data = NULL;
222         /* In that case, don't conceal more than what the ToC says */
223         frame_size = IMIN(frame_size, st->frame_size);
224     }
225     if (data != NULL)
226     {
227         audiosize = st->frame_size;
228         mode = st->mode;
229         ec_dec_init(&dec,(unsigned char*)data,len);
230     } else {
231         audiosize = frame_size;
232
233         if (st->prev_mode == 0)
234         {
235                 /* If we haven't got any packet yet, all we can do is return zeros */
236                 for (i=0;i<audiosize*st->channels;i++)
237                         pcm[i] = 0;
238                 RESTORE_STACK;
239                 return audiosize;
240         } else {
241                 mode = st->prev_mode;
242         }
243     }
244
245     ALLOC(pcm_transition, F5*st->channels, opus_val16);
246
247     if (data!=NULL && !st->prev_redundancy && mode != st->prev_mode && st->prev_mode > 0
248                 && !(mode == MODE_SILK_ONLY && st->prev_mode == MODE_HYBRID)
249                 && !(mode == MODE_HYBRID && st->prev_mode == MODE_SILK_ONLY))
250     {
251         transition = 1;
252         if (mode == MODE_CELT_ONLY)
253             opus_decode_frame(st, NULL, 0, pcm_transition, IMIN(F5, audiosize), 0);
254     }
255     if (audiosize > frame_size)
256     {
257         /*fprintf(stderr, "PCM buffer too small: %d vs %d (mode = %d)\n", audiosize, frame_size, mode);*/
258         RESTORE_STACK;
259         return OPUS_BAD_ARG;
260     } else {
261         frame_size = audiosize;
262     }
263
264     ALLOC(pcm_silk, IMAX(F10, frame_size)*st->channels, opus_int16);
265     ALLOC(redundant_audio, F5*st->channels, opus_val16);
266
267     /* SILK processing */
268     if (mode != MODE_CELT_ONLY)
269     {
270         int lost_flag, decoded_samples;
271         opus_int16 *pcm_ptr = pcm_silk;
272
273         if (st->prev_mode==MODE_CELT_ONLY)
274                 silk_InitDecoder( silk_dec );
275
276         /* The SILK PLC cannot support produce frames of less than 10 ms */
277         st->DecControl.payloadSize_ms = IMAX(10, 1000 * audiosize / st->Fs);
278
279         if (data != NULL)
280         {
281             st->DecControl.nChannelsInternal = st->stream_channels;
282             if( mode == MODE_SILK_ONLY ) {
283                 if( st->bandwidth == OPUS_BANDWIDTH_NARROWBAND ) {
284                     st->DecControl.internalSampleRate = 8000;
285                 } else if( st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND ) {
286                     st->DecControl.internalSampleRate = 12000;
287                 } else if( st->bandwidth == OPUS_BANDWIDTH_WIDEBAND ) {
288                     st->DecControl.internalSampleRate = 16000;
289                 } else {
290                     st->DecControl.internalSampleRate = 16000;
291                     silk_assert( 0 );
292                 }
293             } else {
294                 /* Hybrid mode */
295                 st->DecControl.internalSampleRate = 16000;
296             }
297         }
298
299         lost_flag = data == NULL ? 1 : 2 * decode_fec;
300         decoded_samples = 0;
301         do {
302             /* Call SILK decoder */
303             int first_frame = decoded_samples == 0;
304             silk_ret = silk_Decode( silk_dec, &st->DecControl,
305                 lost_flag, first_frame, &dec, pcm_ptr, &silk_frame_size );
306             if( silk_ret ) {
307                 if (lost_flag) {
308                         /* PLC failure should not be fatal */
309                         silk_frame_size = frame_size;
310                         for (i=0;i<frame_size*st->channels;i++)
311                                 pcm_ptr[i] = 0;
312                 } else {
313                    RESTORE_STACK;
314                    return OPUS_INVALID_PACKET;
315                 }
316             }
317             pcm_ptr += silk_frame_size * st->channels;
318             decoded_samples += silk_frame_size;
319         } while( decoded_samples < frame_size );
320     }
321
322     start_band = 0;
323     if (mode != MODE_CELT_ONLY && data != NULL && ec_tell(&dec)+29+8*(st->mode == MODE_HYBRID) < 8*len)
324     {
325         /* Check if we have a redundant 0-8 kHz band */
326         redundancy = ec_dec_bit_logp(&dec, 12);
327         if (redundancy)
328         {
329             celt_to_silk = ec_dec_bit_logp(&dec, 1);
330             /* redundancy_bytes will be at least two, in the non-hybrid case due to the ec_tell() check above */
331             redundancy_bytes = mode==MODE_HYBRID ? (opus_int32)ec_dec_uint(&dec, 256)+2 : len-((ec_tell(&dec)+7)>>3);
332             len -= redundancy_bytes;
333             if (len<0)
334             {
335                len=0;
336                redundancy_bytes=0;
337                redundancy = 0;
338             }
339             /* Shrink decoder because of raw bits */
340             dec.storage -= redundancy_bytes;
341         }
342     }
343     if (mode != MODE_CELT_ONLY)
344         start_band = 17;
345
346     {
347         int endband=21;
348
349         switch(st->bandwidth)
350         {
351         case OPUS_BANDWIDTH_NARROWBAND:
352             endband = 13;
353             break;
354         case OPUS_BANDWIDTH_MEDIUMBAND:
355         case OPUS_BANDWIDTH_WIDEBAND:
356             endband = 17;
357             break;
358         case OPUS_BANDWIDTH_SUPERWIDEBAND:
359             endband = 19;
360             break;
361         case OPUS_BANDWIDTH_FULLBAND:
362             endband = 21;
363             break;
364         }
365         celt_decoder_ctl(celt_dec, CELT_SET_END_BAND(endband));
366         celt_decoder_ctl(celt_dec, CELT_SET_CHANNELS(st->stream_channels));
367     }
368
369     if (redundancy)
370         transition = 0;
371
372     if (transition && mode != MODE_CELT_ONLY)
373         opus_decode_frame(st, NULL, 0, pcm_transition, IMIN(F5, audiosize), 0);
374
375     /* 5 ms redundant frame for CELT->SILK*/
376     if (redundancy && celt_to_silk)
377     {
378         celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
379         celt_decode_with_ec(celt_dec, data+len, redundancy_bytes, redundant_audio, F5, NULL);
380         celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_RANGE(&redundant_rng));
381         celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
382     }
383
384     /* MUST be after PLC */
385     celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(start_band));
386
387     if (transition)
388         celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
389
390     if (mode != MODE_SILK_ONLY)
391     {
392         int celt_frame_size = IMIN(F20, frame_size);
393         /* Make sure to discard any previous CELT state */
394         if (st->prev_mode == MODE_SILK_ONLY)
395            celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
396         /* Decode CELT */
397         celt_ret = celt_decode_with_ec(celt_dec, decode_fec?NULL:data, len, pcm, celt_frame_size, &dec);
398     } else {
399        unsigned char silence[2] = {0xFF, 0xFF};
400        for (i=0;i<frame_size*st->channels;i++)
401           pcm[i] = 0;
402        /* For hybrid -> SILK transitions, we let the CELT MDCT do a fade-out by decoding a silence frame */
403        if (st->prev_mode == MODE_HYBRID)
404        {
405           celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
406           celt_decode_with_ec(celt_dec, silence, 2, pcm, F2_5, NULL);
407        }
408     }
409
410     if (mode != MODE_CELT_ONLY)
411     {
412 #ifdef FIXED_POINT
413         for (i=0;i<frame_size*st->channels;i++)
414             pcm[i] = SAT16(pcm[i] + pcm_silk[i]);
415 #else
416         for (i=0;i<frame_size*st->channels;i++)
417             pcm[i] = pcm[i] + (1./32768.)*pcm_silk[i];
418 #endif
419     }
420
421     {
422         const CELTMode *celt_mode;
423         celt_decoder_ctl(celt_dec, CELT_GET_MODE(&celt_mode));
424         window = celt_mode->window;
425     }
426
427     /* 5 ms redundant frame for SILK->CELT */
428     if (redundancy && !celt_to_silk)
429     {
430         celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
431         celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
432
433         celt_decode_with_ec(celt_dec, data+len, redundancy_bytes, redundant_audio, F5, NULL);
434         celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_RANGE(&redundant_rng));
435         smooth_fade(pcm+st->channels*(frame_size-F2_5), redundant_audio+st->channels*F2_5,
436                         pcm+st->channels*(frame_size-F2_5), F2_5, st->channels, window, st->Fs);
437     }
438     if (redundancy && celt_to_silk)
439     {
440         for (c=0;c<st->channels;c++)
441         {
442             for (i=0;i<F2_5;i++)
443                 pcm[st->channels*i+c] = redundant_audio[st->channels*i+c];
444         }
445         smooth_fade(redundant_audio+st->channels*F2_5, pcm+st->channels*F2_5,
446                 pcm+st->channels*F2_5, F2_5, st->channels, window, st->Fs);
447     }
448     if (transition)
449     {
450         for (i=0;i<st->channels*F2_5;i++)
451                 pcm[i] = pcm_transition[i];
452         if (audiosize >= F5)
453             smooth_fade(pcm_transition+st->channels*F2_5, pcm+st->channels*F2_5,
454                     pcm+st->channels*F2_5, F2_5,
455                     st->channels, window, st->Fs);
456     }
457
458     if (len <= 1)
459        st->rangeFinal = 0;
460     else
461        st->rangeFinal = dec.rng ^ redundant_rng;
462
463     st->prev_mode = mode;
464     st->prev_redundancy = redundancy;
465     RESTORE_STACK;
466         return celt_ret<0 ? celt_ret : audiosize;
467
468 }
469
470 static int parse_size(const unsigned char *data, int len, short *size)
471 {
472         if (len<1)
473         {
474                 *size = -1;
475                 return -1;
476         } else if (data[0]<252)
477         {
478                 *size = data[0];
479                 return 1;
480         } else if (len<2)
481         {
482                 *size = -1;
483                 return -1;
484         } else {
485                 *size = 4*data[1] + data[0];
486                 return 2;
487         }
488 }
489
490 static int opus_packet_parse_impl(const unsigned char *data, int len,
491       int self_delimited, unsigned char *out_toc,
492       const unsigned char *frames[48], short size[48], int *payload_offset)
493 {
494    int i, bytes;
495    int count;
496    int cbr;
497    unsigned char ch, toc;
498    int framesize;
499    int last_size;
500    const unsigned char *data0 = data;
501
502    if (size==NULL)
503       return OPUS_BAD_ARG;
504
505    framesize = opus_packet_get_samples_per_frame(data, 48000);
506
507    cbr = 0;
508    toc = *data++;
509    len--;
510    last_size = len;
511    switch (toc&0x3)
512    {
513    /* One frame */
514    case 0:
515       count=1;
516       break;
517       /* Two CBR frames */
518    case 1:
519       count=2;
520       cbr = 1;
521       if (!self_delimited)
522       {
523          if (len&0x1)
524             return OPUS_INVALID_PACKET;
525          size[0] = last_size = len/2;
526       }
527       break;
528       /* Two VBR frames */
529    case 2:
530       count = 2;
531       bytes = parse_size(data, len, size);
532       len -= bytes;
533       if (size[0]<0 || size[0] > len)
534          return OPUS_INVALID_PACKET;
535       data += bytes;
536       last_size = len-size[0];
537       break;
538       /* Multiple CBR/VBR frames (from 0 to 120 ms) */
539    case 3:
540       if (len<1)
541          return OPUS_INVALID_PACKET;
542       /* Number of frames encoded in bits 0 to 5 */
543       ch = *data++;
544       count = ch&0x3F;
545       if (count <= 0 || framesize*count > 5760)
546           return OPUS_INVALID_PACKET;
547       len--;
548       /* Padding flag is bit 6 */
549       if (ch&0x40)
550       {
551          int padding=0;
552          int p;
553          do {
554             if (len<=0)
555                return OPUS_INVALID_PACKET;
556             p = *data++;
557             len--;
558             padding += p==255 ? 254: p;
559          } while (p==255);
560          len -= padding;
561       }
562       if (len<0)
563          return OPUS_INVALID_PACKET;
564       /* VBR flag is bit 7 */
565       cbr = !(ch&0x80);
566       if (!cbr)
567       {
568          /* VBR case */
569          last_size = len;
570          for (i=0;i<count-1;i++)
571          {
572             bytes = parse_size(data, len, size+i);
573             len -= bytes;
574             if (size[i]<0 || size[i] > len)
575                return OPUS_INVALID_PACKET;
576             data += bytes;
577             last_size -= bytes+size[i];
578          }
579          if (last_size<0)
580             return OPUS_INVALID_PACKET;
581       } else if (!self_delimited)
582       {
583          /* CBR case */
584          last_size = len/count;
585          if (last_size*count!=len)
586             return OPUS_INVALID_PACKET;
587          for (i=0;i<count-1;i++)
588             size[i] = last_size;
589       }
590       break;
591    }
592    /* Self-delimited framing has an extra size for the last frame. */
593    if (self_delimited)
594    {
595       bytes = parse_size(data, len, size+count-1);
596       len -= bytes;
597       if (size[count-1]<0 || size[count-1] > len)
598          return OPUS_INVALID_PACKET;
599       data += bytes;
600       /* For CBR packets, apply the size to all the frames. */
601       if (cbr)
602       {
603          if (size[count-1]*count > len)
604             return OPUS_INVALID_PACKET;
605          for (i=0;i<count-1;i++)
606             size[i] = size[count-1];
607       } else if(size[count-1] > last_size)
608          return OPUS_INVALID_PACKET;
609    } else
610    {
611       /* Because it's not encoded explicitly, it's possible the size of the
612           last packet (or all the packets, for the CBR case) is larger than
613           1275.
614          Reject them here.*/
615       if (last_size > 1275)
616         return OPUS_INVALID_PACKET;
617       size[count-1] = last_size;
618    }
619
620    if (frames)
621    {
622       for (i=0;i<count;i++)
623       {
624          frames[i] = data;
625          data += size[i];
626       }
627    }
628
629    if (out_toc)
630       *out_toc = toc;
631
632    if (payload_offset)
633       *payload_offset = data-data0;
634
635    return count;
636 }
637
638 int opus_packet_parse(const unsigned char *data, int len,
639       unsigned char *out_toc, const unsigned char *frames[48],
640       short size[48], int *payload_offset)
641 {
642    return opus_packet_parse_impl(data, len, 0,
643          out_toc, frames, size, payload_offset);
644 }
645
646 int opus_decode_native(OpusDecoder *st, const unsigned char *data,
647       int len, opus_val16 *pcm, int frame_size, int decode_fec, int self_delimited, int *packet_offset)
648 {
649         int i, nb_samples;
650         int count, offset;
651         unsigned char toc;
652         int tot_offset;
653         /* 48 x 2.5 ms = 120 ms */
654         short size[48];
655         if (decode_fec<0 || decode_fec>1)return OPUS_BAD_ARG;
656         if (len==0 || data==NULL)
657             return opus_decode_frame(st, NULL, 0, pcm, frame_size, 0);
658         else if (len<0)
659                 return OPUS_BAD_ARG;
660
661         tot_offset = 0;
662         st->mode = opus_packet_get_mode(data);
663         st->bandwidth = opus_packet_get_bandwidth(data);
664         st->frame_size = opus_packet_get_samples_per_frame(data, st->Fs);
665         st->stream_channels = opus_packet_get_nb_channels(data);
666
667         count = opus_packet_parse_impl(data, len, self_delimited, &toc, NULL, size, &offset);
668         if (count < 0)
669            return count;
670
671         data += offset;
672         tot_offset += offset;
673
674         if (count*st->frame_size > frame_size)
675                 return OPUS_BUFFER_TOO_SMALL;
676         nb_samples=0;
677         for (i=0;i<count;i++)
678         {
679                 int ret;
680                 ret = opus_decode_frame(st, data, size[i], pcm, frame_size-nb_samples, decode_fec);
681                 if (ret<0)
682                         return ret;
683                 data += size[i];
684                 tot_offset += size[i];
685                 pcm += ret*st->channels;
686                 nb_samples += ret;
687         }
688         if (packet_offset != NULL)
689            *packet_offset = tot_offset;
690         return nb_samples;
691 }
692
693 #ifdef FIXED_POINT
694
695 int opus_decode(OpusDecoder *st, const unsigned char *data,
696       int len, opus_val16 *pcm, int frame_size, int decode_fec)
697 {
698    return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL);
699 }
700
701 #ifndef DISABLE_FLOAT_API
702 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
703       int len, float *pcm, int frame_size, int decode_fec)
704 {
705    VARDECL(opus_int16, out);
706    int ret, i;
707    ALLOC_STACK;
708
709    ALLOC(out, frame_size*st->channels, opus_int16);
710
711    ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL);
712    if (ret > 0)
713    {
714       for (i=0;i<ret*st->channels;i++)
715          pcm[i] = (1./32768.)*(out[i]);
716    }
717    RESTORE_STACK;
718    return ret;
719 }
720 #endif
721
722
723 #else
724 int opus_decode(OpusDecoder *st, const unsigned char *data,
725       int len, opus_int16 *pcm, int frame_size, int decode_fec)
726 {
727    VARDECL(float, out);
728    int ret, i;
729    ALLOC_STACK;
730
731    ALLOC(out, frame_size*st->channels, float);
732
733    ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL);
734    if (ret > 0)
735    {
736       for (i=0;i<ret*st->channels;i++)
737          pcm[i] = FLOAT2INT16(out[i]);
738    }
739    RESTORE_STACK;
740    return ret;
741 }
742
743 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
744         int len, opus_val16 *pcm, int frame_size, int decode_fec)
745 {
746    return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL);
747 }
748
749 #endif
750
751 int opus_decoder_ctl(OpusDecoder *st, int request, ...)
752 {
753    int ret = OPUS_OK;
754    va_list ap;
755    void *silk_dec;
756    CELTDecoder *celt_dec;
757
758    silk_dec = (char*)st+st->silk_dec_offset;
759    celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
760
761
762    va_start(ap, request);
763
764    switch (request)
765    {
766    case OPUS_GET_BANDWIDTH_REQUEST:
767    {
768       opus_int32 *value = va_arg(ap, opus_int32*);
769       *value = st->bandwidth;
770    }
771    break;
772    case OPUS_GET_FINAL_RANGE_REQUEST:
773    {
774       opus_uint32 *value = va_arg(ap, opus_uint32*);
775       *value = st->rangeFinal;
776    }
777    break;
778    case OPUS_RESET_STATE:
779    {
780       OPUS_CLEAR((char*)&st->OPUS_DECODER_RESET_START,
781             sizeof(OpusDecoder)-
782             ((char*)&st->OPUS_DECODER_RESET_START - (char*)st));
783
784       celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
785       silk_InitDecoder( silk_dec );
786       st->stream_channels = st->channels;
787       st->frame_size = st->Fs/400;
788    }
789    break;
790    case OPUS_GET_PITCH_REQUEST:
791    {
792       int *value = va_arg(ap, opus_int32*);
793       if (value==NULL)
794       {
795          ret = OPUS_BAD_ARG;
796          break;
797       }
798       if (st->prev_mode == MODE_CELT_ONLY)
799          celt_decoder_ctl(celt_dec, OPUS_GET_PITCH(value));
800       else
801          *value = ((silk_decoder_state*)silk_dec)->indices.signalType == TYPE_VOICED
802          ? ((silk_decoder_state*)silk_dec)->lagPrev*48/((silk_decoder_state*)silk_dec)->fs_kHz
803          : 0;
804    }
805    break;
806    default:
807       /*fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);*/
808       ret = OPUS_UNIMPLEMENTED;
809       break;
810    }
811
812    va_end(ap);
813    return ret;
814 }
815
816 void opus_decoder_destroy(OpusDecoder *st)
817 {
818         opus_free(st);
819 }
820
821
822 int opus_packet_get_bandwidth(const unsigned char *data)
823 {
824         int bandwidth;
825     if (data[0]&0x80)
826     {
827         bandwidth = OPUS_BANDWIDTH_MEDIUMBAND + ((data[0]>>5)&0x3);
828         if (bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
829             bandwidth = OPUS_BANDWIDTH_NARROWBAND;
830     } else if ((data[0]&0x60) == 0x60)
831     {
832         bandwidth = (data[0]&0x10) ? OPUS_BANDWIDTH_FULLBAND : OPUS_BANDWIDTH_SUPERWIDEBAND;
833     } else {
834
835         bandwidth = OPUS_BANDWIDTH_NARROWBAND + ((data[0]>>5)&0x3);
836     }
837     return bandwidth;
838 }
839
840 int opus_packet_get_samples_per_frame(const unsigned char *data, opus_int32 Fs)
841 {
842     int audiosize;
843     if (data[0]&0x80)
844     {
845         audiosize = ((data[0]>>3)&0x3);
846         audiosize = (Fs<<audiosize)/400;
847     } else if ((data[0]&0x60) == 0x60)
848     {
849         audiosize = (data[0]&0x08) ? Fs/50 : Fs/100;
850     } else {
851
852         audiosize = ((data[0]>>3)&0x3);
853         if (audiosize == 3)
854             audiosize = Fs*60/1000;
855         else
856             audiosize = (Fs<<audiosize)/100;
857     }
858     return audiosize;
859 }
860
861 int opus_packet_get_nb_channels(const unsigned char *data)
862 {
863     return (data[0]&0x4) ? 2 : 1;
864 }
865
866 int opus_packet_get_nb_frames(const unsigned char packet[], int len)
867 {
868         int count;
869         if (len<1)
870                 return OPUS_BAD_ARG;
871         count = packet[0]&0x3;
872         if (count==0)
873                 return 1;
874         else if (count!=3)
875                 return 2;
876         else if (len<2)
877                 return OPUS_INVALID_PACKET;
878         else
879                 return packet[1]&0x3F;
880 }
881
882 int opus_decoder_get_nb_samples(const OpusDecoder *dec, const unsigned char packet[], int len)
883 {
884         int samples;
885         int count = opus_packet_get_nb_frames(packet, len);
886         samples = count*opus_packet_get_samples_per_frame(packet, dec->Fs);
887         /* Can't have more than 120 ms */
888         if (samples*25 > dec->Fs*3)
889                 return OPUS_INVALID_PACKET;
890         else
891                 return samples;
892 }