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