1 /* Copyright (c) 2007-2008 CSIRO 2 Copyright (c) 2007-2010 Xiph.Org Foundation 3 Copyright (c) 2008 Gregory Maxwell 4 Written by Jean-Marc Valin and Gregory Maxwell */ 5 /* 6 Redistribution and use in source and binary forms, with or without 7 modification, are permitted provided that the following conditions 8 are met: 9 10 - Redistributions of source code must retain the above copyright 11 notice, this list of conditions and the following disclaimer. 12 13 - Redistributions in binary form must reproduce the above copyright 14 notice, this list of conditions and the following disclaimer in the 15 documentation and/or other materials provided with the distribution. 16 17 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18 ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 20 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER 21 OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 22 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 23 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 24 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 25 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 26 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 27 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 */ 29 30 #ifdef HAVE_CONFIG_H 31 #include "config.h" 32 #endif 33 34 #define CELT_DECODER_C 35 36 #include "cpu_support.h" 37 #include "os_support.h" 38 #include "mdct.h" 39 #include <math.h> 40 #include "celt.h" 41 #include "pitch.h" 42 #include "bands.h" 43 #include "modes.h" 44 #include "entcode.h" 45 #include "quant_bands.h" 46 #include "rate.h" 47 #include "stack_alloc.h" 48 #include "mathops.h" 49 #include "float_cast.h" 50 #include <stdarg.h> 51 #include "celt_lpc.h" 52 #include "vq.h" 53 54 /**********************************************************************/ 55 /* */ 56 /* DECODER */ 57 /* */ 58 /**********************************************************************/ 59 #define DECODE_BUFFER_SIZE 2048 60 61 /** Decoder state 62 @brief Decoder state 63 */ 64 struct OpusCustomDecoder { 65 const OpusCustomMode *mode; 66 int overlap; 67 int channels; 68 int stream_channels; 69 70 int downsample; 71 int start, end; 72 int signalling; 73 int arch; 74 75 /* Everything beyond this point gets cleared on a reset */ 76 #define DECODER_RESET_START rng 77 78 opus_uint32 rng; 79 int error; 80 int last_pitch_index; 81 int loss_count; 82 int postfilter_period; 83 int postfilter_period_old; 84 opus_val16 postfilter_gain; 85 opus_val16 postfilter_gain_old; 86 int postfilter_tapset; 87 int postfilter_tapset_old; 88 89 celt_sig preemph_memD[2]; 90 91 celt_sig _decode_mem[1]; /* Size = channels*(DECODE_BUFFER_SIZE+mode->overlap) */ 92 /* opus_val16 lpc[], Size = channels*LPC_ORDER */ 93 /* opus_val16 oldEBands[], Size = 2*mode->nbEBands */ 94 /* opus_val16 oldLogE[], Size = 2*mode->nbEBands */ 95 /* opus_val16 oldLogE2[], Size = 2*mode->nbEBands */ 96 /* opus_val16 backgroundLogE[], Size = 2*mode->nbEBands */ 97 }; 98 99 int celt_decoder_get_size(int channels) 100 { 101 const CELTMode *mode = opus_custom_mode_create(48000, 960, NULL); 102 return opus_custom_decoder_get_size(mode, channels); 103 } 104 105 OPUS_CUSTOM_NOSTATIC int opus_custom_decoder_get_size(const CELTMode *mode, int channels) 106 { 107 int size = sizeof(struct CELTDecoder) 108 + (channels*(DECODE_BUFFER_SIZE+mode->overlap)-1)*sizeof(celt_sig) 109 + channels*LPC_ORDER*sizeof(opus_val16) 110 + 4*2*mode->nbEBands*sizeof(opus_val16); 111 return size; 112 } 113 114 #ifdef CUSTOM_MODES 115 CELTDecoder *opus_custom_decoder_create(const CELTMode *mode, int channels, int *error) 116 { 117 int ret; 118 CELTDecoder *st = (CELTDecoder *)opus_alloc(opus_custom_decoder_get_size(mode, channels)); 119 ret = opus_custom_decoder_init(st, mode, channels); 120 if (ret != OPUS_OK) 121 { 122 opus_custom_decoder_destroy(st); 123 st = NULL; 124 } 125 if (error) 126 *error = ret; 127 return st; 128 } 129 #endif /* CUSTOM_MODES */ 130 131 int celt_decoder_init(CELTDecoder *st, opus_int32 sampling_rate, int channels) 132 { 133 int ret; 134 ret = opus_custom_decoder_init(st, opus_custom_mode_create(48000, 960, NULL), channels); 135 if (ret != OPUS_OK) 136 return ret; 137 st->downsample = resampling_factor(sampling_rate); 138 if (st->downsample==0) 139 return OPUS_BAD_ARG; 140 else 141 return OPUS_OK; 142 } 143 144 OPUS_CUSTOM_NOSTATIC int opus_custom_decoder_init(CELTDecoder *st, const CELTMode *mode, int channels) 145 { 146 if (channels < 0 || channels > 2) 147 return OPUS_BAD_ARG; 148 149 if (st==NULL) 150 return OPUS_ALLOC_FAIL; 151 152 OPUS_CLEAR((char*)st, opus_custom_decoder_get_size(mode, channels)); 153 154 st->mode = mode; 155 st->overlap = mode->overlap; 156 st->stream_channels = st->channels = channels; 157 158 st->downsample = 1; 159 st->start = 0; 160 st->end = st->mode->effEBands; 161 st->signalling = 1; 162 st->arch = opus_select_arch(); 163 164 st->loss_count = 0; 165 166 opus_custom_decoder_ctl(st, OPUS_RESET_STATE); 167 168 return OPUS_OK; 169 } 170 171 #ifdef CUSTOM_MODES 172 void opus_custom_decoder_destroy(CELTDecoder *st) 173 { 174 opus_free(st); 175 } 176 #endif /* CUSTOM_MODES */ 177 178 static OPUS_INLINE opus_val16 SIG2WORD16(celt_sig x) 179 { 180 #ifdef FIXED_POINT 181 x = PSHR32(x, SIG_SHIFT); 182 x = MAX32(x, -32768); 183 x = MIN32(x, 32767); 184 return EXTRACT16(x); 185 #else 186 return (opus_val16)x; 187 #endif 188 } 189 190 #ifndef RESYNTH 191 static 192 #endif 193 void deemphasis(celt_sig *in[], opus_val16 *pcm, int N, int C, int downsample, const opus_val16 *coef, celt_sig *mem, celt_sig * OPUS_RESTRICT scratch) 194 { 195 int c; 196 int Nd; 197 int apply_downsampling=0; 198 opus_val16 coef0; 199 200 coef0 = coef[0]; 201 Nd = N/downsample; 202 c=0; do { 203 int j; 204 celt_sig * OPUS_RESTRICT x; 205 opus_val16 * OPUS_RESTRICT y; 206 celt_sig m = mem[c]; 207 x =in[c]; 208 y = pcm+c; 209 #ifdef CUSTOM_MODES 210 if (coef[1] != 0) 211 { 212 opus_val16 coef1 = coef[1]; 213 opus_val16 coef3 = coef[3]; 214 for (j=0;j<N;j++) 215 { 216 celt_sig tmp = x[j] + m + VERY_SMALL; 217 m = MULT16_32_Q15(coef0, tmp) 218 - MULT16_32_Q15(coef1, x[j]); 219 tmp = SHL32(MULT16_32_Q15(coef3, tmp), 2); 220 scratch[j] = tmp; 221 } 222 apply_downsampling=1; 223 } else 224 #endif 225 if (downsample>1) 226 { 227 /* Shortcut for the standard (non-custom modes) case */ 228 for (j=0;j<N;j++) 229 { 230 celt_sig tmp = x[j] + m + VERY_SMALL; 231 m = MULT16_32_Q15(coef0, tmp); 232 scratch[j] = tmp; 233 } 234 apply_downsampling=1; 235 } else { 236 /* Shortcut for the standard (non-custom modes) case */ 237 for (j=0;j<N;j++) 238 { 239 celt_sig tmp = x[j] + m + VERY_SMALL; 240 m = MULT16_32_Q15(coef0, tmp); 241 y[j*C] = SCALEOUT(SIG2WORD16(tmp)); 242 } 243 } 244 mem[c] = m; 245 246 if (apply_downsampling) 247 { 248 /* Perform down-sampling */ 249 for (j=0;j<Nd;j++) 250 y[j*C] = SCALEOUT(SIG2WORD16(scratch[j*downsample])); 251 } 252 } while (++c<C); 253 } 254 255 /** Compute the IMDCT and apply window for all sub-frames and 256 all channels in a frame */ 257 #ifndef RESYNTH 258 static 259 #endif 260 void compute_inv_mdcts(const CELTMode *mode, int shortBlocks, celt_sig *X, 261 celt_sig * OPUS_RESTRICT out_mem[], int C, int LM) 262 { 263 int b, c; 264 int B; 265 int N; 266 int shift; 267 const int overlap = OVERLAP(mode); 268 269 if (shortBlocks) 270 { 271 B = shortBlocks; 272 N = mode->shortMdctSize; 273 shift = mode->maxLM; 274 } else { 275 B = 1; 276 N = mode->shortMdctSize<<LM; 277 shift = mode->maxLM-LM; 278 } 279 c=0; do { 280 /* IMDCT on the interleaved the sub-frames, overlap-add is performed by the IMDCT */ 281 for (b=0;b<B;b++) 282 clt_mdct_backward(&mode->mdct, &X[b+c*N*B], out_mem[c]+N*b, mode->window, overlap, shift, B); 283 } while (++c<C); 284 } 285 286 static void tf_decode(int start, int end, int isTransient, int *tf_res, int LM, ec_dec *dec) 287 { 288 int i, curr, tf_select; 289 int tf_select_rsv; 290 int tf_changed; 291 int logp; 292 opus_uint32 budget; 293 opus_uint32 tell; 294 295 budget = dec->storage*8; 296 tell = ec_tell(dec); 297 logp = isTransient ? 2 : 4; 298 tf_select_rsv = LM>0 && tell+logp+1<=budget; 299 budget -= tf_select_rsv; 300 tf_changed = curr = 0; 301 for (i=start;i<end;i++) 302 { 303 if (tell+logp<=budget) 304 { 305 curr ^= ec_dec_bit_logp(dec, logp); 306 tell = ec_tell(dec); 307 tf_changed |= curr; 308 } 309 tf_res[i] = curr; 310 logp = isTransient ? 4 : 5; 311 } 312 tf_select = 0; 313 if (tf_select_rsv && 314 tf_select_table[LM][4*isTransient+0+tf_changed] != 315 tf_select_table[LM][4*isTransient+2+tf_changed]) 316 { 317 tf_select = ec_dec_bit_logp(dec, 1); 318 } 319 for (i=start;i<end;i++) 320 { 321 tf_res[i] = tf_select_table[LM][4*isTransient+2*tf_select+tf_res[i]]; 322 } 323 } 324 325 /* The maximum pitch lag to allow in the pitch-based PLC. It's possible to save 326 CPU time in the PLC pitch search by making this smaller than MAX_PERIOD. The 327 current value corresponds to a pitch of 66.67 Hz. */ 328 #define PLC_PITCH_LAG_MAX (720) 329 /* The minimum pitch lag to allow in the pitch-based PLC. This corresponds to a 330 pitch of 480 Hz. */ 331 #define PLC_PITCH_LAG_MIN (100) 332 333 static void celt_decode_lost(CELTDecoder * OPUS_RESTRICT st, opus_val16 * OPUS_RESTRICT pcm, int N, int LM) 334 { 335 int c; 336 int i; 337 const int C = st->channels; 338 celt_sig *decode_mem[2]; 339 celt_sig *out_syn[2]; 340 opus_val16 *lpc; 341 opus_val16 *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE; 342 const OpusCustomMode *mode; 343 int nbEBands; 344 int overlap; 345 int start; 346 int downsample; 347 int loss_count; 348 int noise_based; 349 const opus_int16 *eBands; 350 VARDECL(celt_sig, scratch); 351 SAVE_STACK; 352 353 mode = st->mode; 354 nbEBands = mode->nbEBands; 355 overlap = mode->overlap; 356 eBands = mode->eBands; 357 358 c=0; do { 359 decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+overlap); 360 out_syn[c] = decode_mem[c]+DECODE_BUFFER_SIZE-N; 361 } while (++c<C); 362 lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+overlap)*C); 363 oldBandE = lpc+C*LPC_ORDER; 364 oldLogE = oldBandE + 2*nbEBands; 365 oldLogE2 = oldLogE + 2*nbEBands; 366 backgroundLogE = oldLogE2 + 2*nbEBands; 367 368 loss_count = st->loss_count; 369 start = st->start; 370 downsample = st->downsample; 371 noise_based = loss_count >= 5 || start != 0; 372 ALLOC(scratch, noise_based?N*C:N, celt_sig); 373 if (noise_based) 374 { 375 /* Noise-based PLC/CNG */ 376 celt_sig *freq; 377 VARDECL(celt_norm, X); 378 opus_uint32 seed; 379 opus_val16 *plcLogE; 380 int end; 381 int effEnd; 382 383 end = st->end; 384 effEnd = IMAX(start, IMIN(end, mode->effEBands)); 385 386 /* Share the interleaved signal MDCT coefficient buffer with the 387 deemphasis scratch buffer. */ 388 freq = scratch; 389 ALLOC(X, C*N, celt_norm); /**< Interleaved normalised MDCTs */ 390 391 if (loss_count >= 5) 392 plcLogE = backgroundLogE; 393 else { 394 /* Energy decay */ 395 opus_val16 decay = loss_count==0 ? 396 QCONST16(1.5f, DB_SHIFT) : QCONST16(.5f, DB_SHIFT); 397 c=0; do 398 { 399 for (i=start;i<end;i++) 400 oldBandE[c*nbEBands+i] -= decay; 401 } while (++c<C); 402 plcLogE = oldBandE; 403 } 404 seed = st->rng; 405 for (c=0;c<C;c++) 406 { 407 for (i=start;i<effEnd;i++) 408 { 409 int j; 410 int boffs; 411 int blen; 412 boffs = N*c+(eBands[i]<<LM); 413 blen = (eBands[i+1]-eBands[i])<<LM; 414 for (j=0;j<blen;j++) 415 { 416 seed = celt_lcg_rand(seed); 417 X[boffs+j] = (celt_norm)((opus_int32)seed>>20); 418 } 419 renormalise_vector(X+boffs, blen, Q15ONE); 420 } 421 } 422 st->rng = seed; 423 424 denormalise_bands(mode, X, freq, plcLogE, start, effEnd, C, 1<<LM); 425 426 c=0; do { 427 int bound = eBands[effEnd]<<LM; 428 if (downsample!=1) 429 bound = IMIN(bound, N/downsample); 430 for (i=bound;i<N;i++) 431 freq[c*N+i] = 0; 432 } while (++c<C); 433 c=0; do { 434 OPUS_MOVE(decode_mem[c], decode_mem[c]+N, 435 DECODE_BUFFER_SIZE-N+(overlap>>1)); 436 } while (++c<C); 437 compute_inv_mdcts(mode, 0, freq, out_syn, C, LM); 438 } else { 439 /* Pitch-based PLC */ 440 const opus_val16 *window; 441 opus_val16 fade = Q15ONE; 442 int pitch_index; 443 VARDECL(opus_val32, etmp); 444 VARDECL(opus_val16, exc); 445 446 if (loss_count == 0) 447 { 448 VARDECL( opus_val16, lp_pitch_buf ); 449 ALLOC( lp_pitch_buf, DECODE_BUFFER_SIZE>>1, opus_val16 ); 450 pitch_downsample(decode_mem, lp_pitch_buf, 451 DECODE_BUFFER_SIZE, C, st->arch); 452 pitch_search(lp_pitch_buf+(PLC_PITCH_LAG_MAX>>1), lp_pitch_buf, 453 DECODE_BUFFER_SIZE-PLC_PITCH_LAG_MAX, 454 PLC_PITCH_LAG_MAX-PLC_PITCH_LAG_MIN, &pitch_index, st->arch); 455 pitch_index = PLC_PITCH_LAG_MAX-pitch_index; 456 st->last_pitch_index = pitch_index; 457 } else { 458 pitch_index = st->last_pitch_index; 459 fade = QCONST16(.8f,15); 460 } 461 462 ALLOC(etmp, overlap, opus_val32); 463 ALLOC(exc, MAX_PERIOD, opus_val16); 464 window = mode->window; 465 c=0; do { 466 opus_val16 decay; 467 opus_val16 attenuation; 468 opus_val32 S1=0; 469 celt_sig *buf; 470 int extrapolation_offset; 471 int extrapolation_len; 472 int exc_length; 473 int j; 474 475 buf = decode_mem[c]; 476 for (i=0;i<MAX_PERIOD;i++) { 477 exc[i] = ROUND16(buf[DECODE_BUFFER_SIZE-MAX_PERIOD+i], SIG_SHIFT); 478 } 479 480 if (loss_count == 0) 481 { 482 opus_val32 ac[LPC_ORDER+1]; 483 /* Compute LPC coefficients for the last MAX_PERIOD samples before 484 the first loss so we can work in the excitation-filter domain. */ 485 _celt_autocorr(exc, ac, window, overlap, 486 LPC_ORDER, MAX_PERIOD, st->arch); 487 /* Add a noise floor of -40 dB. */ 488 #ifdef FIXED_POINT 489 ac[0] += SHR32(ac[0],13); 490 #else 491 ac[0] *= 1.0001f; 492 #endif 493 /* Use lag windowing to stabilize the Levinson-Durbin recursion. */ 494 for (i=1;i<=LPC_ORDER;i++) 495 { 496 /*ac[i] *= exp(-.5*(2*M_PI*.002*i)*(2*M_PI*.002*i));*/ 497 #ifdef FIXED_POINT 498 ac[i] -= MULT16_32_Q15(2*i*i, ac[i]); 499 #else 500 ac[i] -= ac[i]*(0.008f*0.008f)*i*i; 501 #endif 502 } 503 _celt_lpc(lpc+c*LPC_ORDER, ac, LPC_ORDER); 504 } 505 /* We want the excitation for 2 pitch periods in order to look for a 506 decaying signal, but we can't get more than MAX_PERIOD. */ 507 exc_length = IMIN(2*pitch_index, MAX_PERIOD); 508 /* Initialize the LPC history with the samples just before the start 509 of the region for which we're computing the excitation. */ 510 { 511 opus_val16 lpc_mem[LPC_ORDER]; 512 for (i=0;i<LPC_ORDER;i++) 513 { 514 lpc_mem[i] = 515 ROUND16(buf[DECODE_BUFFER_SIZE-exc_length-1-i], SIG_SHIFT); 516 } 517 /* Compute the excitation for exc_length samples before the loss. */ 518 celt_fir(exc+MAX_PERIOD-exc_length, lpc+c*LPC_ORDER, 519 exc+MAX_PERIOD-exc_length, exc_length, LPC_ORDER, lpc_mem); 520 } 521 522 /* Check if the waveform is decaying, and if so how fast. 523 We do this to avoid adding energy when concealing in a segment 524 with decaying energy. */ 525 { 526 opus_val32 E1=1, E2=1; 527 int decay_length; 528 #ifdef FIXED_POINT 529 int shift = IMAX(0,2*celt_zlog2(celt_maxabs16(&exc[MAX_PERIOD-exc_length], exc_length))-20); 530 #endif 531 decay_length = exc_length>>1; 532 for (i=0;i<decay_length;i++) 533 { 534 opus_val16 e; 535 e = exc[MAX_PERIOD-decay_length+i]; 536 E1 += SHR32(MULT16_16(e, e), shift); 537 e = exc[MAX_PERIOD-2*decay_length+i]; 538 E2 += SHR32(MULT16_16(e, e), shift); 539 } 540 E1 = MIN32(E1, E2); 541 decay = celt_sqrt(frac_div32(SHR32(E1, 1), E2)); 542 } 543 544 /* Move the decoder memory one frame to the left to give us room to 545 add the data for the new frame. We ignore the overlap that extends 546 past the end of the buffer, because we aren't going to use it. */ 547 OPUS_MOVE(buf, buf+N, DECODE_BUFFER_SIZE-N); 548 549 /* Extrapolate from the end of the excitation with a period of 550 "pitch_index", scaling down each period by an additional factor of 551 "decay". */ 552 extrapolation_offset = MAX_PERIOD-pitch_index; 553 /* We need to extrapolate enough samples to cover a complete MDCT 554 window (including overlap/2 samples on both sides). */ 555 extrapolation_len = N+overlap; 556 /* We also apply fading if this is not the first loss. */ 557 attenuation = MULT16_16_Q15(fade, decay); 558 for (i=j=0;i<extrapolation_len;i++,j++) 559 { 560 opus_val16 tmp; 561 if (j >= pitch_index) { 562 j -= pitch_index; 563 attenuation = MULT16_16_Q15(attenuation, decay); 564 } 565 buf[DECODE_BUFFER_SIZE-N+i] = 566 SHL32(EXTEND32(MULT16_16_Q15(attenuation, 567 exc[extrapolation_offset+j])), SIG_SHIFT); 568 /* Compute the energy of the previously decoded signal whose 569 excitation we're copying. */ 570 tmp = ROUND16( 571 buf[DECODE_BUFFER_SIZE-MAX_PERIOD-N+extrapolation_offset+j], 572 SIG_SHIFT); 573 S1 += SHR32(MULT16_16(tmp, tmp), 8); 574 } 575 576 { 577 opus_val16 lpc_mem[LPC_ORDER]; 578 /* Copy the last decoded samples (prior to the overlap region) to 579 synthesis filter memory so we can have a continuous signal. */ 580 for (i=0;i<LPC_ORDER;i++) 581 lpc_mem[i] = ROUND16(buf[DECODE_BUFFER_SIZE-N-1-i], SIG_SHIFT); 582 /* Apply the synthesis filter to convert the excitation back into 583 the signal domain. */ 584 celt_iir(buf+DECODE_BUFFER_SIZE-N, lpc+c*LPC_ORDER, 585 buf+DECODE_BUFFER_SIZE-N, extrapolation_len, LPC_ORDER, 586 lpc_mem); 587 } 588 589 /* Check if the synthesis energy is higher than expected, which can 590 happen with the signal changes during our window. If so, 591 attenuate. */ 592 { 593 opus_val32 S2=0; 594 for (i=0;i<extrapolation_len;i++) 595 { 596 opus_val16 tmp = ROUND16(buf[DECODE_BUFFER_SIZE-N+i], SIG_SHIFT); 597 S2 += SHR32(MULT16_16(tmp, tmp), 8); 598 } 599 /* This checks for an "explosion" in the synthesis. */ 600 #ifdef FIXED_POINT 601 if (!(S1 > SHR32(S2,2))) 602 #else 603 /* The float test is written this way to catch NaNs in the output 604 of the IIR filter at the same time. */ 605 if (!(S1 > 0.2f*S2)) 606 #endif 607 { 608 for (i=0;i<extrapolation_len;i++) 609 buf[DECODE_BUFFER_SIZE-N+i] = 0; 610 } else if (S1 < S2) 611 { 612 opus_val16 ratio = celt_sqrt(frac_div32(SHR32(S1,1)+1,S2+1)); 613 for (i=0;i<overlap;i++) 614 { 615 opus_val16 tmp_g = Q15ONE 616 - MULT16_16_Q15(window[i], Q15ONE-ratio); 617 buf[DECODE_BUFFER_SIZE-N+i] = 618 MULT16_32_Q15(tmp_g, buf[DECODE_BUFFER_SIZE-N+i]); 619 } 620 for (i=overlap;i<extrapolation_len;i++) 621 { 622 buf[DECODE_BUFFER_SIZE-N+i] = 623 MULT16_32_Q15(ratio, buf[DECODE_BUFFER_SIZE-N+i]); 624 } 625 } 626 } 627 628 /* Apply the pre-filter to the MDCT overlap for the next frame because 629 the post-filter will be re-applied in the decoder after the MDCT 630 overlap. */ 631 comb_filter(etmp, buf+DECODE_BUFFER_SIZE, 632 st->postfilter_period, st->postfilter_period, overlap, 633 -st->postfilter_gain, -st->postfilter_gain, 634 st->postfilter_tapset, st->postfilter_tapset, NULL, 0); 635 636 /* Simulate TDAC on the concealed audio so that it blends with the 637 MDCT of the next frame. */ 638 for (i=0;i<overlap/2;i++) 639 { 640 buf[DECODE_BUFFER_SIZE+i] = 641 MULT16_32_Q15(window[i], etmp[overlap-1-i]) 642 + MULT16_32_Q15(window[overlap-i-1], etmp[i]); 643 } 644 } while (++c<C); 645 } 646 647 deemphasis(out_syn, pcm, N, C, downsample, 648 mode->preemph, st->preemph_memD, scratch); 649 650 st->loss_count = loss_count+1; 651 652 RESTORE_STACK; 653 } 654 655 int celt_decode_with_ec(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, opus_val16 * OPUS_RESTRICT pcm, int frame_size, ec_dec *dec) 656 { 657 int c, i, N; 658 int spread_decision; 659 opus_int32 bits; 660 ec_dec _dec; 661 VARDECL(celt_sig, freq); 662 VARDECL(celt_norm, X); 663 VARDECL(int, fine_quant); 664 VARDECL(int, pulses); 665 VARDECL(int, cap); 666 VARDECL(int, offsets); 667 VARDECL(int, fine_priority); 668 VARDECL(int, tf_res); 669 VARDECL(unsigned char, collapse_masks); 670 celt_sig *decode_mem[2]; 671 celt_sig *out_syn[2]; 672 opus_val16 *lpc; 673 opus_val16 *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE; 674 675 int shortBlocks; 676 int isTransient; 677 int intra_ener; 678 const int CC = st->channels; 679 int LM, M; 680 int effEnd; 681 int codedBands; 682 int alloc_trim; 683 int postfilter_pitch; 684 opus_val16 postfilter_gain; 685 int intensity=0; 686 int dual_stereo=0; 687 opus_int32 total_bits; 688 opus_int32 balance; 689 opus_int32 tell; 690 int dynalloc_logp; 691 int postfilter_tapset; 692 int anti_collapse_rsv; 693 int anti_collapse_on=0; 694 int silence; 695 int C = st->stream_channels; 696 const OpusCustomMode *mode; 697 int nbEBands; 698 int overlap; 699 const opus_int16 *eBands; 700 ALLOC_STACK; 701 702 mode = st->mode; 703 nbEBands = mode->nbEBands; 704 overlap = mode->overlap; 705 eBands = mode->eBands; 706 frame_size *= st->downsample; 707 708 c=0; do { 709 decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+overlap); 710 } while (++c<CC); 711 lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+overlap)*CC); 712 oldBandE = lpc+CC*LPC_ORDER; 713 oldLogE = oldBandE + 2*nbEBands; 714 oldLogE2 = oldLogE + 2*nbEBands; 715 backgroundLogE = oldLogE2 + 2*nbEBands; 716 717 #ifdef CUSTOM_MODES 718 if (st->signalling && data!=NULL) 719 { 720 int data0=data[0]; 721 /* Convert "standard mode" to Opus header */ 722 if (mode->Fs==48000 && mode->shortMdctSize==120) 723 { 724 data0 = fromOpus(data0); 725 if (data0<0) 726 return OPUS_INVALID_PACKET; 727 } 728 st->end = IMAX(1, mode->effEBands-2*(data0>>5)); 729 LM = (data0>>3)&0x3; 730 C = 1 + ((data0>>2)&0x1); 731 data++; 732 len--; 733 if (LM>mode->maxLM) 734 return OPUS_INVALID_PACKET; 735 if (frame_size < mode->shortMdctSize<<LM) 736 return OPUS_BUFFER_TOO_SMALL; 737 else 738 frame_size = mode->shortMdctSize<<LM; 739 } else { 740 #else 741 { 742 #endif 743 for (LM=0;LM<=mode->maxLM;LM++) 744 if (mode->shortMdctSize<<LM==frame_size) 745 break; 746 if (LM>mode->maxLM) 747 return OPUS_BAD_ARG; 748 } 749 M=1<<LM; 750 751 if (len<0 || len>1275 || pcm==NULL) 752 return OPUS_BAD_ARG; 753 754 N = M*mode->shortMdctSize; 755 756 effEnd = st->end; 757 if (effEnd > mode->effEBands) 758 effEnd = mode->effEBands; 759 760 if (data == NULL || len<=1) 761 { 762 celt_decode_lost(st, pcm, N, LM); 763 RESTORE_STACK; 764 return frame_size/st->downsample; 765 } 766 767 if (dec == NULL) 768 { 769 ec_dec_init(&_dec,(unsigned char*)data,len); 770 dec = &_dec; 771 } 772 773 if (C==1) 774 { 775 for (i=0;i<nbEBands;i++) 776 oldBandE[i]=MAX16(oldBandE[i],oldBandE[nbEBands+i]); 777 } 778 779 total_bits = len*8; 780 tell = ec_tell(dec); 781 782 if (tell >= total_bits) 783 silence = 1; 784 else if (tell==1) 785 silence = ec_dec_bit_logp(dec, 15); 786 else 787 silence = 0; 788 if (silence) 789 { 790 /* Pretend we've read all the remaining bits */ 791 tell = len*8; 792 dec->nbits_total+=tell-ec_tell(dec); 793 } 794 795 postfilter_gain = 0; 796 postfilter_pitch = 0; 797 postfilter_tapset = 0; 798 if (st->start==0 && tell+16 <= total_bits) 799 { 800 if(ec_dec_bit_logp(dec, 1)) 801 { 802 int qg, octave; 803 octave = ec_dec_uint(dec, 6); 804 postfilter_pitch = (16<<octave)+ec_dec_bits(dec, 4+octave)-1; 805 qg = ec_dec_bits(dec, 3); 806 if (ec_tell(dec)+2<=total_bits) 807 postfilter_tapset = ec_dec_icdf(dec, tapset_icdf, 2); 808 postfilter_gain = QCONST16(.09375f,15)*(qg+1); 809 } 810 tell = ec_tell(dec); 811 } 812 813 if (LM > 0 && tell+3 <= total_bits) 814 { 815 isTransient = ec_dec_bit_logp(dec, 3); 816 tell = ec_tell(dec); 817 } 818 else 819 isTransient = 0; 820 821 if (isTransient) 822 shortBlocks = M; 823 else 824 shortBlocks = 0; 825 826 /* Decode the global flags (first symbols in the stream) */ 827 intra_ener = tell+3<=total_bits ? ec_dec_bit_logp(dec, 3) : 0; 828 /* Get band energies */ 829 unquant_coarse_energy(mode, st->start, st->end, oldBandE, 830 intra_ener, dec, C, LM); 831 832 ALLOC(tf_res, nbEBands, int); 833 tf_decode(st->start, st->end, isTransient, tf_res, LM, dec); 834 835 tell = ec_tell(dec); 836 spread_decision = SPREAD_NORMAL; 837 if (tell+4 <= total_bits) 838 spread_decision = ec_dec_icdf(dec, spread_icdf, 5); 839 840 ALLOC(cap, nbEBands, int); 841 842 init_caps(mode,cap,LM,C); 843 844 ALLOC(offsets, nbEBands, int); 845 846 dynalloc_logp = 6; 847 total_bits<<=BITRES; 848 tell = ec_tell_frac(dec); 849 for (i=st->start;i<st->end;i++) 850 { 851 int width, quanta; 852 int dynalloc_loop_logp; 853 int boost; 854 width = C*(eBands[i+1]-eBands[i])<<LM; 855 /* quanta is 6 bits, but no more than 1 bit/sample 856 and no less than 1/8 bit/sample */ 857 quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width)); 858 dynalloc_loop_logp = dynalloc_logp; 859 boost = 0; 860 while (tell+(dynalloc_loop_logp<<BITRES) < total_bits && boost < cap[i]) 861 { 862 int flag; 863 flag = ec_dec_bit_logp(dec, dynalloc_loop_logp); 864 tell = ec_tell_frac(dec); 865 if (!flag) 866 break; 867 boost += quanta; 868 total_bits -= quanta; 869 dynalloc_loop_logp = 1; 870 } 871 offsets[i] = boost; 872 /* Making dynalloc more likely */ 873 if (boost>0) 874 dynalloc_logp = IMAX(2, dynalloc_logp-1); 875 } 876 877 ALLOC(fine_quant, nbEBands, int); 878 alloc_trim = tell+(6<<BITRES) <= total_bits ? 879 ec_dec_icdf(dec, trim_icdf, 7) : 5; 880 881 bits = (((opus_int32)len*8)<<BITRES) - ec_tell_frac(dec) - 1; 882 anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES) ? (1<<BITRES) : 0; 883 bits -= anti_collapse_rsv; 884 885 ALLOC(pulses, nbEBands, int); 886 ALLOC(fine_priority, nbEBands, int); 887 888 codedBands = compute_allocation(mode, st->start, st->end, offsets, cap, 889 alloc_trim, &intensity, &dual_stereo, bits, &balance, pulses, 890 fine_quant, fine_priority, C, LM, dec, 0, 0, 0); 891 892 unquant_fine_energy(mode, st->start, st->end, oldBandE, fine_quant, dec, C); 893 894 /* Decode fixed codebook */ 895 ALLOC(collapse_masks, C*nbEBands, unsigned char); 896 ALLOC(X, C*N, celt_norm); /**< Interleaved normalised MDCTs */ 897 898 quant_all_bands(0, mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks, 899 NULL, pulses, shortBlocks, spread_decision, dual_stereo, intensity, tf_res, 900 len*(8<<BITRES)-anti_collapse_rsv, balance, dec, LM, codedBands, &st->rng); 901 902 if (anti_collapse_rsv > 0) 903 { 904 anti_collapse_on = ec_dec_bits(dec, 1); 905 } 906 907 unquant_energy_finalise(mode, st->start, st->end, oldBandE, 908 fine_quant, fine_priority, len*8-ec_tell(dec), dec, C); 909 910 if (anti_collapse_on) 911 anti_collapse(mode, X, collapse_masks, LM, C, N, 912 st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng); 913 914 ALLOC(freq, IMAX(CC,C)*N, celt_sig); /**< Interleaved signal MDCTs */ 915 916 if (silence) 917 { 918 for (i=0;i<C*nbEBands;i++) 919 oldBandE[i] = -QCONST16(28.f,DB_SHIFT); 920 for (i=0;i<C*N;i++) 921 freq[i] = 0; 922 } else { 923 /* Synthesis */ 924 denormalise_bands(mode, X, freq, oldBandE, st->start, effEnd, C, M); 925 } 926 c=0; do { 927 OPUS_MOVE(decode_mem[c], decode_mem[c]+N, DECODE_BUFFER_SIZE-N+overlap/2); 928 } while (++c<CC); 929 930 c=0; do { 931 int bound = M*eBands[effEnd]; 932 if (st->downsample!=1) 933 bound = IMIN(bound, N/st->downsample); 934 for (i=bound;i<N;i++) 935 freq[c*N+i] = 0; 936 } while (++c<C); 937 938 c=0; do { 939 out_syn[c] = decode_mem[c]+DECODE_BUFFER_SIZE-N; 940 } while (++c<CC); 941 942 if (CC==2&&C==1) 943 { 944 for (i=0;i<N;i++) 945 freq[N+i] = freq[i]; 946 } 947 if (CC==1&&C==2) 948 { 949 for (i=0;i<N;i++) 950 freq[i] = HALF32(ADD32(freq[i],freq[N+i])); 951 } 952 953 /* Compute inverse MDCTs */ 954 compute_inv_mdcts(mode, shortBlocks, freq, out_syn, CC, LM); 955 956 c=0; do { 957 st->postfilter_period=IMAX(st->postfilter_period, COMBFILTER_MINPERIOD); 958 st->postfilter_period_old=IMAX(st->postfilter_period_old, COMBFILTER_MINPERIOD); 959 comb_filter(out_syn[c], out_syn[c], st->postfilter_period_old, st->postfilter_period, mode->shortMdctSize, 960 st->postfilter_gain_old, st->postfilter_gain, st->postfilter_tapset_old, st->postfilter_tapset, 961 mode->window, overlap); 962 if (LM!=0) 963 comb_filter(out_syn[c]+mode->shortMdctSize, out_syn[c]+mode->shortMdctSize, st->postfilter_period, postfilter_pitch, N-mode->shortMdctSize, 964 st->postfilter_gain, postfilter_gain, st->postfilter_tapset, postfilter_tapset, 965 mode->window, overlap); 966 967 } while (++c<CC); 968 st->postfilter_period_old = st->postfilter_period; 969 st->postfilter_gain_old = st->postfilter_gain; 970 st->postfilter_tapset_old = st->postfilter_tapset; 971 st->postfilter_period = postfilter_pitch; 972 st->postfilter_gain = postfilter_gain; 973 st->postfilter_tapset = postfilter_tapset; 974 if (LM!=0) 975 { 976 st->postfilter_period_old = st->postfilter_period; 977 st->postfilter_gain_old = st->postfilter_gain; 978 st->postfilter_tapset_old = st->postfilter_tapset; 979 } 980 981 if (C==1) { 982 for (i=0;i<nbEBands;i++) 983 oldBandE[nbEBands+i]=oldBandE[i]; 984 } 985 986 /* In case start or end were to change */ 987 if (!isTransient) 988 { 989 for (i=0;i<2*nbEBands;i++) 990 oldLogE2[i] = oldLogE[i]; 991 for (i=0;i<2*nbEBands;i++) 992 oldLogE[i] = oldBandE[i]; 993 for (i=0;i<2*nbEBands;i++) 994 backgroundLogE[i] = MIN16(backgroundLogE[i] + M*QCONST16(0.001f,DB_SHIFT), oldBandE[i]); 995 } else { 996 for (i=0;i<2*nbEBands;i++) 997 oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]); 998 } 999 c=0; do 1000 { 1001 for (i=0;i<st->start;i++) 1002 { 1003 oldBandE[c*nbEBands+i]=0; 1004 oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT); 1005 } 1006 for (i=st->end;i<nbEBands;i++) 1007 { 1008 oldBandE[c*nbEBands+i]=0; 1009 oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT); 1010 } 1011 } while (++c<2); 1012 st->rng = dec->rng; 1013 1014 /* We reuse freq[] as scratch space for the de-emphasis */ 1015 deemphasis(out_syn, pcm, N, CC, st->downsample, mode->preemph, st->preemph_memD, freq); 1016 st->loss_count = 0; 1017 RESTORE_STACK; 1018 if (ec_tell(dec) > 8*len) 1019 return OPUS_INTERNAL_ERROR; 1020 if(ec_get_error(dec)) 1021 st->error = 1; 1022 return frame_size/st->downsample; 1023 } 1024 1025 1026 #ifdef CUSTOM_MODES 1027 1028 #ifdef FIXED_POINT 1029 int opus_custom_decode(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, opus_int16 * OPUS_RESTRICT pcm, int frame_size) 1030 { 1031 return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL); 1032 } 1033 1034 #ifndef DISABLE_FLOAT_API 1035 int opus_custom_decode_float(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, float * OPUS_RESTRICT pcm, int frame_size) 1036 { 1037 int j, ret, C, N; 1038 VARDECL(opus_int16, out); 1039 ALLOC_STACK; 1040 1041 if (pcm==NULL) 1042 return OPUS_BAD_ARG; 1043 1044 C = st->channels; 1045 N = frame_size; 1046 1047 ALLOC(out, C*N, opus_int16); 1048 ret=celt_decode_with_ec(st, data, len, out, frame_size, NULL); 1049 if (ret>0) 1050 for (j=0;j<C*ret;j++) 1051 pcm[j]=out[j]*(1.f/32768.f); 1052 1053 RESTORE_STACK; 1054 return ret; 1055 } 1056 #endif /* DISABLE_FLOAT_API */ 1057 1058 #else 1059 1060 int opus_custom_decode_float(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, float * OPUS_RESTRICT pcm, int frame_size) 1061 { 1062 return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL); 1063 } 1064 1065 int opus_custom_decode(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, opus_int16 * OPUS_RESTRICT pcm, int frame_size) 1066 { 1067 int j, ret, C, N; 1068 VARDECL(celt_sig, out); 1069 ALLOC_STACK; 1070 1071 if (pcm==NULL) 1072 return OPUS_BAD_ARG; 1073 1074 C = st->channels; 1075 N = frame_size; 1076 ALLOC(out, C*N, celt_sig); 1077 1078 ret=celt_decode_with_ec(st, data, len, out, frame_size, NULL); 1079 1080 if (ret>0) 1081 for (j=0;j<C*ret;j++) 1082 pcm[j] = FLOAT2INT16 (out[j]); 1083 1084 RESTORE_STACK; 1085 return ret; 1086 } 1087 1088 #endif 1089 #endif /* CUSTOM_MODES */ 1090 1091 int opus_custom_decoder_ctl(CELTDecoder * OPUS_RESTRICT st, int request, ...) 1092 { 1093 va_list ap; 1094 1095 va_start(ap, request); 1096 switch (request) 1097 { 1098 case CELT_SET_START_BAND_REQUEST: 1099 { 1100 opus_int32 value = va_arg(ap, opus_int32); 1101 if (value<0 || value>=st->mode->nbEBands) 1102 goto bad_arg; 1103 st->start = value; 1104 } 1105 break; 1106 case CELT_SET_END_BAND_REQUEST: 1107 { 1108 opus_int32 value = va_arg(ap, opus_int32); 1109 if (value<1 || value>st->mode->nbEBands) 1110 goto bad_arg; 1111 st->end = value; 1112 } 1113 break; 1114 case CELT_SET_CHANNELS_REQUEST: 1115 { 1116 opus_int32 value = va_arg(ap, opus_int32); 1117 if (value<1 || value>2) 1118 goto bad_arg; 1119 st->stream_channels = value; 1120 } 1121 break; 1122 case CELT_GET_AND_CLEAR_ERROR_REQUEST: 1123 { 1124 opus_int32 *value = va_arg(ap, opus_int32*); 1125 if (value==NULL) 1126 goto bad_arg; 1127 *value=st->error; 1128 st->error = 0; 1129 } 1130 break; 1131 case OPUS_GET_LOOKAHEAD_REQUEST: 1132 { 1133 opus_int32 *value = va_arg(ap, opus_int32*); 1134 if (value==NULL) 1135 goto bad_arg; 1136 *value = st->overlap/st->downsample; 1137 } 1138 break; 1139 case OPUS_RESET_STATE: 1140 { 1141 int i; 1142 opus_val16 *lpc, *oldBandE, *oldLogE, *oldLogE2; 1143 lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*st->channels); 1144 oldBandE = lpc+st->channels*LPC_ORDER; 1145 oldLogE = oldBandE + 2*st->mode->nbEBands; 1146 oldLogE2 = oldLogE + 2*st->mode->nbEBands; 1147 OPUS_CLEAR((char*)&st->DECODER_RESET_START, 1148 opus_custom_decoder_get_size(st->mode, st->channels)- 1149 ((char*)&st->DECODER_RESET_START - (char*)st)); 1150 for (i=0;i<2*st->mode->nbEBands;i++) 1151 oldLogE[i]=oldLogE2[i]=-QCONST16(28.f,DB_SHIFT); 1152 } 1153 break; 1154 case OPUS_GET_PITCH_REQUEST: 1155 { 1156 opus_int32 *value = va_arg(ap, opus_int32*); 1157 if (value==NULL) 1158 goto bad_arg; 1159 *value = st->postfilter_period; 1160 } 1161 break; 1162 case CELT_GET_MODE_REQUEST: 1163 { 1164 const CELTMode ** value = va_arg(ap, const CELTMode**); 1165 if (value==0) 1166 goto bad_arg; 1167 *value=st->mode; 1168 } 1169 break; 1170 case CELT_SET_SIGNALLING_REQUEST: 1171 { 1172 opus_int32 value = va_arg(ap, opus_int32); 1173 st->signalling = value; 1174 } 1175 break; 1176 case OPUS_GET_FINAL_RANGE_REQUEST: 1177 { 1178 opus_uint32 * value = va_arg(ap, opus_uint32 *); 1179 if (value==0) 1180 goto bad_arg; 1181 *value=st->rng; 1182 } 1183 break; 1184 default: 1185 goto bad_request; 1186 } 1187 va_end(ap); 1188 return OPUS_OK; 1189 bad_arg: 1190 va_end(ap); 1191 return OPUS_BAD_ARG; 1192 bad_request: 1193 va_end(ap); 1194 return OPUS_UNIMPLEMENTED; 1195 } 1196
