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