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