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