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     if (data!=NULL && !st->prev_redundancy && mode != st->prev_mode && st->prev_mode > 0
 149                 && !(mode == MODE_SILK_ONLY && st->prev_mode == MODE_HYBRID)
 150                 && !(mode == MODE_HYBRID && st->prev_mode == MODE_SILK_ONLY))
 151     {
 152         transition = 1;
 153         if (mode == MODE_CELT_ONLY)
 154             opus_decode_frame(st, NULL, 0, pcm_transition, IMAX(F10, audiosize), 0);
 155     }
 156     if (audiosize > frame_size)
 157     {
 158         fprintf(stderr, "PCM buffer too small: %d vs %d (mode = %d)\n", audiosize, frame_size, mode);
 159         return OPUS_BAD_ARG;
 160     } else {
 161         frame_size = audiosize;
 162     }
 163
 164     /* SILK processing */
 165     if (mode != MODE_CELT_ONLY)
 166     {
 167         int lost_flag, decoded_samples;
 168         SKP_int16 *pcm_ptr = pcm;
 169
 170         if (st->prev_mode==MODE_CELT_ONLY)
 171                 SKP_Silk_SDK_InitDecoder( st->silk_dec );
 172
 173         DecControl.API_sampleRate = st->Fs;
 174         DecControl.payloadSize_ms = 1000 * audiosize / st->Fs;
 175         if( mode == MODE_SILK_ONLY ) {
 176             if( st->bandwidth == BANDWIDTH_NARROWBAND ) {
 177                 DecControl.internalSampleRate = 8000;
 178             } else if( st->bandwidth == BANDWIDTH_MEDIUMBAND ) {
 179                 DecControl.internalSampleRate = 12000;
 180             } else if( st->bandwidth == BANDWIDTH_WIDEBAND ) {
 181                 DecControl.internalSampleRate = 16000;
 182             } else {
 183                 DecControl.internalSampleRate = 16000;
 184                 SKP_assert( 0 );
 185             }
 186         } else {
 187             /* Hybrid mode */
 188             DecControl.internalSampleRate = 16000;
 189         }
 190         DecControl.nChannels = st->channels;
 191
 192         lost_flag = data == NULL ? 1 : 2 * decode_fec;
 193         decoded_samples = 0;
 194         do {
 195             /* Call SILK decoder */
 196             int first_frame = decoded_samples == 0;
 197             silk_ret = SKP_Silk_SDK_Decode( st->silk_dec, &DecControl,
 198                 lost_flag, first_frame, &dec, pcm_ptr, &silk_frame_size );
 199             if( silk_ret ) {
 200                 fprintf (stderr, "SILK decode error\n");
 201                 /* Handle error */
 202             }
 203             pcm_ptr += silk_frame_size * st->channels;
 204             decoded_samples += silk_frame_size;
 205         } while( decoded_samples < frame_size );
 206     } else {
 207         for (i=0;i<frame_size*st->channels;i++)
 208             pcm[i] = 0;
 209     }
 210
 211     start_band = 0;
 212     if (mode != MODE_CELT_ONLY && data != NULL)
 213     {
 214         /* Check if we have a redundant 0-8 kHz band */
 215         redundancy = ec_dec_bit_logp(&dec, 12);
 216         if (redundancy)
 217         {
 218             celt_to_silk = ec_dec_bit_logp(&dec, 1);
 219             if (mode == MODE_HYBRID)
 220                 redundancy_bytes = 2 + ec_dec_uint(&dec, 256);
 221             else
 222                 redundancy_bytes = len - ((ec_tell(&dec)+7)>>3);
 223             len -= redundancy_bytes;
 224             if (len<0)
 225                 return CELT_CORRUPTED_DATA;
 226             /* Shrink decoder because of raw bits */
 227             dec.storage -= redundancy_bytes;
 228         }
 229     }
 230     if (mode != MODE_CELT_ONLY)
 231         start_band = 17;
 232
 233     if (mode != MODE_SILK_ONLY)
 234     {
 235         int endband=21;
 236
 237         switch(st->bandwidth)
 238         {
 239         case BANDWIDTH_NARROWBAND:
 240             endband = 13;
 241             break;
 242         case BANDWIDTH_WIDEBAND:
 243             endband = 17;
 244             break;
 245         case BANDWIDTH_SUPERWIDEBAND:
 246             endband = 19;
 247             break;
 248         case BANDWIDTH_FULLBAND:
 249             endband = 21;
 250             break;
 251         }
 252         celt_decoder_ctl(st->celt_dec, CELT_SET_END_BAND(endband));
 253         celt_decoder_ctl(st->celt_dec, CELT_SET_CHANNELS(st->stream_channels));
 254     }
 255
 256     if (redundancy)
 257         transition = 0;
 258
 259     if (transition && mode != MODE_CELT_ONLY)
 260         opus_decode_frame(st, NULL, 0, pcm_transition, IMAX(F10, audiosize), 0);
 261
 262     /* 5 ms redundant frame for CELT->SILK*/
 263     if (redundancy && celt_to_silk)
 264     {
 265         celt_decode(st->celt_dec, data+len, redundancy_bytes, redundant_audio, F5);
 266         celt_decoder_ctl(st->celt_dec, CELT_RESET_STATE);
 267     }
 268
 269     /* MUST be after PLC */
 270     celt_decoder_ctl(st->celt_dec, CELT_SET_START_BAND(start_band));
 271
 272     if (transition)
 273         celt_decoder_ctl(st->celt_dec, CELT_RESET_STATE);
 274
 275     if (mode != MODE_SILK_ONLY)
 276     {
 277         /* Decode CELT */
 278         celt_ret = celt_decode_with_ec(st->celt_dec, decode_fec?NULL:data, len, pcm_celt, frame_size, &dec);
 279         for (i=0;i<frame_size*st->channels;i++)
 280             pcm[i] = ADD_SAT16(pcm[i], pcm_celt[i]);
 281     }
 282
 283
 284     {
 285         const CELTMode *celt_mode;
 286         celt_decoder_ctl(st->celt_dec, CELT_GET_MODE(&celt_mode));
 287         window = celt_mode->window;
 288     }
 289
 290     /* 5 ms redundant frame for SILK->CELT */
 291     if (redundancy && !celt_to_silk)
 292     {
 293         celt_decoder_ctl(st->celt_dec, CELT_RESET_STATE);
 294         celt_decoder_ctl(st->celt_dec, CELT_SET_START_BAND(0));
 295
 296         celt_decode(st->celt_dec, data+len, redundancy_bytes, redundant_audio, F5);
 297         smooth_fade(pcm+st->channels*(frame_size-F2_5), redundant_audio+st->channels*F2_5,
 298                         pcm+st->channels*(frame_size-F2_5), F2_5, st->channels, window, st->Fs);
 299     }
 300     if (redundancy && celt_to_silk)
 301     {
 302         for (c=0;c<st->channels;c++)
 303         {
 304             for (i=0;i<F2_5;i++)
 305                 pcm[st->channels*i+c] = redundant_audio[st->channels*i];
 306         }
 307         smooth_fade(redundant_audio+st->channels*F2_5, pcm+st->channels*F2_5,
 308                 pcm+st->channels*F2_5, F2_5, st->channels, window, st->Fs);
 309     }
 310     if (transition)
 311     {
 312         for (i=0;i<F2_5;i++)
 313                 pcm[i] = pcm_transition[i];
 314         if (audiosize >= F5)
 315             smooth_fade(pcm_transition+F2_5, pcm+F2_5, pcm+F2_5, F2_5,
 316                     st->channels, window, st->Fs);
 317     }
 318 #if OPUS_TEST_RANGE_CODER_STATE
 319     st->rangeFinal = dec.rng;
 320 #endif
 321
 322     st->prev_mode = mode;
 323     st->prev_redundancy = redundancy;
 324         return celt_ret<0 ? celt_ret : audiosize;
 325
 326 }
 327
 328 static int parse_size(const unsigned char *data, int len, short *size)
 329 {
 330         if (len<1)
 331         {
 332                 *size = -1;
 333                 return -1;
 334         } else if (data[0]<252)
 335         {
 336                 *size = data[0];
 337                 return 1;
 338         } else if (len<2)
 339         {
 340                 *size = -1;
 341                 return -1;
 342         } else {
 343                 *size = 4*data[1] + data[0];
 344                 return 2;
 345         }
 346 }
 347
 348 int opus_decode(OpusDecoder *st, const unsigned char *data,
 349                 int len, short *pcm, int frame_size, int decode_fec)
 350 {
 351         int i, bytes, nb_samples;
 352         int count;
 353         unsigned char ch, toc;
 354         /* 48 x 2.5 ms = 120 ms */
 355         short size[48];
 356         if (len==0 || data==NULL)
 357             return opus_decode_frame(st, NULL, 0, pcm, frame_size, 0);
 358         else if (len<0)
 359                 return CELT_BAD_ARG;
 360         st->mode = opus_packet_get_mode(data);
 361         st->bandwidth = opus_packet_get_bandwidth(data);
 362         st->frame_size = opus_packet_get_samples_per_frame(data, st->Fs);
 363         st->stream_channels = opus_packet_get_nb_channels(data);
 364         toc = *data++;
 365         len--;
 366         switch (toc&0x3)
 367         {
 368         /* One frame */
 369         case 0:
 370                 count=1;
 371                 size[0] = len;
 372                 break;
 373                 /* Two CBR frames */
 374         case 1:
 375                 count=2;
 376                 if (len&0x1)
 377                         return OPUS_CORRUPTED_DATA;
 378                 size[0] = size[1] = len/2;
 379                 break;
 380                 /* Two VBR frames */
 381         case 2:
 382                 count = 2;
 383                 bytes = parse_size(data, len, size);
 384                 len -= bytes;
 385                 if (size[0]<0 || size[0] > len)
 386                         return OPUS_CORRUPTED_DATA;
 387                 data += bytes;
 388                 size[1] = len-size[0];
 389                 break;
 390                 /* Multiple CBR/VBR frames (from 0 to 120 ms) */
 391         case 3:
 392                 if (len<1)
 393                         return OPUS_CORRUPTED_DATA;
 394                 /* Number of frames encoded in bits 0 to 5 */
 395                 ch = *data++;
 396                 count = ch&0x3F;
 397                 if (st->frame_size*count*25 > 3*st->Fs)
 398                     return OPUS_CORRUPTED_DATA;
 399                 len--;
 400                 /* Padding bit */
 401                 if (ch&0x40)
 402                 {
 403                         int padding=0;
 404                         int p;
 405                         do {
 406                                 if (len<=0)
 407                                         return OPUS_CORRUPTED_DATA;
 408                                 p = *data++;
 409                                 len--;
 410                                 padding += p==255 ? 254: p;
 411                         } while (p==255);
 412                         len -= padding;
 413                 }
 414                 if (len<0)
 415                         return OPUS_CORRUPTED_DATA;
 416                 /* Bit 7 is VBR flag (bit 6 is ignored) */
 417                 if (ch&0x80)
 418                 {
 419                         /* VBR case */
 420                         int last_size=len;
 421                         for (i=0;i<count-1;i++)
 422                         {
 423                                 bytes = parse_size(data, len, size+i);
 424                                 len -= bytes;
 425                                 if (size[i]<0 || size[i] > len)
 426                                         return OPUS_CORRUPTED_DATA;
 427                                 data += bytes;
 428                                 last_size -= bytes+size[i];
 429                         }
 430                         if (last_size<0)
 431                                 return OPUS_CORRUPTED_DATA;
 432                         if (count)
 433                                 size[count-1]=last_size;
 434                 } else {
 435                         /* CBR case */
 436                         int sz = count != 0 ? len/count : 0;
 437                         if (sz*count!=len)
 438                                 return OPUS_CORRUPTED_DATA;
 439                         for (i=0;i<count;i++)
 440                                 size[i] = sz;
 441                 }
 442                 break;
 443         }
 444         if (count*st->frame_size > frame_size)
 445                 return OPUS_BAD_ARG;
 446         nb_samples=0;
 447         for (i=0;i<count;i++)
 448         {
 449                 int ret;
 450                 ret = opus_decode_frame(st, data, len, pcm, frame_size-nb_samples, decode_fec);
 451                 if (ret<0)
 452                         return ret;
 453                 data += size[i];
 454                 pcm += ret;
 455                 nb_samples += ret;
 456         }
 457         return nb_samples;
 458 }
 459 int opus_decoder_ctl(OpusDecoder *st, int request, ...)
 460 {
 461     va_list ap;
 462
 463     va_start(ap, request);
 464
 465     switch (request)
 466     {
 467         case OPUS_GET_MODE_REQUEST:
 468         {
 469             int *value = va_arg(ap, int*);
 470             *value = st->prev_mode;
 471         }
 472         break;
 473         case OPUS_SET_BANDWIDTH_REQUEST:
 474         {
 475             int value = va_arg(ap, int);
 476             st->bandwidth = value;
 477         }
 478         break;
 479         case OPUS_GET_BANDWIDTH_REQUEST:
 480         {
 481             int *value = va_arg(ap, int*);
 482             *value = st->bandwidth;
 483         }
 484         break;
 485         default:
 486             fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);
 487             break;
 488     }
 489
 490     va_end(ap);
 491     return OPUS_OK;
 492 }
 493
 494 void opus_decoder_destroy(OpusDecoder *st)
 495 {
 496         free(st);
 497 }
 498
 499 #if OPUS_TEST_RANGE_CODER_STATE
 500 int opus_decoder_get_final_range(OpusDecoder *st)
 501 {
 502     return st->rangeFinal;
 503 }
 504 #endif
 505
 506
 507 int opus_packet_get_bandwidth(const unsigned char *data)
 508 {
 509         int bandwidth;
 510     if (data[0]&0x80)
 511     {
 512         bandwidth = BANDWIDTH_MEDIUMBAND + ((data[0]>>5)&0x3);
 513         if (bandwidth == BANDWIDTH_MEDIUMBAND)
 514             bandwidth = BANDWIDTH_NARROWBAND;
 515     } else if ((data[0]&0x60) == 0x60)
 516     {
 517         bandwidth = (data[0]&0x10) ? BANDWIDTH_FULLBAND : BANDWIDTH_SUPERWIDEBAND;
 518     } else {
 519
 520         bandwidth = BANDWIDTH_NARROWBAND + ((data[0]>>5)&0x3);
 521     }
 522     return bandwidth;
 523 }
 524
 525 int opus_packet_get_samples_per_frame(const unsigned char *data, int Fs)
 526 {
 527         int audiosize;
 528     if (data[0]&0x80)
 529     {
 530         audiosize = ((data[0]>>3)&0x3);
 531         audiosize = (Fs<<audiosize)/400;
 532     } else if ((data[0]&0x60) == 0x60)
 533     {
 534         audiosize = (data[0]&0x08) ? Fs/50 : Fs/100;
 535     } else {
 536
 537         audiosize = ((data[0]>>3)&0x3);
 538         if (audiosize == 3)
 539             audiosize = Fs*60/1000;
 540         else
 541             audiosize = (Fs<<audiosize)/100;
 542     }
 543     return audiosize;
 544 }
 545
 546 int opus_packet_get_nb_channels(const unsigned char *data)
 547 {
 548     return (data[0]&0x4) ? 2 : 1;
 549 }
 550
 551 int opus_packet_get_nb_frames(const unsigned char packet[], int len)
 552 {
 553         int count;
 554         if (len<1)
 555                 return OPUS_BAD_ARG;
 556         count = packet[0]&0x3;
 557         if (count==0)
 558                 return 1;
 559         else if (count!=3)
 560                 return 2;
 561         else if (len<2)
 562                 return OPUS_CORRUPTED_DATA;
 563         else
 564                 return packet[1]&0x3F;
 565 }
 566
 567 int opus_decoder_get_nb_samples(const OpusDecoder *dec, const unsigned char packet[], int len)
 568 {
 569         int samples;
 570         int count = opus_packet_get_nb_frames(packet, len);
 571         samples = count*opus_packet_get_samples_per_frame(packet, dec->Fs);
 572         /* Can't have more than 120 ms */
 573         if (samples*25 > dec->Fs*3)
 574                 return OPUS_CORRUPTED_DATA;
 575         else
 576                 return samples;
 577 }
 578