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