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