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 <stdlib.h>
  33 #include <stdio.h>
  34 #include <stdarg.h>
  35 #include "celt.h"
  36 #include "opus_decoder.h"
  37 #include "entdec.h"
  38 #include "modes.h"
  39 #include "SKP_Silk_SDK_API.h"
  40
  41
  42 OpusDecoder *opus_decoder_create(int Fs, int channels)
  43 {
  44     char *raw_state;
  45         int ret, silkDecSizeBytes, celtDecSizeBytes;
  46         OpusDecoder *st;
  47
  48         /* Initialize SILK encoder */
  49     ret = SKP_Silk_SDK_Get_Decoder_Size( &silkDecSizeBytes );
  50     if( ret ) {
  51         /* Handle error */
  52     }
  53     celtDecSizeBytes = celt_decoder_get_size(channels);
  54     raw_state = calloc(sizeof(OpusDecoder)+silkDecSizeBytes+celtDecSizeBytes, 1);
  55     st = (OpusDecoder*)raw_state;
  56     st->silk_dec = (void*)(raw_state+sizeof(OpusDecoder));
  57     st->celt_dec = (CELTDecoder*)(raw_state+sizeof(OpusDecoder)+silkDecSizeBytes);
  58     st->stream_channels = st->channels = channels;
  59
  60     st->Fs = Fs;
  61
  62     /* Reset decoder */
  63     ret = SKP_Silk_SDK_InitDecoder( st->silk_dec );
  64     if( ret ) {
  65         /* Handle error */
  66     }
  67
  68         /* Initialize CELT decoder */
  69         st->celt_dec = celt_decoder_init(st->celt_dec, Fs, channels, NULL);
  70     celt_decoder_ctl(st->celt_dec, CELT_SET_SIGNALLING(0));
  71
  72         st->prev_mode = 0;
  73         return st;
  74 }
  75
  76 static void smooth_fade(const short *in1, const short *in2, short *out,
  77         int overlap, int channels, const celt_word16 *window, int Fs)
  78 {
  79         int i, c;
  80         int inc = 48000/Fs;
  81         for (c=0;c<channels;c++)
  82         {
  83                 for (i=0;i<overlap;i++)
  84                 {
  85                     celt_word16 w = MULT16_16_Q15(window[i*inc], window[i*inc]);
  86                     out[i*channels+c] = SHR32(MAC16_16(MULT16_16(w,in2[i*channels+c]),
  87                             Q15ONE-w, in1[i*channels+c]), 15);
  88                 }
  89         }
  90 }
  91
  92 static int opus_packet_get_mode(const unsigned char *data)
  93 {
  94         int mode;
  95     if (data[0]&0x80)
  96     {
  97         mode = MODE_CELT_ONLY;
  98     } else if ((data[0]&0x60) == 0x60)
  99     {
 100         mode = MODE_HYBRID;
 101     } else {
 102
 103         mode = MODE_SILK_ONLY;
 104     }
 105     return mode;
 106 }
 107
 108 static int opus_decode_frame(OpusDecoder *st, const unsigned char *data,
 109                 int len, short *pcm, int frame_size, int decode_fec)
 110 {
 111         int i, silk_ret=0, celt_ret=0;
 112         ec_dec dec;
 113     SKP_SILK_SDK_DecControlStruct DecControl;
 114     SKP_int32 silk_frame_size;
 115     short pcm_celt[960*2];
 116     short pcm_transition[960*2];
 117     int audiosize;
 118     int mode;
 119     int transition=0;
 120     int start_band;
 121     int redundancy=0;
 122     int redundancy_bytes = 0;
 123     int celt_to_silk=0;
 124     short redundant_audio[240*2];
 125     int c;
 126     int F2_5, F5, F10;
 127     const celt_word16 *window;
 128
 129     F10 = st->Fs/100;
 130     F5 = F10>>1;
 131     F2_5 = F5>>1;
 132     /* Payloads of 1 (2 including ToC) or 0 trigger the PLC/DTX */
 133     if (len<=1)
 134         data = NULL;
 135
 136         audiosize = st->frame_size;
 137     if (data != NULL)
 138     {
 139         mode = st->mode;
 140         ec_dec_init(&dec,(unsigned char*)data,len);
 141     } else {
 142         mode = st->prev_mode;
 143     }
 144
 145     if (st->stream_channels > st->channels)
 146         return OPUS_CORRUPTED_DATA;
 147
 148     /* FIXME: Remove this when we add SILK stereo support */
 149     if (st->stream_channels == 2 && mode != MODE_CELT_ONLY)
 150         return OPUS_UNIMPLEMENTED;
 151
 152     if (data!=NULL && !st->prev_redundancy && mode != st->prev_mode && st->prev_mode > 0
 153                 && !(mode == MODE_SILK_ONLY && st->prev_mode == MODE_HYBRID)
 154                 && !(mode == MODE_HYBRID && st->prev_mode == MODE_SILK_ONLY))
 155     {
 156         transition = 1;
 157         if (mode == MODE_CELT_ONLY)
 158             opus_decode_frame(st, NULL, 0, pcm_transition, IMAX(F10, audiosize), 0);
 159     }
 160     if (audiosize > frame_size)
 161     {
 162         fprintf(stderr, "PCM buffer too small: %d vs %d (mode = %d)\n", audiosize, frame_size, mode);
 163         return OPUS_BAD_ARG;
 164     } else {
 165         frame_size = audiosize;
 166     }
 167
 168     /* SILK processing */
 169     if (mode != MODE_CELT_ONLY)
 170     {
 171         int lost_flag, decoded_samples;
 172         SKP_int16 *pcm_ptr = pcm;
 173
 174         if (st->prev_mode==MODE_CELT_ONLY)
 175                 SKP_Silk_SDK_InitDecoder( st->silk_dec );
 176
 177         DecControl.API_sampleRate = st->Fs;
 178         DecControl.payloadSize_ms = 1000 * audiosize / st->Fs;
 179         if( mode == MODE_SILK_ONLY ) {
 180             if( st->bandwidth == BANDWIDTH_NARROWBAND ) {
 181                 DecControl.internalSampleRate = 8000;
 182             } else if( st->bandwidth == BANDWIDTH_MEDIUMBAND ) {
 183                 DecControl.internalSampleRate = 12000;
 184             } else if( st->bandwidth == BANDWIDTH_WIDEBAND ) {
 185                 DecControl.internalSampleRate = 16000;
 186             } else {
 187                 DecControl.internalSampleRate = 16000;
 188                 SKP_assert( 0 );
 189             }
 190         } else {
 191             /* Hybrid mode */
 192             DecControl.internalSampleRate = 16000;
 193         }
 194
 195         lost_flag = data == NULL ? 1 : 2 * decode_fec;
 196         decoded_samples = 0;
 197         do {
 198             /* Call SILK decoder */
 199             int first_frame = decoded_samples == 0;
 200             silk_ret = SKP_Silk_SDK_Decode( st->silk_dec, &DecControl,
 201                 lost_flag, first_frame, &dec, len, pcm_ptr, &silk_frame_size );
 202             if( silk_ret ) {
 203                 fprintf (stderr, "SILK decode error\n");
 204                 /* Handle error */
 205             }
 206             pcm_ptr += silk_frame_size;
 207             decoded_samples += silk_frame_size;
 208         } while( decoded_samples < frame_size );
 209     } else {
 210         for (i=0;i<frame_size*st->channels;i++)
 211             pcm[i] = 0;
 212     }
 213
 214     start_band = 0;
 215     if (mode != MODE_CELT_ONLY && data != NULL)
 216     {
 217         /* Check if we have a redundant 0-8 kHz band */
 218         redundancy = ec_dec_bit_logp(&dec, 12);
 219         if (redundancy)
 220         {
 221             celt_to_silk = ec_dec_bit_logp(&dec, 1);
 222             if (mode == MODE_HYBRID)
 223                 redundancy_bytes = 2 + ec_dec_uint(&dec, 256);
 224             else
 225                 redundancy_bytes = len - ((ec_tell(&dec)+7)>>3);
 226             len -= redundancy_bytes;
 227             if (len<0)
 228                 return CELT_CORRUPTED_DATA;
 229             /* Shrink decoder because of raw bits */
 230             dec.storage -= redundancy_bytes;
 231         }
 232     }
 233     if (mode != MODE_CELT_ONLY)
 234         start_band = 17;
 235
 236     if (mode != MODE_SILK_ONLY)
 237     {
 238         int endband=21;
 239
 240         switch(st->bandwidth)
 241         {
 242         case BANDWIDTH_NARROWBAND:
 243             endband = 13;
 244             break;
 245         case BANDWIDTH_WIDEBAND:
 246             endband = 17;
 247             break;
 248         case BANDWIDTH_SUPERWIDEBAND:
 249             endband = 19;
 250             break;
 251         case BANDWIDTH_FULLBAND:
 252             endband = 21;
 253             break;
 254         }
 255         celt_decoder_ctl(st->celt_dec, CELT_SET_END_BAND(endband));
 256         celt_decoder_ctl(st->celt_dec, CELT_SET_CHANNELS(st->stream_channels));
 257     }
 258
 259     if (redundancy)
 260         transition = 0;
 261
 262     if (transition && mode != MODE_CELT_ONLY)
 263         opus_decode_frame(st, NULL, 0, pcm_transition, IMAX(F10, audiosize), 0);
 264
 265     /* 5 ms redundant frame for CELT->SILK*/
 266     if (redundancy && celt_to_silk)
 267     {
 268         celt_decode(st->celt_dec, data+len, redundancy_bytes, redundant_audio, F5);
 269         celt_decoder_ctl(st->celt_dec, CELT_RESET_STATE);
 270     }
 271
 272     /* MUST be after PLC */
 273     celt_decoder_ctl(st->celt_dec, CELT_SET_START_BAND(start_band));
 274
 275     if (transition)
 276         celt_decoder_ctl(st->celt_dec, CELT_RESET_STATE);
 277
 278     if (mode != MODE_SILK_ONLY)
 279     {
 280         /* Decode CELT */
 281         celt_ret = celt_decode_with_ec(st->celt_dec, decode_fec?NULL:data, len, pcm_celt, frame_size, &dec);
 282         for (i=0;i<frame_size*st->channels;i++)
 283             pcm[i] = ADD_SAT16(pcm[i], pcm_celt[i]);
 284     }
 285
 286     {
 287         const CELTMode *celt_mode;
 288         celt_decoder_ctl(st->celt_dec, CELT_GET_MODE(&celt_mode));
 289         window = celt_mode->window;
 290     }
 291     /* 5 ms redundant frame for SILK->CELT */
 292     if (redundancy && !celt_to_silk)
 293     {
 294         celt_decoder_ctl(st->celt_dec, CELT_RESET_STATE);
 295         celt_decoder_ctl(st->celt_dec, CELT_SET_START_BAND(0));
 296
 297         celt_decode(st->celt_dec, data+len, redundancy_bytes, redundant_audio, F5);
 298         smooth_fade(pcm+st->channels*(frame_size-F2_5), redundant_audio+st->channels*F2_5,
 299                         pcm+st->channels*(frame_size-F2_5), F2_5, st->channels, window, st->Fs);
 300     }
 301     if (redundancy && celt_to_silk)
 302     {
 303         for (c=0;c<st->channels;c++)
 304         {
 305             for (i=0;i<F2_5;i++)
 306                 pcm[st->channels*i+c] = redundant_audio[st->channels*i];
 307         }
 308         smooth_fade(redundant_audio+st->channels*F2_5, pcm+st->channels*F2_5,
 309                 pcm+st->channels*F2_5, F2_5, st->channels, window, st->Fs);
 310     }
 311     if (transition)
 312     {
 313         for (i=0;i<F2_5;i++)
 314                 pcm[i] = pcm_transition[i];
 315         if (audiosize >= F5)
 316             smooth_fade(pcm_transition+F2_5, pcm+F2_5, pcm+F2_5, F2_5,
 317                     st->channels, window, st->Fs);
 318     }
 319 #if OPUS_TEST_RANGE_CODER_STATE
 320     st->rangeFinal = dec.rng;
 321 #endif
 322
 323     st->prev_mode = mode;
 324     st->prev_redundancy = redundancy;
 325         return celt_ret<0 ? celt_ret : audiosize;
 326
 327 }
 328
 329 static int parse_size(const unsigned char *data, int len, short *size)
 330 {
 331         if (len<1)
 332         {
 333                 *size = -1;
 334                 return -1;
 335         } else if (data[0]<252)
 336         {
 337                 *size = data[0];
 338                 return 1;
 339         } else if (len<2)
 340         {
 341                 *size = -1;
 342                 return -1;
 343         } else {
 344                 *size = 4*data[1] + data[0];
 345                 return 2;
 346         }
 347 }
 348
 349 int opus_decode(OpusDecoder *st, const unsigned char *data,
 350                 int len, short *pcm, int frame_size, int decode_fec)
 351 {
 352         int i, bytes, nb_samples;
 353         int count;
 354         unsigned char ch, toc;
 355         /* 48 x 2.5 ms = 120 ms */
 356         short size[48];
 357         if (len==0 || data==NULL)
 358             return opus_decode_frame(st, NULL, 0, pcm, frame_size, 0);
 359         else if (len<0)
 360                 return CELT_BAD_ARG;
 361         st->mode = opus_packet_get_mode(data);
 362         st->bandwidth = opus_packet_get_bandwidth(data);
 363         st->frame_size = opus_packet_get_samples_per_frame(data, st->Fs);
 364         st->stream_channels = opus_packet_get_nb_channels(data);
 365         toc = *data++;
 366         len--;
 367         switch (toc&0x3)
 368         {
 369         /* One frame */
 370         case 0:
 371                 count=1;
 372                 size[0] = len;
 373                 break;
 374                 /* Two CBR frames */
 375         case 1:
 376                 count=2;
 377                 if (len&0x1)
 378                         return OPUS_CORRUPTED_DATA;
 379                 size[0] = size[1] = len/2;
 380                 break;
 381                 /* Two VBR frames */
 382         case 2:
 383                 count = 2;
 384                 bytes = parse_size(data, len, size);
 385                 len -= bytes;
 386                 if (size[0]<0 || size[0] > len)
 387                         return OPUS_CORRUPTED_DATA;
 388                 data += bytes;
 389                 size[1] = len-size[0];
 390                 break;
 391                 /* Multiple CBR/VBR frames (from 0 to 120 ms) */
 392         case 3:
 393                 if (len<1)
 394                         return OPUS_CORRUPTED_DATA;
 395                 /* Number of frames encoded in bits 0 to 5 */
 396                 ch = *data++;
 397                 count = ch&0x3F;
 398                 if (st->frame_size*count*25 > 3*st->Fs)
 399                     return OPUS_CORRUPTED_DATA;
 400                 len--;
 401                 /* Bit 7 is VBR flag (bit 6 is ignored) */
 402                 if (ch&0x80)
 403                 {
 404                         /* VBR case */
 405                         int last_size=len;
 406                         for (i=0;i<count-1;i++)
 407                         {
 408                                 bytes = parse_size(data, len, size+i);
 409                                 len -= bytes;
 410                                 if (size[i]<0 || size[i] > len)
 411                                         return OPUS_CORRUPTED_DATA;
 412                                 data += bytes;
 413                                 last_size -= bytes+size[i];
 414                         }
 415                         if (last_size<0)
 416                                 return OPUS_CORRUPTED_DATA;
 417                         if (count)
 418                                 size[count-1]=last_size;
 419                 } else {
 420                         /* CBR case */
 421                         int sz = count != 0 ? len/count : 0;
 422                         if (sz*count!=len)
 423                                 return OPUS_CORRUPTED_DATA;
 424                         for (i=0;i<count;i++)
 425                                 size[i] = sz;
 426                 }
 427                 break;
 428         }
 429         if (count*st->frame_size > frame_size)
 430                 return OPUS_BAD_ARG;
 431         nb_samples=0;
 432         for (i=0;i<count;i++)
 433         {
 434                 int ret;
 435                 ret = opus_decode_frame(st, data, len, pcm, frame_size-nb_samples, decode_fec);
 436                 if (ret<0)
 437                         return ret;
 438                 data += size[i];
 439                 pcm += ret;
 440                 nb_samples += ret;
 441         }
 442         return nb_samples;
 443 }
 444 int opus_decoder_ctl(OpusDecoder *st, int request, ...)
 445 {
 446     va_list ap;
 447
 448     va_start(ap, request);
 449
 450     switch (request)
 451     {
 452         case OPUS_GET_MODE_REQUEST:
 453         {
 454             int *value = va_arg(ap, int*);
 455             *value = st->prev_mode;
 456         }
 457         break;
 458         case OPUS_SET_BANDWIDTH_REQUEST:
 459         {
 460             int value = va_arg(ap, int);
 461             st->bandwidth = value;
 462         }
 463         break;
 464         case OPUS_GET_BANDWIDTH_REQUEST:
 465         {
 466             int *value = va_arg(ap, int*);
 467             *value = st->bandwidth;
 468         }
 469         break;
 470         default:
 471             fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);
 472             break;
 473     }
 474
 475     va_end(ap);
 476     return OPUS_OK;
 477 }
 478
 479 void opus_decoder_destroy(OpusDecoder *st)
 480 {
 481         free(st);
 482 }
 483
 484 #if OPUS_TEST_RANGE_CODER_STATE
 485 int opus_decoder_get_final_range(OpusDecoder *st)
 486 {
 487     return st->rangeFinal;
 488 }
 489 #endif
 490
 491
 492 int opus_packet_get_bandwidth(const unsigned char *data)
 493 {
 494         int bandwidth;
 495     if (data[0]&0x80)
 496     {
 497         bandwidth = BANDWIDTH_MEDIUMBAND + ((data[0]>>5)&0x3);
 498         if (bandwidth == BANDWIDTH_MEDIUMBAND)
 499             bandwidth = BANDWIDTH_NARROWBAND;
 500     } else if ((data[0]&0x60) == 0x60)
 501     {
 502         bandwidth = (data[0]&0x10) ? BANDWIDTH_FULLBAND : BANDWIDTH_SUPERWIDEBAND;
 503     } else {
 504
 505         bandwidth = BANDWIDTH_NARROWBAND + ((data[0]>>5)&0x3);
 506     }
 507     return bandwidth;
 508 }
 509
 510 int opus_packet_get_samples_per_frame(const unsigned char *data, int Fs)
 511 {
 512         int audiosize;
 513     if (data[0]&0x80)
 514     {
 515         audiosize = ((data[0]>>3)&0x3);
 516         audiosize = (Fs<<audiosize)/400;
 517     } else if ((data[0]&0x60) == 0x60)
 518     {
 519         audiosize = (data[0]&0x08) ? Fs/50 : Fs/100;
 520     } else {
 521
 522         audiosize = ((data[0]>>3)&0x3);
 523         if (audiosize == 3)
 524             audiosize = Fs*60/1000;
 525         else
 526             audiosize = (Fs<<audiosize)/100;
 527     }
 528     return audiosize;
 529 }
 530
 531 int opus_packet_get_nb_channels(const unsigned char *data)
 532 {
 533     return (data[0]&0x4) ? 2 : 1;
 534 }
 535
 536 int opus_packet_get_nb_frames(const unsigned char packet[], int len)
 537 {
 538         int count;
 539         if (len<1)
 540                 return OPUS_BAD_ARG;
 541         count = packet[0]&0x3;
 542         if (count==0)
 543                 return 1;
 544         else if (count!=3)
 545                 return 2;
 546         else if (len<2)
 547                 return OPUS_CORRUPTED_DATA;
 548         else
 549                 return packet[1]&0x3F;
 550 }
 551
 552 int opus_decoder_get_nb_samples(const OpusDecoder *dec, const unsigned char packet[], int len)
 553 {
 554         int samples;
 555         int count = opus_packet_get_nb_frames(packet, len);
 556         samples = count*opus_packet_get_samples_per_frame(packet, dec->Fs);
 557         /* Can't have more than 120 ms */
 558         if (samples*25 > dec->Fs*3)
 559                 return OPUS_CORRUPTED_DATA;
 560         else
 561                 return samples;
 562 }
 563