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