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