00fd2abfe652914f350a34f950cf29b4de6a9aca
[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)+29+8*(st->mode == MODE_HYBRID) < 8*len)
325     {
326         /* Check if we have a redundant 0-8 kHz band */
327         redundancy = ec_dec_bit_logp(&dec, 12);
328         if (redundancy)
329         {
330             celt_to_silk = ec_dec_bit_logp(&dec, 1);
331             /* redundancy_bytes will be at least two, in the non-hybrid case due to the ec_tell() check above */
332             redundancy_bytes = mode==MODE_HYBRID ? (opus_int32)ec_dec_uint(&dec, 256)+2 : len-((ec_tell(&dec)+7)>>3);
333             len -= redundancy_bytes;
334             if (len<0)
335             {
336                len=0;
337                redundancy_bytes=0;
338                redundancy = 0;
339             }
340             /* Shrink decoder because of raw bits */
341             dec.storage -= redundancy_bytes;
342         }
343     }
344     if (mode != MODE_CELT_ONLY)
345         start_band = 17;
346
347     {
348         int endband=21;
349
350         switch(st->bandwidth)
351         {
352         case OPUS_BANDWIDTH_NARROWBAND:
353             endband = 13;
354             break;
355         case OPUS_BANDWIDTH_MEDIUMBAND:
356         case OPUS_BANDWIDTH_WIDEBAND:
357             endband = 17;
358             break;
359         case OPUS_BANDWIDTH_SUPERWIDEBAND:
360             endband = 19;
361             break;
362         case OPUS_BANDWIDTH_FULLBAND:
363             endband = 21;
364             break;
365         }
366         celt_decoder_ctl(celt_dec, CELT_SET_END_BAND(endband));
367         celt_decoder_ctl(celt_dec, CELT_SET_CHANNELS(st->stream_channels));
368     }
369
370     if (redundancy)
371         transition = 0;
372
373     if (transition && mode != MODE_CELT_ONLY)
374         opus_decode_frame(st, NULL, 0, pcm_transition, IMIN(F5, audiosize), 0);
375
376     /* 5 ms redundant frame for CELT->SILK*/
377     if (redundancy && celt_to_silk)
378     {
379         celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
380         celt_decode_with_ec(celt_dec, data+len, redundancy_bytes, redundant_audio, F5, NULL);
381         celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_RANGE(&redundant_rng));
382         celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
383     }
384
385     /* MUST be after PLC */
386     celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(start_band));
387
388     if (transition)
389         celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
390
391     if (mode != MODE_SILK_ONLY)
392     {
393         int celt_frame_size = IMIN(F20, frame_size);
394         /* Make sure to discard any previous CELT state */
395         if (st->prev_mode == MODE_SILK_ONLY)
396            celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
397         /* Decode CELT */
398         celt_ret = celt_decode_with_ec(celt_dec, decode_fec?NULL:data, len, pcm, celt_frame_size, &dec);
399     } else {
400        unsigned char silence[2] = {0xFF, 0xFF};
401        for (i=0;i<frame_size*st->channels;i++)
402           pcm[i] = 0;
403        /* For hybrid -> SILK transitions, we let the CELT MDCT do a fade-out by decoding a silence frame */
404        if (st->prev_mode == MODE_HYBRID)
405        {
406           celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
407           celt_decode_with_ec(celt_dec, silence, 2, pcm, F2_5, NULL);
408        }
409     }
410
411     if (mode != MODE_CELT_ONLY)
412     {
413 #ifdef FIXED_POINT
414         for (i=0;i<frame_size*st->channels;i++)
415             pcm[i] = SAT16(pcm[i] + pcm_silk[i]);
416 #else
417         for (i=0;i<frame_size*st->channels;i++)
418             pcm[i] = pcm[i] + (1./32768.)*pcm_silk[i];
419 #endif
420     }
421
422     {
423         const CELTMode *celt_mode;
424         celt_decoder_ctl(celt_dec, CELT_GET_MODE(&celt_mode));
425         window = celt_mode->window;
426     }
427
428     /* 5 ms redundant frame for SILK->CELT */
429     if (redundancy && !celt_to_silk)
430     {
431         celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
432         celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
433
434         celt_decode_with_ec(celt_dec, data+len, redundancy_bytes, redundant_audio, F5, NULL);
435         celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_RANGE(&redundant_rng));
436         smooth_fade(pcm+st->channels*(frame_size-F2_5), redundant_audio+st->channels*F2_5,
437                         pcm+st->channels*(frame_size-F2_5), F2_5, st->channels, window, st->Fs);
438     }
439     if (redundancy && celt_to_silk)
440     {
441         for (c=0;c<st->channels;c++)
442         {
443             for (i=0;i<F2_5;i++)
444                 pcm[st->channels*i+c] = redundant_audio[st->channels*i+c];
445         }
446         smooth_fade(redundant_audio+st->channels*F2_5, pcm+st->channels*F2_5,
447                 pcm+st->channels*F2_5, F2_5, st->channels, window, st->Fs);
448     }
449     if (transition)
450     {
451         for (i=0;i<st->channels*F2_5;i++)
452                 pcm[i] = pcm_transition[i];
453         if (audiosize >= F5)
454             smooth_fade(pcm_transition+st->channels*F2_5, pcm+st->channels*F2_5,
455                     pcm+st->channels*F2_5, F2_5,
456                     st->channels, window, st->Fs);
457     }
458
459     if (len <= 1)
460        st->rangeFinal = 0;
461     else
462        st->rangeFinal = dec.rng ^ redundant_rng;
463
464     st->prev_mode = mode;
465     st->prev_redundancy = redundancy;
466     RESTORE_STACK;
467         return celt_ret<0 ? celt_ret : audiosize;
468
469 }
470
471 static int parse_size(const unsigned char *data, int len, short *size)
472 {
473         if (len<1)
474         {
475                 *size = -1;
476                 return -1;
477         } else if (data[0]<252)
478         {
479                 *size = data[0];
480                 return 1;
481         } else if (len<2)
482         {
483                 *size = -1;
484                 return -1;
485         } else {
486                 *size = 4*data[1] + data[0];
487                 return 2;
488         }
489 }
490
491 static int opus_packet_parse_impl(const unsigned char *data, int len,
492       int self_delimited, unsigned char *out_toc,
493       const unsigned char *frames[48], short size[48], int *payload_offset)
494 {
495    int i, bytes;
496    int count;
497    int cbr;
498    unsigned char ch, toc;
499    int framesize;
500    int last_size;
501    const unsigned char *data0 = data;
502
503    if (size==NULL)
504       return OPUS_BAD_ARG;
505
506    framesize = opus_packet_get_samples_per_frame(data, 48000);
507
508    cbr = 0;
509    toc = *data++;
510    len--;
511    last_size = len;
512    switch (toc&0x3)
513    {
514    /* One frame */
515    case 0:
516       count=1;
517       break;
518       /* Two CBR frames */
519    case 1:
520       count=2;
521       cbr = 1;
522       if (!self_delimited)
523       {
524          if (len&0x1)
525             return OPUS_INVALID_PACKET;
526          size[0] = last_size = len/2;
527       }
528       break;
529       /* Two VBR frames */
530    case 2:
531       count = 2;
532       bytes = parse_size(data, len, size);
533       len -= bytes;
534       if (size[0]<0 || size[0] > len)
535          return OPUS_INVALID_PACKET;
536       data += bytes;
537       last_size = len-size[0];
538       break;
539       /* Multiple CBR/VBR frames (from 0 to 120 ms) */
540    case 3:
541       if (len<1)
542          return OPUS_INVALID_PACKET;
543       /* Number of frames encoded in bits 0 to 5 */
544       ch = *data++;
545       count = ch&0x3F;
546       if (count <= 0 || framesize*count > 5760)
547           return OPUS_INVALID_PACKET;
548       len--;
549       /* Padding flag is bit 6 */
550       if (ch&0x40)
551       {
552          int padding=0;
553          int p;
554          do {
555             if (len<=0)
556                return OPUS_INVALID_PACKET;
557             p = *data++;
558             len--;
559             padding += p==255 ? 254: p;
560          } while (p==255);
561          len -= padding;
562       }
563       if (len<0)
564          return OPUS_INVALID_PACKET;
565       /* VBR flag is bit 7 */
566       cbr = !(ch&0x80);
567       if (!cbr)
568       {
569          /* VBR case */
570          last_size = len;
571          for (i=0;i<count-1;i++)
572          {
573             bytes = parse_size(data, len, size+i);
574             len -= bytes;
575             if (size[i]<0 || size[i] > len)
576                return OPUS_INVALID_PACKET;
577             data += bytes;
578             last_size -= bytes+size[i];
579          }
580          if (last_size<0)
581             return OPUS_INVALID_PACKET;
582       } else if (!self_delimited)
583       {
584          /* CBR case */
585          last_size = len/count;
586          if (last_size*count!=len)
587             return OPUS_INVALID_PACKET;
588          for (i=0;i<count-1;i++)
589             size[i] = last_size;
590       }
591       break;
592    }
593    /* Self-delimited framing has an extra size for the last frame. */
594    if (self_delimited)
595    {
596       bytes = parse_size(data, len, size+count-1);
597       len -= bytes;
598       if (size[count-1]<0 || size[count-1] > len)
599          return OPUS_INVALID_PACKET;
600       data += bytes;
601       /* For CBR packets, apply the size to all the frames. */
602       if (cbr)
603       {
604          if (size[count-1]*count > len)
605             return OPUS_INVALID_PACKET;
606          for (i=0;i<count-1;i++)
607             size[i] = size[count-1];
608       } else if(size[count-1] > last_size)
609          return OPUS_INVALID_PACKET;
610    } else
611    {
612       /* Because it's not encoded explicitly, it's possible the size of the
613           last packet (or all the packets, for the CBR case) is larger than
614           1275.
615          Reject them here.*/
616       if (last_size > 1275)
617         return OPUS_INVALID_PACKET;
618       size[count-1] = last_size;
619    }
620
621    if (frames)
622    {
623       for (i=0;i<count;i++)
624       {
625          frames[i] = data;
626          data += size[i];
627       }
628    }
629
630    if (out_toc)
631       *out_toc = toc;
632
633    if (payload_offset)
634       *payload_offset = data-data0;
635
636    return count;
637 }
638
639 int opus_packet_parse(const unsigned char *data, int len,
640       unsigned char *out_toc, const unsigned char *frames[48],
641       short size[48], int *payload_offset)
642 {
643    return opus_packet_parse_impl(data, len, 0,
644          out_toc, frames, size, payload_offset);
645 }
646
647 int opus_decode_native(OpusDecoder *st, const unsigned char *data,
648       int len, opus_val16 *pcm, int frame_size, int decode_fec, int self_delimited, int *packet_offset)
649 {
650         int i, nb_samples;
651         int count, offset;
652         unsigned char toc;
653         int tot_offset;
654         /* 48 x 2.5 ms = 120 ms */
655         short size[48];
656         if (decode_fec<0 || decode_fec>1)return OPUS_BAD_ARG;
657         if (len==0 || data==NULL)
658             return opus_decode_frame(st, NULL, 0, pcm, frame_size, 0);
659         else if (len<0)
660                 return OPUS_BAD_ARG;
661
662         tot_offset = 0;
663         st->mode = opus_packet_get_mode(data);
664         st->bandwidth = opus_packet_get_bandwidth(data);
665         st->frame_size = opus_packet_get_samples_per_frame(data, st->Fs);
666         st->stream_channels = opus_packet_get_nb_channels(data);
667
668         count = opus_packet_parse_impl(data, len, self_delimited, &toc, NULL, size, &offset);
669         if (count < 0)
670            return count;
671
672         data += offset;
673         tot_offset += offset;
674
675         if (count*st->frame_size > frame_size)
676                 return OPUS_BUFFER_TOO_SMALL;
677         nb_samples=0;
678         for (i=0;i<count;i++)
679         {
680                 int ret;
681                 ret = opus_decode_frame(st, data, size[i], pcm, frame_size-nb_samples, decode_fec);
682                 if (ret<0)
683                         return ret;
684                 data += size[i];
685                 tot_offset += size[i];
686                 pcm += ret*st->channels;
687                 nb_samples += ret;
688         }
689         if (packet_offset != NULL)
690            *packet_offset = tot_offset;
691         return nb_samples;
692 }
693
694 #ifdef FIXED_POINT
695
696 int opus_decode(OpusDecoder *st, const unsigned char *data,
697       int len, opus_val16 *pcm, int frame_size, int decode_fec)
698 {
699    return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL);
700 }
701
702 #ifndef DISABLE_FLOAT_API
703 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
704       int len, float *pcm, int frame_size, int decode_fec)
705 {
706    VARDECL(opus_int16, out);
707    int ret, i;
708    ALLOC_STACK;
709
710    ALLOC(out, frame_size*st->channels, opus_int16);
711
712    ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL);
713    if (ret > 0)
714    {
715       for (i=0;i<ret*st->channels;i++)
716          pcm[i] = (1./32768.)*(out[i]);
717    }
718    RESTORE_STACK;
719    return ret;
720 }
721 #endif
722
723
724 #else
725 int opus_decode(OpusDecoder *st, const unsigned char *data,
726       int len, opus_int16 *pcm, int frame_size, int decode_fec)
727 {
728    VARDECL(float, out);
729    int ret, i;
730    ALLOC_STACK;
731
732    ALLOC(out, frame_size*st->channels, float);
733
734    ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL);
735    if (ret > 0)
736    {
737       for (i=0;i<ret*st->channels;i++)
738          pcm[i] = FLOAT2INT16(out[i]);
739    }
740    RESTORE_STACK;
741    return ret;
742 }
743
744 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
745         int len, opus_val16 *pcm, int frame_size, int decode_fec)
746 {
747    return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL);
748 }
749
750 #endif
751
752 int opus_decoder_ctl(OpusDecoder *st, int request, ...)
753 {
754    int ret = OPUS_OK;
755    va_list ap;
756    void *silk_dec;
757    CELTDecoder *celt_dec;
758
759    silk_dec = (char*)st+st->silk_dec_offset;
760    celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
761
762
763    va_start(ap, request);
764
765    switch (request)
766    {
767    case OPUS_GET_BANDWIDTH_REQUEST:
768    {
769       opus_int32 *value = va_arg(ap, opus_int32*);
770       *value = st->bandwidth;
771    }
772    break;
773    case OPUS_GET_FINAL_RANGE_REQUEST:
774    {
775       opus_uint32 *value = va_arg(ap, opus_uint32*);
776       *value = st->rangeFinal;
777    }
778    break;
779    case OPUS_RESET_STATE:
780    {
781       OPUS_CLEAR((char*)&st->OPUS_DECODER_RESET_START,
782             sizeof(OpusDecoder)-
783             ((char*)&st->OPUS_DECODER_RESET_START - (char*)st));
784
785       celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
786       silk_InitDecoder( silk_dec );
787       st->stream_channels = st->channels;
788       st->frame_size = st->Fs/400;
789    }
790    break;
791    case OPUS_GET_PITCH_REQUEST:
792    {
793       int *value = va_arg(ap, opus_int32*);
794       if (value==NULL)
795       {
796          ret = OPUS_BAD_ARG;
797          break;
798       }
799       if (st->prev_mode == MODE_CELT_ONLY)
800          celt_decoder_ctl(celt_dec, OPUS_GET_PITCH(value));
801       else
802          *value = ((silk_decoder_state*)silk_dec)->indices.signalType == TYPE_VOICED
803          ? ((silk_decoder_state*)silk_dec)->lagPrev*48/((silk_decoder_state*)silk_dec)->fs_kHz
804          : 0;
805    }
806    break;
807    default:
808       /*fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);*/
809       ret = OPUS_UNIMPLEMENTED;
810       break;
811    }
812
813    va_end(ap);
814    return ret;
815 }
816
817 void opus_decoder_destroy(OpusDecoder *st)
818 {
819         opus_free(st);
820 }
821
822
823 int opus_packet_get_bandwidth(const unsigned char *data)
824 {
825         int bandwidth;
826     if (data[0]&0x80)
827     {
828         bandwidth = OPUS_BANDWIDTH_MEDIUMBAND + ((data[0]>>5)&0x3);
829         if (bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
830             bandwidth = OPUS_BANDWIDTH_NARROWBAND;
831     } else if ((data[0]&0x60) == 0x60)
832     {
833         bandwidth = (data[0]&0x10) ? OPUS_BANDWIDTH_FULLBAND : OPUS_BANDWIDTH_SUPERWIDEBAND;
834     } else {
835
836         bandwidth = OPUS_BANDWIDTH_NARROWBAND + ((data[0]>>5)&0x3);
837     }
838     return bandwidth;
839 }
840
841 int opus_packet_get_samples_per_frame(const unsigned char *data, opus_int32 Fs)
842 {
843     int audiosize;
844     if (data[0]&0x80)
845     {
846         audiosize = ((data[0]>>3)&0x3);
847         audiosize = (Fs<<audiosize)/400;
848     } else if ((data[0]&0x60) == 0x60)
849     {
850         audiosize = (data[0]&0x08) ? Fs/50 : Fs/100;
851     } else {
852
853         audiosize = ((data[0]>>3)&0x3);
854         if (audiosize == 3)
855             audiosize = Fs*60/1000;
856         else
857             audiosize = (Fs<<audiosize)/100;
858     }
859     return audiosize;
860 }
861
862 int opus_packet_get_nb_channels(const unsigned char *data)
863 {
864     return (data[0]&0x4) ? 2 : 1;
865 }
866
867 int opus_packet_get_nb_frames(const unsigned char packet[], int len)
868 {
869         int count;
870         if (len<1)
871                 return OPUS_BAD_ARG;
872         count = packet[0]&0x3;
873         if (count==0)
874                 return 1;
875         else if (count!=3)
876                 return 2;
877         else if (len<2)
878                 return OPUS_INVALID_PACKET;
879         else
880                 return packet[1]&0x3F;
881 }
882
883 int opus_decoder_get_nb_samples(const OpusDecoder *dec, const unsigned char packet[], int len)
884 {
885         int samples;
886         int count = opus_packet_get_nb_frames(packet, len);
887         samples = count*opus_packet_get_samples_per_frame(packet, dec->Fs);
888         /* Can't have more than 120 ms */
889         if (samples*25 > dec->Fs*3)
890                 return OPUS_INVALID_PACKET;
891         else
892                 return samples;
893 }