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