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