Eliminate redundant redundancy code.
[opus.git] / src / opus_decoder.c
1 /* Copyright (c) 2010 Xiph.Org Foundation, Skype Limited
2    Written by Jean-Marc Valin and Koen Vos */
3 /*
4    Redistribution and use in source and binary forms, with or without
5    modification, are permitted provided that the following conditions
6    are met:
7
8    - Redistributions of source code must retain the above copyright
9    notice, this list of conditions and the following disclaimer.
10
11    - Redistributions in binary form must reproduce the above copyright
12    notice, this list of conditions and the following disclaimer in the
13    documentation and/or other materials provided with the distribution.
14
15    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
18    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
19    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
23    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
24    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #ifdef HAVE_CONFIG_H
29 #include "config.h"
30 #endif
31
32 #include <stdarg.h>
33 #include "celt.h"
34 #include "opus.h"
35 #include "entdec.h"
36 #include "modes.h"
37 #include "API.h"
38 #include "stack_alloc.h"
39 #include "float_cast.h"
40 #include "opus_private.h"
41 #include "os_support.h"
42 #include "structs.h"
43 #include "define.h"
44
45 struct OpusDecoder {
46    int          celt_dec_offset;
47    int          silk_dec_offset;
48    int          channels;
49    opus_int32   Fs;          /** Sampling rate (at the API level) */
50
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((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2))
92       return OPUS_BAD_ARG;
93
94    OPUS_CLEAR((char*)st, opus_decoder_get_size(channels));
95    /* Initialize SILK encoder */
96    ret = silk_Get_Decoder_Size(&silkDecSizeBytes);
97    if(ret)return OPUS_INTERNAL_ERROR;
98
99    silkDecSizeBytes = align(silkDecSizeBytes);
100    st->silk_dec_offset = align(sizeof(OpusDecoder));
101    st->celt_dec_offset = st->silk_dec_offset+silkDecSizeBytes;
102    silk_dec = (char*)st+st->silk_dec_offset;
103    celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
104    st->stream_channels = st->channels = channels;
105
106    st->Fs = Fs;
107
108    /* Reset decoder */
109    ret = silk_InitDecoder( silk_dec );
110    if(ret)return OPUS_INTERNAL_ERROR;
111
112    /* Initialize CELT decoder */
113    ret = celt_decoder_init(celt_dec, Fs, channels);
114    if(ret!=OPUS_OK)return OPUS_INTERNAL_ERROR;
115
116    celt_decoder_ctl(celt_dec, CELT_SET_SIGNALLING(0));
117
118    st->prev_mode = 0;
119    st->frame_size = Fs/400;
120    return OPUS_OK;
121 }
122
123 OpusDecoder *opus_decoder_create(opus_int32 Fs, int channels, int *error)
124 {
125    int ret;
126    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2))
127    {
128       if (error)
129          *error = OPUS_BAD_ARG;
130       return NULL;
131    }
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 (error)
141       *error = ret;
142    if (ret != OPUS_OK)
143    {
144       opus_free(st);
145       st = NULL;
146    }
147    return st;
148 }
149
150 static void smooth_fade(const opus_val16 *in1, const opus_val16 *in2, opus_val16 *out,
151         int overlap, int channels, const opus_val16 *window, opus_int32 Fs)
152 {
153         int i, c;
154         int inc = 48000/Fs;
155         for (c=0;c<channels;c++)
156         {
157                 for (i=0;i<overlap;i++)
158                 {
159                     opus_val16 w = MULT16_16_Q15(window[i*inc], window[i*inc]);
160                     out[i*channels+c] = SHR32(MAC16_16(MULT16_16(w,in2[i*channels+c]),
161                             Q15ONE-w, in1[i*channels+c]), 15);
162                 }
163         }
164 }
165
166 static int opus_packet_get_mode(const unsigned char *data)
167 {
168         int mode;
169     if (data[0]&0x80)
170     {
171         mode = MODE_CELT_ONLY;
172     } else if ((data[0]&0x60) == 0x60)
173     {
174         mode = MODE_HYBRID;
175     } else {
176
177         mode = MODE_SILK_ONLY;
178     }
179     return mode;
180 }
181
182 static int opus_decode_frame(OpusDecoder *st, const unsigned char *data,
183                 int len, opus_val16 *pcm, int frame_size, int decode_fec)
184 {
185     void *silk_dec;
186     CELTDecoder *celt_dec;
187     int i, silk_ret=0, celt_ret=0;
188     ec_dec dec;
189     silk_DecControlStruct DecControl;
190     opus_int32 silk_frame_size;
191     VARDECL(opus_int16, pcm_silk);
192     VARDECL(opus_val16, pcm_transition);
193     VARDECL(opus_val16, redundant_audio);
194
195     int audiosize;
196     int mode;
197     int transition=0;
198     int start_band;
199     int redundancy=0;
200     int redundancy_bytes = 0;
201     int celt_to_silk=0;
202     int c;
203     int F2_5, F5, F10, F20;
204     const opus_val16 *window;
205     opus_uint32 redundant_rng = 0;
206     ALLOC_STACK;
207
208     silk_dec = (char*)st+st->silk_dec_offset;
209     celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
210     F20 = st->Fs/50;
211     F10 = F20>>1;
212     F5 = F10>>1;
213     F2_5 = F5>>1;
214     if (frame_size < F2_5)
215        return OPUS_BUFFER_TOO_SMALL;
216     /* Payloads of 1 (2 including ToC) or 0 trigger the PLC/DTX */
217     if (len<=1)
218     {
219         data = NULL;
220         /* In that case, don't conceal more than what the ToC says */
221         frame_size = IMIN(frame_size, st->frame_size);
222     }
223     if (data != NULL)
224     {
225         audiosize = st->frame_size;
226         mode = st->mode;
227         ec_dec_init(&dec,(unsigned char*)data,len);
228     } else {
229         audiosize = frame_size;
230
231         if (st->prev_mode == 0)
232         {
233                 /* If we haven't got any packet yet, all we can do is return zeros */
234                 for (i=0;i<audiosize*st->channels;i++)
235                         pcm[i] = 0;
236                 RESTORE_STACK;
237                 return audiosize;
238         } else {
239                 mode = st->prev_mode;
240         }
241     }
242
243     ALLOC(pcm_transition, F5*st->channels, opus_val16);
244
245     if (data!=NULL && !st->prev_redundancy && mode != st->prev_mode && st->prev_mode > 0
246                 && !(mode == MODE_SILK_ONLY && st->prev_mode == MODE_HYBRID)
247                 && !(mode == MODE_HYBRID && st->prev_mode == MODE_SILK_ONLY))
248     {
249         transition = 1;
250         if (mode == MODE_CELT_ONLY)
251             opus_decode_frame(st, NULL, 0, pcm_transition, IMIN(F5, audiosize), 0);
252     }
253     if (audiosize > frame_size)
254     {
255         /*fprintf(stderr, "PCM buffer too small: %d vs %d (mode = %d)\n", audiosize, frame_size, mode);*/
256         RESTORE_STACK;
257         return OPUS_BAD_ARG;
258     } else {
259         frame_size = audiosize;
260     }
261
262     ALLOC(pcm_silk, frame_size*st->channels, opus_int16);
263     ALLOC(redundant_audio, F5*st->channels, opus_val16);
264
265     /* SILK processing */
266     if (mode != MODE_CELT_ONLY)
267     {
268         int lost_flag, decoded_samples;
269         opus_int16 *pcm_ptr = pcm_silk;
270
271         if (st->prev_mode==MODE_CELT_ONLY)
272                 silk_InitDecoder( silk_dec );
273
274         DecControl.API_sampleRate = st->Fs;
275         DecControl.nChannelsAPI      = st->channels;
276         DecControl.nChannelsInternal = st->stream_channels;
277         DecControl.payloadSize_ms = 1000 * audiosize / st->Fs;
278         if( mode == MODE_SILK_ONLY ) {
279             if( st->bandwidth == OPUS_BANDWIDTH_NARROWBAND ) {
280                 DecControl.internalSampleRate = 8000;
281             } else if( st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND ) {
282                 DecControl.internalSampleRate = 12000;
283             } else if( st->bandwidth == OPUS_BANDWIDTH_WIDEBAND ) {
284                 DecControl.internalSampleRate = 16000;
285             } else {
286                 DecControl.internalSampleRate = 16000;
287                 silk_assert( 0 );
288             }
289         } else {
290             /* Hybrid mode */
291             DecControl.internalSampleRate = 16000;
292         }
293
294         lost_flag = data == NULL ? 1 : 2 * decode_fec;
295         decoded_samples = 0;
296         do {
297             /* Call SILK decoder */
298             int first_frame = decoded_samples == 0;
299             silk_ret = silk_Decode( silk_dec, &DecControl,
300                 lost_flag, first_frame, &dec, pcm_ptr, &silk_frame_size );
301             if( silk_ret ) {
302                 if (lost_flag) {
303                         /* PLC failure should not be fatal */
304                         silk_frame_size = frame_size;
305                         for (i=0;i<frame_size*st->channels;i++)
306                                 pcm_ptr[i] = 0;
307                 } else {
308                    RESTORE_STACK;
309                    return OPUS_INVALID_PACKET;
310                 }
311             }
312             pcm_ptr += silk_frame_size * st->channels;
313             decoded_samples += silk_frame_size;
314         } while( decoded_samples < frame_size );
315     }
316
317     start_band = 0;
318     if (mode != MODE_CELT_ONLY && data != NULL && ec_tell(&dec)+29+8*(st->mode == MODE_HYBRID) < 8*len)
319     {
320         /* Check if we have a redundant 0-8 kHz band */
321         redundancy = ec_dec_bit_logp(&dec, 12);
322         if (redundancy)
323         {
324             celt_to_silk = ec_dec_bit_logp(&dec, 1);
325             /*Due to the ec_tell check above redundancy_bytes will be at least two for hybrid*/
326             redundancy_bytes = mode==MODE_HYBRID ? ec_dec_uint(&dec, 256)+2 : len-((ec_tell(&dec)+7)>>3);
327             len -= redundancy_bytes;
328             if (len<0)
329             {
330                len=0;
331                redundancy_bytes=0;
332                redundancy = 0;
333             }
334             /* Shrink decoder because of raw bits */
335             dec.storage -= redundancy_bytes;
336         }
337     }
338     if (mode != MODE_CELT_ONLY)
339         start_band = 17;
340
341     {
342         int endband=21;
343
344         switch(st->bandwidth)
345         {
346         case OPUS_BANDWIDTH_NARROWBAND:
347             endband = 13;
348             break;
349         case OPUS_BANDWIDTH_MEDIUMBAND:
350         case OPUS_BANDWIDTH_WIDEBAND:
351             endband = 17;
352             break;
353         case OPUS_BANDWIDTH_SUPERWIDEBAND:
354             endband = 19;
355             break;
356         case OPUS_BANDWIDTH_FULLBAND:
357             endband = 21;
358             break;
359         }
360         celt_decoder_ctl(celt_dec, CELT_SET_END_BAND(endband));
361         celt_decoder_ctl(celt_dec, CELT_SET_CHANNELS(st->stream_channels));
362     }
363
364     if (redundancy)
365         transition = 0;
366
367     if (transition && mode != MODE_CELT_ONLY)
368         opus_decode_frame(st, NULL, 0, pcm_transition, IMIN(F5, audiosize), 0);
369
370     /* 5 ms redundant frame for CELT->SILK*/
371     if (redundancy && celt_to_silk)
372     {
373         celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
374         celt_decode_with_ec(celt_dec, data+len, redundancy_bytes, redundant_audio, F5, NULL);
375         celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_RANGE(&redundant_rng));
376         celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
377     }
378
379     /* MUST be after PLC */
380     celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(start_band));
381
382     if (transition)
383         celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
384
385     if (mode != MODE_SILK_ONLY)
386     {
387         int celt_frame_size = IMIN(F20, frame_size);
388         /* Decode CELT */
389         celt_ret = celt_decode_with_ec(celt_dec, decode_fec?NULL:data, len, pcm, celt_frame_size, &dec);
390     } else {
391        for (i=0;i<frame_size*st->channels;i++)
392           pcm[i] = 0;
393     }
394
395     if (mode != MODE_CELT_ONLY)
396     {
397 #ifdef FIXED_POINT
398         for (i=0;i<frame_size*st->channels;i++)
399             pcm[i] = SAT16(pcm[i] + pcm_silk[i]);
400 #else
401         for (i=0;i<frame_size*st->channels;i++)
402             pcm[i] = pcm[i] + (1./32768.)*pcm_silk[i];
403 #endif
404     }
405
406     {
407         const CELTMode *celt_mode;
408         celt_decoder_ctl(celt_dec, CELT_GET_MODE(&celt_mode));
409         window = celt_mode->window;
410     }
411
412     /* 5 ms redundant frame for SILK->CELT */
413     if (redundancy && !celt_to_silk)
414     {
415         celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
416         celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
417
418         celt_decode_with_ec(celt_dec, data+len, redundancy_bytes, redundant_audio, F5, NULL);
419         celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_RANGE(&redundant_rng));
420         smooth_fade(pcm+st->channels*(frame_size-F2_5), redundant_audio+st->channels*F2_5,
421                         pcm+st->channels*(frame_size-F2_5), F2_5, st->channels, window, st->Fs);
422     }
423     if (redundancy && celt_to_silk)
424     {
425         for (c=0;c<st->channels;c++)
426         {
427             for (i=0;i<F2_5;i++)
428                 pcm[st->channels*i+c] = redundant_audio[st->channels*i+c];
429         }
430         smooth_fade(redundant_audio+st->channels*F2_5, pcm+st->channels*F2_5,
431                 pcm+st->channels*F2_5, F2_5, st->channels, window, st->Fs);
432     }
433     if (transition)
434     {
435         for (i=0;i<st->channels*F2_5;i++)
436                 pcm[i] = pcm_transition[i];
437         if (audiosize >= F5)
438             smooth_fade(pcm_transition+st->channels*F2_5, pcm+st->channels*F2_5,
439                     pcm+st->channels*F2_5, F2_5,
440                     st->channels, window, st->Fs);
441     }
442
443     if (len <= 1)
444        st->rangeFinal = 0;
445     else
446        st->rangeFinal = dec.rng ^ redundant_rng;
447
448     st->prev_mode = mode;
449     st->prev_redundancy = redundancy;
450     RESTORE_STACK;
451         return celt_ret<0 ? celt_ret : audiosize;
452
453 }
454
455 static int parse_size(const unsigned char *data, int len, short *size)
456 {
457         if (len<1)
458         {
459                 *size = -1;
460                 return -1;
461         } else if (data[0]<252)
462         {
463                 *size = data[0];
464                 return 1;
465         } else if (len<2)
466         {
467                 *size = -1;
468                 return -1;
469         } else {
470                 *size = 4*data[1] + data[0];
471                 return 2;
472         }
473 }
474
475 static int opus_packet_parse_impl(const unsigned char *data, int len,
476       int self_delimited, unsigned char *out_toc,
477       const unsigned char *frames[48], short size[48], int *payload_offset)
478 {
479    int i, bytes;
480    int count;
481    int cbr;
482    unsigned char ch, toc;
483    int framesize;
484    int last_size;
485    const unsigned char *data0 = data;
486
487    if (size==NULL)
488       return OPUS_BAD_ARG;
489
490    framesize = opus_packet_get_samples_per_frame(data, 48000);
491
492    cbr = 0;
493    toc = *data++;
494    len--;
495    last_size = len;
496    switch (toc&0x3)
497    {
498    /* One frame */
499    case 0:
500       count=1;
501       break;
502       /* Two CBR frames */
503    case 1:
504       count=2;
505       cbr = 1;
506       if (!self_delimited)
507       {
508          if (len&0x1)
509             return OPUS_INVALID_PACKET;
510          size[0] = last_size = len/2;
511       }
512       break;
513       /* Two VBR frames */
514    case 2:
515       count = 2;
516       bytes = parse_size(data, len, size);
517       len -= bytes;
518       if (size[0]<0 || size[0] > len)
519          return OPUS_INVALID_PACKET;
520       data += bytes;
521       last_size = len-size[0];
522       break;
523       /* Multiple CBR/VBR frames (from 0 to 120 ms) */
524    case 3:
525       if (len<1)
526          return OPUS_INVALID_PACKET;
527       /* Number of frames encoded in bits 0 to 5 */
528       ch = *data++;
529       count = ch&0x3F;
530       if (count <= 0 || framesize*count > 5760)
531           return OPUS_INVALID_PACKET;
532       len--;
533       /* Padding flag is bit 6 */
534       if (ch&0x40)
535       {
536          int padding=0;
537          int p;
538          do {
539             if (len<=0)
540                return OPUS_INVALID_PACKET;
541             p = *data++;
542             len--;
543             padding += p==255 ? 254: p;
544          } while (p==255);
545          len -= padding;
546       }
547       if (len<0)
548          return OPUS_INVALID_PACKET;
549       /* VBR flag is bit 7 */
550       cbr = !(ch&0x80);
551       if (!cbr)
552       {
553          /* VBR case */
554          last_size = len;
555          for (i=0;i<count-1;i++)
556          {
557             bytes = parse_size(data, len, size+i);
558             len -= bytes;
559             if (size[i]<0 || size[i] > len)
560                return OPUS_INVALID_PACKET;
561             data += bytes;
562             last_size -= bytes+size[i];
563          }
564          if (last_size<0)
565             return OPUS_INVALID_PACKET;
566       } else if (!self_delimited)
567       {
568          /* CBR case */
569          last_size = len/count;
570          if (last_size*count!=len)
571             return OPUS_INVALID_PACKET;
572          for (i=0;i<count-1;i++)
573             size[i] = last_size;
574       }
575       break;
576    }
577    /* Self-delimited framing has an extra size for the last frame. */
578    if (self_delimited)
579    {
580       bytes = parse_size(data, len, size+count-1);
581       len -= bytes;
582       if (size[count-1]<0 || size[count-1] > len)
583          return OPUS_INVALID_PACKET;
584       data += bytes;
585       /* For CBR packets, apply the size to all the frames. */
586       if (cbr)
587       {
588          if (size[count-1]*count > len)
589             return OPUS_INVALID_PACKET;
590          for (i=0;i<count-1;i++)
591             size[i] = size[count-1];
592       } else if(size[count-1] > last_size)
593          return OPUS_INVALID_PACKET;
594    } else
595    {
596       /* Because it's not encoded explicitly, it's possible the size of the
597           last packet (or all the packets, for the CBR case) is larger than
598           1275.
599          Reject them here.*/
600       if (last_size > 1275)
601         return OPUS_INVALID_PACKET;
602       size[count-1] = last_size;
603    }
604
605    if (frames)
606    {
607       for (i=0;i<count;i++)
608       {
609          frames[i] = data;
610          data += size[i];
611       }
612    }
613
614    if (out_toc)
615       *out_toc = toc;
616
617    if (payload_offset)
618       *payload_offset = data-data0;
619
620    return count;
621 }
622
623 int opus_packet_parse(const unsigned char *data, int len,
624       unsigned char *out_toc, const unsigned char *frames[48],
625       short size[48], int *payload_offset)
626 {
627    return opus_packet_parse_impl(data, len, 0,
628          out_toc, frames, size, payload_offset);
629 }
630
631 int opus_decode_native(OpusDecoder *st, const unsigned char *data,
632       int len, opus_val16 *pcm, int frame_size, int decode_fec, int self_delimited, int *packet_offset)
633 {
634         int i, nb_samples;
635         int count, offset;
636         unsigned char toc;
637         int tot_offset;
638         /* 48 x 2.5 ms = 120 ms */
639         short size[48];
640         if (decode_fec<0 || decode_fec>1)return OPUS_BAD_ARG;
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, self_delimited, &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_BUFFER_TOO_SMALL;
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    void *silk_dec;
741    CELTDecoder *celt_dec;
742
743    silk_dec = (char*)st+st->silk_dec_offset;
744    celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
745
746
747    va_start(ap, request);
748
749    switch (request)
750    {
751    case OPUS_GET_BANDWIDTH_REQUEST:
752    {
753       opus_int32 *value = va_arg(ap, opus_int32*);
754       *value = st->bandwidth;
755    }
756    break;
757    case OPUS_GET_FINAL_RANGE_REQUEST:
758    {
759       opus_uint32 *value = va_arg(ap, opus_uint32*);
760       *value = st->rangeFinal;
761    }
762    break;
763    case OPUS_RESET_STATE:
764    {
765       OPUS_CLEAR((char*)&st->OPUS_DECODER_RESET_START,
766             sizeof(OpusDecoder)-
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    case OPUS_GET_PITCH_REQUEST:
776    {
777       int *value = va_arg(ap, opus_int32*);
778       if (value==NULL)
779       {
780          ret = OPUS_BAD_ARG;
781          break;
782       }
783       if (st->prev_mode == MODE_CELT_ONLY)
784          celt_decoder_ctl(celt_dec, OPUS_GET_PITCH(value));
785       else
786          *value = ((silk_decoder_state*)silk_dec)->indices.signalType == TYPE_VOICED
787          ? ((silk_decoder_state*)silk_dec)->lagPrev*48/((silk_decoder_state*)silk_dec)->fs_kHz
788          : 0;
789    }
790    break;
791    default:
792       /*fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);*/
793       ret = OPUS_UNIMPLEMENTED;
794       break;
795    }
796
797    va_end(ap);
798    return ret;
799 }
800
801 void opus_decoder_destroy(OpusDecoder *st)
802 {
803         opus_free(st);
804 }
805
806
807 int opus_packet_get_bandwidth(const unsigned char *data)
808 {
809         int bandwidth;
810     if (data[0]&0x80)
811     {
812         bandwidth = OPUS_BANDWIDTH_MEDIUMBAND + ((data[0]>>5)&0x3);
813         if (bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
814             bandwidth = OPUS_BANDWIDTH_NARROWBAND;
815     } else if ((data[0]&0x60) == 0x60)
816     {
817         bandwidth = (data[0]&0x10) ? OPUS_BANDWIDTH_FULLBAND : OPUS_BANDWIDTH_SUPERWIDEBAND;
818     } else {
819
820         bandwidth = OPUS_BANDWIDTH_NARROWBAND + ((data[0]>>5)&0x3);
821     }
822     return bandwidth;
823 }
824
825 int opus_packet_get_samples_per_frame(const unsigned char *data, opus_int32 Fs)
826 {
827     int audiosize;
828     if (data[0]&0x80)
829     {
830         audiosize = ((data[0]>>3)&0x3);
831         audiosize = (Fs<<audiosize)/400;
832     } else if ((data[0]&0x60) == 0x60)
833     {
834         audiosize = (data[0]&0x08) ? Fs/50 : Fs/100;
835     } else {
836
837         audiosize = ((data[0]>>3)&0x3);
838         if (audiosize == 3)
839             audiosize = Fs*60/1000;
840         else
841             audiosize = (Fs<<audiosize)/100;
842     }
843     return audiosize;
844 }
845
846 int opus_packet_get_nb_channels(const unsigned char *data)
847 {
848     return (data[0]&0x4) ? 2 : 1;
849 }
850
851 int opus_packet_get_nb_frames(const unsigned char packet[], int len)
852 {
853         int count;
854         if (len<1)
855                 return OPUS_BAD_ARG;
856         count = packet[0]&0x3;
857         if (count==0)
858                 return 1;
859         else if (count!=3)
860                 return 2;
861         else if (len<2)
862                 return OPUS_INVALID_PACKET;
863         else
864                 return packet[1]&0x3F;
865 }
866
867 int opus_decoder_get_nb_samples(const OpusDecoder *dec, const unsigned char packet[], int len)
868 {
869         int samples;
870         int count = opus_packet_get_nb_frames(packet, len);
871         samples = count*opus_packet_get_samples_per_frame(packet, dec->Fs);
872         /* Can't have more than 120 ms */
873         if (samples*25 > dec->Fs*3)
874                 return OPUS_INVALID_PACKET;
875         else
876                 return samples;
877 }