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 FOUNDATION OR
  19    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 #include <string.h>
  33 #include <stdlib.h>
  34 #include <stdio.h>
  35 #include <stdarg.h>
  36 #include "celt.h"
  37 #include "opus.h"
  38 #include "entdec.h"
  39 #include "modes.h"
  40 #include "silk_API.h"
  41 #include "stack_alloc.h"
  42 #include "float_cast.h"
  43 #include "opus_private.h"
  44 #include "os_support.h"
  45
  46 #ifdef FIXED_POINT
  47 #define celt_decode_native celt_decode
  48 #else
  49 #define celt_decode_native celt_decode_float
  50 #endif
  51
  52 struct OpusDecoder {
  53    int          celt_dec_offset;
  54    int          silk_dec_offset;
  55    int          channels;
  56    int          stream_channels;
  57
  58     int          bandwidth;
  59     /* Sampling rate (at the API level) */
  60     int          Fs;
  61     int          mode;
  62     int          prev_mode;
  63     int          frame_size;
  64     int          prev_redundancy;
  65
  66     int          rangeFinal;
  67 };
  68
  69 #ifdef FIXED_POINT
  70 static inline opus_int16 SAT16(opus_int32 x) {
  71     return x > 32767 ? 32767 : x < -32768 ? -32768 : (opus_int16)x;
  72 };
  73 #endif
  74
  75
  76 int opus_decoder_get_size(int channels)
  77 {
  78         int silkDecSizeBytes, celtDecSizeBytes;
  79         int ret;
  80     ret = silk_Get_Decoder_Size( &silkDecSizeBytes );
  81         if(ret)
  82                 return 0;
  83         silkDecSizeBytes = align(silkDecSizeBytes);
  84     celtDecSizeBytes = celt_decoder_get_size(channels);
  85     return align(sizeof(OpusDecoder))+silkDecSizeBytes+celtDecSizeBytes;
  86
  87 }
  88
  89 int opus_decoder_init(OpusDecoder *st, int Fs, int channels)
  90 {
  91         void *silk_dec;
  92         CELTDecoder *celt_dec;
  93         int ret, silkDecSizeBytes;
  94
  95         if (channels<1 || channels > 2)
  96             return OPUS_BAD_ARG;
  97         memset(st, 0, opus_decoder_get_size(channels));
  98         /* Initialize SILK encoder */
  99     ret = silk_Get_Decoder_Size( &silkDecSizeBytes );
 100     if( ret ) {
 101         return OPUS_INTERNAL_ERROR;
 102     }
 103     silkDecSizeBytes = align(silkDecSizeBytes);
 104     st->silk_dec_offset = align(sizeof(OpusDecoder));
 105     st->celt_dec_offset = st->silk_dec_offset+silkDecSizeBytes;
 106     silk_dec = (char*)st+st->silk_dec_offset;
 107     celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
 108     st->stream_channels = st->channels = channels;
 109
 110     st->Fs = Fs;
 111
 112     /* Reset decoder */
 113     ret = silk_InitDecoder( silk_dec );
 114     if( ret ) {
 115         goto failure;
 116     }
 117
 118         /* Initialize CELT decoder */
 119         celt_decoder_init(celt_dec, Fs, channels, &ret);
 120         if (ret != CELT_OK)
 121                 goto failure;
 122     celt_decoder_ctl(celt_dec, CELT_SET_SIGNALLING(0));
 123
 124         st->prev_mode = 0;
 125         st->frame_size = Fs/400;
 126         return OPUS_OK;
 127 failure:
 128     opus_free(st);
 129     return OPUS_INTERNAL_ERROR;
 130 }
 131
 132 OpusDecoder *opus_decoder_create(int Fs, int channels, int *error)
 133 {
 134    int ret;
 135    char *raw_state = (char*)opus_alloc(opus_decoder_get_size(channels));
 136    if (raw_state == NULL)
 137    {
 138       if (error)
 139          *error = OPUS_ALLOC_FAIL;
 140       return NULL;
 141    }
 142    ret = opus_decoder_init((OpusDecoder*)raw_state, Fs, channels);
 143    if (ret != OPUS_OK)
 144    {
 145       opus_free(raw_state);
 146       raw_state = NULL;
 147    }
 148    return (OpusDecoder*)raw_state;
 149 }
 150
 151 static void smooth_fade(const opus_val16 *in1, const opus_val16 *in2, opus_val16 *out,
 152         int overlap, int channels, const opus_val16 *window, int Fs)
 153 {
 154         int i, c;
 155         int inc = 48000/Fs;
 156         for (c=0;c<channels;c++)
 157         {
 158                 for (i=0;i<overlap;i++)
 159                 {
 160                     opus_val16 w = MULT16_16_Q15(window[i*inc], window[i*inc]);
 161                     out[i*channels+c] = SHR32(MAC16_16(MULT16_16(w,in2[i*channels+c]),
 162                             Q15ONE-w, in1[i*channels+c]), 15);
 163                 }
 164         }
 165 }
 166
 167 static int opus_packet_get_mode(const unsigned char *data)
 168 {
 169         int mode;
 170     if (data[0]&0x80)
 171     {
 172         mode = MODE_CELT_ONLY;
 173     } else if ((data[0]&0x60) == 0x60)
 174     {
 175         mode = MODE_HYBRID;
 176     } else {
 177
 178         mode = MODE_SILK_ONLY;
 179     }
 180     return mode;
 181 }
 182
 183 static int opus_decode_frame(OpusDecoder *st, const unsigned char *data,
 184                 int len, opus_val16 *pcm, int frame_size, int decode_fec)
 185 {
 186         void *silk_dec;
 187         CELTDecoder *celt_dec;
 188         int i, silk_ret=0, celt_ret=0;
 189         ec_dec dec;
 190     silk_DecControlStruct DecControl;
 191     opus_int32 silk_frame_size;
 192     VARDECL(opus_int16, pcm_silk);
 193     VARDECL(opus_val16, pcm_transition);
 194     VARDECL(opus_val16, redundant_audio);
 195
 196     int audiosize;
 197     int mode;
 198     int transition=0;
 199     int start_band;
 200     int redundancy=0;
 201     int redundancy_bytes = 0;
 202     int celt_to_silk=0;
 203     int c;
 204     int F2_5, F5, F10, F20;
 205     const opus_val16 *window;
 206     opus_uint32 redundant_rng = 0;
 207     ALLOC_STACK;
 208
 209     silk_dec = (char*)st+st->silk_dec_offset;
 210     celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
 211     F20 = st->Fs/50;
 212     F10 = F20>>1;
 213     F5 = F10>>1;
 214     F2_5 = F5>>1;
 215     if (frame_size < F2_5)
 216        return OPUS_BUFFER_TOO_SMALL;
 217     /* Payloads of 1 (2 including ToC) or 0 trigger the PLC/DTX */
 218     if (len<=1)
 219     {
 220         data = NULL;
 221         /* In that case, don't conceal more than what the ToC says */
 222         /* FIXME: What if st->frame_size has never been set? */
 223         frame_size = IMIN(frame_size, st->frame_size);
 224     }
 225     if (data != NULL)
 226     {
 227         audiosize = st->frame_size;
 228         mode = st->mode;
 229         ec_dec_init(&dec,(unsigned char*)data,len);
 230     } else {
 231         audiosize = frame_size;
 232
 233         if (st->prev_mode == 0)
 234         {
 235                 /* If we haven't got any packet yet, all we can do is return zeros */
 236                 for (i=0;i<audiosize*st->channels;i++)
 237                         pcm[i] = 0;
 238                 RESTORE_STACK;
 239                 return audiosize;
 240         } else {
 241                 mode = st->prev_mode;
 242         }
 243     }
 244
 245     ALLOC(pcm_transition, F5*st->channels, opus_val16);
 246
 247     if (data!=NULL && !st->prev_redundancy && mode != st->prev_mode && st->prev_mode > 0
 248                 && !(mode == MODE_SILK_ONLY && st->prev_mode == MODE_HYBRID)
 249                 && !(mode == MODE_HYBRID && st->prev_mode == MODE_SILK_ONLY))
 250     {
 251         transition = 1;
 252         if (mode == MODE_CELT_ONLY)
 253             opus_decode_frame(st, NULL, 0, pcm_transition, IMIN(F5, audiosize), 0);
 254     }
 255     if (audiosize > frame_size)
 256     {
 257         fprintf(stderr, "PCM buffer too small: %d vs %d (mode = %d)\n", audiosize, frame_size, mode);
 258         RESTORE_STACK;
 259         return OPUS_BAD_ARG;
 260     } else {
 261         frame_size = audiosize;
 262     }
 263
 264     ALLOC(pcm_silk, frame_size*st->channels, opus_int16);
 265     ALLOC(redundant_audio, F5*st->channels, opus_val16);
 266
 267     /* SILK processing */
 268     if (mode != MODE_CELT_ONLY)
 269     {
 270         int lost_flag, decoded_samples;
 271         opus_int16 *pcm_ptr = pcm_silk;
 272
 273         if (st->prev_mode==MODE_CELT_ONLY)
 274                 silk_InitDecoder( silk_dec );
 275
 276         DecControl.API_sampleRate = st->Fs;
 277         DecControl.nChannelsAPI      = st->channels;
 278         DecControl.nChannelsInternal = st->stream_channels;
 279         DecControl.payloadSize_ms = 1000 * audiosize / st->Fs;
 280         if( mode == MODE_SILK_ONLY ) {
 281             if( st->bandwidth == OPUS_BANDWIDTH_NARROWBAND ) {
 282                 DecControl.internalSampleRate = 8000;
 283             } else if( st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND ) {
 284                 DecControl.internalSampleRate = 12000;
 285             } else if( st->bandwidth == OPUS_BANDWIDTH_WIDEBAND ) {
 286                 DecControl.internalSampleRate = 16000;
 287             } else {
 288                 DecControl.internalSampleRate = 16000;
 289                 SKP_assert( 0 );
 290             }
 291         } else {
 292             /* Hybrid mode */
 293             DecControl.internalSampleRate = 16000;
 294         }
 295
 296         lost_flag = data == NULL ? 1 : 2 * decode_fec;
 297         decoded_samples = 0;
 298         do {
 299             /* Call SILK decoder */
 300             int first_frame = decoded_samples == 0;
 301             silk_ret = silk_Decode( silk_dec, &DecControl,
 302                 lost_flag, first_frame, &dec, pcm_ptr, &silk_frame_size );
 303             if( silk_ret ) {
 304                 if (lost_flag) {
 305                         /* PLC failure should not be fatal */
 306                         silk_frame_size = frame_size;
 307                         for (i=0;i<frame_size*st->channels;i++)
 308                                 pcm_ptr[i] = 0;
 309                 } else {
 310                    RESTORE_STACK;
 311                    return OPUS_CORRUPTED_DATA;
 312                 }
 313             }
 314             pcm_ptr += silk_frame_size * st->channels;
 315             decoded_samples += silk_frame_size;
 316         } while( decoded_samples < frame_size );
 317     }
 318
 319     start_band = 0;
 320     if (mode != MODE_CELT_ONLY && data != NULL)
 321     {
 322         /* Check if we have a redundant 0-8 kHz band */
 323         redundancy = ec_dec_bit_logp(&dec, 12);
 324         if (redundancy)
 325         {
 326             celt_to_silk = ec_dec_bit_logp(&dec, 1);
 327             if (mode == MODE_HYBRID)
 328                 redundancy_bytes = 2 + ec_dec_uint(&dec, 256);
 329             else {
 330                 redundancy_bytes = len - ((ec_tell(&dec)+7)>>3);
 331                 /* Can only happen on an invalid packet */
 332                 if (redundancy_bytes<0)
 333                 {
 334                         redundancy_bytes = 0;
 335                         redundancy = 0;
 336                 }
 337             }
 338             len -= redundancy_bytes;
 339             if (len<0) {
 340                RESTORE_STACK;
 341                return OPUS_CORRUPTED_DATA;
 342             }
 343             /* Shrink decoder because of raw bits */
 344             dec.storage -= redundancy_bytes;
 345         }
 346     }
 347     if (mode != MODE_CELT_ONLY)
 348         start_band = 17;
 349
 350     {
 351         int endband=21;
 352
 353         switch(st->bandwidth)
 354         {
 355         case OPUS_BANDWIDTH_NARROWBAND:
 356             endband = 13;
 357             break;
 358         case OPUS_BANDWIDTH_MEDIUMBAND:
 359         case OPUS_BANDWIDTH_WIDEBAND:
 360             endband = 17;
 361             break;
 362         case OPUS_BANDWIDTH_SUPERWIDEBAND:
 363             endband = 19;
 364             break;
 365         case OPUS_BANDWIDTH_FULLBAND:
 366             endband = 21;
 367             break;
 368         }
 369         celt_decoder_ctl(celt_dec, CELT_SET_END_BAND(endband));
 370         celt_decoder_ctl(celt_dec, CELT_SET_CHANNELS(st->stream_channels));
 371     }
 372
 373     if (redundancy)
 374         transition = 0;
 375
 376     if (transition && mode != MODE_CELT_ONLY)
 377         opus_decode_frame(st, NULL, 0, pcm_transition, IMIN(F5, audiosize), 0);
 378
 379     /* 5 ms redundant frame for CELT->SILK*/
 380     if (redundancy && celt_to_silk)
 381     {
 382         celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
 383         celt_decode_native(celt_dec, data+len, redundancy_bytes, redundant_audio, F5);
 384         celt_decoder_ctl(celt_dec, CELT_GET_RANGE(&redundant_rng));
 385         celt_decoder_ctl(celt_dec, CELT_RESET_STATE);
 386     }
 387
 388     /* MUST be after PLC */
 389     celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(start_band));
 390
 391     if (transition)
 392         celt_decoder_ctl(celt_dec, CELT_RESET_STATE);
 393
 394     if (mode != MODE_SILK_ONLY)
 395     {
 396         int celt_frame_size = IMIN(F20, frame_size);
 397         /* Decode CELT */
 398         celt_ret = celt_decode_with_ec(celt_dec, decode_fec?NULL:data, len, pcm, celt_frame_size, &dec);
 399     } else {
 400        for (i=0;i<frame_size*st->channels;i++)
 401           pcm[i] = 0;
 402     }
 403
 404     if (mode != MODE_CELT_ONLY)
 405     {
 406 #ifdef FIXED_POINT
 407         for (i=0;i<frame_size*st->channels;i++)
 408             pcm[i] = SAT16(pcm[i] + pcm_silk[i]);
 409 #else
 410         for (i=0;i<frame_size*st->channels;i++)
 411             pcm[i] = pcm[i] + (1./32768.)*pcm_silk[i];
 412 #endif
 413     }
 414
 415     {
 416         const CELTMode *celt_mode;
 417         celt_decoder_ctl(celt_dec, CELT_GET_MODE(&celt_mode));
 418         window = celt_mode->window;
 419     }
 420
 421     /* 5 ms redundant frame for SILK->CELT */
 422     if (redundancy && !celt_to_silk)
 423     {
 424         celt_decoder_ctl(celt_dec, CELT_RESET_STATE);
 425         celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
 426
 427         celt_decode_native(celt_dec, data+len, redundancy_bytes, redundant_audio, F5);
 428         celt_decoder_ctl(celt_dec, CELT_GET_RANGE(&redundant_rng));
 429         smooth_fade(pcm+st->channels*(frame_size-F2_5), redundant_audio+st->channels*F2_5,
 430                         pcm+st->channels*(frame_size-F2_5), F2_5, st->channels, window, st->Fs);
 431     }
 432     if (redundancy && celt_to_silk)
 433     {
 434         for (c=0;c<st->channels;c++)
 435         {
 436             for (i=0;i<F2_5;i++)
 437                 pcm[st->channels*i+c] = redundant_audio[st->channels*i+c];
 438         }
 439         smooth_fade(redundant_audio+st->channels*F2_5, pcm+st->channels*F2_5,
 440                 pcm+st->channels*F2_5, F2_5, st->channels, window, st->Fs);
 441     }
 442     if (transition)
 443     {
 444         for (i=0;i<st->channels*F2_5;i++)
 445                 pcm[i] = pcm_transition[i];
 446         if (audiosize >= F5)
 447             smooth_fade(pcm_transition+st->channels*F2_5, pcm+st->channels*F2_5,
 448                     pcm+st->channels*F2_5, F2_5,
 449                     st->channels, window, st->Fs);
 450     }
 451
 452     if (len <= 1)
 453        st->rangeFinal = 0;
 454     else
 455        st->rangeFinal = dec.rng ^ redundant_rng;
 456
 457     st->prev_mode = mode;
 458     st->prev_redundancy = redundancy;
 459     RESTORE_STACK;
 460         return celt_ret<0 ? celt_ret : audiosize;
 461
 462 }
 463
 464 static int parse_size(const unsigned char *data, int len, short *size)
 465 {
 466         if (len<1)
 467         {
 468                 *size = -1;
 469                 return -1;
 470         } else if (data[0]<252)
 471         {
 472                 *size = data[0];
 473                 return 1;
 474         } else if (len<2)
 475         {
 476                 *size = -1;
 477                 return -1;
 478         } else {
 479                 *size = 4*data[1] + data[0];
 480                 return 2;
 481         }
 482 }
 483
 484 static int opus_packet_parse_impl(const unsigned char *data, int len,
 485       int self_delimited, unsigned char *out_toc,
 486       const unsigned char *frames[48], short size[48], int *payload_offset)
 487 {
 488    int i, bytes;
 489    int count;
 490    int cbr;
 491    unsigned char ch, toc;
 492    int framesize;
 493    int last_size;
 494    const unsigned char *data0 = data;
 495
 496    if (size==NULL)
 497       return OPUS_BAD_ARG;
 498
 499    framesize = opus_packet_get_samples_per_frame(data, 48000);
 500
 501    cbr = 0;
 502    toc = *data++;
 503    len--;
 504    last_size = len;
 505    switch (toc&0x3)
 506    {
 507    /* One frame */
 508    case 0:
 509       count=1;
 510       break;
 511       /* Two CBR frames */
 512    case 1:
 513       count=2;
 514       cbr = 1;
 515       if (!self_delimited)
 516       {
 517          if (len&0x1)
 518             return OPUS_CORRUPTED_DATA;
 519          size[0] = last_size = len/2;
 520       }
 521       break;
 522       /* Two VBR frames */
 523    case 2:
 524       count = 2;
 525       bytes = parse_size(data, len, size);
 526       len -= bytes;
 527       if (size[0]<0 || size[0] > len)
 528          return OPUS_CORRUPTED_DATA;
 529       data += bytes;
 530       last_size = len-size[0];
 531       break;
 532       /* Multiple CBR/VBR frames (from 0 to 120 ms) */
 533    case 3:
 534       if (len<1)
 535          return OPUS_CORRUPTED_DATA;
 536       /* Number of frames encoded in bits 0 to 5 */
 537       ch = *data++;
 538       count = ch&0x3F;
 539       if (count <= 0 || framesize*count > 5760)
 540           return OPUS_CORRUPTED_DATA;
 541       len--;
 542       /* Padding flag is bit 6 */
 543       if (ch&0x40)
 544       {
 545          int padding=0;
 546          int p;
 547          do {
 548             if (len<=0)
 549                return OPUS_CORRUPTED_DATA;
 550             p = *data++;
 551             len--;
 552             padding += p==255 ? 254: p;
 553          } while (p==255);
 554          len -= padding;
 555       }
 556       if (len<0)
 557          return OPUS_CORRUPTED_DATA;
 558       /* VBR flag is bit 7 */
 559       cbr = !(ch&0x80);
 560       if (cbr)
 561       {
 562          /* VBR case */
 563          last_size = len;
 564          for (i=0;i<count-1;i++)
 565          {
 566             bytes = parse_size(data, len, size+i);
 567             len -= bytes;
 568             if (size[i]<0 || size[i] > len)
 569                return OPUS_CORRUPTED_DATA;
 570             data += bytes;
 571             last_size -= bytes+size[i];
 572          }
 573          if (last_size<0)
 574             return OPUS_CORRUPTED_DATA;
 575       } else if (!self_delimited)
 576       {
 577          /* CBR case */
 578          last_size = len/count;
 579          if (last_size*count!=len)
 580             return OPUS_CORRUPTED_DATA;
 581          for (i=0;i<count-1;i++)
 582             size[i] = last_size;
 583       }
 584       break;
 585    }
 586    /* Self-delimited framing has an extra size for the last frame. */
 587    if (self_delimited)
 588    {
 589       bytes = parse_size(data, len, size+count-1);
 590       len -= bytes;
 591       if (size[count-1]<0 || size[count-1] > len)
 592          return OPUS_CORRUPTED_DATA;
 593       data += bytes;
 594       /* For CBR packets, apply the size to all the frames. */
 595       if (cbr)
 596       {
 597          if (size[count-1]*count > len)
 598             return OPUS_CORRUPTED_DATA;
 599          for (i=0;i<count-1;i++)
 600             size[i] = size[count-1];
 601       } else if(size[count-1] > last_size)
 602          return OPUS_CORRUPTED_DATA;
 603    } else
 604    {
 605       /* Because it's not encoded explicitly, it's possible the size of the
 606           last packet (or all the packets, for the CBR case) is larger than
 607           1275.
 608          Reject them here.*/
 609       if (last_size > 1275)
 610         return OPUS_CORRUPTED_DATA;
 611       size[count-1] = last_size;
 612    }
 613
 614    if (frames)
 615    {
 616       for (i=0;i<count;i++)
 617       {
 618          frames[i] = data;
 619          data += size[i];
 620       }
 621    }
 622
 623    if (out_toc)
 624       *out_toc = toc;
 625
 626    if (payload_offset)
 627       *payload_offset = data-data0;
 628
 629    return count;
 630 }
 631
 632 int opus_packet_parse(const unsigned char *data, int len,
 633       unsigned char *out_toc, const unsigned char *frames[48],
 634       short size[48], int *payload_offset)
 635 {
 636    return opus_packet_parse_impl(data, len, 0,
 637          out_toc, frames, size, payload_offset);
 638 }
 639
 640 int opus_decode_native(OpusDecoder *st, const unsigned char *data,
 641       int len, opus_val16 *pcm, int frame_size, int decode_fec, int self_delimited, int *packet_offset)
 642 {
 643         int i, nb_samples;
 644         int count, offset;
 645         unsigned char toc;
 646         int tot_offset;
 647         /* 48 x 2.5 ms = 120 ms */
 648         short size[48];
 649         if (len==0 || data==NULL)
 650             return opus_decode_frame(st, NULL, 0, pcm, frame_size, 0);
 651         else if (len<0)
 652                 return OPUS_BAD_ARG;
 653
 654         tot_offset = 0;
 655         st->mode = opus_packet_get_mode(data);
 656         st->bandwidth = opus_packet_get_bandwidth(data);
 657         st->frame_size = opus_packet_get_samples_per_frame(data, st->Fs);
 658         st->stream_channels = opus_packet_get_nb_channels(data);
 659
 660         count = opus_packet_parse_impl(data, len, 0, &toc, NULL, size, &offset);
 661         if (count < 0)
 662            return count;
 663
 664         data += offset;
 665         tot_offset += offset;
 666
 667         if (count*st->frame_size > frame_size)
 668                 return OPUS_BAD_ARG;
 669         nb_samples=0;
 670         for (i=0;i<count;i++)
 671         {
 672                 int ret;
 673                 ret = opus_decode_frame(st, data, size[i], pcm, frame_size-nb_samples, decode_fec);
 674                 if (ret<0)
 675                         return ret;
 676                 data += size[i];
 677                 tot_offset += size[i];
 678                 pcm += ret*st->channels;
 679                 nb_samples += ret;
 680         }
 681         if (packet_offset != NULL)
 682            *packet_offset = tot_offset;
 683         return nb_samples;
 684 }
 685
 686 #ifdef FIXED_POINT
 687
 688 int opus_decode(OpusDecoder *st, const unsigned char *data,
 689       int len, opus_val16 *pcm, int frame_size, int decode_fec)
 690 {
 691    return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL);
 692 }
 693
 694 #ifndef DISABLE_FLOAT_API
 695 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
 696       int len, float *pcm, int frame_size, int decode_fec)
 697 {
 698    VARDECL(opus_int16, out);
 699    int ret, i;
 700    ALLOC_STACK;
 701
 702    ALLOC(out, frame_size*st->channels, opus_int16);
 703
 704    ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL);
 705    if (ret > 0)
 706    {
 707       for (i=0;i<ret*st->channels;i++)
 708          pcm[i] = (1./32768.)*(out[i]);
 709    }
 710    RESTORE_STACK;
 711    return ret;
 712 }
 713 #endif
 714
 715
 716 #else
 717 int opus_decode(OpusDecoder *st, const unsigned char *data,
 718       int len, opus_int16 *pcm, int frame_size, int decode_fec)
 719 {
 720    VARDECL(float, out);
 721    int ret, i;
 722    ALLOC_STACK;
 723
 724    ALLOC(out, frame_size*st->channels, float);
 725
 726    ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL);
 727    if (ret > 0)
 728    {
 729       for (i=0;i<ret*st->channels;i++)
 730          pcm[i] = FLOAT2INT16(out[i]);
 731    }
 732    RESTORE_STACK;
 733    return ret;
 734 }
 735
 736 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
 737         int len, opus_val16 *pcm, int frame_size, int decode_fec)
 738 {
 739    return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL);
 740 }
 741
 742 #endif
 743
 744 int opus_decoder_ctl(OpusDecoder *st, int request, ...)
 745 {
 746     va_list ap;
 747
 748     va_start(ap, request);
 749
 750     switch (request)
 751     {
 752         case OPUS_GET_BANDWIDTH_REQUEST:
 753         {
 754             opus_int32 *value = va_arg(ap, opus_int32*);
 755             *value = st->bandwidth;
 756         }
 757         break;
 758         case OPUS_GET_FINAL_RANGE_REQUEST:
 759         {
 760             opus_uint32 *value = va_arg(ap, opus_uint32*);
 761             *value = st->rangeFinal;
 762         }
 763         break;
 764         default:
 765             fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);
 766             break;
 767     }
 768
 769     va_end(ap);
 770     return OPUS_OK;
 771 }
 772
 773 void opus_decoder_destroy(OpusDecoder *st)
 774 {
 775         opus_free(st);
 776 }
 777
 778
 779 int opus_packet_get_bandwidth(const unsigned char *data)
 780 {
 781         int bandwidth;
 782     if (data[0]&0x80)
 783     {
 784         bandwidth = OPUS_BANDWIDTH_MEDIUMBAND + ((data[0]>>5)&0x3);
 785         if (bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
 786             bandwidth = OPUS_BANDWIDTH_NARROWBAND;
 787     } else if ((data[0]&0x60) == 0x60)
 788     {
 789         bandwidth = (data[0]&0x10) ? OPUS_BANDWIDTH_FULLBAND : OPUS_BANDWIDTH_SUPERWIDEBAND;
 790     } else {
 791
 792         bandwidth = OPUS_BANDWIDTH_NARROWBAND + ((data[0]>>5)&0x3);
 793     }
 794     return bandwidth;
 795 }
 796
 797 int opus_packet_get_samples_per_frame(const unsigned char *data, int Fs)
 798 {
 799         int audiosize;
 800     if (data[0]&0x80)
 801     {
 802         audiosize = ((data[0]>>3)&0x3);
 803         audiosize = (Fs<<audiosize)/400;
 804     } else if ((data[0]&0x60) == 0x60)
 805     {
 806         audiosize = (data[0]&0x08) ? Fs/50 : Fs/100;
 807     } else {
 808
 809         audiosize = ((data[0]>>3)&0x3);
 810         if (audiosize == 3)
 811             audiosize = Fs*60/1000;
 812         else
 813             audiosize = (Fs<<audiosize)/100;
 814     }
 815     return audiosize;
 816 }
 817
 818 int opus_packet_get_nb_channels(const unsigned char *data)
 819 {
 820     return (data[0]&0x4) ? 2 : 1;
 821 }
 822
 823 int opus_packet_get_nb_frames(const unsigned char packet[], int len)
 824 {
 825         int count;
 826         if (len<1)
 827                 return OPUS_BAD_ARG;
 828         count = packet[0]&0x3;
 829         if (count==0)
 830                 return 1;
 831         else if (count!=3)
 832                 return 2;
 833         else if (len<2)
 834                 return OPUS_CORRUPTED_DATA;
 835         else
 836                 return packet[1]&0x3F;
 837 }
 838
 839 int opus_decoder_get_nb_samples(const OpusDecoder *dec, const unsigned char packet[], int len)
 840 {
 841         int samples;
 842         int count = opus_packet_get_nb_frames(packet, len);
 843         samples = count*opus_packet_get_samples_per_frame(packet, dec->Fs);
 844         /* Can't have more than 120 ms */
 845         if (samples*25 > dec->Fs*3)
 846                 return OPUS_CORRUPTED_DATA;
 847         else
 848                 return samples;
 849 }
 850