celt_decoder.c (61451B)
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 #ifdef ENABLE_DEEP_PLC 55 #include "lpcnet.h" 56 #include "lpcnet_private.h" 57 #endif 58 59 /* The maximum pitch lag to allow in the pitch-based PLC. It's possible to save 60 CPU time in the PLC pitch search by making this smaller than MAX_PERIOD. The 61 current value corresponds to a pitch of 66.67 Hz. */ 62 #define PLC_PITCH_LAG_MAX (720) 63 /* The minimum pitch lag to allow in the pitch-based PLC. This corresponds to a 64 pitch of 480 Hz. */ 65 #define PLC_PITCH_LAG_MIN (100) 66 67 #define FRAME_NONE 0 68 #define FRAME_NORMAL 1 69 #define FRAME_PLC_NOISE 2 70 #define FRAME_PLC_PERIODIC 3 71 #define FRAME_PLC_NEURAL 4 72 #define FRAME_DRED 5 73 74 /**********************************************************************/ 75 /* */ 76 /* DECODER */ 77 /* */ 78 /**********************************************************************/ 79 #define DECODE_BUFFER_SIZE DEC_PITCH_BUF_SIZE 80 81 #define PLC_UPDATE_FRAMES 4 82 #define PLC_UPDATE_SAMPLES (PLC_UPDATE_FRAMES*FRAME_SIZE) 83 84 /** Decoder state 85 @brief Decoder state 86 */ 87 struct OpusCustomDecoder { 88 const OpusCustomMode *mode; 89 int overlap; 90 int channels; 91 int stream_channels; 92 93 int downsample; 94 int start, end; 95 int signalling; 96 int disable_inv; 97 int complexity; 98 int arch; 99 #ifdef ENABLE_QEXT 100 int qext_scale; 101 #endif 102 103 /* Everything beyond this point gets cleared on a reset */ 104 #define DECODER_RESET_START rng 105 106 opus_uint32 rng; 107 int error; 108 int last_pitch_index; 109 int loss_duration; 110 int plc_duration; 111 int last_frame_type; 112 int skip_plc; 113 int postfilter_period; 114 int postfilter_period_old; 115 opus_val16 postfilter_gain; 116 opus_val16 postfilter_gain_old; 117 int postfilter_tapset; 118 int postfilter_tapset_old; 119 int prefilter_and_fold; 120 121 celt_sig preemph_memD[2]; 122 123 #ifdef ENABLE_DEEP_PLC 124 opus_int16 plc_pcm[PLC_UPDATE_SAMPLES]; 125 int plc_fill; 126 float plc_preemphasis_mem; 127 #endif 128 129 #ifdef ENABLE_QEXT 130 celt_glog qext_oldBandE[2*NB_QEXT_BANDS]; 131 #endif 132 133 celt_sig _decode_mem[1]; /* Size = channels*(DECODE_BUFFER_SIZE+mode->overlap) */ 134 /* celt_glog oldEBands[], Size = 2*mode->nbEBands */ 135 /* celt_glog oldLogE[], Size = 2*mode->nbEBands */ 136 /* celt_glog oldLogE2[], Size = 2*mode->nbEBands */ 137 /* celt_glog backgroundLogE[], Size = 2*mode->nbEBands */ 138 /* opus_val16 lpc[], Size = channels*CELT_LPC_ORDER */ 139 }; 140 141 #if defined(ENABLE_HARDENING) || defined(ENABLE_ASSERTIONS) 142 /* Make basic checks on the CELT state to ensure we don't end 143 up writing all over memory. */ 144 void validate_celt_decoder(CELTDecoder *st) 145 { 146 #if !defined(CUSTOM_MODES) && !defined(ENABLE_OPUS_CUSTOM_API) && !defined(ENABLE_QEXT) 147 celt_assert(st->mode == opus_custom_mode_create(48000, 960, NULL)); 148 celt_assert(st->overlap == 120); 149 celt_assert(st->end <= 21); 150 #else 151 /* From Section 4.3 in the spec: "The normal CELT layer uses 21 of those bands, 152 though Opus Custom (see Section 6.2) may use a different number of bands" 153 154 Check if it's within the maximum number of Bark frequency bands instead */ 155 celt_assert(st->end <= 25); 156 #endif 157 celt_assert(st->channels == 1 || st->channels == 2); 158 celt_assert(st->stream_channels == 1 || st->stream_channels == 2); 159 celt_assert(st->downsample > 0); 160 celt_assert(st->start == 0 || st->start == 17); 161 celt_assert(st->start < st->end); 162 #ifdef OPUS_ARCHMASK 163 celt_assert(st->arch >= 0); 164 celt_assert(st->arch <= OPUS_ARCHMASK); 165 #endif 166 #ifndef ENABLE_QEXT 167 celt_assert(st->last_pitch_index <= PLC_PITCH_LAG_MAX); 168 celt_assert(st->last_pitch_index >= PLC_PITCH_LAG_MIN || st->last_pitch_index == 0); 169 #endif 170 celt_assert(st->postfilter_period < MAX_PERIOD); 171 celt_assert(st->postfilter_period >= COMBFILTER_MINPERIOD || st->postfilter_period == 0); 172 celt_assert(st->postfilter_period_old < MAX_PERIOD); 173 celt_assert(st->postfilter_period_old >= COMBFILTER_MINPERIOD || st->postfilter_period_old == 0); 174 celt_assert(st->postfilter_tapset <= 2); 175 celt_assert(st->postfilter_tapset >= 0); 176 celt_assert(st->postfilter_tapset_old <= 2); 177 celt_assert(st->postfilter_tapset_old >= 0); 178 } 179 #endif 180 181 int celt_decoder_get_size(int channels) 182 { 183 #ifdef ENABLE_QEXT 184 const CELTMode *mode = opus_custom_mode_create(96000, 960, NULL); 185 #else 186 const CELTMode *mode = opus_custom_mode_create(48000, 960, NULL); 187 #endif 188 return opus_custom_decoder_get_size(mode, channels); 189 } 190 191 OPUS_CUSTOM_NOSTATIC int opus_custom_decoder_get_size(const CELTMode *mode, int channels) 192 { 193 int size; 194 #ifdef ENABLE_QEXT 195 int qext_scale; 196 if (mode->Fs == 96000 && (mode->shortMdctSize==240 || mode->shortMdctSize==180)) { 197 qext_scale = 2; 198 } else qext_scale = 1; 199 #endif 200 size = sizeof(struct CELTDecoder) 201 + (channels*(QEXT_SCALE(DECODE_BUFFER_SIZE)+mode->overlap)-1)*sizeof(celt_sig) 202 + 4*2*mode->nbEBands*sizeof(celt_glog) 203 + channels*CELT_LPC_ORDER*sizeof(opus_val16); 204 return size; 205 } 206 207 #if defined(CUSTOM_MODES) || defined(ENABLE_OPUS_CUSTOM_API) 208 CELTDecoder *opus_custom_decoder_create(const CELTMode *mode, int channels, int *error) 209 { 210 int ret; 211 CELTDecoder *st = (CELTDecoder *)opus_alloc(opus_custom_decoder_get_size(mode, channels)); 212 ret = opus_custom_decoder_init(st, mode, channels); 213 if (ret != OPUS_OK) 214 { 215 opus_custom_decoder_destroy(st); 216 st = NULL; 217 } 218 if (error) 219 *error = ret; 220 return st; 221 } 222 #endif /* CUSTOM_MODES */ 223 224 int celt_decoder_init(CELTDecoder *st, opus_int32 sampling_rate, int channels) 225 { 226 int ret; 227 #ifdef ENABLE_QEXT 228 if (sampling_rate == 96000) { 229 return opus_custom_decoder_init(st, opus_custom_mode_create(96000, 960, NULL), channels); 230 } 231 #endif 232 ret = opus_custom_decoder_init(st, opus_custom_mode_create(48000, 960, NULL), channels); 233 if (ret != OPUS_OK) 234 return ret; 235 st->downsample = resampling_factor(sampling_rate); 236 if (st->downsample==0) 237 return OPUS_BAD_ARG; 238 else 239 return OPUS_OK; 240 } 241 242 OPUS_CUSTOM_NOSTATIC int opus_custom_decoder_init(CELTDecoder *st, const CELTMode *mode, int channels) 243 { 244 if (channels < 0 || channels > 2) 245 return OPUS_BAD_ARG; 246 247 if (st==NULL) 248 return OPUS_ALLOC_FAIL; 249 250 OPUS_CLEAR((char*)st, opus_custom_decoder_get_size(mode, channels)); 251 252 st->mode = mode; 253 st->overlap = mode->overlap; 254 st->stream_channels = st->channels = channels; 255 256 st->downsample = 1; 257 st->start = 0; 258 st->end = st->mode->effEBands; 259 st->signalling = 1; 260 #ifndef DISABLE_UPDATE_DRAFT 261 st->disable_inv = channels == 1; 262 #else 263 st->disable_inv = 0; 264 #endif 265 st->arch = opus_select_arch(); 266 267 #ifdef ENABLE_QEXT 268 if (st->mode->Fs == 96000 && (mode->shortMdctSize==240 || mode->shortMdctSize==180)) st->qext_scale = 2; 269 else st->qext_scale = 1; 270 #endif 271 272 opus_custom_decoder_ctl(st, OPUS_RESET_STATE); 273 274 return OPUS_OK; 275 } 276 277 #if defined(CUSTOM_MODES) || defined(ENABLE_OPUS_CUSTOM_API) 278 void opus_custom_decoder_destroy(CELTDecoder *st) 279 { 280 opus_free(st); 281 } 282 #endif /* CUSTOM_MODES */ 283 284 #if !defined(CUSTOM_MODES) && !defined(ENABLE_OPUS_CUSTOM_API) && !defined(ENABLE_QEXT) 285 /* Special case for stereo with no downsampling and no accumulation. This is 286 quite common and we can make it faster by processing both channels in the 287 same loop, reducing overhead due to the dependency loop in the IIR filter. */ 288 static void deemphasis_stereo_simple(celt_sig *in[], opus_res *pcm, int N, const opus_val16 coef0, 289 celt_sig *mem) 290 { 291 celt_sig * OPUS_RESTRICT x0; 292 celt_sig * OPUS_RESTRICT x1; 293 celt_sig m0, m1; 294 int j; 295 x0=in[0]; 296 x1=in[1]; 297 m0 = mem[0]; 298 m1 = mem[1]; 299 for (j=0;j<N;j++) 300 { 301 celt_sig tmp0, tmp1; 302 /* Add VERY_SMALL to x[] first to reduce dependency chain. */ 303 tmp0 = SATURATE(x0[j] + VERY_SMALL + m0, SIG_SAT); 304 tmp1 = SATURATE(x1[j] + VERY_SMALL + m1, SIG_SAT); 305 m0 = MULT16_32_Q15(coef0, tmp0); 306 m1 = MULT16_32_Q15(coef0, tmp1); 307 pcm[2*j ] = SIG2RES(tmp0); 308 pcm[2*j+1] = SIG2RES(tmp1); 309 } 310 mem[0] = m0; 311 mem[1] = m1; 312 } 313 #endif 314 315 #ifndef RESYNTH 316 static 317 #endif 318 void deemphasis(celt_sig *in[], opus_res *pcm, int N, int C, int downsample, const opus_val16 *coef, 319 celt_sig *mem, int accum) 320 { 321 int c; 322 int Nd; 323 int apply_downsampling=0; 324 opus_val16 coef0; 325 VARDECL(celt_sig, scratch); 326 SAVE_STACK; 327 #if !defined(CUSTOM_MODES) && !defined(ENABLE_OPUS_CUSTOM_API) && !defined(ENABLE_QEXT) 328 /* Short version for common case. */ 329 if (downsample == 1 && C == 2 && !accum) 330 { 331 deemphasis_stereo_simple(in, pcm, N, coef[0], mem); 332 return; 333 } 334 #endif 335 ALLOC(scratch, N, celt_sig); 336 coef0 = coef[0]; 337 Nd = N/downsample; 338 c=0; do { 339 int j; 340 celt_sig * OPUS_RESTRICT x; 341 opus_res * OPUS_RESTRICT y; 342 celt_sig m = mem[c]; 343 x =in[c]; 344 y = pcm+c; 345 #if defined(CUSTOM_MODES) || defined(ENABLE_OPUS_CUSTOM_API) || defined(ENABLE_QEXT) 346 if (coef[1] != 0) 347 { 348 opus_val16 coef1 = coef[1]; 349 opus_val16 coef3 = coef[3]; 350 for (j=0;j<N;j++) 351 { 352 celt_sig tmp = SATURATE(x[j] + m + VERY_SMALL, SIG_SAT); 353 m = MULT16_32_Q15(coef0, tmp) 354 - MULT16_32_Q15(coef1, x[j]); 355 tmp = SHL32(MULT16_32_Q15(coef3, tmp), 2); 356 scratch[j] = tmp; 357 } 358 apply_downsampling=1; 359 } else 360 #endif 361 if (downsample>1) 362 { 363 /* Shortcut for the standard (non-custom modes) case */ 364 for (j=0;j<N;j++) 365 { 366 celt_sig tmp = SATURATE(x[j] + VERY_SMALL + m, SIG_SAT); 367 m = MULT16_32_Q15(coef0, tmp); 368 scratch[j] = tmp; 369 } 370 apply_downsampling=1; 371 } else { 372 /* Shortcut for the standard (non-custom modes) case */ 373 if (accum) 374 { 375 for (j=0;j<N;j++) 376 { 377 celt_sig tmp = SATURATE(x[j] + m + VERY_SMALL, SIG_SAT); 378 m = MULT16_32_Q15(coef0, tmp); 379 y[j*C] = ADD_RES(y[j*C], SIG2RES(tmp)); 380 } 381 } else 382 { 383 for (j=0;j<N;j++) 384 { 385 celt_sig tmp = SATURATE(x[j] + VERY_SMALL + m, SIG_SAT); 386 m = MULT16_32_Q15(coef0, tmp); 387 y[j*C] = SIG2RES(tmp); 388 } 389 } 390 } 391 mem[c] = m; 392 393 if (apply_downsampling) 394 { 395 /* Perform down-sampling */ 396 if (accum) 397 { 398 for (j=0;j<Nd;j++) 399 y[j*C] = ADD_RES(y[j*C], SIG2RES(scratch[j*downsample])); 400 } else 401 { 402 for (j=0;j<Nd;j++) 403 y[j*C] = SIG2RES(scratch[j*downsample]); 404 } 405 } 406 } while (++c<C); 407 RESTORE_STACK; 408 } 409 410 #ifndef RESYNTH 411 static 412 #endif 413 void celt_synthesis(const CELTMode *mode, celt_norm *X, celt_sig * out_syn[], 414 celt_glog *oldBandE, int start, int effEnd, int C, int CC, 415 int isTransient, int LM, int downsample, 416 int silence, int arch ARG_QEXT(const CELTMode *qext_mode) ARG_QEXT(const celt_glog *qext_bandLogE) ARG_QEXT(int qext_end)) 417 { 418 int c, i; 419 int M; 420 int b; 421 int B; 422 int N, NB; 423 int shift; 424 int nbEBands; 425 int overlap; 426 VARDECL(celt_sig, freq); 427 SAVE_STACK; 428 429 overlap = mode->overlap; 430 nbEBands = mode->nbEBands; 431 N = mode->shortMdctSize<<LM; 432 ALLOC(freq, N, celt_sig); /**< Interleaved signal MDCTs */ 433 M = 1<<LM; 434 #ifdef ENABLE_QEXT 435 if (mode->Fs != 96000) qext_end=2; 436 #endif 437 438 if (isTransient) 439 { 440 B = M; 441 NB = mode->shortMdctSize; 442 shift = mode->maxLM; 443 } else { 444 B = 1; 445 NB = mode->shortMdctSize<<LM; 446 shift = mode->maxLM-LM; 447 } 448 449 if (CC==2&&C==1) 450 { 451 /* Copying a mono streams to two channels */ 452 celt_sig *freq2; 453 denormalise_bands(mode, X, freq, oldBandE, start, effEnd, M, 454 downsample, silence); 455 #ifdef ENABLE_QEXT 456 if (qext_mode) 457 denormalise_bands(qext_mode, X, freq, qext_bandLogE, 0, qext_end, M, 458 downsample, silence); 459 #endif 460 /* Store a temporary copy in the output buffer because the IMDCT destroys its input. */ 461 freq2 = out_syn[1]+overlap/2; 462 OPUS_COPY(freq2, freq, N); 463 for (b=0;b<B;b++) 464 clt_mdct_backward(&mode->mdct, &freq2[b], out_syn[0]+NB*b, mode->window, overlap, shift, B, arch); 465 for (b=0;b<B;b++) 466 clt_mdct_backward(&mode->mdct, &freq[b], out_syn[1]+NB*b, mode->window, overlap, shift, B, arch); 467 } else if (CC==1&&C==2) 468 { 469 /* Downmixing a stereo stream to mono */ 470 celt_sig *freq2; 471 freq2 = out_syn[0]+overlap/2; 472 denormalise_bands(mode, X, freq, oldBandE, start, effEnd, M, 473 downsample, silence); 474 /* Use the output buffer as temp array before downmixing. */ 475 denormalise_bands(mode, X+N, freq2, oldBandE+nbEBands, start, effEnd, M, 476 downsample, silence); 477 #ifdef ENABLE_QEXT 478 if (qext_mode) 479 { 480 denormalise_bands(qext_mode, X, freq, qext_bandLogE, 0, qext_end, M, 481 downsample, silence); 482 denormalise_bands(qext_mode, X+N, freq2, qext_bandLogE+NB_QEXT_BANDS, 0, qext_end, M, 483 downsample, silence); 484 } 485 #endif 486 for (i=0;i<N;i++) 487 freq[i] = ADD32(HALF32(freq[i]), HALF32(freq2[i])); 488 for (b=0;b<B;b++) 489 clt_mdct_backward(&mode->mdct, &freq[b], out_syn[0]+NB*b, mode->window, overlap, shift, B, arch); 490 } else { 491 /* Normal case (mono or stereo) */ 492 c=0; do { 493 denormalise_bands(mode, X+c*N, freq, oldBandE+c*nbEBands, start, effEnd, M, 494 downsample, silence); 495 #ifdef ENABLE_QEXT 496 if (qext_mode) 497 denormalise_bands(qext_mode, X+c*N, freq, qext_bandLogE+c*NB_QEXT_BANDS, 0, qext_end, M, 498 downsample, silence); 499 #endif 500 for (b=0;b<B;b++) 501 clt_mdct_backward(&mode->mdct, &freq[b], out_syn[c]+NB*b, mode->window, overlap, shift, B, arch); 502 } while (++c<CC); 503 } 504 /* Saturate IMDCT output so that we can't overflow in the pitch postfilter 505 or in the */ 506 c=0; do { 507 for (i=0;i<N;i++) 508 out_syn[c][i] = SATURATE(out_syn[c][i], SIG_SAT); 509 } while (++c<CC); 510 RESTORE_STACK; 511 } 512 513 static void tf_decode(int start, int end, int isTransient, int *tf_res, int LM, ec_dec *dec) 514 { 515 int i, curr, tf_select; 516 int tf_select_rsv; 517 int tf_changed; 518 int logp; 519 opus_uint32 budget; 520 opus_uint32 tell; 521 522 budget = dec->storage*8; 523 tell = ec_tell(dec); 524 logp = isTransient ? 2 : 4; 525 tf_select_rsv = LM>0 && tell+logp+1<=budget; 526 budget -= tf_select_rsv; 527 tf_changed = curr = 0; 528 for (i=start;i<end;i++) 529 { 530 if (tell+logp<=budget) 531 { 532 curr ^= ec_dec_bit_logp(dec, logp); 533 tell = ec_tell(dec); 534 tf_changed |= curr; 535 } 536 tf_res[i] = curr; 537 logp = isTransient ? 4 : 5; 538 } 539 tf_select = 0; 540 if (tf_select_rsv && 541 tf_select_table[LM][4*isTransient+0+tf_changed] != 542 tf_select_table[LM][4*isTransient+2+tf_changed]) 543 { 544 tf_select = ec_dec_bit_logp(dec, 1); 545 } 546 for (i=start;i<end;i++) 547 { 548 tf_res[i] = tf_select_table[LM][4*isTransient+2*tf_select+tf_res[i]]; 549 } 550 } 551 552 static int celt_plc_pitch_search(CELTDecoder *st, celt_sig *decode_mem[2], int C, int arch) 553 { 554 int pitch_index; 555 #ifdef ENABLE_QEXT 556 int qext_scale; 557 #endif 558 VARDECL( opus_val16, lp_pitch_buf ); 559 SAVE_STACK; 560 #ifdef ENABLE_QEXT 561 qext_scale = st->qext_scale; 562 #else 563 (void)st; 564 #endif 565 ALLOC( lp_pitch_buf, DECODE_BUFFER_SIZE>>1, opus_val16 ); 566 pitch_downsample(decode_mem, lp_pitch_buf, 567 DECODE_BUFFER_SIZE>>1, C, QEXT_SCALE(2), arch); 568 pitch_search(lp_pitch_buf+(PLC_PITCH_LAG_MAX>>1), lp_pitch_buf, 569 DECODE_BUFFER_SIZE-PLC_PITCH_LAG_MAX, 570 PLC_PITCH_LAG_MAX-PLC_PITCH_LAG_MIN, &pitch_index, arch); 571 pitch_index = PLC_PITCH_LAG_MAX-pitch_index; 572 RESTORE_STACK; 573 return QEXT_SCALE(pitch_index); 574 } 575 576 static void prefilter_and_fold(CELTDecoder * OPUS_RESTRICT st, int N) 577 { 578 int c; 579 int CC; 580 int i; 581 int overlap; 582 celt_sig *decode_mem[2]; 583 const OpusCustomMode *mode; 584 int decode_buffer_size; 585 #ifdef ENABLE_QEXT 586 int qext_scale; 587 #endif 588 VARDECL(opus_val32, etmp); 589 SAVE_STACK 590 #ifdef ENABLE_QEXT 591 qext_scale = st->qext_scale; 592 #endif 593 decode_buffer_size = QEXT_SCALE(DECODE_BUFFER_SIZE); 594 mode = st->mode; 595 overlap = st->overlap; 596 CC = st->channels; 597 ALLOC(etmp, overlap, opus_val32); 598 c=0; do { 599 decode_mem[c] = st->_decode_mem + c*(decode_buffer_size+overlap); 600 } while (++c<CC); 601 602 c=0; do { 603 /* Apply the pre-filter to the MDCT overlap for the next frame because 604 the post-filter will be re-applied in the decoder after the MDCT 605 overlap. */ 606 comb_filter(etmp, decode_mem[c]+decode_buffer_size-N, 607 st->postfilter_period_old, st->postfilter_period, overlap, 608 -st->postfilter_gain_old, -st->postfilter_gain, 609 st->postfilter_tapset_old, st->postfilter_tapset, NULL, 0, st->arch); 610 611 /* Simulate TDAC on the concealed audio so that it blends with the 612 MDCT of the next frame. */ 613 for (i=0;i<overlap/2;i++) 614 { 615 decode_mem[c][decode_buffer_size-N+i] = 616 MULT16_32_Q15(COEF2VAL16(mode->window[i]), etmp[overlap-1-i]) 617 + MULT16_32_Q15 (COEF2VAL16(mode->window[overlap-i-1]), etmp[i]); 618 } 619 } while (++c<CC); 620 RESTORE_STACK; 621 } 622 623 #ifdef ENABLE_DEEP_PLC 624 625 #define SINC_ORDER 48 626 /* h=cos(pi/2*abs(sin([-24:24]/48*pi*23./24)).^2); 627 b=sinc([-24:24]/3*1.02).*h; 628 b=b/sum(b); */ 629 static const float sinc_filter[SINC_ORDER+1] = { 630 4.2931e-05f, -0.000190293f, -0.000816132f, -0.000637162f, 0.00141662f, 0.00354764f, 0.00184368f, -0.00428274f, 631 -0.00856105f, -0.0034003f, 0.00930201f, 0.0159616f, 0.00489785f, -0.0169649f, -0.0259484f, -0.00596856f, 632 0.0286551f, 0.0405872f, 0.00649994f, -0.0509284f, -0.0716655f, -0.00665212f, 0.134336f, 0.278927f, 633 0.339995f, 0.278927f, 0.134336f, -0.00665212f, -0.0716655f, -0.0509284f, 0.00649994f, 0.0405872f, 634 0.0286551f, -0.00596856f, -0.0259484f, -0.0169649f, 0.00489785f, 0.0159616f, 0.00930201f, -0.0034003f, 635 -0.00856105f, -0.00428274f, 0.00184368f, 0.00354764f, 0.00141662f, -0.000637162f, -0.000816132f, -0.000190293f, 636 4.2931e-05f 637 }; 638 639 void update_plc_state(LPCNetPLCState *lpcnet, celt_sig *decode_mem[2], float *plc_preemphasis_mem, int CC) 640 { 641 int i; 642 int tmp_read_post, tmp_fec_skip; 643 int offset; 644 celt_sig buf48k[DECODE_BUFFER_SIZE]; 645 opus_int16 buf16k[PLC_UPDATE_SAMPLES]; 646 if (CC == 1) OPUS_COPY(buf48k, decode_mem[0], DECODE_BUFFER_SIZE); 647 else { 648 for (i=0;i<DECODE_BUFFER_SIZE;i++) { 649 buf48k[i] = .5*(decode_mem[0][i] + decode_mem[1][i]); 650 } 651 } 652 /* Down-sample the last 40 ms. */ 653 for (i=1;i<DECODE_BUFFER_SIZE;i++) buf48k[i] += PREEMPHASIS*buf48k[i-1]; 654 *plc_preemphasis_mem = buf48k[DECODE_BUFFER_SIZE-1]; 655 offset = DECODE_BUFFER_SIZE-SINC_ORDER-1 - 3*(PLC_UPDATE_SAMPLES-1); 656 celt_assert(3*(PLC_UPDATE_SAMPLES-1) + SINC_ORDER + offset == DECODE_BUFFER_SIZE-1); 657 for (i=0;i<PLC_UPDATE_SAMPLES;i++) { 658 int j; 659 float sum = 0; 660 for (j=0;j<SINC_ORDER+1;j++) { 661 sum += buf48k[3*i + j + offset]*sinc_filter[j]; 662 } 663 buf16k[i] = float2int(MIN32(32767.f, MAX32(-32767.f, sum))); 664 } 665 tmp_read_post = lpcnet->fec_read_pos; 666 tmp_fec_skip = lpcnet->fec_skip; 667 for (i=0;i<PLC_UPDATE_FRAMES;i++) { 668 lpcnet_plc_update(lpcnet, &buf16k[FRAME_SIZE*i]); 669 } 670 lpcnet->fec_read_pos = tmp_read_post; 671 lpcnet->fec_skip = tmp_fec_skip; 672 } 673 #endif 674 675 static void celt_decode_lost(CELTDecoder * OPUS_RESTRICT st, int N, int LM 676 #ifdef ENABLE_DEEP_PLC 677 ,LPCNetPLCState *lpcnet 678 #endif 679 ) 680 { 681 int c; 682 int i; 683 const int C = st->channels; 684 celt_sig *decode_mem[2]; 685 celt_sig *out_syn[2]; 686 opus_val16 *lpc; 687 celt_glog *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE; 688 const OpusCustomMode *mode; 689 int nbEBands; 690 int overlap; 691 int start; 692 int loss_duration; 693 int curr_frame_type; 694 const opus_int16 *eBands; 695 int decode_buffer_size; 696 int max_period; 697 #ifdef ENABLE_QEXT 698 int qext_scale; 699 #endif 700 SAVE_STACK; 701 #ifdef ENABLE_QEXT 702 qext_scale = st->qext_scale; 703 #endif 704 decode_buffer_size = QEXT_SCALE(DECODE_BUFFER_SIZE); 705 max_period = QEXT_SCALE(MAX_PERIOD); 706 mode = st->mode; 707 nbEBands = mode->nbEBands; 708 overlap = mode->overlap; 709 eBands = mode->eBands; 710 711 c=0; do { 712 decode_mem[c] = st->_decode_mem + c*(decode_buffer_size+overlap); 713 out_syn[c] = decode_mem[c]+decode_buffer_size-N; 714 } while (++c<C); 715 oldBandE = (celt_glog*)(st->_decode_mem+(decode_buffer_size+overlap)*C); 716 oldLogE = oldBandE + 2*nbEBands; 717 oldLogE2 = oldLogE + 2*nbEBands; 718 backgroundLogE = oldLogE2 + 2*nbEBands; 719 lpc = (opus_val16*)(backgroundLogE + 2*nbEBands); 720 721 loss_duration = st->loss_duration; 722 start = st->start; 723 curr_frame_type = FRAME_PLC_PERIODIC; 724 if (st->plc_duration >= 40 || start != 0 || st->skip_plc) 725 curr_frame_type = FRAME_PLC_NOISE; 726 #ifdef ENABLE_DEEP_PLC 727 if (start == 0 && lpcnet != NULL && st->mode->Fs != 96000 && lpcnet->loaded) 728 { 729 if (st->complexity >= 5 && st->plc_duration < 80 && !st->skip_plc) 730 curr_frame_type = FRAME_PLC_NEURAL; 731 #ifdef ENABLE_DRED 732 if (lpcnet->fec_fill_pos > lpcnet->fec_read_pos) 733 curr_frame_type = FRAME_DRED; 734 #endif 735 } 736 #endif 737 738 if (curr_frame_type == FRAME_PLC_NOISE) 739 { 740 /* Noise-based PLC/CNG */ 741 VARDECL(celt_norm, X); 742 opus_uint32 seed; 743 int end; 744 int effEnd; 745 celt_glog decay; 746 end = st->end; 747 effEnd = IMAX(start, IMIN(end, mode->effEBands)); 748 749 ALLOC(X, C*N, celt_norm); /**< Interleaved normalised MDCTs */ 750 c=0; do { 751 OPUS_MOVE(decode_mem[c], decode_mem[c]+N, 752 decode_buffer_size-N+overlap); 753 } while (++c<C); 754 755 if (st->prefilter_and_fold) { 756 prefilter_and_fold(st, N); 757 } 758 759 /* Energy decay */ 760 decay = loss_duration==0 ? GCONST(1.5f) : GCONST(.5f); 761 c=0; do 762 { 763 for (i=start;i<end;i++) 764 oldBandE[c*nbEBands+i] = MAXG(backgroundLogE[c*nbEBands+i], oldBandE[c*nbEBands+i] - decay); 765 } while (++c<C); 766 seed = st->rng; 767 for (c=0;c<C;c++) 768 { 769 for (i=start;i<effEnd;i++) 770 { 771 int j; 772 int boffs; 773 int blen; 774 boffs = N*c+(eBands[i]<<LM); 775 blen = (eBands[i+1]-eBands[i])<<LM; 776 for (j=0;j<blen;j++) 777 { 778 seed = celt_lcg_rand(seed); 779 X[boffs+j] = SHL32((celt_norm)((opus_int32)seed>>20), NORM_SHIFT-14); 780 } 781 renormalise_vector(X+boffs, blen, Q31ONE, st->arch); 782 } 783 } 784 st->rng = seed; 785 786 celt_synthesis(mode, X, out_syn, oldBandE, start, effEnd, C, C, 0, LM, st->downsample, 0, st->arch ARG_QEXT(NULL) ARG_QEXT(NULL) ARG_QEXT(0)); 787 788 /* Run the postfilter with the last parameters. */ 789 c=0; do { 790 st->postfilter_period=IMAX(st->postfilter_period, COMBFILTER_MINPERIOD); 791 st->postfilter_period_old=IMAX(st->postfilter_period_old, COMBFILTER_MINPERIOD); 792 comb_filter(out_syn[c], out_syn[c], st->postfilter_period_old, st->postfilter_period, mode->shortMdctSize, 793 st->postfilter_gain_old, st->postfilter_gain, st->postfilter_tapset_old, st->postfilter_tapset, 794 mode->window, overlap, st->arch); 795 if (LM!=0) 796 comb_filter(out_syn[c]+mode->shortMdctSize, out_syn[c]+mode->shortMdctSize, st->postfilter_period, st->postfilter_period, N-mode->shortMdctSize, 797 st->postfilter_gain, st->postfilter_gain, st->postfilter_tapset, st->postfilter_tapset, 798 mode->window, overlap, st->arch); 799 800 } while (++c<C); 801 st->postfilter_period_old = st->postfilter_period; 802 st->postfilter_gain_old = st->postfilter_gain; 803 st->postfilter_tapset_old = st->postfilter_tapset; 804 805 st->prefilter_and_fold = 0; 806 /* Skip regular PLC until we get two consecutive packets. */ 807 st->skip_plc = 1; 808 } else { 809 int exc_length; 810 /* Pitch-based PLC */ 811 const celt_coef *window; 812 opus_val16 *exc; 813 opus_val16 fade = Q15ONE; 814 int pitch_index; 815 int curr_neural; 816 int last_neural; 817 VARDECL(opus_val16, _exc); 818 VARDECL(opus_val16, fir_tmp); 819 820 curr_neural = curr_frame_type == FRAME_PLC_NEURAL || curr_frame_type == FRAME_DRED; 821 last_neural = st->last_frame_type == FRAME_PLC_NEURAL || st->last_frame_type == FRAME_DRED; 822 if (st->last_frame_type != FRAME_PLC_PERIODIC && !(last_neural && curr_neural)) 823 { 824 st->last_pitch_index = pitch_index = celt_plc_pitch_search(st, decode_mem, C, st->arch); 825 } else { 826 pitch_index = st->last_pitch_index; 827 fade = QCONST16(.8f,15); 828 } 829 #ifdef ENABLE_DEEP_PLC 830 if (curr_neural && !last_neural) update_plc_state(lpcnet, decode_mem, &st->plc_preemphasis_mem, C); 831 #endif 832 833 /* We want the excitation for 2 pitch periods in order to look for a 834 decaying signal, but we can't get more than MAX_PERIOD. */ 835 exc_length = IMIN(2*pitch_index, max_period); 836 837 ALLOC(_exc, max_period+CELT_LPC_ORDER, opus_val16); 838 ALLOC(fir_tmp, exc_length, opus_val16); 839 exc = _exc+CELT_LPC_ORDER; 840 window = mode->window; 841 c=0; do { 842 opus_val16 decay; 843 opus_val16 attenuation; 844 opus_val32 S1=0; 845 celt_sig *buf; 846 int extrapolation_offset; 847 int extrapolation_len; 848 int j; 849 850 buf = decode_mem[c]; 851 for (i=0;i<max_period+CELT_LPC_ORDER;i++) 852 exc[i-CELT_LPC_ORDER] = SROUND16(buf[decode_buffer_size-max_period-CELT_LPC_ORDER+i], SIG_SHIFT); 853 854 if (st->last_frame_type != FRAME_PLC_PERIODIC && !(last_neural && curr_neural)) 855 { 856 opus_val32 ac[CELT_LPC_ORDER+1]; 857 /* Compute LPC coefficients for the last MAX_PERIOD samples before 858 the first loss so we can work in the excitation-filter domain. */ 859 _celt_autocorr(exc, ac, window, overlap, 860 CELT_LPC_ORDER, max_period, st->arch); 861 /* Add a noise floor of -40 dB. */ 862 #ifdef FIXED_POINT 863 ac[0] += SHR32(ac[0],13); 864 #else 865 ac[0] *= 1.0001f; 866 #endif 867 /* Use lag windowing to stabilize the Levinson-Durbin recursion. */ 868 for (i=1;i<=CELT_LPC_ORDER;i++) 869 { 870 /*ac[i] *= exp(-.5*(2*M_PI*.002*i)*(2*M_PI*.002*i));*/ 871 #ifdef FIXED_POINT 872 ac[i] -= MULT16_32_Q15(2*i*i, ac[i]); 873 #else 874 ac[i] -= ac[i]*(0.008f*0.008f)*i*i; 875 #endif 876 } 877 _celt_lpc(lpc+c*CELT_LPC_ORDER, ac, CELT_LPC_ORDER); 878 #ifdef FIXED_POINT 879 /* For fixed-point, apply bandwidth expansion until we can guarantee that 880 no overflow can happen in the IIR filter. This means: 881 32768*sum(abs(filter)) < 2^31 */ 882 while (1) { 883 opus_val16 tmp=Q15ONE; 884 opus_val32 sum=QCONST16(1., SIG_SHIFT); 885 for (i=0;i<CELT_LPC_ORDER;i++) 886 sum += ABS16(lpc[c*CELT_LPC_ORDER+i]); 887 if (sum < 65535) break; 888 for (i=0;i<CELT_LPC_ORDER;i++) 889 { 890 tmp = MULT16_16_Q15(QCONST16(.99f,15), tmp); 891 lpc[c*CELT_LPC_ORDER+i] = MULT16_16_Q15(lpc[c*CELT_LPC_ORDER+i], tmp); 892 } 893 } 894 #endif 895 } 896 /* Initialize the LPC history with the samples just before the start 897 of the region for which we're computing the excitation. */ 898 { 899 /* Compute the excitation for exc_length samples before the loss. We need the copy 900 because celt_fir() cannot filter in-place. */ 901 celt_fir(exc+max_period-exc_length, lpc+c*CELT_LPC_ORDER, 902 fir_tmp, exc_length, CELT_LPC_ORDER, st->arch); 903 OPUS_COPY(exc+max_period-exc_length, fir_tmp, exc_length); 904 } 905 906 /* Check if the waveform is decaying, and if so how fast. 907 We do this to avoid adding energy when concealing in a segment 908 with decaying energy. */ 909 { 910 opus_val32 E1=1, E2=1; 911 int decay_length; 912 #ifdef FIXED_POINT 913 int shift = IMAX(0,2*celt_zlog2(celt_maxabs16(&exc[max_period-exc_length], exc_length))-20); 914 #ifdef ENABLE_QEXT 915 if (st->qext_scale==2) shift++; 916 #endif 917 #endif 918 decay_length = exc_length>>1; 919 for (i=0;i<decay_length;i++) 920 { 921 opus_val16 e; 922 e = exc[max_period-decay_length+i]; 923 E1 += SHR32(MULT16_16(e, e), shift); 924 e = exc[max_period-2*decay_length+i]; 925 E2 += SHR32(MULT16_16(e, e), shift); 926 } 927 E1 = MIN32(E1, E2); 928 decay = celt_sqrt(frac_div32(SHR32(E1, 1), E2)); 929 } 930 931 /* Move the decoder memory one frame to the left to give us room to 932 add the data for the new frame. We ignore the overlap that extends 933 past the end of the buffer, because we aren't going to use it. */ 934 OPUS_MOVE(buf, buf+N, decode_buffer_size-N); 935 936 /* Extrapolate from the end of the excitation with a period of 937 "pitch_index", scaling down each period by an additional factor of 938 "decay". */ 939 extrapolation_offset = max_period-pitch_index; 940 /* We need to extrapolate enough samples to cover a complete MDCT 941 window (including overlap/2 samples on both sides). */ 942 extrapolation_len = N+overlap; 943 /* We also apply fading if this is not the first loss. */ 944 attenuation = MULT16_16_Q15(fade, decay); 945 for (i=j=0;i<extrapolation_len;i++,j++) 946 { 947 opus_val16 tmp; 948 if (j >= pitch_index) { 949 j -= pitch_index; 950 attenuation = MULT16_16_Q15(attenuation, decay); 951 } 952 buf[decode_buffer_size-N+i] = 953 SHL32(EXTEND32(MULT16_16_Q15(attenuation, 954 exc[extrapolation_offset+j])), SIG_SHIFT); 955 /* Compute the energy of the previously decoded signal whose 956 excitation we're copying. */ 957 tmp = SROUND16( 958 buf[decode_buffer_size-max_period-N+extrapolation_offset+j], 959 SIG_SHIFT); 960 S1 += SHR32(MULT16_16(tmp, tmp), 11); 961 } 962 { 963 opus_val16 lpc_mem[CELT_LPC_ORDER]; 964 /* Copy the last decoded samples (prior to the overlap region) to 965 synthesis filter memory so we can have a continuous signal. */ 966 for (i=0;i<CELT_LPC_ORDER;i++) 967 lpc_mem[i] = SROUND16(buf[decode_buffer_size-N-1-i], SIG_SHIFT); 968 /* Apply the synthesis filter to convert the excitation back into 969 the signal domain. */ 970 celt_iir(buf+decode_buffer_size-N, lpc+c*CELT_LPC_ORDER, 971 buf+decode_buffer_size-N, extrapolation_len, CELT_LPC_ORDER, 972 lpc_mem, st->arch); 973 #ifdef FIXED_POINT 974 for (i=0; i < extrapolation_len; i++) 975 buf[decode_buffer_size-N+i] = SATURATE(buf[decode_buffer_size-N+i], SIG_SAT); 976 #endif 977 } 978 979 /* Check if the synthesis energy is higher than expected, which can 980 happen with the signal changes during our window. If so, 981 attenuate. */ 982 { 983 opus_val32 S2=0; 984 for (i=0;i<extrapolation_len;i++) 985 { 986 opus_val16 tmp = SROUND16(buf[decode_buffer_size-N+i], SIG_SHIFT); 987 S2 += SHR32(MULT16_16(tmp, tmp), 11); 988 } 989 /* This checks for an "explosion" in the synthesis. */ 990 #ifdef FIXED_POINT 991 if (!(S1 > SHR32(S2,2))) 992 #else 993 /* The float test is written this way to catch NaNs in the output 994 of the IIR filter at the same time. */ 995 if (!(S1 > 0.2f*S2)) 996 #endif 997 { 998 for (i=0;i<extrapolation_len;i++) 999 buf[decode_buffer_size-N+i] = 0; 1000 } else if (S1 < S2) 1001 { 1002 opus_val16 ratio = celt_sqrt(frac_div32(SHR32(S1,1)+1,S2+1)); 1003 for (i=0;i<overlap;i++) 1004 { 1005 opus_val16 tmp_g = Q15ONE 1006 - MULT16_16_Q15(COEF2VAL16(window[i]), Q15ONE-ratio); 1007 buf[decode_buffer_size-N+i] = 1008 MULT16_32_Q15(tmp_g, buf[decode_buffer_size-N+i]); 1009 } 1010 for (i=overlap;i<extrapolation_len;i++) 1011 { 1012 buf[decode_buffer_size-N+i] = 1013 MULT16_32_Q15(ratio, buf[decode_buffer_size-N+i]); 1014 } 1015 } 1016 } 1017 1018 } while (++c<C); 1019 1020 #ifdef ENABLE_DEEP_PLC 1021 if (curr_neural) { 1022 float overlap_mem; 1023 int samples_needed16k; 1024 celt_sig *buf; 1025 VARDECL(float, buf_copy); 1026 buf = decode_mem[0]; 1027 ALLOC(buf_copy, C*overlap, float); 1028 c=0; do { 1029 OPUS_COPY(buf_copy+c*overlap, &decode_mem[c][decode_buffer_size-N], overlap); 1030 } while (++c<C); 1031 1032 /* Need enough samples from the PLC to cover the frame size, resampling delay, 1033 and the overlap at the end. */ 1034 samples_needed16k = (N+SINC_ORDER+overlap)/3; 1035 if (!last_neural) { 1036 st->plc_fill = 0; 1037 } 1038 while (st->plc_fill < samples_needed16k) { 1039 lpcnet_plc_conceal(lpcnet, &st->plc_pcm[st->plc_fill]); 1040 st->plc_fill += FRAME_SIZE; 1041 } 1042 /* Resample to 48 kHz. */ 1043 for (i=0;i<(N+overlap)/3;i++) { 1044 int j; 1045 float sum; 1046 for (sum=0, j=0;j<17;j++) sum += 3*st->plc_pcm[i+j]*sinc_filter[3*j]; 1047 buf[decode_buffer_size-N+3*i] = sum; 1048 for (sum=0, j=0;j<16;j++) sum += 3*st->plc_pcm[i+j+1]*sinc_filter[3*j+2]; 1049 buf[decode_buffer_size-N+3*i+1] = sum; 1050 for (sum=0, j=0;j<16;j++) sum += 3*st->plc_pcm[i+j+1]*sinc_filter[3*j+1]; 1051 buf[decode_buffer_size-N+3*i+2] = sum; 1052 } 1053 OPUS_MOVE(st->plc_pcm, &st->plc_pcm[N/3], st->plc_fill-N/3); 1054 st->plc_fill -= N/3; 1055 for (i=0;i<N;i++) { 1056 float tmp = buf[decode_buffer_size-N+i]; 1057 buf[decode_buffer_size-N+i] -= PREEMPHASIS*st->plc_preemphasis_mem; 1058 st->plc_preemphasis_mem = tmp; 1059 } 1060 overlap_mem = st->plc_preemphasis_mem; 1061 for (i=0;i<overlap;i++) { 1062 float tmp = buf[decode_buffer_size+i]; 1063 buf[decode_buffer_size+i] -= PREEMPHASIS*overlap_mem; 1064 overlap_mem = tmp; 1065 } 1066 /* For now, we just do mono PLC. */ 1067 if (C==2) OPUS_COPY(decode_mem[1], decode_mem[0], decode_buffer_size+overlap); 1068 c=0; do { 1069 /* Cross-fade with 48-kHz non-neural PLC for the first 2.5 ms to avoid a discontinuity. */ 1070 if (!last_neural) { 1071 for (i=0;i<overlap;i++) decode_mem[c][decode_buffer_size-N+i] = (1-window[i])*buf_copy[c*overlap+i] + (window[i])*decode_mem[c][decode_buffer_size-N+i]; 1072 } 1073 } while (++c<C); 1074 } 1075 #endif 1076 st->prefilter_and_fold = 1; 1077 } 1078 1079 /* Saturate to something large to avoid wrap-around. */ 1080 st->loss_duration = IMIN(10000, loss_duration+(1<<LM)); 1081 st->plc_duration = IMIN(10000, st->plc_duration+(1<<LM)); 1082 #ifdef ENABLE_DRED 1083 if (curr_frame_type == FRAME_DRED) { 1084 st->plc_duration = 0; 1085 st->skip_plc = 0; 1086 } 1087 #endif 1088 st->last_frame_type = curr_frame_type; 1089 RESTORE_STACK; 1090 } 1091 1092 #ifdef ENABLE_QEXT 1093 static void decode_qext_stereo_params(ec_dec *ec, int qext_end, int *qext_intensity, int *qext_dual_stereo) { 1094 *qext_intensity = ec_dec_uint(ec, qext_end+1); 1095 if (*qext_intensity != 0) *qext_dual_stereo = ec_dec_bit_logp(ec, 1); 1096 else *qext_dual_stereo = 0; 1097 } 1098 #endif 1099 1100 int celt_decode_with_ec_dred(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, 1101 int len, opus_res * OPUS_RESTRICT pcm, int frame_size, ec_dec *dec, int accum 1102 #ifdef ENABLE_DEEP_PLC 1103 ,LPCNetPLCState *lpcnet 1104 #endif 1105 ARG_QEXT(const unsigned char *qext_payload) ARG_QEXT(int qext_payload_len) 1106 ) 1107 { 1108 int c, i, N; 1109 int spread_decision; 1110 opus_int32 bits; 1111 ec_dec _dec; 1112 VARDECL(celt_norm, X); 1113 VARDECL(int, fine_quant); 1114 VARDECL(int, pulses); 1115 VARDECL(int, cap); 1116 VARDECL(int, offsets); 1117 VARDECL(int, fine_priority); 1118 VARDECL(int, tf_res); 1119 VARDECL(unsigned char, collapse_masks); 1120 celt_sig *decode_mem[2]; 1121 celt_sig *out_syn[2]; 1122 celt_glog *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE; 1123 1124 int shortBlocks; 1125 int isTransient; 1126 int intra_ener; 1127 const int CC = st->channels; 1128 int LM, M; 1129 int start; 1130 int end; 1131 int effEnd; 1132 int codedBands; 1133 int alloc_trim; 1134 int postfilter_pitch; 1135 opus_val16 postfilter_gain; 1136 int intensity=0; 1137 int dual_stereo=0; 1138 opus_int32 total_bits; 1139 opus_int32 balance; 1140 opus_int32 tell; 1141 int dynalloc_logp; 1142 int postfilter_tapset; 1143 int anti_collapse_rsv; 1144 int anti_collapse_on=0; 1145 int silence; 1146 int C = st->stream_channels; 1147 const OpusCustomMode *mode; 1148 int nbEBands; 1149 int overlap; 1150 const opus_int16 *eBands; 1151 celt_glog max_background_increase; 1152 int decode_buffer_size; 1153 #ifdef ENABLE_QEXT 1154 opus_int32 qext_bits; 1155 ec_dec ext_dec; 1156 int qext_bytes=0; 1157 int qext_end=0; 1158 int qext_intensity=0; 1159 int qext_dual_stereo=0; 1160 VARDECL(int, extra_quant); 1161 VARDECL(int, extra_pulses); 1162 const CELTMode *qext_mode = NULL; 1163 CELTMode qext_mode_struct; 1164 int qext_scale; 1165 #else 1166 # define qext_bytes 0 1167 #endif 1168 ALLOC_STACK; 1169 #ifdef ENABLE_QEXT 1170 qext_scale = st->qext_scale; 1171 #endif 1172 decode_buffer_size = QEXT_SCALE(DECODE_BUFFER_SIZE); 1173 1174 VALIDATE_CELT_DECODER(st); 1175 mode = st->mode; 1176 nbEBands = mode->nbEBands; 1177 overlap = mode->overlap; 1178 eBands = mode->eBands; 1179 start = st->start; 1180 end = st->end; 1181 frame_size *= st->downsample; 1182 1183 oldBandE = (celt_glog*)(st->_decode_mem+(decode_buffer_size+overlap)*CC); 1184 oldLogE = oldBandE + 2*nbEBands; 1185 oldLogE2 = oldLogE + 2*nbEBands; 1186 backgroundLogE = oldLogE2 + 2*nbEBands; 1187 1188 #ifdef ENABLE_QEXT 1189 if (qext_payload) { 1190 ec_dec_init(&ext_dec, (unsigned char*)qext_payload, qext_payload_len); 1191 qext_bytes = qext_payload_len; 1192 } else { 1193 ec_dec_init(&ext_dec, NULL, 0); 1194 } 1195 #endif 1196 #if defined(CUSTOM_MODES) || defined(ENABLE_OPUS_CUSTOM_API) 1197 if (st->signalling && data!=NULL) 1198 { 1199 int data0=data[0]; 1200 /* Convert "standard mode" to Opus header */ 1201 # ifndef ENABLE_QEXT 1202 if (mode->Fs==48000 && mode->shortMdctSize==120) 1203 # endif 1204 { 1205 data0 = fromOpus(data0); 1206 if (data0<0) 1207 return OPUS_INVALID_PACKET; 1208 } 1209 st->end = end = IMAX(1, mode->effEBands-2*(data0>>5)); 1210 LM = (data0>>3)&0x3; 1211 C = 1 + ((data0>>2)&0x1); 1212 if ((data[0] & 0x03) == 0x03) { 1213 data++; 1214 len--; 1215 if (len<=0) 1216 return OPUS_INVALID_PACKET; 1217 if (data[0] & 0x40) { 1218 int p; 1219 int padding=0; 1220 data++; 1221 len--; 1222 do { 1223 int tmp; 1224 if (len<=0) 1225 return OPUS_INVALID_PACKET; 1226 p = *data++; 1227 len--; 1228 tmp = p==255 ? 254: p; 1229 len -= tmp; 1230 padding += tmp; 1231 } while (p==255); 1232 padding--; 1233 if (len <= 0 || padding<0) return OPUS_INVALID_PACKET; 1234 #ifdef ENABLE_QEXT 1235 qext_bytes = padding; 1236 if (data[len] != QEXT_EXTENSION_ID<<1) 1237 qext_bytes=0; 1238 ec_dec_init(&ext_dec, (unsigned char*)data+len+1, qext_bytes); 1239 #endif 1240 } 1241 } else 1242 { 1243 data++; 1244 len--; 1245 } 1246 if (LM>mode->maxLM) 1247 return OPUS_INVALID_PACKET; 1248 if (frame_size < mode->shortMdctSize<<LM) 1249 return OPUS_BUFFER_TOO_SMALL; 1250 else 1251 frame_size = mode->shortMdctSize<<LM; 1252 } else { 1253 #else 1254 { 1255 #endif 1256 for (LM=0;LM<=mode->maxLM;LM++) 1257 if (mode->shortMdctSize<<LM==frame_size) 1258 break; 1259 if (LM>mode->maxLM) 1260 return OPUS_BAD_ARG; 1261 } 1262 M=1<<LM; 1263 1264 if (len<0 || len>1275 || pcm==NULL) 1265 return OPUS_BAD_ARG; 1266 1267 N = M*mode->shortMdctSize; 1268 c=0; do { 1269 decode_mem[c] = st->_decode_mem + c*(decode_buffer_size+overlap); 1270 out_syn[c] = decode_mem[c]+decode_buffer_size-N; 1271 } while (++c<CC); 1272 1273 effEnd = end; 1274 if (effEnd > mode->effEBands) 1275 effEnd = mode->effEBands; 1276 1277 if (data == NULL || len<=1) 1278 { 1279 celt_decode_lost(st, N, LM 1280 #ifdef ENABLE_DEEP_PLC 1281 , lpcnet 1282 #endif 1283 ); 1284 deemphasis(out_syn, pcm, N, CC, st->downsample, mode->preemph, st->preemph_memD, accum); 1285 RESTORE_STACK; 1286 return frame_size/st->downsample; 1287 } 1288 #ifdef ENABLE_DEEP_PLC 1289 else { 1290 /* FIXME: This is a bit of a hack just to make sure opus_decode_native() knows we're no longer in PLC. */ 1291 if (lpcnet) lpcnet->blend = 0; 1292 } 1293 #endif 1294 1295 /* Check if there are at least two packets received consecutively before 1296 * turning on the pitch-based PLC */ 1297 if (st->loss_duration == 0) st->skip_plc = 0; 1298 1299 if (dec == NULL) 1300 { 1301 ec_dec_init(&_dec,(unsigned char*)data,len); 1302 dec = &_dec; 1303 } 1304 1305 if (C==1) 1306 { 1307 for (i=0;i<nbEBands;i++) 1308 oldBandE[i]=MAXG(oldBandE[i],oldBandE[nbEBands+i]); 1309 } 1310 1311 total_bits = len*8; 1312 tell = ec_tell(dec); 1313 1314 if (tell >= total_bits) 1315 silence = 1; 1316 else if (tell==1) 1317 silence = ec_dec_bit_logp(dec, 15); 1318 else 1319 silence = 0; 1320 if (silence) 1321 { 1322 /* Pretend we've read all the remaining bits */ 1323 tell = len*8; 1324 dec->nbits_total+=tell-ec_tell(dec); 1325 } 1326 1327 postfilter_gain = 0; 1328 postfilter_pitch = 0; 1329 postfilter_tapset = 0; 1330 if (start==0 && tell+16 <= total_bits) 1331 { 1332 if(ec_dec_bit_logp(dec, 1)) 1333 { 1334 int qg, octave; 1335 octave = ec_dec_uint(dec, 6); 1336 postfilter_pitch = (16<<octave)+ec_dec_bits(dec, 4+octave)-1; 1337 qg = ec_dec_bits(dec, 3); 1338 if (ec_tell(dec)+2<=total_bits) 1339 postfilter_tapset = ec_dec_icdf(dec, tapset_icdf, 2); 1340 postfilter_gain = QCONST16(.09375f,15)*(qg+1); 1341 } 1342 tell = ec_tell(dec); 1343 } 1344 1345 if (LM > 0 && tell+3 <= total_bits) 1346 { 1347 isTransient = ec_dec_bit_logp(dec, 3); 1348 tell = ec_tell(dec); 1349 } 1350 else 1351 isTransient = 0; 1352 1353 if (isTransient) 1354 shortBlocks = M; 1355 else 1356 shortBlocks = 0; 1357 1358 /* Decode the global flags (first symbols in the stream) */ 1359 intra_ener = tell+3<=total_bits ? ec_dec_bit_logp(dec, 3) : 0; 1360 /* If recovering from packet loss, make sure we make the energy prediction safe to reduce the 1361 risk of getting loud artifacts. */ 1362 if (!intra_ener && st->loss_duration != 0) { 1363 c=0; do 1364 { 1365 celt_glog safety = 0; 1366 int missing = IMIN(10, st->loss_duration>>LM); 1367 if (LM==0) safety = GCONST(1.5f); 1368 else if (LM==1) safety = GCONST(.5f); 1369 for (i=start;i<end;i++) 1370 { 1371 if (oldBandE[c*nbEBands+i] < MAXG(oldLogE[c*nbEBands+i], oldLogE2[c*nbEBands+i])) { 1372 /* If energy is going down already, continue the trend. */ 1373 opus_val32 slope; 1374 opus_val32 E0, E1, E2; 1375 E0 = oldBandE[c*nbEBands+i]; 1376 E1 = oldLogE[c*nbEBands+i]; 1377 E2 = oldLogE2[c*nbEBands+i]; 1378 slope = MAX32(E1 - E0, HALF32(E2 - E0)); 1379 slope = MING(slope, GCONST(2.f)); 1380 E0 -= MAX32(0, (1+missing)*slope); 1381 oldBandE[c*nbEBands+i] = MAX32(-GCONST(20.f), E0); 1382 } else { 1383 /* Otherwise take the min of the last frames. */ 1384 oldBandE[c*nbEBands+i] = MING(MING(oldBandE[c*nbEBands+i], oldLogE[c*nbEBands+i]), oldLogE2[c*nbEBands+i]); 1385 } 1386 /* Shorter frames have more natural fluctuations -- play it safe. */ 1387 oldBandE[c*nbEBands+i] -= safety; 1388 } 1389 } while (++c<2); 1390 } 1391 /* Get band energies */ 1392 unquant_coarse_energy(mode, start, end, oldBandE, 1393 intra_ener, dec, C, LM); 1394 1395 ALLOC(tf_res, nbEBands, int); 1396 tf_decode(start, end, isTransient, tf_res, LM, dec); 1397 1398 tell = ec_tell(dec); 1399 spread_decision = SPREAD_NORMAL; 1400 if (tell+4 <= total_bits) 1401 spread_decision = ec_dec_icdf(dec, spread_icdf, 5); 1402 1403 ALLOC(cap, nbEBands, int); 1404 1405 init_caps(mode,cap,LM,C); 1406 1407 ALLOC(offsets, nbEBands, int); 1408 1409 dynalloc_logp = 6; 1410 total_bits<<=BITRES; 1411 tell = ec_tell_frac(dec); 1412 for (i=start;i<end;i++) 1413 { 1414 int width, quanta; 1415 int dynalloc_loop_logp; 1416 int boost; 1417 width = C*(eBands[i+1]-eBands[i])<<LM; 1418 /* quanta is 6 bits, but no more than 1 bit/sample 1419 and no less than 1/8 bit/sample */ 1420 quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width)); 1421 dynalloc_loop_logp = dynalloc_logp; 1422 boost = 0; 1423 while (tell+(dynalloc_loop_logp<<BITRES) < total_bits && boost < cap[i]) 1424 { 1425 int flag; 1426 flag = ec_dec_bit_logp(dec, dynalloc_loop_logp); 1427 tell = ec_tell_frac(dec); 1428 if (!flag) 1429 break; 1430 boost += quanta; 1431 total_bits -= quanta; 1432 dynalloc_loop_logp = 1; 1433 } 1434 offsets[i] = boost; 1435 /* Making dynalloc more likely */ 1436 if (boost>0) 1437 dynalloc_logp = IMAX(2, dynalloc_logp-1); 1438 } 1439 1440 ALLOC(fine_quant, nbEBands, int); 1441 alloc_trim = tell+(6<<BITRES) <= total_bits ? 1442 ec_dec_icdf(dec, trim_icdf, 7) : 5; 1443 1444 bits = (((opus_int32)len*8)<<BITRES) - (opus_int32)ec_tell_frac(dec) - 1; 1445 anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES) ? (1<<BITRES) : 0; 1446 bits -= anti_collapse_rsv; 1447 1448 ALLOC(pulses, nbEBands, int); 1449 ALLOC(fine_priority, nbEBands, int); 1450 1451 codedBands = clt_compute_allocation(mode, start, end, offsets, cap, 1452 alloc_trim, &intensity, &dual_stereo, bits, &balance, pulses, 1453 fine_quant, fine_priority, C, LM, dec, 0, 0, 0); 1454 1455 unquant_fine_energy(mode, start, end, oldBandE, NULL, fine_quant, dec, C); 1456 1457 ALLOC(X, C*N, celt_norm); /**< Interleaved normalised MDCTs */ 1458 1459 #ifdef ENABLE_QEXT 1460 if (qext_bytes && end == nbEBands && 1461 ((mode->Fs == 48000 && (mode->shortMdctSize==120 || mode->shortMdctSize==90)) 1462 || (mode->Fs == 96000 && (mode->shortMdctSize==240 || mode->shortMdctSize==180)))) { 1463 int qext_intra_ener; 1464 compute_qext_mode(&qext_mode_struct, mode); 1465 qext_mode = &qext_mode_struct; 1466 qext_end = ec_dec_bit_logp(&ext_dec, 1) ? NB_QEXT_BANDS : 2; 1467 if (C==2) decode_qext_stereo_params(&ext_dec, qext_end, &qext_intensity, &qext_dual_stereo); 1468 qext_intra_ener = ec_tell(&ext_dec)+3<=qext_bytes*8 ? ec_dec_bit_logp(&ext_dec, 3) : 0; 1469 unquant_coarse_energy(qext_mode, 0, qext_end, st->qext_oldBandE, 1470 qext_intra_ener, &ext_dec, C, LM); 1471 } 1472 ALLOC(extra_quant, nbEBands+NB_QEXT_BANDS, int); 1473 ALLOC(extra_pulses, nbEBands+NB_QEXT_BANDS, int); 1474 qext_bits = ((opus_int32)qext_bytes*8<<BITRES) - (opus_int32)ec_tell_frac(dec) - 1; 1475 clt_compute_extra_allocation(mode, qext_mode, start, end, qext_end, NULL, NULL, 1476 qext_bits, extra_pulses, extra_quant, C, LM, &ext_dec, 0, 0, 0); 1477 if (qext_bytes > 0) { 1478 unquant_fine_energy(mode, start, end, oldBandE, fine_quant, extra_quant, &ext_dec, C); 1479 } 1480 #endif 1481 1482 c=0; do { 1483 OPUS_MOVE(decode_mem[c], decode_mem[c]+N, decode_buffer_size-N+overlap); 1484 } while (++c<CC); 1485 1486 /* Decode fixed codebook */ 1487 ALLOC(collapse_masks, C*nbEBands, unsigned char); 1488 1489 quant_all_bands(0, mode, start, end, X, C==2 ? X+N : NULL, collapse_masks, 1490 NULL, pulses, shortBlocks, spread_decision, dual_stereo, intensity, tf_res, 1491 len*(8<<BITRES)-anti_collapse_rsv, balance, dec, LM, codedBands, &st->rng, 0, 1492 st->arch, st->disable_inv 1493 ARG_QEXT(&ext_dec) ARG_QEXT(extra_pulses) 1494 ARG_QEXT(qext_bytes*(8<<BITRES)) ARG_QEXT(cap)); 1495 1496 #ifdef ENABLE_QEXT 1497 if (qext_mode) { 1498 VARDECL(int, zeros); 1499 VARDECL(unsigned char, qext_collapse_masks); 1500 ec_dec dummy_dec; 1501 int ext_balance; 1502 ALLOC(zeros, nbEBands, int); 1503 ALLOC(qext_collapse_masks, C*NB_QEXT_BANDS, unsigned char); 1504 ec_dec_init(&dummy_dec, NULL, 0); 1505 OPUS_CLEAR(zeros, end); 1506 ext_balance = qext_bytes*(8<<BITRES) - ec_tell_frac(&ext_dec); 1507 for (i=0;i<qext_end;i++) ext_balance -= extra_pulses[nbEBands+i] + C*(extra_quant[nbEBands+1]<<BITRES); 1508 unquant_fine_energy(qext_mode, 0, qext_end, st->qext_oldBandE, NULL, &extra_quant[nbEBands], &ext_dec, C); 1509 quant_all_bands(0, qext_mode, 0, qext_end, X, C==2 ? X+N : NULL, qext_collapse_masks, 1510 NULL, &extra_pulses[nbEBands], shortBlocks, spread_decision, qext_dual_stereo, qext_intensity, zeros, 1511 qext_bytes*(8<<BITRES), ext_balance, &ext_dec, LM, qext_end, &st->rng, 0, 1512 st->arch, st->disable_inv, &dummy_dec, zeros, 0, NULL); 1513 } 1514 #endif 1515 1516 if (anti_collapse_rsv > 0) 1517 { 1518 anti_collapse_on = ec_dec_bits(dec, 1); 1519 } 1520 unquant_energy_finalise(mode, start, end, (qext_bytes > 0) ? NULL : oldBandE, 1521 fine_quant, fine_priority, len*8-ec_tell(dec), dec, C); 1522 if (anti_collapse_on) 1523 anti_collapse(mode, X, collapse_masks, LM, C, N, 1524 start, end, oldBandE, oldLogE, oldLogE2, pulses, st->rng, 0, st->arch); 1525 1526 if (silence) 1527 { 1528 for (i=0;i<C*nbEBands;i++) 1529 oldBandE[i] = -GCONST(28.f); 1530 } 1531 if (st->prefilter_and_fold) { 1532 prefilter_and_fold(st, N); 1533 } 1534 celt_synthesis(mode, X, out_syn, oldBandE, start, effEnd, 1535 C, CC, isTransient, LM, st->downsample, silence, st->arch ARG_QEXT(qext_mode) ARG_QEXT(st->qext_oldBandE) ARG_QEXT(qext_end)); 1536 1537 c=0; do { 1538 st->postfilter_period=IMAX(st->postfilter_period, COMBFILTER_MINPERIOD); 1539 st->postfilter_period_old=IMAX(st->postfilter_period_old, COMBFILTER_MINPERIOD); 1540 comb_filter(out_syn[c], out_syn[c], st->postfilter_period_old, st->postfilter_period, mode->shortMdctSize, 1541 st->postfilter_gain_old, st->postfilter_gain, st->postfilter_tapset_old, st->postfilter_tapset, 1542 mode->window, overlap, st->arch); 1543 if (LM!=0) 1544 comb_filter(out_syn[c]+mode->shortMdctSize, out_syn[c]+mode->shortMdctSize, st->postfilter_period, postfilter_pitch, N-mode->shortMdctSize, 1545 st->postfilter_gain, postfilter_gain, st->postfilter_tapset, postfilter_tapset, 1546 mode->window, overlap, st->arch); 1547 1548 } while (++c<CC); 1549 st->postfilter_period_old = st->postfilter_period; 1550 st->postfilter_gain_old = st->postfilter_gain; 1551 st->postfilter_tapset_old = st->postfilter_tapset; 1552 st->postfilter_period = postfilter_pitch; 1553 st->postfilter_gain = postfilter_gain; 1554 st->postfilter_tapset = postfilter_tapset; 1555 if (LM!=0) 1556 { 1557 st->postfilter_period_old = st->postfilter_period; 1558 st->postfilter_gain_old = st->postfilter_gain; 1559 st->postfilter_tapset_old = st->postfilter_tapset; 1560 } 1561 1562 if (C==1) 1563 OPUS_COPY(&oldBandE[nbEBands], oldBandE, nbEBands); 1564 1565 if (!isTransient) 1566 { 1567 OPUS_COPY(oldLogE2, oldLogE, 2*nbEBands); 1568 OPUS_COPY(oldLogE, oldBandE, 2*nbEBands); 1569 } else { 1570 for (i=0;i<2*nbEBands;i++) 1571 oldLogE[i] = MING(oldLogE[i], oldBandE[i]); 1572 } 1573 /* In normal circumstances, we only allow the noise floor to increase by 1574 up to 2.4 dB/second, but when we're in DTX we give the weight of 1575 all missing packets to the update packet. */ 1576 max_background_increase = IMIN(160, st->loss_duration+M)*GCONST(0.001f); 1577 for (i=0;i<2*nbEBands;i++) 1578 backgroundLogE[i] = MING(backgroundLogE[i] + max_background_increase, oldBandE[i]); 1579 /* In case start or end were to change */ 1580 c=0; do 1581 { 1582 for (i=0;i<start;i++) 1583 { 1584 oldBandE[c*nbEBands+i]=0; 1585 oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-GCONST(28.f); 1586 } 1587 for (i=end;i<nbEBands;i++) 1588 { 1589 oldBandE[c*nbEBands+i]=0; 1590 oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-GCONST(28.f); 1591 } 1592 } while (++c<2); 1593 st->rng = dec->rng; 1594 #ifdef ENABLE_QEXT 1595 if (qext_bytes) st->rng = st->rng ^ ext_dec.rng; 1596 #endif 1597 1598 deemphasis(out_syn, pcm, N, CC, st->downsample, mode->preemph, st->preemph_memD, accum); 1599 st->loss_duration = 0; 1600 st->plc_duration = 0; 1601 st->last_frame_type = FRAME_NORMAL; 1602 st->prefilter_and_fold = 0; 1603 RESTORE_STACK; 1604 if (ec_tell(dec) > 8*len) 1605 return OPUS_INTERNAL_ERROR; 1606 #ifdef ENABLE_QEXT 1607 if (qext_bytes != 0 && ec_tell(&ext_dec) > 8*qext_bytes) 1608 return OPUS_INTERNAL_ERROR; 1609 #endif 1610 if(ec_get_error(dec)) 1611 st->error = 1; 1612 return frame_size/st->downsample; 1613 } 1614 1615 int celt_decode_with_ec(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, 1616 int len, opus_res * OPUS_RESTRICT pcm, int frame_size, ec_dec *dec, int accum) 1617 { 1618 return celt_decode_with_ec_dred(st, data, len, pcm, frame_size, dec, accum 1619 #ifdef ENABLE_DEEP_PLC 1620 , NULL 1621 #endif 1622 ARG_QEXT(NULL) ARG_QEXT(0) 1623 ); 1624 } 1625 1626 #if defined(CUSTOM_MODES) || defined(ENABLE_OPUS_CUSTOM_API) 1627 1628 #if defined(FIXED_POINT) && !defined(ENABLE_RES24) 1629 int opus_custom_decode(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, opus_int16 * OPUS_RESTRICT pcm, int frame_size) 1630 { 1631 return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL, 0); 1632 } 1633 #else 1634 int opus_custom_decode(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, opus_int16 * OPUS_RESTRICT pcm, int frame_size) 1635 { 1636 int j, ret, C, N; 1637 VARDECL(opus_res, out); 1638 ALLOC_STACK; 1639 1640 if (pcm==NULL) 1641 return OPUS_BAD_ARG; 1642 1643 C = st->channels; 1644 N = frame_size; 1645 1646 ALLOC(out, C*N, opus_res); 1647 ret = celt_decode_with_ec(st, data, len, out, frame_size, NULL, 0); 1648 if (ret>0) 1649 for (j=0;j<C*ret;j++) 1650 pcm[j]=RES2INT16(out[j]); 1651 1652 RESTORE_STACK; 1653 return ret; 1654 } 1655 #endif 1656 1657 #if defined(FIXED_POINT) && defined(ENABLE_RES24) 1658 int opus_custom_decode24(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, opus_int32 * OPUS_RESTRICT pcm, int frame_size) 1659 { 1660 return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL, 0); 1661 } 1662 #else 1663 int opus_custom_decode24(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, opus_int32 * OPUS_RESTRICT pcm, int frame_size) 1664 { 1665 int j, ret, C, N; 1666 VARDECL(opus_res, out); 1667 ALLOC_STACK; 1668 1669 if (pcm==NULL) 1670 return OPUS_BAD_ARG; 1671 1672 C = st->channels; 1673 N = frame_size; 1674 1675 ALLOC(out, C*N, opus_res); 1676 ret = celt_decode_with_ec(st, data, len, out, frame_size, NULL, 0); 1677 if (ret>0) 1678 for (j=0;j<C*ret;j++) 1679 pcm[j]=RES2INT24(out[j]); 1680 1681 RESTORE_STACK; 1682 return ret; 1683 } 1684 #endif 1685 1686 1687 #ifndef DISABLE_FLOAT_API 1688 1689 # if !defined(FIXED_POINT) 1690 int opus_custom_decode_float(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, float * OPUS_RESTRICT pcm, int frame_size) 1691 { 1692 return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL, 0); 1693 } 1694 # else 1695 int opus_custom_decode_float(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, float * OPUS_RESTRICT pcm, int frame_size) 1696 { 1697 int j, ret, C, N; 1698 VARDECL(opus_res, out); 1699 ALLOC_STACK; 1700 1701 if (pcm==NULL) 1702 return OPUS_BAD_ARG; 1703 1704 C = st->channels; 1705 N = frame_size; 1706 1707 ALLOC(out, C*N, opus_res); 1708 ret=celt_decode_with_ec(st, data, len, out, frame_size, NULL, 0); 1709 if (ret>0) 1710 for (j=0;j<C*ret;j++) 1711 pcm[j]=RES2FLOAT(out[j]); 1712 1713 RESTORE_STACK; 1714 return ret; 1715 } 1716 # endif 1717 1718 #endif 1719 1720 #endif /* CUSTOM_MODES */ 1721 1722 int opus_custom_decoder_ctl(CELTDecoder * OPUS_RESTRICT st, int request, ...) 1723 { 1724 va_list ap; 1725 1726 va_start(ap, request); 1727 switch (request) 1728 { 1729 case OPUS_SET_COMPLEXITY_REQUEST: 1730 { 1731 opus_int32 value = va_arg(ap, opus_int32); 1732 if(value<0 || value>10) 1733 { 1734 goto bad_arg; 1735 } 1736 st->complexity = value; 1737 } 1738 break; 1739 case OPUS_GET_COMPLEXITY_REQUEST: 1740 { 1741 opus_int32 *value = va_arg(ap, opus_int32*); 1742 if (!value) 1743 { 1744 goto bad_arg; 1745 } 1746 *value = st->complexity; 1747 } 1748 break; 1749 case CELT_SET_START_BAND_REQUEST: 1750 { 1751 opus_int32 value = va_arg(ap, opus_int32); 1752 if (value<0 || value>=st->mode->nbEBands) 1753 goto bad_arg; 1754 st->start = value; 1755 } 1756 break; 1757 case CELT_SET_END_BAND_REQUEST: 1758 { 1759 opus_int32 value = va_arg(ap, opus_int32); 1760 if (value<1 || value>st->mode->nbEBands) 1761 goto bad_arg; 1762 st->end = value; 1763 } 1764 break; 1765 case CELT_SET_CHANNELS_REQUEST: 1766 { 1767 opus_int32 value = va_arg(ap, opus_int32); 1768 if (value<1 || value>2) 1769 goto bad_arg; 1770 st->stream_channels = value; 1771 } 1772 break; 1773 case CELT_GET_AND_CLEAR_ERROR_REQUEST: 1774 { 1775 opus_int32 *value = va_arg(ap, opus_int32*); 1776 if (value==NULL) 1777 goto bad_arg; 1778 *value=st->error; 1779 st->error = 0; 1780 } 1781 break; 1782 case OPUS_GET_LOOKAHEAD_REQUEST: 1783 { 1784 opus_int32 *value = va_arg(ap, opus_int32*); 1785 if (value==NULL) 1786 goto bad_arg; 1787 *value = st->overlap/st->downsample; 1788 } 1789 break; 1790 case OPUS_RESET_STATE: 1791 { 1792 int i; 1793 celt_glog *oldBandE, *oldLogE, *oldLogE2; 1794 int decode_buffer_size; 1795 #ifdef ENABLE_QEXT 1796 int qext_scale = st->qext_scale; 1797 #endif 1798 decode_buffer_size = QEXT_SCALE(DECODE_BUFFER_SIZE); 1799 oldBandE = (celt_glog*)(st->_decode_mem+(decode_buffer_size+st->overlap)*st->channels); 1800 oldLogE = oldBandE + 2*st->mode->nbEBands; 1801 oldLogE2 = oldLogE + 2*st->mode->nbEBands; 1802 OPUS_CLEAR((char*)&st->DECODER_RESET_START, 1803 opus_custom_decoder_get_size(st->mode, st->channels)- 1804 ((char*)&st->DECODER_RESET_START - (char*)st)); 1805 for (i=0;i<2*st->mode->nbEBands;i++) 1806 oldLogE[i]=oldLogE2[i]=-GCONST(28.f); 1807 st->skip_plc = 1; 1808 st->last_frame_type = FRAME_NONE; 1809 } 1810 break; 1811 case OPUS_GET_PITCH_REQUEST: 1812 { 1813 opus_int32 *value = va_arg(ap, opus_int32*); 1814 if (value==NULL) 1815 goto bad_arg; 1816 *value = st->postfilter_period; 1817 } 1818 break; 1819 case CELT_GET_MODE_REQUEST: 1820 { 1821 const CELTMode ** value = va_arg(ap, const CELTMode**); 1822 if (value==0) 1823 goto bad_arg; 1824 *value=st->mode; 1825 } 1826 break; 1827 case CELT_SET_SIGNALLING_REQUEST: 1828 { 1829 opus_int32 value = va_arg(ap, opus_int32); 1830 st->signalling = value; 1831 } 1832 break; 1833 case OPUS_GET_FINAL_RANGE_REQUEST: 1834 { 1835 opus_uint32 * value = va_arg(ap, opus_uint32 *); 1836 if (value==0) 1837 goto bad_arg; 1838 *value=st->rng; 1839 } 1840 break; 1841 case OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST: 1842 { 1843 opus_int32 value = va_arg(ap, opus_int32); 1844 if(value<0 || value>1) 1845 { 1846 goto bad_arg; 1847 } 1848 st->disable_inv = value; 1849 } 1850 break; 1851 case OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST: 1852 { 1853 opus_int32 *value = va_arg(ap, opus_int32*); 1854 if (!value) 1855 { 1856 goto bad_arg; 1857 } 1858 *value = st->disable_inv; 1859 } 1860 break; 1861 default: 1862 goto bad_request; 1863 } 1864 va_end(ap); 1865 return OPUS_OK; 1866 bad_arg: 1867 va_end(ap); 1868 return OPUS_BAD_ARG; 1869 bad_request: 1870 va_end(ap); 1871 return OPUS_UNIMPLEMENTED; 1872 }