Implements OPUS_RESET_STATE for the decoder (untested)
[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 #ifdef FIXED_POINT
44 #define celt_decode_native celt_decode
45 #else
46 #define celt_decode_native celt_decode_float
47 #endif
48
49 struct OpusDecoder {
50    int          celt_dec_offset;
51    int          silk_dec_offset;
52    int          channels;
53    int          Fs;          /** Sampling rate (at the API level) */
54
55    /* Everything beyond this point gets cleared on a reset */
56 #define OPUS_DECODER_RESET_START stream_channels
57    int          stream_channels;
58
59    int          bandwidth;
60    int          mode;
61    int          prev_mode;
62    int          frame_size;
63    int          prev_redundancy;
64
65    int          rangeFinal;
66 };
67
68 #ifdef FIXED_POINT
69 static inline opus_int16 SAT16(opus_int32 x) {
70     return x > 32767 ? 32767 : x < -32768 ? -32768 : (opus_int16)x;
71 };
72 #endif
73
74
75 int opus_decoder_get_size(int channels)
76 {
77         int silkDecSizeBytes, celtDecSizeBytes;
78         int ret;
79     ret = silk_Get_Decoder_Size( &silkDecSizeBytes );
80         if(ret)
81                 return 0;
82         silkDecSizeBytes = align(silkDecSizeBytes);
83     celtDecSizeBytes = celt_decoder_get_size(channels);
84     return align(sizeof(OpusDecoder))+silkDecSizeBytes+celtDecSizeBytes;
85
86 }
87
88 int opus_decoder_init(OpusDecoder *st, int Fs, int channels)
89 {
90         void *silk_dec;
91         CELTDecoder *celt_dec;
92         int ret, silkDecSizeBytes;
93
94         if (channels<1 || channels > 2)
95             return OPUS_BAD_ARG;
96         OPUS_CLEAR((char*)st, opus_decoder_get_size(channels));
97         /* Initialize SILK encoder */
98     ret = silk_Get_Decoder_Size( &silkDecSizeBytes );
99     if( ret ) {
100         return OPUS_INTERNAL_ERROR;
101     }
102     silkDecSizeBytes = align(silkDecSizeBytes);
103     st->silk_dec_offset = align(sizeof(OpusDecoder));
104     st->celt_dec_offset = st->silk_dec_offset+silkDecSizeBytes;
105     silk_dec = (char*)st+st->silk_dec_offset;
106     celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
107     st->stream_channels = st->channels = channels;
108
109     st->Fs = Fs;
110
111     /* Reset decoder */
112     ret = silk_InitDecoder( silk_dec );
113     if( ret ) {
114         goto failure;
115     }
116
117         /* Initialize CELT decoder */
118         celt_decoder_init(celt_dec, Fs, channels, &ret);
119         if (ret != CELT_OK)
120                 goto failure;
121     celt_decoder_ctl(celt_dec, CELT_SET_SIGNALLING(0));
122
123         st->prev_mode = 0;
124         st->frame_size = Fs/400;
125         return OPUS_OK;
126 failure:
127     opus_free(st);
128     return OPUS_INTERNAL_ERROR;
129 }
130
131 OpusDecoder *opus_decoder_create(int Fs, int channels, int *error)
132 {
133    int ret;
134    OpusDecoder *st = (OpusDecoder *)opus_alloc(opus_decoder_get_size(channels));
135    if (st == NULL)
136    {
137       if (error)
138          *error = OPUS_ALLOC_FAIL;
139       return NULL;
140    }
141    ret = opus_decoder_init(st, Fs, channels);
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, int 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                 SKP_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_CORRUPTED_DATA;
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)
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                RESTORE_STACK;
339                return OPUS_CORRUPTED_DATA;
340             }
341             /* Shrink decoder because of raw bits */
342             dec.storage -= redundancy_bytes;
343         }
344     }
345     if (mode != MODE_CELT_ONLY)
346         start_band = 17;
347
348     {
349         int endband=21;
350
351         switch(st->bandwidth)
352         {
353         case OPUS_BANDWIDTH_NARROWBAND:
354             endband = 13;
355             break;
356         case OPUS_BANDWIDTH_MEDIUMBAND:
357         case OPUS_BANDWIDTH_WIDEBAND:
358             endband = 17;
359             break;
360         case OPUS_BANDWIDTH_SUPERWIDEBAND:
361             endband = 19;
362             break;
363         case OPUS_BANDWIDTH_FULLBAND:
364             endband = 21;
365             break;
366         }
367         celt_decoder_ctl(celt_dec, CELT_SET_END_BAND(endband));
368         celt_decoder_ctl(celt_dec, CELT_SET_CHANNELS(st->stream_channels));
369     }
370
371     if (redundancy)
372         transition = 0;
373
374     if (transition && mode != MODE_CELT_ONLY)
375         opus_decode_frame(st, NULL, 0, pcm_transition, IMIN(F5, audiosize), 0);
376
377     /* 5 ms redundant frame for CELT->SILK*/
378     if (redundancy && celt_to_silk)
379     {
380         celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
381         celt_decode_native(celt_dec, data+len, redundancy_bytes, redundant_audio, F5);
382         celt_decoder_ctl(celt_dec, CELT_GET_RANGE(&redundant_rng));
383         celt_decoder_ctl(celt_dec, CELT_RESET_STATE);
384     }
385
386     /* MUST be after PLC */
387     celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(start_band));
388
389     if (transition)
390         celt_decoder_ctl(celt_dec, CELT_RESET_STATE);
391
392     if (mode != MODE_SILK_ONLY)
393     {
394         int celt_frame_size = IMIN(F20, frame_size);
395         /* Decode CELT */
396         celt_ret = celt_decode_with_ec(celt_dec, decode_fec?NULL:data, len, pcm, celt_frame_size, &dec);
397     } else {
398        for (i=0;i<frame_size*st->channels;i++)
399           pcm[i] = 0;
400     }
401
402     if (mode != MODE_CELT_ONLY)
403     {
404 #ifdef FIXED_POINT
405         for (i=0;i<frame_size*st->channels;i++)
406             pcm[i] = SAT16(pcm[i] + pcm_silk[i]);
407 #else
408         for (i=0;i<frame_size*st->channels;i++)
409             pcm[i] = pcm[i] + (1./32768.)*pcm_silk[i];
410 #endif
411     }
412
413     {
414         const CELTMode *celt_mode;
415         celt_decoder_ctl(celt_dec, CELT_GET_MODE(&celt_mode));
416         window = celt_mode->window;
417     }
418
419     /* 5 ms redundant frame for SILK->CELT */
420     if (redundancy && !celt_to_silk)
421     {
422         celt_decoder_ctl(celt_dec, CELT_RESET_STATE);
423         celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
424
425         celt_decode_native(celt_dec, data+len, redundancy_bytes, redundant_audio, F5);
426         celt_decoder_ctl(celt_dec, CELT_GET_RANGE(&redundant_rng));
427         smooth_fade(pcm+st->channels*(frame_size-F2_5), redundant_audio+st->channels*F2_5,
428                         pcm+st->channels*(frame_size-F2_5), F2_5, st->channels, window, st->Fs);
429     }
430     if (redundancy && celt_to_silk)
431     {
432         for (c=0;c<st->channels;c++)
433         {
434             for (i=0;i<F2_5;i++)
435                 pcm[st->channels*i+c] = redundant_audio[st->channels*i+c];
436         }
437         smooth_fade(redundant_audio+st->channels*F2_5, pcm+st->channels*F2_5,
438                 pcm+st->channels*F2_5, F2_5, st->channels, window, st->Fs);
439     }
440     if (transition)
441     {
442         for (i=0;i<st->channels*F2_5;i++)
443                 pcm[i] = pcm_transition[i];
444         if (audiosize >= F5)
445             smooth_fade(pcm_transition+st->channels*F2_5, pcm+st->channels*F2_5,
446                     pcm+st->channels*F2_5, F2_5,
447                     st->channels, window, st->Fs);
448     }
449
450     if (len <= 1)
451        st->rangeFinal = 0;
452     else
453        st->rangeFinal = dec.rng ^ redundant_rng;
454
455     st->prev_mode = mode;
456     st->prev_redundancy = redundancy;
457     RESTORE_STACK;
458         return celt_ret<0 ? celt_ret : audiosize;
459
460 }
461
462 static int parse_size(const unsigned char *data, int len, short *size)
463 {
464         if (len<1)
465         {
466                 *size = -1;
467                 return -1;
468         } else if (data[0]<252)
469         {
470                 *size = data[0];
471                 return 1;
472         } else if (len<2)
473         {
474                 *size = -1;
475                 return -1;
476         } else {
477                 *size = 4*data[1] + data[0];
478                 return 2;
479         }
480 }
481
482 static int opus_packet_parse_impl(const unsigned char *data, int len,
483       int self_delimited, unsigned char *out_toc,
484       const unsigned char *frames[48], short size[48], int *payload_offset)
485 {
486    int i, bytes;
487    int count;
488    int cbr;
489    unsigned char ch, toc;
490    int framesize;
491    int last_size;
492    const unsigned char *data0 = data;
493
494    if (size==NULL)
495       return OPUS_BAD_ARG;
496
497    framesize = opus_packet_get_samples_per_frame(data, 48000);
498
499    cbr = 0;
500    toc = *data++;
501    len--;
502    last_size = len;
503    switch (toc&0x3)
504    {
505    /* One frame */
506    case 0:
507       count=1;
508       break;
509       /* Two CBR frames */
510    case 1:
511       count=2;
512       cbr = 1;
513       if (!self_delimited)
514       {
515          if (len&0x1)
516             return OPUS_CORRUPTED_DATA;
517          size[0] = last_size = len/2;
518       }
519       break;
520       /* Two VBR frames */
521    case 2:
522       count = 2;
523       bytes = parse_size(data, len, size);
524       len -= bytes;
525       if (size[0]<0 || size[0] > len)
526          return OPUS_CORRUPTED_DATA;
527       data += bytes;
528       last_size = len-size[0];
529       break;
530       /* Multiple CBR/VBR frames (from 0 to 120 ms) */
531    case 3:
532       if (len<1)
533          return OPUS_CORRUPTED_DATA;
534       /* Number of frames encoded in bits 0 to 5 */
535       ch = *data++;
536       count = ch&0x3F;
537       if (count <= 0 || framesize*count > 5760)
538           return OPUS_CORRUPTED_DATA;
539       len--;
540       /* Padding flag is bit 6 */
541       if (ch&0x40)
542       {
543          int padding=0;
544          int p;
545          do {
546             if (len<=0)
547                return OPUS_CORRUPTED_DATA;
548             p = *data++;
549             len--;
550             padding += p==255 ? 254: p;
551          } while (p==255);
552          len -= padding;
553       }
554       if (len<0)
555          return OPUS_CORRUPTED_DATA;
556       /* VBR flag is bit 7 */
557       cbr = !(ch&0x80);
558       if (cbr)
559       {
560          /* VBR case */
561          last_size = len;
562          for (i=0;i<count-1;i++)
563          {
564             bytes = parse_size(data, len, size+i);
565             len -= bytes;
566             if (size[i]<0 || size[i] > len)
567                return OPUS_CORRUPTED_DATA;
568             data += bytes;
569             last_size -= bytes+size[i];
570          }
571          if (last_size<0)
572             return OPUS_CORRUPTED_DATA;
573       } else if (!self_delimited)
574       {
575          /* CBR case */
576          last_size = len/count;
577          if (last_size*count!=len)
578             return OPUS_CORRUPTED_DATA;
579          for (i=0;i<count-1;i++)
580             size[i] = last_size;
581       }
582       break;
583    }
584    /* Self-delimited framing has an extra size for the last frame. */
585    if (self_delimited)
586    {
587       bytes = parse_size(data, len, size+count-1);
588       len -= bytes;
589       if (size[count-1]<0 || size[count-1] > len)
590          return OPUS_CORRUPTED_DATA;
591       data += bytes;
592       /* For CBR packets, apply the size to all the frames. */
593       if (cbr)
594       {
595          if (size[count-1]*count > len)
596             return OPUS_CORRUPTED_DATA;
597          for (i=0;i<count-1;i++)
598             size[i] = size[count-1];
599       } else if(size[count-1] > last_size)
600          return OPUS_CORRUPTED_DATA;
601    } else
602    {
603       /* Because it's not encoded explicitly, it's possible the size of the
604           last packet (or all the packets, for the CBR case) is larger than
605           1275.
606          Reject them here.*/
607       if (last_size > 1275)
608         return OPUS_CORRUPTED_DATA;
609       size[count-1] = last_size;
610    }
611
612    if (frames)
613    {
614       for (i=0;i<count;i++)
615       {
616          frames[i] = data;
617          data += size[i];
618       }
619    }
620
621    if (out_toc)
622       *out_toc = toc;
623
624    if (payload_offset)
625       *payload_offset = data-data0;
626
627    return count;
628 }
629
630 int opus_packet_parse(const unsigned char *data, int len,
631       unsigned char *out_toc, const unsigned char *frames[48],
632       short size[48], int *payload_offset)
633 {
634    return opus_packet_parse_impl(data, len, 0,
635          out_toc, frames, size, payload_offset);
636 }
637
638 int opus_decode_native(OpusDecoder *st, const unsigned char *data,
639       int len, opus_val16 *pcm, int frame_size, int decode_fec, int self_delimited, int *packet_offset)
640 {
641         int i, nb_samples;
642         int count, offset;
643         unsigned char toc;
644         int tot_offset;
645         /* 48 x 2.5 ms = 120 ms */
646         short size[48];
647         if (len==0 || data==NULL)
648             return opus_decode_frame(st, NULL, 0, pcm, frame_size, 0);
649         else if (len<0)
650                 return OPUS_BAD_ARG;
651
652         tot_offset = 0;
653         st->mode = opus_packet_get_mode(data);
654         st->bandwidth = opus_packet_get_bandwidth(data);
655         st->frame_size = opus_packet_get_samples_per_frame(data, st->Fs);
656         st->stream_channels = opus_packet_get_nb_channels(data);
657
658         count = opus_packet_parse_impl(data, len, 0, &toc, NULL, size, &offset);
659         if (count < 0)
660            return count;
661
662         data += offset;
663         tot_offset += offset;
664
665         if (count*st->frame_size > frame_size)
666                 return OPUS_BAD_ARG;
667         nb_samples=0;
668         for (i=0;i<count;i++)
669         {
670                 int ret;
671                 ret = opus_decode_frame(st, data, size[i], pcm, frame_size-nb_samples, decode_fec);
672                 if (ret<0)
673                         return ret;
674                 data += size[i];
675                 tot_offset += size[i];
676                 pcm += ret*st->channels;
677                 nb_samples += ret;
678         }
679         if (packet_offset != NULL)
680            *packet_offset = tot_offset;
681         return nb_samples;
682 }
683
684 #ifdef FIXED_POINT
685
686 int opus_decode(OpusDecoder *st, const unsigned char *data,
687       int len, opus_val16 *pcm, int frame_size, int decode_fec)
688 {
689    return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL);
690 }
691
692 #ifndef DISABLE_FLOAT_API
693 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
694       int len, float *pcm, int frame_size, int decode_fec)
695 {
696    VARDECL(opus_int16, out);
697    int ret, i;
698    ALLOC_STACK;
699
700    ALLOC(out, frame_size*st->channels, opus_int16);
701
702    ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL);
703    if (ret > 0)
704    {
705       for (i=0;i<ret*st->channels;i++)
706          pcm[i] = (1./32768.)*(out[i]);
707    }
708    RESTORE_STACK;
709    return ret;
710 }
711 #endif
712
713
714 #else
715 int opus_decode(OpusDecoder *st, const unsigned char *data,
716       int len, opus_int16 *pcm, int frame_size, int decode_fec)
717 {
718    VARDECL(float, out);
719    int ret, i;
720    ALLOC_STACK;
721
722    ALLOC(out, frame_size*st->channels, float);
723
724    ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL);
725    if (ret > 0)
726    {
727       for (i=0;i<ret*st->channels;i++)
728          pcm[i] = FLOAT2INT16(out[i]);
729    }
730    RESTORE_STACK;
731    return ret;
732 }
733
734 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
735         int len, opus_val16 *pcm, int frame_size, int decode_fec)
736 {
737    return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL);
738 }
739
740 #endif
741
742 int opus_decoder_ctl(OpusDecoder *st, int request, ...)
743 {
744    int ret = OPUS_OK;
745    va_list ap;
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       void *silk_dec;
766       CELTDecoder *celt_dec;
767
768       silk_dec = (char*)st+st->silk_dec_offset;
769       celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
770
771       OPUS_CLEAR((char*)&st->OPUS_DECODER_RESET_START,
772             opus_decoder_get_size(st->channels)-
773             ((char*)&st->OPUS_DECODER_RESET_START - (char*)st));
774
775       celt_decoder_ctl(celt_dec, CELT_RESET_STATE);
776       silk_InitDecoder( silk_dec );
777       st->stream_channels = st->channels;
778       st->frame_size = st->Fs/400;
779    }
780    break;
781    default:
782       /*fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);*/
783       ret = OPUS_BAD_ARG;
784       break;
785    }
786
787    va_end(ap);
788    return ret;
789 }
790
791 void opus_decoder_destroy(OpusDecoder *st)
792 {
793         opus_free(st);
794 }
795
796
797 int opus_packet_get_bandwidth(const unsigned char *data)
798 {
799         int bandwidth;
800     if (data[0]&0x80)
801     {
802         bandwidth = OPUS_BANDWIDTH_MEDIUMBAND + ((data[0]>>5)&0x3);
803         if (bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
804             bandwidth = OPUS_BANDWIDTH_NARROWBAND;
805     } else if ((data[0]&0x60) == 0x60)
806     {
807         bandwidth = (data[0]&0x10) ? OPUS_BANDWIDTH_FULLBAND : OPUS_BANDWIDTH_SUPERWIDEBAND;
808     } else {
809
810         bandwidth = OPUS_BANDWIDTH_NARROWBAND + ((data[0]>>5)&0x3);
811     }
812     return bandwidth;
813 }
814
815 int opus_packet_get_samples_per_frame(const unsigned char *data, int Fs)
816 {
817         int audiosize;
818     if (data[0]&0x80)
819     {
820         audiosize = ((data[0]>>3)&0x3);
821         audiosize = (Fs<<audiosize)/400;
822     } else if ((data[0]&0x60) == 0x60)
823     {
824         audiosize = (data[0]&0x08) ? Fs/50 : Fs/100;
825     } else {
826
827         audiosize = ((data[0]>>3)&0x3);
828         if (audiosize == 3)
829             audiosize = Fs*60/1000;
830         else
831             audiosize = (Fs<<audiosize)/100;
832     }
833     return audiosize;
834 }
835
836 int opus_packet_get_nb_channels(const unsigned char *data)
837 {
838     return (data[0]&0x4) ? 2 : 1;
839 }
840
841 int opus_packet_get_nb_frames(const unsigned char packet[], int len)
842 {
843         int count;
844         if (len<1)
845                 return OPUS_BAD_ARG;
846         count = packet[0]&0x3;
847         if (count==0)
848                 return 1;
849         else if (count!=3)
850                 return 2;
851         else if (len<2)
852                 return OPUS_CORRUPTED_DATA;
853         else
854                 return packet[1]&0x3F;
855 }
856
857 int opus_decoder_get_nb_samples(const OpusDecoder *dec, const unsigned char packet[], int len)
858 {
859         int samples;
860         int count = opus_packet_get_nb_frames(packet, len);
861         samples = count*opus_packet_get_samples_per_frame(packet, dec->Fs);
862         /* Can't have more than 120 ms */
863         if (samples*25 > dec->Fs*3)
864                 return OPUS_CORRUPTED_DATA;
865         else
866                 return samples;
867 }
868