Using a table on ARM for unsigned division by small (<=256) integers.
[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    int nb_samples;
726    ALLOC_STACK;
727
728    if(frame_size<=0)
729    {
730       RESTORE_STACK;
731       return OPUS_BAD_ARG;
732    }
733    if (data != NULL && len > 0 && !decode_fec)
734    {
735       nb_samples = opus_decoder_get_nb_samples(st, data, len);
736       if (nb_samples>0)
737          frame_size = IMIN(frame_size, nb_samples);
738       else
739          return OPUS_INVALID_PACKET;
740    }
741    ALLOC(out, frame_size*st->channels, opus_int16);
742
743    ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL, 0);
744    if (ret > 0)
745    {
746       for (i=0;i<ret*st->channels;i++)
747          pcm[i] = (1.f/32768.f)*(out[i]);
748    }
749    RESTORE_STACK;
750    return ret;
751 }
752 #endif
753
754
755 #else
756 int opus_decode(OpusDecoder *st, const unsigned char *data,
757       opus_int32 len, opus_int16 *pcm, int frame_size, int decode_fec)
758 {
759    VARDECL(float, out);
760    int ret, i;
761    int nb_samples;
762    ALLOC_STACK;
763
764    if(frame_size<=0)
765    {
766       RESTORE_STACK;
767       return OPUS_BAD_ARG;
768    }
769
770    if (data != NULL && len > 0 && !decode_fec)
771    {
772       nb_samples = opus_decoder_get_nb_samples(st, data, len);
773       if (nb_samples>0)
774          frame_size = IMIN(frame_size, nb_samples);
775       else
776          return OPUS_INVALID_PACKET;
777    }
778    ALLOC(out, frame_size*st->channels, float);
779
780    ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL, 1);
781    if (ret > 0)
782    {
783       for (i=0;i<ret*st->channels;i++)
784          pcm[i] = FLOAT2INT16(out[i]);
785    }
786    RESTORE_STACK;
787    return ret;
788 }
789
790 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
791       opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec)
792 {
793    if(frame_size<=0)
794       return OPUS_BAD_ARG;
795    return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL, 0);
796 }
797
798 #endif
799
800 int opus_decoder_ctl(OpusDecoder *st, int request, ...)
801 {
802    int ret = OPUS_OK;
803    va_list ap;
804    void *silk_dec;
805    CELTDecoder *celt_dec;
806
807    silk_dec = (char*)st+st->silk_dec_offset;
808    celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
809
810
811    va_start(ap, request);
812
813    switch (request)
814    {
815    case OPUS_GET_BANDWIDTH_REQUEST:
816    {
817       opus_int32 *value = va_arg(ap, opus_int32*);
818       if (!value)
819       {
820          goto bad_arg;
821       }
822       *value = st->bandwidth;
823    }
824    break;
825    case OPUS_GET_FINAL_RANGE_REQUEST:
826    {
827       opus_uint32 *value = va_arg(ap, opus_uint32*);
828       if (!value)
829       {
830          goto bad_arg;
831       }
832       *value = st->rangeFinal;
833    }
834    break;
835    case OPUS_RESET_STATE:
836    {
837       OPUS_CLEAR((char*)&st->OPUS_DECODER_RESET_START,
838             sizeof(OpusDecoder)-
839             ((char*)&st->OPUS_DECODER_RESET_START - (char*)st));
840
841       celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
842       silk_InitDecoder( silk_dec );
843       st->stream_channels = st->channels;
844       st->frame_size = st->Fs/400;
845    }
846    break;
847    case OPUS_GET_SAMPLE_RATE_REQUEST:
848    {
849       opus_int32 *value = va_arg(ap, opus_int32*);
850       if (!value)
851       {
852          goto bad_arg;
853       }
854       *value = st->Fs;
855    }
856    break;
857    case OPUS_GET_PITCH_REQUEST:
858    {
859       opus_int32 *value = va_arg(ap, opus_int32*);
860       if (!value)
861       {
862          goto bad_arg;
863       }
864       if (st->prev_mode == MODE_CELT_ONLY)
865          celt_decoder_ctl(celt_dec, OPUS_GET_PITCH(value));
866       else
867          *value = st->DecControl.prevPitchLag;
868    }
869    break;
870    case OPUS_GET_GAIN_REQUEST:
871    {
872       opus_int32 *value = va_arg(ap, opus_int32*);
873       if (!value)
874       {
875          goto bad_arg;
876       }
877       *value = st->decode_gain;
878    }
879    break;
880    case OPUS_SET_GAIN_REQUEST:
881    {
882        opus_int32 value = va_arg(ap, opus_int32);
883        if (value<-32768 || value>32767)
884        {
885           goto bad_arg;
886        }
887        st->decode_gain = value;
888    }
889    break;
890    case OPUS_GET_LAST_PACKET_DURATION_REQUEST:
891    {
892       opus_uint32 *value = va_arg(ap, opus_uint32*);
893       if (!value)
894       {
895          goto bad_arg;
896       }
897       *value = st->last_packet_duration;
898    }
899    break;
900    default:
901       /*fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);*/
902       ret = OPUS_UNIMPLEMENTED;
903       break;
904    }
905
906    va_end(ap);
907    return ret;
908 bad_arg:
909    va_end(ap);
910    return OPUS_BAD_ARG;
911 }
912
913 void opus_decoder_destroy(OpusDecoder *st)
914 {
915    opus_free(st);
916 }
917
918
919 int opus_packet_get_bandwidth(const unsigned char *data)
920 {
921    int bandwidth;
922    if (data[0]&0x80)
923    {
924       bandwidth = OPUS_BANDWIDTH_MEDIUMBAND + ((data[0]>>5)&0x3);
925       if (bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
926          bandwidth = OPUS_BANDWIDTH_NARROWBAND;
927    } else if ((data[0]&0x60) == 0x60)
928    {
929       bandwidth = (data[0]&0x10) ? OPUS_BANDWIDTH_FULLBAND :
930                                    OPUS_BANDWIDTH_SUPERWIDEBAND;
931    } else {
932       bandwidth = OPUS_BANDWIDTH_NARROWBAND + ((data[0]>>5)&0x3);
933    }
934    return bandwidth;
935 }
936
937 int opus_packet_get_samples_per_frame(const unsigned char *data,
938       opus_int32 Fs)
939 {
940    int audiosize;
941    if (data[0]&0x80)
942    {
943       audiosize = ((data[0]>>3)&0x3);
944       audiosize = (Fs<<audiosize)/400;
945    } else if ((data[0]&0x60) == 0x60)
946    {
947       audiosize = (data[0]&0x08) ? Fs/50 : Fs/100;
948    } else {
949       audiosize = ((data[0]>>3)&0x3);
950       if (audiosize == 3)
951          audiosize = Fs*60/1000;
952       else
953          audiosize = (Fs<<audiosize)/100;
954    }
955    return audiosize;
956 }
957
958 int opus_packet_get_nb_channels(const unsigned char *data)
959 {
960    return (data[0]&0x4) ? 2 : 1;
961 }
962
963 int opus_packet_get_nb_frames(const unsigned char packet[], opus_int32 len)
964 {
965    int count;
966    if (len<1)
967       return OPUS_BAD_ARG;
968    count = packet[0]&0x3;
969    if (count==0)
970       return 1;
971    else if (count!=3)
972       return 2;
973    else if (len<2)
974       return OPUS_INVALID_PACKET;
975    else
976       return packet[1]&0x3F;
977 }
978
979 int opus_packet_get_nb_samples(const unsigned char packet[], opus_int32 len,
980       opus_int32 Fs)
981 {
982    int samples;
983    int count = opus_packet_get_nb_frames(packet, len);
984
985    if (count<0)
986       return count;
987
988    samples = count*opus_packet_get_samples_per_frame(packet, Fs);
989    /* Can't have more than 120 ms */
990    if (samples*25 > Fs*3)
991       return OPUS_INVALID_PACKET;
992    else
993       return samples;
994 }
995
996 int opus_decoder_get_nb_samples(const OpusDecoder *dec,
997       const unsigned char packet[], opus_int32 len)
998 {
999    return opus_packet_get_nb_samples(packet, len, dec->Fs);
1000 }