Adding decoder state validation
[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 COPYRIGHT OWNER
19    OR 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 #ifndef OPUS_BUILD
33 # error "OPUS_BUILD _MUST_ be defined to build Opus. This probably means you need other defines as well, as in a config.h. See the included build files for details."
34 #endif
35
36 #if defined(__GNUC__) && (__GNUC__ >= 2) && !defined(__OPTIMIZE__) && !defined(OPUS_WILL_BE_SLOW)
37 # pragma message "You appear to be compiling without optimization, if so opus will be very slow."
38 #endif
39
40 #include <stdarg.h>
41 #include "celt.h"
42 #include "opus.h"
43 #include "entdec.h"
44 #include "modes.h"
45 #include "API.h"
46 #include "stack_alloc.h"
47 #include "float_cast.h"
48 #include "opus_private.h"
49 #include "os_support.h"
50 #include "structs.h"
51 #include "define.h"
52 #include "mathops.h"
53 #include "cpu_support.h"
54
55 struct OpusDecoder {
56    int          celt_dec_offset;
57    int          silk_dec_offset;
58    int          channels;
59    opus_int32   Fs;          /** Sampling rate (at the API level) */
60    silk_DecControlStruct DecControl;
61    int          decode_gain;
62    int          arch;
63
64    /* Everything beyond this point gets cleared on a reset */
65 #define OPUS_DECODER_RESET_START stream_channels
66    int          stream_channels;
67
68    int          bandwidth;
69    int          mode;
70    int          prev_mode;
71    int          frame_size;
72    int          prev_redundancy;
73    int          last_packet_duration;
74 #ifndef FIXED_POINT
75    opus_val16   softclip_mem[2];
76 #endif
77
78    opus_uint32  rangeFinal;
79 };
80
81
82 int opus_decoder_get_size(int channels)
83 {
84    int silkDecSizeBytes, celtDecSizeBytes;
85    int ret;
86    if (channels<1 || channels > 2)
87       return 0;
88    ret = silk_Get_Decoder_Size( &silkDecSizeBytes );
89    if(ret)
90       return 0;
91    silkDecSizeBytes = align(silkDecSizeBytes);
92    celtDecSizeBytes = celt_decoder_get_size(channels);
93    return align(sizeof(OpusDecoder))+silkDecSizeBytes+celtDecSizeBytes;
94 }
95
96 int opus_decoder_init(OpusDecoder *st, opus_int32 Fs, int channels)
97 {
98    void *silk_dec;
99    CELTDecoder *celt_dec;
100    int ret, silkDecSizeBytes;
101
102    if ((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)
103     || (channels!=1&&channels!=2))
104       return OPUS_BAD_ARG;
105
106    OPUS_CLEAR((char*)st, opus_decoder_get_size(channels));
107    /* Initialize SILK decoder */
108    ret = silk_Get_Decoder_Size(&silkDecSizeBytes);
109    if (ret)
110       return OPUS_INTERNAL_ERROR;
111
112    silkDecSizeBytes = align(silkDecSizeBytes);
113    st->silk_dec_offset = align(sizeof(OpusDecoder));
114    st->celt_dec_offset = st->silk_dec_offset+silkDecSizeBytes;
115    silk_dec = (char*)st+st->silk_dec_offset;
116    celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
117    st->stream_channels = st->channels = channels;
118
119    st->Fs = Fs;
120    st->DecControl.API_sampleRate = st->Fs;
121    st->DecControl.nChannelsAPI      = st->channels;
122
123    /* Reset decoder */
124    ret = silk_InitDecoder( silk_dec );
125    if(ret)return OPUS_INTERNAL_ERROR;
126
127    /* Initialize CELT decoder */
128    ret = celt_decoder_init(celt_dec, Fs, channels);
129    if(ret!=OPUS_OK)return OPUS_INTERNAL_ERROR;
130
131    celt_decoder_ctl(celt_dec, CELT_SET_SIGNALLING(0));
132
133    st->prev_mode = 0;
134    st->frame_size = Fs/400;
135    st->arch = opus_select_arch();
136    return OPUS_OK;
137 }
138
139 OpusDecoder *opus_decoder_create(opus_int32 Fs, int channels, int *error)
140 {
141    int ret;
142    OpusDecoder *st;
143    if ((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)
144     || (channels!=1&&channels!=2))
145    {
146       if (error)
147          *error = OPUS_BAD_ARG;
148       return NULL;
149    }
150    st = (OpusDecoder *)opus_alloc(opus_decoder_get_size(channels));
151    if (st == NULL)
152    {
153       if (error)
154          *error = OPUS_ALLOC_FAIL;
155       return NULL;
156    }
157    ret = opus_decoder_init(st, Fs, channels);
158    if (error)
159       *error = ret;
160    if (ret != OPUS_OK)
161    {
162       opus_free(st);
163       st = NULL;
164    }
165    return st;
166 }
167
168 static void smooth_fade(const opus_val16 *in1, const opus_val16 *in2,
169       opus_val16 *out, int overlap, int channels,
170       const opus_val16 *window, opus_int32 Fs)
171 {
172    int i, c;
173    int inc = 48000/Fs;
174    for (c=0;c<channels;c++)
175    {
176       for (i=0;i<overlap;i++)
177       {
178          opus_val16 w = MULT16_16_Q15(window[i*inc], window[i*inc]);
179          out[i*channels+c] = SHR32(MAC16_16(MULT16_16(w,in2[i*channels+c]),
180                                    Q15ONE-w, in1[i*channels+c]), 15);
181       }
182    }
183 }
184
185 static int opus_packet_get_mode(const unsigned char *data)
186 {
187    int mode;
188    if (data[0]&0x80)
189    {
190       mode = MODE_CELT_ONLY;
191    } else if ((data[0]&0x60) == 0x60)
192    {
193       mode = MODE_HYBRID;
194    } else {
195       mode = MODE_SILK_ONLY;
196    }
197    return mode;
198 }
199
200 static int opus_decode_frame(OpusDecoder *st, const unsigned char *data,
201       opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec)
202 {
203    void *silk_dec;
204    CELTDecoder *celt_dec;
205    int i, silk_ret=0, celt_ret=0;
206    ec_dec dec;
207    opus_int32 silk_frame_size;
208    int pcm_silk_size;
209    VARDECL(opus_int16, pcm_silk);
210    int pcm_transition_silk_size;
211    VARDECL(opus_val16, pcm_transition_silk);
212    int pcm_transition_celt_size;
213    VARDECL(opus_val16, pcm_transition_celt);
214    opus_val16 *pcm_transition=NULL;
215    int redundant_audio_size;
216    VARDECL(opus_val16, redundant_audio);
217
218    int audiosize;
219    int mode;
220    int bandwidth;
221    int transition=0;
222    int start_band;
223    int redundancy=0;
224    int redundancy_bytes = 0;
225    int celt_to_silk=0;
226    int c;
227    int F2_5, F5, F10, F20;
228    const opus_val16 *window;
229    opus_uint32 redundant_rng = 0;
230    int celt_accum;
231    ALLOC_STACK;
232
233    silk_dec = (char*)st+st->silk_dec_offset;
234    celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
235    F20 = st->Fs/50;
236    F10 = F20>>1;
237    F5 = F10>>1;
238    F2_5 = F5>>1;
239    if (frame_size < F2_5)
240    {
241       RESTORE_STACK;
242       return OPUS_BUFFER_TOO_SMALL;
243    }
244    /* Limit frame_size to avoid excessive stack allocations. */
245    frame_size = IMIN(frame_size, st->Fs/25*3);
246    /* Payloads of 1 (2 including ToC) or 0 trigger the PLC/DTX */
247    if (len<=1)
248    {
249       data = NULL;
250       /* In that case, don't conceal more than what the ToC says */
251       frame_size = IMIN(frame_size, st->frame_size);
252    }
253    if (data != NULL)
254    {
255       audiosize = st->frame_size;
256       mode = st->mode;
257       bandwidth = st->bandwidth;
258       ec_dec_init(&dec,(unsigned char*)data,len);
259    } else {
260       audiosize = frame_size;
261       mode = st->prev_mode;
262       bandwidth = 0;
263
264       if (mode == 0)
265       {
266          /* If we haven't got any packet yet, all we can do is return zeros */
267          for (i=0;i<audiosize*st->channels;i++)
268             pcm[i] = 0;
269          RESTORE_STACK;
270          return audiosize;
271       }
272
273       /* Avoids trying to run the PLC on sizes other than 2.5 (CELT), 5 (CELT),
274          10, or 20 (e.g. 12.5 or 30 ms). */
275       if (audiosize > F20)
276       {
277          do {
278             int ret = opus_decode_frame(st, NULL, 0, pcm, IMIN(audiosize, F20), 0);
279             if (ret<0)
280             {
281                RESTORE_STACK;
282                return ret;
283             }
284             pcm += ret*st->channels;
285             audiosize -= ret;
286          } while (audiosize > 0);
287          RESTORE_STACK;
288          return frame_size;
289       } else if (audiosize < F20)
290       {
291          if (audiosize > F10)
292             audiosize = F10;
293          else if (mode != MODE_SILK_ONLY && audiosize > F5 && audiosize < F10)
294             audiosize = F5;
295       }
296    }
297
298    /* In fixed-point, we can tell CELT to do the accumulation on top of the
299       SILK PCM buffer. This saves some stack space. */
300 #ifdef FIXED_POINT
301    celt_accum = (mode != MODE_CELT_ONLY) && (frame_size >= F10);
302 #else
303    celt_accum = 0;
304 #endif
305
306    pcm_transition_silk_size = ALLOC_NONE;
307    pcm_transition_celt_size = ALLOC_NONE;
308    if (data!=NULL && st->prev_mode > 0 && (
309        (mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY && !st->prev_redundancy)
310     || (mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) )
311       )
312    {
313       transition = 1;
314       /* Decide where to allocate the stack memory for pcm_transition */
315       if (mode == MODE_CELT_ONLY)
316          pcm_transition_celt_size = F5*st->channels;
317       else
318          pcm_transition_silk_size = F5*st->channels;
319    }
320    ALLOC(pcm_transition_celt, pcm_transition_celt_size, opus_val16);
321    if (transition && mode == MODE_CELT_ONLY)
322    {
323       pcm_transition = pcm_transition_celt;
324       opus_decode_frame(st, NULL, 0, pcm_transition, IMIN(F5, audiosize), 0);
325    }
326    if (audiosize > frame_size)
327    {
328       /*fprintf(stderr, "PCM buffer too small: %d vs %d (mode = %d)\n", audiosize, frame_size, mode);*/
329       RESTORE_STACK;
330       return OPUS_BAD_ARG;
331    } else {
332       frame_size = audiosize;
333    }
334
335    /* Don't allocate any memory when in CELT-only mode */
336    pcm_silk_size = (mode != MODE_CELT_ONLY && !celt_accum) ? IMAX(F10, frame_size)*st->channels : ALLOC_NONE;
337    ALLOC(pcm_silk, pcm_silk_size, opus_int16);
338
339    /* SILK processing */
340    if (mode != MODE_CELT_ONLY)
341    {
342       int lost_flag, decoded_samples;
343       opus_int16 *pcm_ptr;
344 #ifdef FIXED_POINT
345       if (celt_accum)
346          pcm_ptr = pcm;
347       else
348 #endif
349          pcm_ptr = pcm_silk;
350
351       if (st->prev_mode==MODE_CELT_ONLY)
352          silk_InitDecoder( silk_dec );
353
354       /* The SILK PLC cannot produce frames of less than 10 ms */
355       st->DecControl.payloadSize_ms = IMAX(10, 1000 * audiosize / st->Fs);
356
357       if (data != NULL)
358       {
359         st->DecControl.nChannelsInternal = st->stream_channels;
360         if( mode == MODE_SILK_ONLY ) {
361            if( bandwidth == OPUS_BANDWIDTH_NARROWBAND ) {
362               st->DecControl.internalSampleRate = 8000;
363            } else if( bandwidth == OPUS_BANDWIDTH_MEDIUMBAND ) {
364               st->DecControl.internalSampleRate = 12000;
365            } else if( bandwidth == OPUS_BANDWIDTH_WIDEBAND ) {
366               st->DecControl.internalSampleRate = 16000;
367            } else {
368               st->DecControl.internalSampleRate = 16000;
369               celt_assert( 0 );
370            }
371         } else {
372            /* Hybrid mode */
373            st->DecControl.internalSampleRate = 16000;
374         }
375      }
376
377      lost_flag = data == NULL ? 1 : 2 * decode_fec;
378      decoded_samples = 0;
379      do {
380         /* Call SILK decoder */
381         int first_frame = decoded_samples == 0;
382         silk_ret = silk_Decode( silk_dec, &st->DecControl,
383                                 lost_flag, first_frame, &dec, pcm_ptr, &silk_frame_size, st->arch );
384         if( silk_ret ) {
385            if (lost_flag) {
386               /* PLC failure should not be fatal */
387               silk_frame_size = frame_size;
388               for (i=0;i<frame_size*st->channels;i++)
389                  pcm_ptr[i] = 0;
390            } else {
391              RESTORE_STACK;
392              return OPUS_INTERNAL_ERROR;
393            }
394         }
395         pcm_ptr += silk_frame_size * st->channels;
396         decoded_samples += silk_frame_size;
397       } while( decoded_samples < frame_size );
398    }
399
400    start_band = 0;
401    if (!decode_fec && mode != MODE_CELT_ONLY && data != NULL
402     && ec_tell(&dec)+17+20*(st->mode == MODE_HYBRID) <= 8*len)
403    {
404       /* Check if we have a redundant 0-8 kHz band */
405       if (mode == MODE_HYBRID)
406          redundancy = ec_dec_bit_logp(&dec, 12);
407       else
408          redundancy = 1;
409       if (redundancy)
410       {
411          celt_to_silk = ec_dec_bit_logp(&dec, 1);
412          /* redundancy_bytes will be at least two, in the non-hybrid
413             case due to the ec_tell() check above */
414          redundancy_bytes = mode==MODE_HYBRID ?
415                (opus_int32)ec_dec_uint(&dec, 256)+2 :
416                len-((ec_tell(&dec)+7)>>3);
417          len -= redundancy_bytes;
418          /* This is a sanity check. It should never happen for a valid
419             packet, so the exact behaviour is not normative. */
420          if (len*8 < ec_tell(&dec))
421          {
422             len = 0;
423             redundancy_bytes = 0;
424             redundancy = 0;
425          }
426          /* Shrink decoder because of raw bits */
427          dec.storage -= redundancy_bytes;
428       }
429    }
430    if (mode != MODE_CELT_ONLY)
431       start_band = 17;
432
433    if (redundancy)
434    {
435       transition = 0;
436       pcm_transition_silk_size=ALLOC_NONE;
437    }
438
439    ALLOC(pcm_transition_silk, pcm_transition_silk_size, opus_val16);
440
441    if (transition && mode != MODE_CELT_ONLY)
442    {
443       pcm_transition = pcm_transition_silk;
444       opus_decode_frame(st, NULL, 0, pcm_transition, IMIN(F5, audiosize), 0);
445    }
446
447
448    if (bandwidth)
449    {
450       int endband=21;
451
452       switch(bandwidth)
453       {
454       case OPUS_BANDWIDTH_NARROWBAND:
455          endband = 13;
456          break;
457       case OPUS_BANDWIDTH_MEDIUMBAND:
458       case OPUS_BANDWIDTH_WIDEBAND:
459          endband = 17;
460          break;
461       case OPUS_BANDWIDTH_SUPERWIDEBAND:
462          endband = 19;
463          break;
464       case OPUS_BANDWIDTH_FULLBAND:
465          endband = 21;
466          break;
467       default:
468          celt_assert(0);
469          break;
470       }
471       celt_decoder_ctl(celt_dec, CELT_SET_END_BAND(endband));
472    }
473    celt_decoder_ctl(celt_dec, CELT_SET_CHANNELS(st->stream_channels));
474
475    /* Only allocation memory for redundancy if/when needed */
476    redundant_audio_size = redundancy ? F5*st->channels : ALLOC_NONE;
477    ALLOC(redundant_audio, redundant_audio_size, opus_val16);
478
479    /* 5 ms redundant frame for CELT->SILK*/
480    if (redundancy && celt_to_silk)
481    {
482       celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
483       celt_decode_with_ec(celt_dec, data+len, redundancy_bytes,
484                           redundant_audio, F5, NULL, 0);
485       celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_RANGE(&redundant_rng));
486    }
487
488    /* MUST be after PLC */
489    celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(start_band));
490
491    if (mode != MODE_SILK_ONLY)
492    {
493       int celt_frame_size = IMIN(F20, frame_size);
494       /* Make sure to discard any previous CELT state */
495       if (mode != st->prev_mode && st->prev_mode > 0 && !st->prev_redundancy)
496          celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
497       /* Decode CELT */
498       celt_ret = celt_decode_with_ec(celt_dec, decode_fec ? NULL : data,
499                                      len, pcm, celt_frame_size, &dec, celt_accum);
500    } else {
501       unsigned char silence[2] = {0xFF, 0xFF};
502       if (!celt_accum)
503       {
504          for (i=0;i<frame_size*st->channels;i++)
505             pcm[i] = 0;
506       }
507       /* For hybrid -> SILK transitions, we let the CELT MDCT
508          do a fade-out by decoding a silence frame */
509       if (st->prev_mode == MODE_HYBRID && !(redundancy && celt_to_silk && st->prev_redundancy) )
510       {
511          celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
512          celt_decode_with_ec(celt_dec, silence, 2, pcm, F2_5, NULL, celt_accum);
513       }
514    }
515
516    if (mode != MODE_CELT_ONLY && !celt_accum)
517    {
518 #ifdef FIXED_POINT
519       for (i=0;i<frame_size*st->channels;i++)
520          pcm[i] = SAT16(ADD32(pcm[i], pcm_silk[i]));
521 #else
522       for (i=0;i<frame_size*st->channels;i++)
523          pcm[i] = pcm[i] + (opus_val16)((1.f/32768.f)*pcm_silk[i]);
524 #endif
525    }
526
527    {
528       const CELTMode *celt_mode;
529       celt_decoder_ctl(celt_dec, CELT_GET_MODE(&celt_mode));
530       window = celt_mode->window;
531    }
532
533    /* 5 ms redundant frame for SILK->CELT */
534    if (redundancy && !celt_to_silk)
535    {
536       celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
537       celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
538
539       celt_decode_with_ec(celt_dec, data+len, redundancy_bytes, redundant_audio, F5, NULL, 0);
540       celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_RANGE(&redundant_rng));
541       smooth_fade(pcm+st->channels*(frame_size-F2_5), redundant_audio+st->channels*F2_5,
542                   pcm+st->channels*(frame_size-F2_5), F2_5, st->channels, window, st->Fs);
543    }
544    if (redundancy && celt_to_silk)
545    {
546       for (c=0;c<st->channels;c++)
547       {
548          for (i=0;i<F2_5;i++)
549             pcm[st->channels*i+c] = redundant_audio[st->channels*i+c];
550       }
551       smooth_fade(redundant_audio+st->channels*F2_5, pcm+st->channels*F2_5,
552                   pcm+st->channels*F2_5, F2_5, st->channels, window, st->Fs);
553    }
554    if (transition)
555    {
556       if (audiosize >= F5)
557       {
558          for (i=0;i<st->channels*F2_5;i++)
559             pcm[i] = pcm_transition[i];
560          smooth_fade(pcm_transition+st->channels*F2_5, pcm+st->channels*F2_5,
561                      pcm+st->channels*F2_5, F2_5,
562                      st->channels, window, st->Fs);
563       } else {
564          /* Not enough time to do a clean transition, but we do it anyway
565             This will not preserve amplitude perfectly and may introduce
566             a bit of temporal aliasing, but it shouldn't be too bad and
567             that's pretty much the best we can do. In any case, generating this
568             transition it pretty silly in the first place */
569          smooth_fade(pcm_transition, pcm,
570                      pcm, F2_5,
571                      st->channels, window, st->Fs);
572       }
573    }
574
575    if(st->decode_gain)
576    {
577       opus_val32 gain;
578       gain = celt_exp2(MULT16_16_P15(QCONST16(6.48814081e-4f, 25), st->decode_gain));
579       for (i=0;i<frame_size*st->channels;i++)
580       {
581          opus_val32 x;
582          x = MULT16_32_P16(pcm[i],gain);
583          pcm[i] = SATURATE(x, 32767);
584       }
585    }
586
587    if (len <= 1)
588       st->rangeFinal = 0;
589    else
590       st->rangeFinal = dec.rng ^ redundant_rng;
591
592    st->prev_mode = mode;
593    st->prev_redundancy = redundancy && !celt_to_silk;
594
595    if (celt_ret>=0)
596    {
597       if (OPUS_CHECK_ARRAY(pcm, audiosize*st->channels))
598          OPUS_PRINT_INT(audiosize);
599    }
600
601    RESTORE_STACK;
602    return celt_ret < 0 ? celt_ret : audiosize;
603
604 }
605
606 int opus_decode_native(OpusDecoder *st, const unsigned char *data,
607       opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec,
608       int self_delimited, opus_int32 *packet_offset, int soft_clip)
609 {
610    int i, nb_samples;
611    int count, offset;
612    unsigned char toc;
613    int packet_frame_size, packet_bandwidth, packet_mode, packet_stream_channels;
614    /* 48 x 2.5 ms = 120 ms */
615    opus_int16 size[48];
616    if (decode_fec<0 || decode_fec>1)
617       return OPUS_BAD_ARG;
618    /* For FEC/PLC, frame_size has to be to have a multiple of 2.5 ms */
619    if ((decode_fec || len==0 || data==NULL) && frame_size%(st->Fs/400)!=0)
620       return OPUS_BAD_ARG;
621    if (len==0 || data==NULL)
622    {
623       int pcm_count=0;
624       do {
625          int ret;
626          ret = opus_decode_frame(st, NULL, 0, pcm+pcm_count*st->channels, frame_size-pcm_count, 0);
627          if (ret<0)
628             return ret;
629          pcm_count += ret;
630       } while (pcm_count < frame_size);
631       celt_assert(pcm_count == frame_size);
632       if (OPUS_CHECK_ARRAY(pcm, pcm_count*st->channels))
633          OPUS_PRINT_INT(pcm_count);
634       st->last_packet_duration = pcm_count;
635       return pcm_count;
636    } else if (len<0)
637       return OPUS_BAD_ARG;
638
639    packet_mode = opus_packet_get_mode(data);
640    packet_bandwidth = opus_packet_get_bandwidth(data);
641    packet_frame_size = opus_packet_get_samples_per_frame(data, st->Fs);
642    packet_stream_channels = opus_packet_get_nb_channels(data);
643
644    count = opus_packet_parse_impl(data, len, self_delimited, &toc, NULL,
645                                   size, &offset, packet_offset);
646    if (count<0)
647       return count;
648
649    data += offset;
650
651    if (decode_fec)
652    {
653       int duration_copy;
654       int ret;
655       /* If no FEC can be present, run the PLC (recursive call) */
656       if (frame_size < packet_frame_size || packet_mode == MODE_CELT_ONLY || st->mode == MODE_CELT_ONLY)
657          return opus_decode_native(st, NULL, 0, pcm, frame_size, 0, 0, NULL, soft_clip);
658       /* Otherwise, run the PLC on everything except the size for which we might have FEC */
659       duration_copy = st->last_packet_duration;
660       if (frame_size-packet_frame_size!=0)
661       {
662          ret = opus_decode_native(st, NULL, 0, pcm, frame_size-packet_frame_size, 0, 0, NULL, soft_clip);
663          if (ret<0)
664          {
665             st->last_packet_duration = duration_copy;
666             return ret;
667          }
668          celt_assert(ret==frame_size-packet_frame_size);
669       }
670       /* Complete with FEC */
671       st->mode = packet_mode;
672       st->bandwidth = packet_bandwidth;
673       st->frame_size = packet_frame_size;
674       st->stream_channels = packet_stream_channels;
675       ret = opus_decode_frame(st, data, size[0], pcm+st->channels*(frame_size-packet_frame_size),
676             packet_frame_size, 1);
677       if (ret<0)
678          return ret;
679       else {
680          if (OPUS_CHECK_ARRAY(pcm, frame_size*st->channels))
681             OPUS_PRINT_INT(frame_size);
682          st->last_packet_duration = frame_size;
683          return frame_size;
684       }
685    }
686
687    if (count*packet_frame_size > frame_size)
688       return OPUS_BUFFER_TOO_SMALL;
689
690    /* Update the state as the last step to avoid updating it on an invalid packet */
691    st->mode = packet_mode;
692    st->bandwidth = packet_bandwidth;
693    st->frame_size = packet_frame_size;
694    st->stream_channels = packet_stream_channels;
695
696    nb_samples=0;
697    for (i=0;i<count;i++)
698    {
699       int ret;
700       ret = opus_decode_frame(st, data, size[i], pcm+nb_samples*st->channels, frame_size-nb_samples, 0);
701       if (ret<0)
702          return ret;
703       celt_assert(ret==packet_frame_size);
704       data += size[i];
705       nb_samples += ret;
706    }
707    st->last_packet_duration = nb_samples;
708    if (OPUS_CHECK_ARRAY(pcm, nb_samples*st->channels))
709       OPUS_PRINT_INT(nb_samples);
710 #ifndef FIXED_POINT
711    if (soft_clip)
712       opus_pcm_soft_clip(pcm, nb_samples, st->channels, st->softclip_mem);
713    else
714       st->softclip_mem[0]=st->softclip_mem[1]=0;
715 #endif
716    return nb_samples;
717 }
718
719 #ifdef FIXED_POINT
720
721 int opus_decode(OpusDecoder *st, const unsigned char *data,
722       opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec)
723 {
724    if(frame_size<=0)
725       return OPUS_BAD_ARG;
726    return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL, 0);
727 }
728
729 #ifndef DISABLE_FLOAT_API
730 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
731       opus_int32 len, float *pcm, int frame_size, int decode_fec)
732 {
733    VARDECL(opus_int16, out);
734    int ret, i;
735    int nb_samples;
736    ALLOC_STACK;
737
738    if(frame_size<=0)
739    {
740       RESTORE_STACK;
741       return OPUS_BAD_ARG;
742    }
743    if (data != NULL && len > 0 && !decode_fec)
744    {
745       nb_samples = opus_decoder_get_nb_samples(st, data, len);
746       if (nb_samples>0)
747          frame_size = IMIN(frame_size, nb_samples);
748       else
749          return OPUS_INVALID_PACKET;
750    }
751    ALLOC(out, frame_size*st->channels, opus_int16);
752
753    ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL, 0);
754    if (ret > 0)
755    {
756       for (i=0;i<ret*st->channels;i++)
757          pcm[i] = (1.f/32768.f)*(out[i]);
758    }
759    RESTORE_STACK;
760    return ret;
761 }
762 #endif
763
764
765 #else
766 int opus_decode(OpusDecoder *st, const unsigned char *data,
767       opus_int32 len, opus_int16 *pcm, int frame_size, int decode_fec)
768 {
769    VARDECL(float, out);
770    int ret, i;
771    int nb_samples;
772    ALLOC_STACK;
773
774    if(frame_size<=0)
775    {
776       RESTORE_STACK;
777       return OPUS_BAD_ARG;
778    }
779
780    if (data != NULL && len > 0 && !decode_fec)
781    {
782       nb_samples = opus_decoder_get_nb_samples(st, data, len);
783       if (nb_samples>0)
784          frame_size = IMIN(frame_size, nb_samples);
785       else
786          return OPUS_INVALID_PACKET;
787    }
788    ALLOC(out, frame_size*st->channels, float);
789
790    ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL, 1);
791    if (ret > 0)
792    {
793       for (i=0;i<ret*st->channels;i++)
794          pcm[i] = FLOAT2INT16(out[i]);
795    }
796    RESTORE_STACK;
797    return ret;
798 }
799
800 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
801       opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec)
802 {
803    if(frame_size<=0)
804       return OPUS_BAD_ARG;
805    return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL, 0);
806 }
807
808 #endif
809
810 int opus_decoder_ctl(OpusDecoder *st, int request, ...)
811 {
812    int ret = OPUS_OK;
813    va_list ap;
814    void *silk_dec;
815    CELTDecoder *celt_dec;
816
817    silk_dec = (char*)st+st->silk_dec_offset;
818    celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
819
820
821    va_start(ap, request);
822
823    switch (request)
824    {
825    case OPUS_GET_BANDWIDTH_REQUEST:
826    {
827       opus_int32 *value = va_arg(ap, opus_int32*);
828       if (!value)
829       {
830          goto bad_arg;
831       }
832       *value = st->bandwidth;
833    }
834    break;
835    case OPUS_GET_FINAL_RANGE_REQUEST:
836    {
837       opus_uint32 *value = va_arg(ap, opus_uint32*);
838       if (!value)
839       {
840          goto bad_arg;
841       }
842       *value = st->rangeFinal;
843    }
844    break;
845    case OPUS_RESET_STATE:
846    {
847       OPUS_CLEAR((char*)&st->OPUS_DECODER_RESET_START,
848             sizeof(OpusDecoder)-
849             ((char*)&st->OPUS_DECODER_RESET_START - (char*)st));
850
851       celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
852       silk_InitDecoder( silk_dec );
853       st->stream_channels = st->channels;
854       st->frame_size = st->Fs/400;
855    }
856    break;
857    case OPUS_GET_SAMPLE_RATE_REQUEST:
858    {
859       opus_int32 *value = va_arg(ap, opus_int32*);
860       if (!value)
861       {
862          goto bad_arg;
863       }
864       *value = st->Fs;
865    }
866    break;
867    case OPUS_GET_PITCH_REQUEST:
868    {
869       opus_int32 *value = va_arg(ap, opus_int32*);
870       if (!value)
871       {
872          goto bad_arg;
873       }
874       if (st->prev_mode == MODE_CELT_ONLY)
875          celt_decoder_ctl(celt_dec, OPUS_GET_PITCH(value));
876       else
877          *value = st->DecControl.prevPitchLag;
878    }
879    break;
880    case OPUS_GET_GAIN_REQUEST:
881    {
882       opus_int32 *value = va_arg(ap, opus_int32*);
883       if (!value)
884       {
885          goto bad_arg;
886       }
887       *value = st->decode_gain;
888    }
889    break;
890    case OPUS_SET_GAIN_REQUEST:
891    {
892        opus_int32 value = va_arg(ap, opus_int32);
893        if (value<-32768 || value>32767)
894        {
895           goto bad_arg;
896        }
897        st->decode_gain = value;
898    }
899    break;
900    case OPUS_GET_LAST_PACKET_DURATION_REQUEST:
901    {
902       opus_int32 *value = va_arg(ap, opus_int32*);
903       if (!value)
904       {
905          goto bad_arg;
906       }
907       *value = st->last_packet_duration;
908    }
909    break;
910    case OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST:
911    {
912        opus_int32 value = va_arg(ap, opus_int32);
913        if(value<0 || value>1)
914        {
915           goto bad_arg;
916        }
917        celt_decoder_ctl(celt_dec, OPUS_SET_PHASE_INVERSION_DISABLED(value));
918    }
919    break;
920    case OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST:
921    {
922        opus_int32 *value = va_arg(ap, opus_int32*);
923        if (!value)
924        {
925           goto bad_arg;
926        }
927        celt_decoder_ctl(celt_dec, OPUS_GET_PHASE_INVERSION_DISABLED(value));
928    }
929    break;
930    default:
931       /*fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);*/
932       ret = OPUS_UNIMPLEMENTED;
933       break;
934    }
935
936    va_end(ap);
937    return ret;
938 bad_arg:
939    va_end(ap);
940    return OPUS_BAD_ARG;
941 }
942
943 void opus_decoder_destroy(OpusDecoder *st)
944 {
945    opus_free(st);
946 }
947
948
949 int opus_packet_get_bandwidth(const unsigned char *data)
950 {
951    int bandwidth;
952    if (data[0]&0x80)
953    {
954       bandwidth = OPUS_BANDWIDTH_MEDIUMBAND + ((data[0]>>5)&0x3);
955       if (bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
956          bandwidth = OPUS_BANDWIDTH_NARROWBAND;
957    } else if ((data[0]&0x60) == 0x60)
958    {
959       bandwidth = (data[0]&0x10) ? OPUS_BANDWIDTH_FULLBAND :
960                                    OPUS_BANDWIDTH_SUPERWIDEBAND;
961    } else {
962       bandwidth = OPUS_BANDWIDTH_NARROWBAND + ((data[0]>>5)&0x3);
963    }
964    return bandwidth;
965 }
966
967 int opus_packet_get_nb_channels(const unsigned char *data)
968 {
969    return (data[0]&0x4) ? 2 : 1;
970 }
971
972 int opus_packet_get_nb_frames(const unsigned char packet[], opus_int32 len)
973 {
974    int count;
975    if (len<1)
976       return OPUS_BAD_ARG;
977    count = packet[0]&0x3;
978    if (count==0)
979       return 1;
980    else if (count!=3)
981       return 2;
982    else if (len<2)
983       return OPUS_INVALID_PACKET;
984    else
985       return packet[1]&0x3F;
986 }
987
988 int opus_packet_get_nb_samples(const unsigned char packet[], opus_int32 len,
989       opus_int32 Fs)
990 {
991    int samples;
992    int count = opus_packet_get_nb_frames(packet, len);
993
994    if (count<0)
995       return count;
996
997    samples = count*opus_packet_get_samples_per_frame(packet, Fs);
998    /* Can't have more than 120 ms */
999    if (samples*25 > Fs*3)
1000       return OPUS_INVALID_PACKET;
1001    else
1002       return samples;
1003 }
1004
1005 int opus_decoder_get_nb_samples(const OpusDecoder *dec,
1006       const unsigned char packet[], opus_int32 len)
1007 {
1008    return opus_packet_get_nb_samples(packet, len, dec->Fs);
1009 }