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