Merge remote-tracking branch 'greg/master'
[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             if (mode == MODE_HYBRID)
326                 redundancy_bytes = 2 + ec_dec_uint(&dec, 256);
327             else {
328                 redundancy_bytes = len - ((ec_tell(&dec)+7)>>3);
329                 /* Can only happen on an invalid packet */
330                 if (redundancy_bytes<0)
331                 {
332                         redundancy_bytes = 0;
333                         redundancy = 0;
334                 }
335             }
336             len -= redundancy_bytes;
337             if (len<0)
338             {
339                len=0;
340                redundancy_bytes=0;
341                redundancy = 0;
342             }
343             /* Shrink decoder because of raw bits */
344             dec.storage -= redundancy_bytes;
345         }
346     }
347     if (mode != MODE_CELT_ONLY)
348         start_band = 17;
349
350     {
351         int endband=21;
352
353         switch(st->bandwidth)
354         {
355         case OPUS_BANDWIDTH_NARROWBAND:
356             endband = 13;
357             break;
358         case OPUS_BANDWIDTH_MEDIUMBAND:
359         case OPUS_BANDWIDTH_WIDEBAND:
360             endband = 17;
361             break;
362         case OPUS_BANDWIDTH_SUPERWIDEBAND:
363             endband = 19;
364             break;
365         case OPUS_BANDWIDTH_FULLBAND:
366             endband = 21;
367             break;
368         }
369         celt_decoder_ctl(celt_dec, CELT_SET_END_BAND(endband));
370         celt_decoder_ctl(celt_dec, CELT_SET_CHANNELS(st->stream_channels));
371     }
372
373     if (redundancy)
374         transition = 0;
375
376     if (transition && mode != MODE_CELT_ONLY)
377         opus_decode_frame(st, NULL, 0, pcm_transition, IMIN(F5, audiosize), 0);
378
379     /* 5 ms redundant frame for CELT->SILK*/
380     if (redundancy && celt_to_silk)
381     {
382         celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
383         celt_decode_with_ec(celt_dec, data+len, redundancy_bytes, redundant_audio, F5, NULL);
384         celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_RANGE(&redundant_rng));
385         celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
386     }
387
388     /* MUST be after PLC */
389     celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(start_band));
390
391     if (transition)
392         celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
393
394     if (mode != MODE_SILK_ONLY)
395     {
396         int celt_frame_size = IMIN(F20, frame_size);
397         /* Decode CELT */
398         celt_ret = celt_decode_with_ec(celt_dec, decode_fec?NULL:data, len, pcm, celt_frame_size, &dec);
399     } else {
400        for (i=0;i<frame_size*st->channels;i++)
401           pcm[i] = 0;
402     }
403
404     if (mode != MODE_CELT_ONLY)
405     {
406 #ifdef FIXED_POINT
407         for (i=0;i<frame_size*st->channels;i++)
408             pcm[i] = SAT16(pcm[i] + pcm_silk[i]);
409 #else
410         for (i=0;i<frame_size*st->channels;i++)
411             pcm[i] = pcm[i] + (1./32768.)*pcm_silk[i];
412 #endif
413     }
414
415     {
416         const CELTMode *celt_mode;
417         celt_decoder_ctl(celt_dec, CELT_GET_MODE(&celt_mode));
418         window = celt_mode->window;
419     }
420
421     /* 5 ms redundant frame for SILK->CELT */
422     if (redundancy && !celt_to_silk)
423     {
424         celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
425         celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
426
427         celt_decode_with_ec(celt_dec, data+len, redundancy_bytes, redundant_audio, F5, NULL);
428         celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_RANGE(&redundant_rng));
429         smooth_fade(pcm+st->channels*(frame_size-F2_5), redundant_audio+st->channels*F2_5,
430                         pcm+st->channels*(frame_size-F2_5), F2_5, st->channels, window, st->Fs);
431     }
432     if (redundancy && celt_to_silk)
433     {
434         for (c=0;c<st->channels;c++)
435         {
436             for (i=0;i<F2_5;i++)
437                 pcm[st->channels*i+c] = redundant_audio[st->channels*i+c];
438         }
439         smooth_fade(redundant_audio+st->channels*F2_5, pcm+st->channels*F2_5,
440                 pcm+st->channels*F2_5, F2_5, st->channels, window, st->Fs);
441     }
442     if (transition)
443     {
444         for (i=0;i<st->channels*F2_5;i++)
445                 pcm[i] = pcm_transition[i];
446         if (audiosize >= F5)
447             smooth_fade(pcm_transition+st->channels*F2_5, pcm+st->channels*F2_5,
448                     pcm+st->channels*F2_5, F2_5,
449                     st->channels, window, st->Fs);
450     }
451
452     if (len <= 1)
453        st->rangeFinal = 0;
454     else
455        st->rangeFinal = dec.rng ^ redundant_rng;
456
457     st->prev_mode = mode;
458     st->prev_redundancy = redundancy;
459     RESTORE_STACK;
460         return celt_ret<0 ? celt_ret : audiosize;
461
462 }
463
464 static int parse_size(const unsigned char *data, int len, short *size)
465 {
466         if (len<1)
467         {
468                 *size = -1;
469                 return -1;
470         } else if (data[0]<252)
471         {
472                 *size = data[0];
473                 return 1;
474         } else if (len<2)
475         {
476                 *size = -1;
477                 return -1;
478         } else {
479                 *size = 4*data[1] + data[0];
480                 return 2;
481         }
482 }
483
484 static int opus_packet_parse_impl(const unsigned char *data, int len,
485       int self_delimited, unsigned char *out_toc,
486       const unsigned char *frames[48], short size[48], int *payload_offset)
487 {
488    int i, bytes;
489    int count;
490    int cbr;
491    unsigned char ch, toc;
492    int framesize;
493    int last_size;
494    const unsigned char *data0 = data;
495
496    if (size==NULL)
497       return OPUS_BAD_ARG;
498
499    framesize = opus_packet_get_samples_per_frame(data, 48000);
500
501    cbr = 0;
502    toc = *data++;
503    len--;
504    last_size = len;
505    switch (toc&0x3)
506    {
507    /* One frame */
508    case 0:
509       count=1;
510       break;
511       /* Two CBR frames */
512    case 1:
513       count=2;
514       cbr = 1;
515       if (!self_delimited)
516       {
517          if (len&0x1)
518             return OPUS_INVALID_PACKET;
519          size[0] = last_size = len/2;
520       }
521       break;
522       /* Two VBR frames */
523    case 2:
524       count = 2;
525       bytes = parse_size(data, len, size);
526       len -= bytes;
527       if (size[0]<0 || size[0] > len)
528          return OPUS_INVALID_PACKET;
529       data += bytes;
530       last_size = len-size[0];
531       break;
532       /* Multiple CBR/VBR frames (from 0 to 120 ms) */
533    case 3:
534       if (len<1)
535          return OPUS_INVALID_PACKET;
536       /* Number of frames encoded in bits 0 to 5 */
537       ch = *data++;
538       count = ch&0x3F;
539       if (count <= 0 || framesize*count > 5760)
540           return OPUS_INVALID_PACKET;
541       len--;
542       /* Padding flag is bit 6 */
543       if (ch&0x40)
544       {
545          int padding=0;
546          int p;
547          do {
548             if (len<=0)
549                return OPUS_INVALID_PACKET;
550             p = *data++;
551             len--;
552             padding += p==255 ? 254: p;
553          } while (p==255);
554          len -= padding;
555       }
556       if (len<0)
557          return OPUS_INVALID_PACKET;
558       /* VBR flag is bit 7 */
559       cbr = !(ch&0x80);
560       if (!cbr)
561       {
562          /* VBR case */
563          last_size = len;
564          for (i=0;i<count-1;i++)
565          {
566             bytes = parse_size(data, len, size+i);
567             len -= bytes;
568             if (size[i]<0 || size[i] > len)
569                return OPUS_INVALID_PACKET;
570             data += bytes;
571             last_size -= bytes+size[i];
572          }
573          if (last_size<0)
574             return OPUS_INVALID_PACKET;
575       } else if (!self_delimited)
576       {
577          /* CBR case */
578          last_size = len/count;
579          if (last_size*count!=len)
580             return OPUS_INVALID_PACKET;
581          for (i=0;i<count-1;i++)
582             size[i] = last_size;
583       }
584       break;
585    }
586    /* Self-delimited framing has an extra size for the last frame. */
587    if (self_delimited)
588    {
589       bytes = parse_size(data, len, size+count-1);
590       len -= bytes;
591       if (size[count-1]<0 || size[count-1] > len)
592          return OPUS_INVALID_PACKET;
593       data += bytes;
594       /* For CBR packets, apply the size to all the frames. */
595       if (cbr)
596       {
597          if (size[count-1]*count > len)
598             return OPUS_INVALID_PACKET;
599          for (i=0;i<count-1;i++)
600             size[i] = size[count-1];
601       } else if(size[count-1] > last_size)
602          return OPUS_INVALID_PACKET;
603    } else
604    {
605       /* Because it's not encoded explicitly, it's possible the size of the
606           last packet (or all the packets, for the CBR case) is larger than
607           1275.
608          Reject them here.*/
609       if (last_size > 1275)
610         return OPUS_INVALID_PACKET;
611       size[count-1] = last_size;
612    }
613
614    if (frames)
615    {
616       for (i=0;i<count;i++)
617       {
618          frames[i] = data;
619          data += size[i];
620       }
621    }
622
623    if (out_toc)
624       *out_toc = toc;
625
626    if (payload_offset)
627       *payload_offset = data-data0;
628
629    return count;
630 }
631
632 int opus_packet_parse(const unsigned char *data, int len,
633       unsigned char *out_toc, const unsigned char *frames[48],
634       short size[48], int *payload_offset)
635 {
636    return opus_packet_parse_impl(data, len, 0,
637          out_toc, frames, size, payload_offset);
638 }
639
640 int opus_decode_native(OpusDecoder *st, const unsigned char *data,
641       int len, opus_val16 *pcm, int frame_size, int decode_fec, int self_delimited, int *packet_offset)
642 {
643         int i, nb_samples;
644         int count, offset;
645         unsigned char toc;
646         int tot_offset;
647         /* 48 x 2.5 ms = 120 ms */
648         short size[48];
649         if (decode_fec<0 || decode_fec>1)return OPUS_BAD_ARG;
650         if (len==0 || data==NULL)
651             return opus_decode_frame(st, NULL, 0, pcm, frame_size, 0);
652         else if (len<0)
653                 return OPUS_BAD_ARG;
654
655         tot_offset = 0;
656         st->mode = opus_packet_get_mode(data);
657         st->bandwidth = opus_packet_get_bandwidth(data);
658         st->frame_size = opus_packet_get_samples_per_frame(data, st->Fs);
659         st->stream_channels = opus_packet_get_nb_channels(data);
660
661         count = opus_packet_parse_impl(data, len, self_delimited, &toc, NULL, size, &offset);
662         if (count < 0)
663            return count;
664
665         data += offset;
666         tot_offset += offset;
667
668         if (count*st->frame_size > frame_size)
669                 return OPUS_BUFFER_TOO_SMALL;
670         nb_samples=0;
671         for (i=0;i<count;i++)
672         {
673                 int ret;
674                 ret = opus_decode_frame(st, data, size[i], pcm, frame_size-nb_samples, decode_fec);
675                 if (ret<0)
676                         return ret;
677                 data += size[i];
678                 tot_offset += size[i];
679                 pcm += ret*st->channels;
680                 nb_samples += ret;
681         }
682         if (packet_offset != NULL)
683            *packet_offset = tot_offset;
684         return nb_samples;
685 }
686
687 #ifdef FIXED_POINT
688
689 int opus_decode(OpusDecoder *st, const unsigned char *data,
690       int len, opus_val16 *pcm, int frame_size, int decode_fec)
691 {
692    return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL);
693 }
694
695 #ifndef DISABLE_FLOAT_API
696 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
697       int len, float *pcm, int frame_size, int decode_fec)
698 {
699    VARDECL(opus_int16, out);
700    int ret, i;
701    ALLOC_STACK;
702
703    ALLOC(out, frame_size*st->channels, opus_int16);
704
705    ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL);
706    if (ret > 0)
707    {
708       for (i=0;i<ret*st->channels;i++)
709          pcm[i] = (1./32768.)*(out[i]);
710    }
711    RESTORE_STACK;
712    return ret;
713 }
714 #endif
715
716
717 #else
718 int opus_decode(OpusDecoder *st, const unsigned char *data,
719       int len, opus_int16 *pcm, int frame_size, int decode_fec)
720 {
721    VARDECL(float, out);
722    int ret, i;
723    ALLOC_STACK;
724
725    ALLOC(out, frame_size*st->channels, float);
726
727    ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL);
728    if (ret > 0)
729    {
730       for (i=0;i<ret*st->channels;i++)
731          pcm[i] = FLOAT2INT16(out[i]);
732    }
733    RESTORE_STACK;
734    return ret;
735 }
736
737 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
738         int len, opus_val16 *pcm, int frame_size, int decode_fec)
739 {
740    return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL);
741 }
742
743 #endif
744
745 int opus_decoder_ctl(OpusDecoder *st, int request, ...)
746 {
747    int ret = OPUS_OK;
748    va_list ap;
749    void *silk_dec;
750    CELTDecoder *celt_dec;
751
752    silk_dec = (char*)st+st->silk_dec_offset;
753    celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
754
755
756    va_start(ap, request);
757
758    switch (request)
759    {
760    case OPUS_GET_BANDWIDTH_REQUEST:
761    {
762       opus_int32 *value = va_arg(ap, opus_int32*);
763       *value = st->bandwidth;
764    }
765    break;
766    case OPUS_GET_FINAL_RANGE_REQUEST:
767    {
768       opus_uint32 *value = va_arg(ap, opus_uint32*);
769       *value = st->rangeFinal;
770    }
771    break;
772    case OPUS_RESET_STATE:
773    {
774       OPUS_CLEAR((char*)&st->OPUS_DECODER_RESET_START,
775             sizeof(OpusDecoder)-
776             ((char*)&st->OPUS_DECODER_RESET_START - (char*)st));
777
778       celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
779       silk_InitDecoder( silk_dec );
780       st->stream_channels = st->channels;
781       st->frame_size = st->Fs/400;
782    }
783    break;
784    case OPUS_GET_PITCH_REQUEST:
785    {
786       int *value = va_arg(ap, opus_int32*);
787       if (value==NULL)
788       {
789          ret = OPUS_BAD_ARG;
790          break;
791       }
792       if (st->prev_mode == MODE_CELT_ONLY)
793          celt_decoder_ctl(celt_dec, OPUS_GET_PITCH(value));
794       else
795          *value = ((silk_decoder_state*)silk_dec)->indices.signalType == TYPE_VOICED
796          ? ((silk_decoder_state*)silk_dec)->lagPrev*48/((silk_decoder_state*)silk_dec)->fs_kHz
797          : 0;
798    }
799    break;
800    default:
801       /*fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);*/
802       ret = OPUS_UNIMPLEMENTED;
803       break;
804    }
805
806    va_end(ap);
807    return ret;
808 }
809
810 void opus_decoder_destroy(OpusDecoder *st)
811 {
812         opus_free(st);
813 }
814
815
816 int opus_packet_get_bandwidth(const unsigned char *data)
817 {
818         int bandwidth;
819     if (data[0]&0x80)
820     {
821         bandwidth = OPUS_BANDWIDTH_MEDIUMBAND + ((data[0]>>5)&0x3);
822         if (bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
823             bandwidth = OPUS_BANDWIDTH_NARROWBAND;
824     } else if ((data[0]&0x60) == 0x60)
825     {
826         bandwidth = (data[0]&0x10) ? OPUS_BANDWIDTH_FULLBAND : OPUS_BANDWIDTH_SUPERWIDEBAND;
827     } else {
828
829         bandwidth = OPUS_BANDWIDTH_NARROWBAND + ((data[0]>>5)&0x3);
830     }
831     return bandwidth;
832 }
833
834 int opus_packet_get_samples_per_frame(const unsigned char *data, opus_int32 Fs)
835 {
836     int audiosize;
837     if (data[0]&0x80)
838     {
839         audiosize = ((data[0]>>3)&0x3);
840         audiosize = (Fs<<audiosize)/400;
841     } else if ((data[0]&0x60) == 0x60)
842     {
843         audiosize = (data[0]&0x08) ? Fs/50 : Fs/100;
844     } else {
845
846         audiosize = ((data[0]>>3)&0x3);
847         if (audiosize == 3)
848             audiosize = Fs*60/1000;
849         else
850             audiosize = (Fs<<audiosize)/100;
851     }
852     return audiosize;
853 }
854
855 int opus_packet_get_nb_channels(const unsigned char *data)
856 {
857     return (data[0]&0x4) ? 2 : 1;
858 }
859
860 int opus_packet_get_nb_frames(const unsigned char packet[], int len)
861 {
862         int count;
863         if (len<1)
864                 return OPUS_BAD_ARG;
865         count = packet[0]&0x3;
866         if (count==0)
867                 return 1;
868         else if (count!=3)
869                 return 2;
870         else if (len<2)
871                 return OPUS_INVALID_PACKET;
872         else
873                 return packet[1]&0x3F;
874 }
875
876 int opus_decoder_get_nb_samples(const OpusDecoder *dec, const unsigned char packet[], int len)
877 {
878         int samples;
879         int count = opus_packet_get_nb_frames(packet, len);
880         samples = count*opus_packet_get_samples_per_frame(packet, dec->Fs);
881         /* Can't have more than 120 ms */
882         if (samples*25 > dec->Fs*3)
883                 return OPUS_INVALID_PACKET;
884         else
885                 return samples;
886 }