1 /* Copyright (c) 2010 Xiph.Org Foundation, Skype Limited 2 Written by Jean-Marc Valin and Koen Vos */ 3 /* 4 Redistribution and use in source and binary forms, with or without 5 modification, are permitted provided that the following conditions 6 are met: 7 8 - Redistributions of source code must retain the above copyright 9 notice, this list of conditions and the following disclaimer. 10 11 - Redistributions in binary form must reproduce the above copyright 12 notice, this list of conditions and the following disclaimer in the 13 documentation and/or other materials provided with the distribution. 14 15 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 16 ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 17 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 18 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER 19 OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 20 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 21 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 22 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 23 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 24 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 25 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28 #ifdef HAVE_CONFIG_H 29 # include "config.h" 30 #endif 31 32 #ifndef OPUS_BUILD 33 # error "OPUS_BUILD _MUST_ be defined to build Opus. This probably means you need other defines as well, as in a config.h. See the included build files for details." 34 #endif 35 36 #if defined(__GNUC__) && (__GNUC__ >= 2) && !defined(__OPTIMIZE__) && !defined(OPUS_WILL_BE_SLOW) 37 # pragma message "You appear to be compiling without optimization, if so opus will be very slow." 38 #endif 39 40 #include <stdarg.h> 41 #include "celt.h" 42 #include "opus.h" 43 #include "entdec.h" 44 #include "modes.h" 45 #include "API.h" 46 #include "stack_alloc.h" 47 #include "float_cast.h" 48 #include "opus_private.h" 49 #include "os_support.h" 50 #include "structs.h" 51 #include "define.h" 52 #include "mathops.h" 53 #include "cpu_support.h" 54 55 struct OpusDecoder { 56 int celt_dec_offset; 57 int silk_dec_offset; 58 int channels; 59 opus_int32 Fs; /** Sampling rate (at the API level) */ 60 silk_DecControlStruct DecControl; 61 int decode_gain; 62 int arch; 63 64 /* Everything beyond this point gets cleared on a reset */ 65 #define OPUS_DECODER_RESET_START stream_channels 66 int stream_channels; 67 68 int bandwidth; 69 int mode; 70 int prev_mode; 71 int frame_size; 72 int prev_redundancy; 73 int last_packet_duration; 74 #ifndef FIXED_POINT 75 opus_val16 softclip_mem[2]; 76 #endif 77 78 opus_uint32 rangeFinal; 79 }; 80 81 82 int opus_decoder_get_size(int channels) 83 { 84 int silkDecSizeBytes, celtDecSizeBytes; 85 int ret; 86 if (channels<1 || channels > 2) 87 return 0; 88 ret = silk_Get_Decoder_Size( &silkDecSizeBytes ); 89 if(ret) 90 return 0; 91 silkDecSizeBytes = align(silkDecSizeBytes); 92 celtDecSizeBytes = celt_decoder_get_size(channels); 93 return align(sizeof(OpusDecoder))+silkDecSizeBytes+celtDecSizeBytes; 94 } 95 96 int opus_decoder_init(OpusDecoder *st, opus_int32 Fs, int channels) 97 { 98 void *silk_dec; 99 CELTDecoder *celt_dec; 100 int ret, silkDecSizeBytes; 101 102 if ((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000) 103 || (channels!=1&&channels!=2)) 104 return OPUS_BAD_ARG; 105 106 OPUS_CLEAR((char*)st, opus_decoder_get_size(channels)); 107 /* Initialize SILK encoder */ 108 ret = silk_Get_Decoder_Size(&silkDecSizeBytes); 109 if (ret) 110 return OPUS_INTERNAL_ERROR; 111 112 silkDecSizeBytes = align(silkDecSizeBytes); 113 st->silk_dec_offset = align(sizeof(OpusDecoder)); 114 st->celt_dec_offset = st->silk_dec_offset+silkDecSizeBytes; 115 silk_dec = (char*)st+st->silk_dec_offset; 116 celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset); 117 st->stream_channels = st->channels = channels; 118 119 st->Fs = Fs; 120 st->DecControl.API_sampleRate = st->Fs; 121 st->DecControl.nChannelsAPI = st->channels; 122 123 /* Reset decoder */ 124 ret = silk_InitDecoder( silk_dec ); 125 if(ret)return OPUS_INTERNAL_ERROR; 126 127 /* Initialize CELT decoder */ 128 ret = celt_decoder_init(celt_dec, Fs, channels); 129 if(ret!=OPUS_OK)return OPUS_INTERNAL_ERROR; 130 131 celt_decoder_ctl(celt_dec, CELT_SET_SIGNALLING(0)); 132 133 st->prev_mode = 0; 134 st->frame_size = Fs/400; 135 st->arch = opus_select_arch(); 136 return OPUS_OK; 137 } 138 139 OpusDecoder *opus_decoder_create(opus_int32 Fs, int channels, int *error) 140 { 141 int ret; 142 OpusDecoder *st; 143 if ((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000) 144 || (channels!=1&&channels!=2)) 145 { 146 if (error) 147 *error = OPUS_BAD_ARG; 148 return NULL; 149 } 150 st = (OpusDecoder *)opus_alloc(opus_decoder_get_size(channels)); 151 if (st == NULL) 152 { 153 if (error) 154 *error = OPUS_ALLOC_FAIL; 155 return NULL; 156 } 157 ret = opus_decoder_init(st, Fs, channels); 158 if (error) 159 *error = ret; 160 if (ret != OPUS_OK) 161 { 162 opus_free(st); 163 st = NULL; 164 } 165 return st; 166 } 167 168 static void smooth_fade(const opus_val16 *in1, const opus_val16 *in2, 169 opus_val16 *out, int overlap, int channels, 170 const opus_val16 *window, opus_int32 Fs) 171 { 172 int i, c; 173 int inc = 48000/Fs; 174 for (c=0;c<channels;c++) 175 { 176 for (i=0;i<overlap;i++) 177 { 178 opus_val16 w = MULT16_16_Q15(window[i*inc], window[i*inc]); 179 out[i*channels+c] = SHR32(MAC16_16(MULT16_16(w,in2[i*channels+c]), 180 Q15ONE-w, in1[i*channels+c]), 15); 181 } 182 } 183 } 184 185 static int opus_packet_get_mode(const unsigned char *data) 186 { 187 int mode; 188 if (data[0]&0x80) 189 { 190 mode = MODE_CELT_ONLY; 191 } else if ((data[0]&0x60) == 0x60) 192 { 193 mode = MODE_HYBRID; 194 } else { 195 mode = MODE_SILK_ONLY; 196 } 197 return mode; 198 } 199 200 static int opus_decode_frame(OpusDecoder *st, const unsigned char *data, 201 opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec) 202 { 203 void *silk_dec; 204 CELTDecoder *celt_dec; 205 int i, silk_ret=0, celt_ret=0; 206 ec_dec dec; 207 opus_int32 silk_frame_size; 208 int pcm_silk_size; 209 VARDECL(opus_int16, pcm_silk); 210 int pcm_transition_silk_size; 211 VARDECL(opus_val16, pcm_transition_silk); 212 int pcm_transition_celt_size; 213 VARDECL(opus_val16, pcm_transition_celt); 214 opus_val16 *pcm_transition=NULL; 215 int redundant_audio_size; 216 VARDECL(opus_val16, redundant_audio); 217 218 int audiosize; 219 int mode; 220 int transition=0; 221 int start_band; 222 int redundancy=0; 223 int redundancy_bytes = 0; 224 int celt_to_silk=0; 225 int c; 226 int F2_5, F5, F10, F20; 227 const opus_val16 *window; 228 opus_uint32 redundant_rng = 0; 229 int celt_accum; 230 ALLOC_STACK; 231 232 silk_dec = (char*)st+st->silk_dec_offset; 233 celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset); 234 F20 = st->Fs/50; 235 F10 = F20>>1; 236 F5 = F10>>1; 237 F2_5 = F5>>1; 238 if (frame_size < F2_5) 239 { 240 RESTORE_STACK; 241 return OPUS_BUFFER_TOO_SMALL; 242 } 243 /* Limit frame_size to avoid excessive stack allocations. */ 244 frame_size = IMIN(frame_size, st->Fs/25*3); 245 /* Payloads of 1 (2 including ToC) or 0 trigger the PLC/DTX */ 246 if (len<=1) 247 { 248 data = NULL; 249 /* In that case, don't conceal more than what the ToC says */ 250 frame_size = IMIN(frame_size, st->frame_size); 251 } 252 if (data != NULL) 253 { 254 audiosize = st->frame_size; 255 mode = st->mode; 256 ec_dec_init(&dec,(unsigned char*)data,len); 257 } else { 258 audiosize = frame_size; 259 mode = st->prev_mode; 260 261 if (mode == 0) 262 { 263 /* If we haven't got any packet yet, all we can do is return zeros */ 264 for (i=0;i<audiosize*st->channels;i++) 265 pcm[i] = 0; 266 RESTORE_STACK; 267 return audiosize; 268 } 269 270 /* Avoids trying to run the PLC on sizes other than 2.5 (CELT), 5 (CELT), 271 10, or 20 (e.g. 12.5 or 30 ms). */ 272 if (audiosize > F20) 273 { 274 do { 275 int ret = opus_decode_frame(st, NULL, 0, pcm, IMIN(audiosize, F20), 0); 276 if (ret<0) 277 { 278 RESTORE_STACK; 279 return ret; 280 } 281 pcm += ret*st->channels; 282 audiosize -= ret; 283 } while (audiosize > 0); 284 RESTORE_STACK; 285 return frame_size; 286 } else if (audiosize < F20) 287 { 288 if (audiosize > F10) 289 audiosize = F10; 290 else if (mode != MODE_SILK_ONLY && audiosize > F5 && audiosize < F10) 291 audiosize = F5; 292 } 293 } 294 295 /* In fixed-point, we can tell CELT to do the accumulation on top of the 296 SILK PCM buffer. This saves some stack space. */ 297 #ifdef FIXED_POINT 298 celt_accum = (mode != MODE_CELT_ONLY) && (frame_size >= F10); 299 #else 300 celt_accum = 0; 301 #endif 302 303 pcm_transition_silk_size = ALLOC_NONE; 304 pcm_transition_celt_size = ALLOC_NONE; 305 if (data!=NULL && st->prev_mode > 0 && ( 306 (mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY && !st->prev_redundancy) 307 || (mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ) 308 ) 309 { 310 transition = 1; 311 /* Decide where to allocate the stack memory for pcm_transition */ 312 if (mode == MODE_CELT_ONLY) 313 pcm_transition_celt_size = F5*st->channels; 314 else 315 pcm_transition_silk_size = F5*st->channels; 316 } 317 ALLOC(pcm_transition_celt, pcm_transition_celt_size, opus_val16); 318 if (transition && mode == MODE_CELT_ONLY) 319 { 320 pcm_transition = pcm_transition_celt; 321 opus_decode_frame(st, NULL, 0, pcm_transition, IMIN(F5, audiosize), 0); 322 } 323 if (audiosize > frame_size) 324 { 325 /*fprintf(stderr, "PCM buffer too small: %d vs %d (mode = %d)\n", audiosize, frame_size, mode);*/ 326 RESTORE_STACK; 327 return OPUS_BAD_ARG; 328 } else { 329 frame_size = audiosize; 330 } 331 332 /* Don't allocate any memory when in CELT-only mode */ 333 pcm_silk_size = (mode != MODE_CELT_ONLY && !celt_accum) ? IMAX(F10, frame_size)*st->channels : ALLOC_NONE; 334 ALLOC(pcm_silk, pcm_silk_size, opus_int16); 335 336 /* SILK processing */ 337 if (mode != MODE_CELT_ONLY) 338 { 339 int lost_flag, decoded_samples; 340 opus_int16 *pcm_ptr; 341 #ifdef FIXED_POINT 342 if (celt_accum) 343 pcm_ptr = pcm; 344 else 345 #endif 346 pcm_ptr = pcm_silk; 347 348 if (st->prev_mode==MODE_CELT_ONLY) 349 silk_InitDecoder( silk_dec ); 350 351 /* The SILK PLC cannot produce frames of less than 10 ms */ 352 st->DecControl.payloadSize_ms = IMAX(10, 1000 * audiosize / st->Fs); 353 354 if (data != NULL) 355 { 356 st->DecControl.nChannelsInternal = st->stream_channels; 357 if( mode == MODE_SILK_ONLY ) { 358 if( st->bandwidth == OPUS_BANDWIDTH_NARROWBAND ) { 359 st->DecControl.internalSampleRate = 8000; 360 } else if( st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND ) { 361 st->DecControl.internalSampleRate = 12000; 362 } else if( st->bandwidth == OPUS_BANDWIDTH_WIDEBAND ) { 363 st->DecControl.internalSampleRate = 16000; 364 } else { 365 st->DecControl.internalSampleRate = 16000; 366 silk_assert( 0 ); 367 } 368 } else { 369 /* Hybrid mode */ 370 st->DecControl.internalSampleRate = 16000; 371 } 372 } 373 374 lost_flag = data == NULL ? 1 : 2 * decode_fec; 375 decoded_samples = 0; 376 do { 377 /* Call SILK decoder */ 378 int first_frame = decoded_samples == 0; 379 silk_ret = silk_Decode( silk_dec, &st->DecControl, 380 lost_flag, first_frame, &dec, pcm_ptr, &silk_frame_size, st->arch ); 381 if( silk_ret ) { 382 if (lost_flag) { 383 /* PLC failure should not be fatal */ 384 silk_frame_size = frame_size; 385 for (i=0;i<frame_size*st->channels;i++) 386 pcm_ptr[i] = 0; 387 } else { 388 RESTORE_STACK; 389 return OPUS_INTERNAL_ERROR; 390 } 391 } 392 pcm_ptr += silk_frame_size * st->channels; 393 decoded_samples += silk_frame_size; 394 } while( decoded_samples < frame_size ); 395 } 396 397 start_band = 0; 398 if (!decode_fec && mode != MODE_CELT_ONLY && data != NULL 399 && ec_tell(&dec)+17+20*(st->mode == MODE_HYBRID) <= 8*len) 400 { 401 /* Check if we have a redundant 0-8 kHz band */ 402 if (mode == MODE_HYBRID) 403 redundancy = ec_dec_bit_logp(&dec, 12); 404 else 405 redundancy = 1; 406 if (redundancy) 407 { 408 celt_to_silk = ec_dec_bit_logp(&dec, 1); 409 /* redundancy_bytes will be at least two, in the non-hybrid 410 case due to the ec_tell() check above */ 411 redundancy_bytes = mode==MODE_HYBRID ? 412 (opus_int32)ec_dec_uint(&dec, 256)+2 : 413 len-((ec_tell(&dec)+7)>>3); 414 len -= redundancy_bytes; 415 /* This is a sanity check. It should never happen for a valid 416 packet, so the exact behaviour is not normative. */ 417 if (len*8 < ec_tell(&dec)) 418 { 419 len = 0; 420 redundancy_bytes = 0; 421 redundancy = 0; 422 } 423 /* Shrink decoder because of raw bits */ 424 dec.storage -= redundancy_bytes; 425 } 426 } 427 if (mode != MODE_CELT_ONLY) 428 start_band = 17; 429 430 { 431 int endband=21; 432 433 switch(st->bandwidth) 434 { 435 case OPUS_BANDWIDTH_NARROWBAND: 436 endband = 13; 437 break; 438 case OPUS_BANDWIDTH_MEDIUMBAND: 439 case OPUS_BANDWIDTH_WIDEBAND: 440 endband = 17; 441 break; 442 case OPUS_BANDWIDTH_SUPERWIDEBAND: 443 endband = 19; 444 break; 445 case OPUS_BANDWIDTH_FULLBAND: 446 endband = 21; 447 break; 448 } 449 celt_decoder_ctl(celt_dec, CELT_SET_END_BAND(endband)); 450 celt_decoder_ctl(celt_dec, CELT_SET_CHANNELS(st->stream_channels)); 451 } 452 453 if (redundancy) 454 { 455 transition = 0; 456 pcm_transition_silk_size=ALLOC_NONE; 457 } 458 459 ALLOC(pcm_transition_silk, pcm_transition_silk_size, opus_val16); 460 461 if (transition && mode != MODE_CELT_ONLY) 462 { 463 pcm_transition = pcm_transition_silk; 464 opus_decode_frame(st, NULL, 0, pcm_transition, IMIN(F5, audiosize), 0); 465 } 466 467 /* Only allocation memory for redundancy if/when needed */ 468 redundant_audio_size = redundancy ? F5*st->channels : ALLOC_NONE; 469 ALLOC(redundant_audio, redundant_audio_size, opus_val16); 470 471 /* 5 ms redundant frame for CELT->SILK*/ 472 if (redundancy && celt_to_silk) 473 { 474 celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0)); 475 celt_decode_with_ec(celt_dec, data+len, redundancy_bytes, 476 redundant_audio, F5, NULL, 0); 477 celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_RANGE(&redundant_rng)); 478 } 479 480 /* MUST be after PLC */ 481 celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(start_band)); 482 483 if (mode != MODE_SILK_ONLY) 484 { 485 int celt_frame_size = IMIN(F20, frame_size); 486 /* Make sure to discard any previous CELT state */ 487 if (mode != st->prev_mode && st->prev_mode > 0 && !st->prev_redundancy) 488 celt_decoder_ctl(celt_dec, OPUS_RESET_STATE); 489 /* Decode CELT */ 490 celt_ret = celt_decode_with_ec(celt_dec, decode_fec ? NULL : data, 491 len, pcm, celt_frame_size, &dec, celt_accum); 492 } else { 493 unsigned char silence[2] = {0xFF, 0xFF}; 494 if (!celt_accum) 495 { 496 for (i=0;i<frame_size*st->channels;i++) 497 pcm[i] = 0; 498 } 499 /* For hybrid -> SILK transitions, we let the CELT MDCT 500 do a fade-out by decoding a silence frame */ 501 if (st->prev_mode == MODE_HYBRID && !(redundancy && celt_to_silk && st->prev_redundancy) ) 502 { 503 celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0)); 504 celt_decode_with_ec(celt_dec, silence, 2, pcm, F2_5, NULL, celt_accum); 505 } 506 } 507 508 if (mode != MODE_CELT_ONLY && !celt_accum) 509 { 510 #ifdef FIXED_POINT 511 for (i=0;i<frame_size*st->channels;i++) 512 pcm[i] = SAT16(ADD32(pcm[i], pcm_silk[i])); 513 #else 514 for (i=0;i<frame_size*st->channels;i++) 515 pcm[i] = pcm[i] + (opus_val16)((1.f/32768.f)*pcm_silk[i]); 516 #endif 517 } 518 519 { 520 const CELTMode *celt_mode; 521 celt_decoder_ctl(celt_dec, CELT_GET_MODE(&celt_mode)); 522 window = celt_mode->window; 523 } 524 525 /* 5 ms redundant frame for SILK->CELT */ 526 if (redundancy && !celt_to_silk) 527 { 528 celt_decoder_ctl(celt_dec, OPUS_RESET_STATE); 529 celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0)); 530 531 celt_decode_with_ec(celt_dec, data+len, redundancy_bytes, redundant_audio, F5, NULL, 0); 532 celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_RANGE(&redundant_rng)); 533 smooth_fade(pcm+st->channels*(frame_size-F2_5), redundant_audio+st->channels*F2_5, 534 pcm+st->channels*(frame_size-F2_5), F2_5, st->channels, window, st->Fs); 535 } 536 if (redundancy && celt_to_silk) 537 { 538 for (c=0;c<st->channels;c++) 539 { 540 for (i=0;i<F2_5;i++) 541 pcm[st->channels*i+c] = redundant_audio[st->channels*i+c]; 542 } 543 smooth_fade(redundant_audio+st->channels*F2_5, pcm+st->channels*F2_5, 544 pcm+st->channels*F2_5, F2_5, st->channels, window, st->Fs); 545 } 546 if (transition) 547 { 548 if (audiosize >= F5) 549 { 550 for (i=0;i<st->channels*F2_5;i++) 551 pcm[i] = pcm_transition[i]; 552 smooth_fade(pcm_transition+st->channels*F2_5, pcm+st->channels*F2_5, 553 pcm+st->channels*F2_5, F2_5, 554 st->channels, window, st->Fs); 555 } else { 556 /* Not enough time to do a clean transition, but we do it anyway 557 This will not preserve amplitude perfectly and may introduce 558 a bit of temporal aliasing, but it shouldn't be too bad and 559 that's pretty much the best we can do. In any case, generating this 560 transition it pretty silly in the first place */ 561 smooth_fade(pcm_transition, pcm, 562 pcm, F2_5, 563 st->channels, window, st->Fs); 564 } 565 } 566 567 if(st->decode_gain) 568 { 569 opus_val32 gain; 570 gain = celt_exp2(MULT16_16_P15(QCONST16(6.48814081e-4f, 25), st->decode_gain)); 571 for (i=0;i<frame_size*st->channels;i++) 572 { 573 opus_val32 x; 574 x = MULT16_32_P16(pcm[i],gain); 575 pcm[i] = SATURATE(x, 32767); 576 } 577 } 578 579 if (len <= 1) 580 st->rangeFinal = 0; 581 else 582 st->rangeFinal = dec.rng ^ redundant_rng; 583 584 st->prev_mode = mode; 585 st->prev_redundancy = redundancy && !celt_to_silk; 586 587 if (celt_ret>=0) 588 { 589 if (OPUS_CHECK_ARRAY(pcm, audiosize*st->channels)) 590 OPUS_PRINT_INT(audiosize); 591 } 592 593 RESTORE_STACK; 594 return celt_ret < 0 ? celt_ret : audiosize; 595 596 } 597 598 int opus_decode_native(OpusDecoder *st, const unsigned char *data, 599 opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec, 600 int self_delimited, opus_int32 *packet_offset, int soft_clip) 601 { 602 int i, nb_samples; 603 int count, offset; 604 unsigned char toc; 605 int packet_frame_size, packet_bandwidth, packet_mode, packet_stream_channels; 606 /* 48 x 2.5 ms = 120 ms */ 607 opus_int16 size[48]; 608 if (decode_fec<0 || decode_fec>1) 609 return OPUS_BAD_ARG; 610 /* For FEC/PLC, frame_size has to be to have a multiple of 2.5 ms */ 611 if ((decode_fec || len==0 || data==NULL) && frame_size%(st->Fs/400)!=0) 612 return OPUS_BAD_ARG; 613 if (len==0 || data==NULL) 614 { 615 int pcm_count=0; 616 do { 617 int ret; 618 ret = opus_decode_frame(st, NULL, 0, pcm+pcm_count*st->channels, frame_size-pcm_count, 0); 619 if (ret<0) 620 return ret; 621 pcm_count += ret; 622 } while (pcm_count < frame_size); 623 celt_assert(pcm_count == frame_size); 624 if (OPUS_CHECK_ARRAY(pcm, pcm_count*st->channels)) 625 OPUS_PRINT_INT(pcm_count); 626 st->last_packet_duration = pcm_count; 627 return pcm_count; 628 } else if (len<0) 629 return OPUS_BAD_ARG; 630 631 packet_mode = opus_packet_get_mode(data); 632 packet_bandwidth = opus_packet_get_bandwidth(data); 633 packet_frame_size = opus_packet_get_samples_per_frame(data, st->Fs); 634 packet_stream_channels = opus_packet_get_nb_channels(data); 635 636 count = opus_packet_parse_impl(data, len, self_delimited, &toc, NULL, 637 size, &offset, packet_offset); 638 if (count<0) 639 return count; 640 641 data += offset; 642 643 if (decode_fec) 644 { 645 int duration_copy; 646 int ret; 647 /* If no FEC can be present, run the PLC (recursive call) */ 648 if (frame_size < packet_frame_size || packet_mode == MODE_CELT_ONLY || st->mode == MODE_CELT_ONLY) 649 return opus_decode_native(st, NULL, 0, pcm, frame_size, 0, 0, NULL, soft_clip); 650 /* Otherwise, run the PLC on everything except the size for which we might have FEC */ 651 duration_copy = st->last_packet_duration; 652 if (frame_size-packet_frame_size!=0) 653 { 654 ret = opus_decode_native(st, NULL, 0, pcm, frame_size-packet_frame_size, 0, 0, NULL, soft_clip); 655 if (ret<0) 656 { 657 st->last_packet_duration = duration_copy; 658 return ret; 659 } 660 celt_assert(ret==frame_size-packet_frame_size); 661 } 662 /* Complete with FEC */ 663 st->mode = packet_mode; 664 st->bandwidth = packet_bandwidth; 665 st->frame_size = packet_frame_size; 666 st->stream_channels = packet_stream_channels; 667 ret = opus_decode_frame(st, data, size[0], pcm+st->channels*(frame_size-packet_frame_size), 668 packet_frame_size, 1); 669 if (ret<0) 670 return ret; 671 else { 672 if (OPUS_CHECK_ARRAY(pcm, frame_size*st->channels)) 673 OPUS_PRINT_INT(frame_size); 674 st->last_packet_duration = frame_size; 675 return frame_size; 676 } 677 } 678 679 if (count*packet_frame_size > frame_size) 680 return OPUS_BUFFER_TOO_SMALL; 681 682 /* Update the state as the last step to avoid updating it on an invalid packet */ 683 st->mode = packet_mode; 684 st->bandwidth = packet_bandwidth; 685 st->frame_size = packet_frame_size; 686 st->stream_channels = packet_stream_channels; 687 688 nb_samples=0; 689 for (i=0;i<count;i++) 690 { 691 int ret; 692 ret = opus_decode_frame(st, data, size[i], pcm+nb_samples*st->channels, frame_size-nb_samples, 0); 693 if (ret<0) 694 return ret; 695 celt_assert(ret==packet_frame_size); 696 data += size[i]; 697 nb_samples += ret; 698 } 699 st->last_packet_duration = nb_samples; 700 if (OPUS_CHECK_ARRAY(pcm, nb_samples*st->channels)) 701 OPUS_PRINT_INT(nb_samples); 702 #ifndef FIXED_POINT 703 if (soft_clip) 704 opus_pcm_soft_clip(pcm, nb_samples, st->channels, st->softclip_mem); 705 else 706 st->softclip_mem[0]=st->softclip_mem[1]=0; 707 #endif 708 return nb_samples; 709 } 710 711 #ifdef FIXED_POINT 712 713 int opus_decode(OpusDecoder *st, const unsigned char *data, 714 opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec) 715 { 716 if(frame_size<=0) 717 return OPUS_BAD_ARG; 718 return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL, 0); 719 } 720 721 #ifndef DISABLE_FLOAT_API 722 int opus_decode_float(OpusDecoder *st, const unsigned char *data, 723 opus_int32 len, float *pcm, int frame_size, int decode_fec) 724 { 725 VARDECL(opus_int16, out); 726 int ret, i; 727 int nb_samples; 728 ALLOC_STACK; 729 730 if(frame_size<=0) 731 { 732 RESTORE_STACK; 733 return OPUS_BAD_ARG; 734 } 735 if (data != NULL && len > 0 && !decode_fec) 736 { 737 nb_samples = opus_decoder_get_nb_samples(st, data, len); 738 if (nb_samples>0) 739 frame_size = IMIN(frame_size, nb_samples); 740 else 741 return OPUS_INVALID_PACKET; 742 } 743 ALLOC(out, frame_size*st->channels, opus_int16); 744 745 ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL, 0); 746 if (ret > 0) 747 { 748 for (i=0;i<ret*st->channels;i++) 749 pcm[i] = (1.f/32768.f)*(out[i]); 750 } 751 RESTORE_STACK; 752 return ret; 753 } 754 #endif 755 756 757 #else 758 int opus_decode(OpusDecoder *st, const unsigned char *data, 759 opus_int32 len, opus_int16 *pcm, int frame_size, int decode_fec) 760 { 761 VARDECL(float, out); 762 int ret, i; 763 int nb_samples; 764 ALLOC_STACK; 765 766 if(frame_size<=0) 767 { 768 RESTORE_STACK; 769 return OPUS_BAD_ARG; 770 } 771 772 if (data != NULL && len > 0 && !decode_fec) 773 { 774 nb_samples = opus_decoder_get_nb_samples(st, data, len); 775 if (nb_samples>0) 776 frame_size = IMIN(frame_size, nb_samples); 777 else 778 return OPUS_INVALID_PACKET; 779 } 780 ALLOC(out, frame_size*st->channels, float); 781 782 ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL, 1); 783 if (ret > 0) 784 { 785 for (i=0;i<ret*st->channels;i++) 786 pcm[i] = FLOAT2INT16(out[i]); 787 } 788 RESTORE_STACK; 789 return ret; 790 } 791 792 int opus_decode_float(OpusDecoder *st, const unsigned char *data, 793 opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec) 794 { 795 if(frame_size<=0) 796 return OPUS_BAD_ARG; 797 return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL, 0); 798 } 799 800 #endif 801 802 int opus_decoder_ctl(OpusDecoder *st, int request, ...) 803 { 804 int ret = OPUS_OK; 805 va_list ap; 806 void *silk_dec; 807 CELTDecoder *celt_dec; 808 809 silk_dec = (char*)st+st->silk_dec_offset; 810 celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset); 811 812 813 va_start(ap, request); 814 815 switch (request) 816 { 817 case OPUS_GET_BANDWIDTH_REQUEST: 818 { 819 opus_int32 *value = va_arg(ap, opus_int32*); 820 if (!value) 821 { 822 goto bad_arg; 823 } 824 *value = st->bandwidth; 825 } 826 break; 827 case OPUS_GET_FINAL_RANGE_REQUEST: 828 { 829 opus_uint32 *value = va_arg(ap, opus_uint32*); 830 if (!value) 831 { 832 goto bad_arg; 833 } 834 *value = st->rangeFinal; 835 } 836 break; 837 case OPUS_RESET_STATE: 838 { 839 OPUS_CLEAR((char*)&st->OPUS_DECODER_RESET_START, 840 sizeof(OpusDecoder)- 841 ((char*)&st->OPUS_DECODER_RESET_START - (char*)st)); 842 843 celt_decoder_ctl(celt_dec, OPUS_RESET_STATE); 844 silk_InitDecoder( silk_dec ); 845 st->stream_channels = st->channels; 846 st->frame_size = st->Fs/400; 847 } 848 break; 849 case OPUS_GET_SAMPLE_RATE_REQUEST: 850 { 851 opus_int32 *value = va_arg(ap, opus_int32*); 852 if (!value) 853 { 854 goto bad_arg; 855 } 856 *value = st->Fs; 857 } 858 break; 859 case OPUS_GET_PITCH_REQUEST: 860 { 861 opus_int32 *value = va_arg(ap, opus_int32*); 862 if (!value) 863 { 864 goto bad_arg; 865 } 866 if (st->prev_mode == MODE_CELT_ONLY) 867 celt_decoder_ctl(celt_dec, OPUS_GET_PITCH(value)); 868 else 869 *value = st->DecControl.prevPitchLag; 870 } 871 break; 872 case OPUS_GET_GAIN_REQUEST: 873 { 874 opus_int32 *value = va_arg(ap, opus_int32*); 875 if (!value) 876 { 877 goto bad_arg; 878 } 879 *value = st->decode_gain; 880 } 881 break; 882 case OPUS_SET_GAIN_REQUEST: 883 { 884 opus_int32 value = va_arg(ap, opus_int32); 885 if (value<-32768 || value>32767) 886 { 887 goto bad_arg; 888 } 889 st->decode_gain = value; 890 } 891 break; 892 case OPUS_GET_LAST_PACKET_DURATION_REQUEST: 893 { 894 opus_uint32 *value = va_arg(ap, opus_uint32*); 895 if (!value) 896 { 897 goto bad_arg; 898 } 899 *value = st->last_packet_duration; 900 } 901 break; 902 default: 903 /*fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);*/ 904 ret = OPUS_UNIMPLEMENTED; 905 break; 906 } 907 908 va_end(ap); 909 return ret; 910 bad_arg: 911 va_end(ap); 912 return OPUS_BAD_ARG; 913 } 914 915 void opus_decoder_destroy(OpusDecoder *st) 916 { 917 opus_free(st); 918 } 919 920 921 int opus_packet_get_bandwidth(const unsigned char *data) 922 { 923 int bandwidth; 924 if (data[0]&0x80) 925 { 926 bandwidth = OPUS_BANDWIDTH_MEDIUMBAND + ((data[0]>>5)&0x3); 927 if (bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) 928 bandwidth = OPUS_BANDWIDTH_NARROWBAND; 929 } else if ((data[0]&0x60) == 0x60) 930 { 931 bandwidth = (data[0]&0x10) ? OPUS_BANDWIDTH_FULLBAND : 932 OPUS_BANDWIDTH_SUPERWIDEBAND; 933 } else { 934 bandwidth = OPUS_BANDWIDTH_NARROWBAND + ((data[0]>>5)&0x3); 935 } 936 return bandwidth; 937 } 938 939 int opus_packet_get_nb_channels(const unsigned char *data) 940 { 941 return (data[0]&0x4) ? 2 : 1; 942 } 943 944 int opus_packet_get_nb_frames(const unsigned char packet[], opus_int32 len) 945 { 946 int count; 947 if (len<1) 948 return OPUS_BAD_ARG; 949 count = packet[0]&0x3; 950 if (count==0) 951 return 1; 952 else if (count!=3) 953 return 2; 954 else if (len<2) 955 return OPUS_INVALID_PACKET; 956 else 957 return packet[1]&0x3F; 958 } 959 960 int opus_packet_get_nb_samples(const unsigned char packet[], opus_int32 len, 961 opus_int32 Fs) 962 { 963 int samples; 964 int count = opus_packet_get_nb_frames(packet, len); 965 966 if (count<0) 967 return count; 968 969 samples = count*opus_packet_get_samples_per_frame(packet, Fs); 970 /* Can't have more than 120 ms */ 971 if (samples*25 > Fs*3) 972 return OPUS_INVALID_PACKET; 973 else 974 return samples; 975 } 976 977 int opus_decoder_get_nb_samples(const OpusDecoder *dec, 978 const unsigned char packet[], opus_int32 len) 979 { 980 return opus_packet_get_nb_samples(packet, len, dec->Fs); 981 } 982
