Showing the changes to codec/decoder/core/src/get_intra_predictor.cpp (1 of 25 files). Show all
Unified · Split
| @@ -380,6 +380,507 @@ void WelsI4x4LumaPredHD_c (uint8_t* pPred, const int32_t kiStride) { · 379 unmodified lines | |||
| 380 | ST32A4 (pPred + kiStride3, LD32 (kuiList)); | 380 | ST32A4 (pPred + kiStride3, LD32 (kuiList)); |
| 381 | } | 381 | } |
| 382 | 382 | ||
| 383 | void WelsI8x8LumaPredV_c (uint8_t* pPred, const int32_t kiStride, bool bTLAvail, bool bTRAvail) { | ||
| 384 | uint64_t uiTop = 0; | ||
| 385 | int32_t iStride[8]; | ||
| 386 | uint8_t uiPixelFilterT[8]; | ||
| 387 | int32_t i; | ||
| 388 | |||
| 389 | for (iStride[0] = 0, i = 1; i < 8; i++) { | ||
| 390 | iStride[i] = iStride[i - 1] + kiStride; | ||
| 391 | } | ||
| 392 | |||
| 393 | uiPixelFilterT[0] = bTLAvail ? ((pPred[-1 - kiStride] + (pPred[-kiStride] << 1) + pPred[1 - kiStride] + 2) >> 2) : (( | ||
| 394 | pPred[-kiStride] * 3 + pPred[1 - kiStride] + 2) >> 2); | ||
| 395 | for (i = 1; i < 7; i++) { | ||
| 396 | uiPixelFilterT[i] = ((pPred[i - 1 - kiStride] + (pPred[i - kiStride] << 1) + pPred[i + 1 - kiStride] + 2) >> 2); | ||
| 397 | } | ||
| 398 | uiPixelFilterT[7] = bTRAvail ? ((pPred[6 - kiStride] + (pPred[7 - kiStride] << 1) + pPred[8 - kiStride] + 2) >> 2) : (( | ||
| 399 | pPred[6 - kiStride] + pPred[7 - kiStride] * 3 + 2) >> 2); | ||
| 400 | |||
| 401 | // 8-89 | ||
| 402 | for (i = 7; i >= 0; i--) { | ||
| 403 | uiTop = ((uiTop << 8) | uiPixelFilterT[i]); | ||
| 404 | } | ||
| 405 | |||
| 406 | for (i = 0; i < 8; i++) { | ||
| 407 | ST64A8 (pPred + kiStride * i, uiTop); | ||
| 408 | } | ||
| 409 | } | ||
| 410 | |||
| 411 | void WelsI8x8LumaPredH_c (uint8_t* pPred, const int32_t kiStride, bool bTLAvail, bool bTRAvail) { | ||
| 412 | uint64_t uiLeft; | ||
| 413 | int32_t iStride[8]; | ||
| 414 | uint8_t uiPixelFilterL[8]; | ||
| 415 | int32_t i; | ||
| 416 | |||
| 417 | for (iStride[0] = 0, i = 1; i < 8; i++) { | ||
| 418 | iStride[i] = iStride[i - 1] + kiStride; | ||
| 419 | } | ||
| 420 | |||
| 421 | uiPixelFilterL[0] = bTLAvail ? ((pPred[-1 - kiStride] + (pPred[-1] << 1) + pPred[-1 + iStride[1]] + 2) >> 2) : (( | ||
| 422 | pPred[-1] * 3 + pPred[-1 + iStride[1]] + 2) >> 2); | ||
| 423 | for (i = 1; i < 7; i++) { | ||
| 424 | uiPixelFilterL[i] = ((pPred[-1 + iStride[i - 1]] + (pPred[-1 + iStride[i]] << 1) + pPred[-1 + iStride[i + 1]] + 2) >> | ||
| 425 | 2); | ||
| 426 | } | ||
| 427 | uiPixelFilterL[7] = ((pPred[-1 + iStride[6]] + pPred[-1 + iStride[7]] * 3 + 2) >> 2); | ||
| 428 | |||
| 429 | // 8-90 | ||
| 430 | for (i = 0; i < 8; i++) { | ||
| 431 | uiLeft = 0x0101010101010101U * uiPixelFilterL[i]; | ||
| 432 | ST64A8 (pPred + iStride[i], uiLeft); | ||
| 433 | } | ||
| 434 | } | ||
| 435 | |||
| 436 | void WelsI8x8LumaPredDc_c (uint8_t* pPred, const int32_t kiStride, bool bTLAvail, bool bTRAvail) { | ||
| 437 | int32_t iStride[8]; | ||
| 438 | uint8_t uiPixelFilterL[8]; | ||
| 439 | uint8_t uiPixelFilterT[8]; | ||
| 440 | uint16_t uiTotal = 0; | ||
| 441 | int32_t i; | ||
| 442 | |||
| 443 | for (iStride[0] = 0, i = 1; i < 8; i++) { | ||
| 444 | iStride[i] = iStride[i - 1] + kiStride; | ||
| 445 | } | ||
| 446 | |||
| 447 | uiPixelFilterL[0] = bTLAvail ? ((pPred[-1 - kiStride] + (pPred[-1] << 1) + pPred[-1 + iStride[1]] + 2) >> 2) : (( | ||
| 448 | pPred[-1] * 3 + pPred[-1 + iStride[1]] + 2) >> 2); | ||
| 449 | uiPixelFilterT[0] = bTLAvail ? ((pPred[-1 - kiStride] + (pPred[-kiStride] << 1) + pPred[1 - kiStride] + 2) >> 2) : (( | ||
| 450 | pPred[-kiStride] * 3 + pPred[1 - kiStride] + 2) >> 2); | ||
| 451 | for (i = 1; i < 7; i++) { | ||
| 452 | uiPixelFilterL[i] = ((pPred[-1 + iStride[i - 1]] + (pPred[-1 + iStride[i]] << 1) + pPred[-1 + iStride[i + 1]] + 2) >> | ||
| 453 | 2); | ||
| 454 | uiPixelFilterT[i] = ((pPred[i - 1 - kiStride] + (pPred[i - kiStride] << 1) + pPred[i + 1 - kiStride] + 2) >> 2); | ||
| 455 | } | ||
| 456 | uiPixelFilterL[7] = ((pPred[-1 + iStride[6]] + pPred[-1 + iStride[7]] * 3 + 2) >> 2); | ||
| 457 | uiPixelFilterT[7] = bTRAvail ? ((pPred[6 - kiStride] + (pPred[7 - kiStride] << 1) + pPred[8 - kiStride] + 2) >> 2) : (( | ||
| 458 | pPred[6 - kiStride] + pPred[7 - kiStride] * 3 + 2) >> 2); | ||
| 459 | |||
| 460 | // 8-91 | ||
| 461 | for (i = 0; i < 8; i++) { | ||
| 462 | uiTotal += uiPixelFilterL[i]; | ||
| 463 | uiTotal += uiPixelFilterT[i]; | ||
| 464 | } | ||
| 465 | |||
| 466 | const uint8_t kuiMean = ((uiTotal + 8) >> 4); | ||
| 467 | const uint64_t kuiMean64 = 0x0101010101010101U * kuiMean; | ||
| 468 | |||
| 469 | for (i = 0; i < 8; i++) { | ||
| 470 | ST64A8 (pPred + iStride[i], kuiMean64); | ||
| 471 | } | ||
| 472 | } | ||
| 473 | |||
| 474 | void WelsI8x8LumaPredDcLeft_c (uint8_t* pPred, const int32_t kiStride, bool bTLAvail, bool bTRAvail) { | ||
| 475 | int32_t iStride[8]; | ||
| 476 | uint8_t uiPixelFilterL[8]; | ||
| 477 | uint16_t uiTotal = 0; | ||
| 478 | int32_t i; | ||
| 479 | |||
| 480 | for (iStride[0] = 0, i = 1; i < 8; i++) { | ||
| 481 | iStride[i] = iStride[i - 1] + kiStride; | ||
| 482 | } | ||
| 483 | |||
| 484 | uiPixelFilterL[0] = bTLAvail ? ((pPred[-1 - kiStride] + (pPred[-1] << 1) + pPred[-1 + iStride[1]] + 2) >> 2) : (( | ||
| 485 | pPred[-1] * 3 + pPred[-1 + iStride[1]] + 2) >> 2); | ||
| 486 | for (i = 1; i < 7; i++) { | ||
| 487 | uiPixelFilterL[i] = ((pPred[-1 + iStride[i - 1]] + (pPred[-1 + iStride[i]] << 1) + pPred[-1 + iStride[i + 1]] + 2) >> | ||
| 488 | 2); | ||
| 489 | } | ||
| 490 | uiPixelFilterL[7] = ((pPred[-1 + iStride[6]] + pPred[-1 + iStride[7]] * 3 + 2) >> 2); | ||
| 491 | |||
| 492 | // 8-92 | ||
| 493 | for (i = 0; i < 8; i++) { | ||
| 494 | uiTotal += uiPixelFilterL[i]; | ||
| 495 | } | ||
| 496 | |||
| 497 | const uint8_t kuiMean = ((uiTotal + 4) >> 3); | ||
| 498 | const uint64_t kuiMean64 = 0x0101010101010101U * kuiMean; | ||
| 499 | |||
| 500 | for (i = 0; i < 8; i++) { | ||
| 501 | ST64A8 (pPred + iStride[i], kuiMean64); | ||
| 502 | } | ||
| 503 | } | ||
| 504 | |||
| 505 | void WelsI8x8LumaPredDcTop_c (uint8_t* pPred, const int32_t kiStride, bool bTLAvail, bool bTRAvail) { | ||
| 506 | int32_t iStride[8]; | ||
| 507 | uint8_t uiPixelFilterT[8]; | ||
| 508 | uint16_t uiTotal = 0; | ||
| 509 | int32_t i; | ||
| 510 | |||
| 511 | for (iStride[0] = 0, i = 1; i < 8; i++) { | ||
| 512 | iStride[i] = iStride[i - 1] + kiStride; | ||
| 513 | } | ||
| 514 | |||
| 515 | uiPixelFilterT[0] = bTLAvail ? ((pPred[-1 - kiStride] + (pPred[-kiStride] << 1) + pPred[1 - kiStride] + 2) >> 2) : (( | ||
| 516 | pPred[-kiStride] * 3 + pPred[1 - kiStride] + 2) >> 2); | ||
| 517 | for (i = 1; i < 7; i++) { | ||
| 518 | uiPixelFilterT[i] = ((pPred[i - 1 - kiStride] + (pPred[i - kiStride] << 1) + pPred[i + 1 - kiStride] + 2) >> 2); | ||
| 519 | } | ||
| 520 | uiPixelFilterT[7] = bTRAvail ? ((pPred[6 - kiStride] + (pPred[7 - kiStride] << 1) + pPred[8 - kiStride] + 2) >> 2) : (( | ||
| 521 | pPred[6 - kiStride] + pPred[7 - kiStride] * 3 + 2) >> 2); | ||
| 522 | |||
| 523 | // 8-93 | ||
| 524 | for (i = 0; i < 8; i++) { | ||
| 525 | uiTotal += uiPixelFilterT[i]; | ||
| 526 | } | ||
| 527 | |||
| 528 | const uint8_t kuiMean = ((uiTotal + 4) >> 3); | ||
| 529 | const uint64_t kuiMean64 = 0x0101010101010101U * kuiMean; | ||
| 530 | |||
| 531 | for (i = 0; i < 8; i++) { | ||
| 532 | ST64A8 (pPred + iStride[i], kuiMean64); | ||
| 533 | } | ||
| 534 | } | ||
| 535 | |||
| 536 | void WelsI8x8LumaPredDcNA_c (uint8_t* pPred, const int32_t kiStride, bool bTLAvail, bool bTRAvail) { | ||
| 537 | // for normal 8 bit depth, 8-94 | ||
| 538 | const uint64_t kuiDC64 = 0x8080808080808080U; | ||
| 539 | |||
| 540 | int32_t iStride[8]; | ||
| 541 | int32_t i; | ||
| 542 | ST64A8 (pPred, kuiDC64); | ||
| 543 | for (iStride[0] = 0, i = 1; i < 8; i++) { | ||
| 544 | iStride[i] = iStride[i - 1] + kiStride; | ||
| 545 | ST64A8 (pPred + iStride[i], kuiDC64); | ||
| 546 | } | ||
| 547 | } | ||
| 548 | |||
| 549 | /*down pLeft*/ | ||
| 550 | void WelsI8x8LumaPredDDL_c (uint8_t* pPred, const int32_t kiStride, bool bTLAvail, bool bTRAvail) { | ||
| 551 | // Top and Top-right available | ||
| 552 | int32_t iStride[8]; | ||
| 553 | uint8_t uiPixelFilterT[16]; | ||
| 554 | int32_t i, j; | ||
| 555 | |||
| 556 | for (iStride[0] = 0, i = 1; i < 8; i++) { | ||
| 557 | iStride[i] = iStride[i - 1] + kiStride; | ||
| 558 | } | ||
| 559 | |||
| 560 | uiPixelFilterT[0] = bTLAvail ? ((pPred[-1 - kiStride] + (pPred[-kiStride] << 1) + pPred[1 - kiStride] + 2) >> 2) : (( | ||
| 561 | pPred[-kiStride] * 3 + pPred[1 - kiStride] + 2) >> 2); | ||
| 562 | for (i = 1; i < 15; i++) { | ||
| 563 | uiPixelFilterT[i] = ((pPred[i - 1 - kiStride] + (pPred[i - kiStride] << 1) + pPred[i + 1 - kiStride] + 2) >> 2); | ||
| 564 | } | ||
| 565 | uiPixelFilterT[15] = ((pPred[14 - kiStride] + pPred[15 - kiStride] * 3 + 2) >> 2); | ||
| 566 | |||
| 567 | for (i = 0; i < 8; i++) { // y | ||
| 568 | for (j = 0; j < 8; j++) { // x | ||
| 569 | if (i == 7 && j == 7) { // 8-95 | ||
| 570 | pPred[j + iStride[i]] = (uiPixelFilterT[14] + 3 * uiPixelFilterT[15] + 2) >> 2; | ||
| 571 | } else { // 8-96 | ||
| 572 | pPred[j + iStride[i]] = (uiPixelFilterT[i + j] + (uiPixelFilterT[i + j + 1] << 1) + uiPixelFilterT[i + j + 2] + 2) >> 2; | ||
| 573 | } | ||
| 574 | } | ||
| 575 | } | ||
| 576 | } | ||
| 577 | |||
| 578 | /*down pLeft*/ | ||
| 579 | void WelsI8x8LumaPredDDLTop_c (uint8_t* pPred, const int32_t kiStride, bool bTLAvail, bool bTRAvail) { | ||
| 580 | // Top available and Top-right unavailable | ||
| 581 | int32_t iStride[8]; | ||
| 582 | uint8_t uiPixelFilterT[16]; | ||
| 583 | int32_t i, j; | ||
| 584 | |||
| 585 | for (iStride[0] = 0, i = 1; i < 8; i++) { | ||
| 586 | iStride[i] = iStride[i - 1] + kiStride; | ||
| 587 | } | ||
| 588 | |||
| 589 | uiPixelFilterT[0] = bTLAvail ? ((pPred[-1 - kiStride] + (pPred[-kiStride] << 1) + pPred[1 - kiStride] + 2) >> 2) : (( | ||
| 590 | pPred[-kiStride] * 3 + pPred[1 - kiStride] + 2) >> 2); | ||
| 591 | for (i = 1; i < 7; i++) { | ||
| 592 | uiPixelFilterT[i] = ((pPred[i - 1 - kiStride] + (pPred[i - kiStride] << 1) + pPred[i + 1 - kiStride] + 2) >> 2); | ||
| 593 | } | ||
| 594 | // p[x, -1] x=8...15 are replaced with p[7, -1] | ||
| 595 | uiPixelFilterT[7] = ((pPred[6 - kiStride] + pPred[7 - kiStride] * 3 + 2) >> 2); | ||
| 596 | for (i = 8; i < 16; i++) { | ||
| 597 | uiPixelFilterT[i] = pPred[7 - kiStride]; | ||
| 598 | } | ||
| 599 | |||
| 600 | for (i = 0; i < 8; i++) { // y | ||
| 601 | for (j = 0; j < 8; j++) { // x | ||
| 602 | if (i == 7 && j == 7) { // 8-95 | ||
| 603 | pPred[j + iStride[i]] = (uiPixelFilterT[14] + 3 * uiPixelFilterT[15] + 2) >> 2; | ||
| 604 | } else { // 8-96 | ||
| 605 | pPred[j + iStride[i]] = (uiPixelFilterT[i + j] + (uiPixelFilterT[i + j + 1] << 1) + uiPixelFilterT[i + j + 2] + 2) >> 2; | ||
| 606 | } | ||
| 607 | } | ||
| 608 | } | ||
| 609 | } | ||
| 610 | |||
| 611 | /*down right*/ | ||
| 612 | void WelsI8x8LumaPredDDR_c (uint8_t* pPred, const int32_t kiStride, bool bTLAvail, bool bTRAvail) { | ||
| 613 | // The TopLeft, Top, Left are all available under this mode | ||
| 614 | int32_t iStride[8]; | ||
| 615 | uint8_t uiPixelFilterTL; | ||
| 616 | uint8_t uiPixelFilterL[8]; | ||
| 617 | uint8_t uiPixelFilterT[8]; | ||
| 618 | int32_t i, j; | ||
| 619 | |||
| 620 | for (iStride[0] = 0, i = 1; i < 8; i++) { | ||
| 621 | iStride[i] = iStride[i - 1] + kiStride; | ||
| 622 | } | ||
| 623 | |||
| 624 | uiPixelFilterTL = (pPred[-1] + (pPred[-1 - kiStride] << 1) + pPred[-kiStride] + 2) >> 2; | ||
| 625 | |||
| 626 | uiPixelFilterL[0] = ((pPred[-1 - kiStride] + (pPred[-1] << 1) + pPred[-1 + iStride[1]] + 2) >> 2); | ||
| 627 | uiPixelFilterT[0] = ((pPred[-1 - kiStride] + (pPred[-kiStride] << 1) + pPred[1 - kiStride] + 2) >> 2); | ||
| 628 | for (i = 1; i < 7; i++) { | ||
| 629 | uiPixelFilterL[i] = ((pPred[-1 + iStride[i - 1]] + (pPred[-1 + iStride[i]] << 1) + pPred[-1 + iStride[i + 1]] + 2) >> | ||
| 630 | 2); | ||
| 631 | uiPixelFilterT[i] = ((pPred[i - 1 - kiStride] + (pPred[i - kiStride] << 1) + pPred[i + 1 - kiStride] + 2) >> 2); | ||
| 632 | } | ||
| 633 | uiPixelFilterL[7] = ((pPred[-1 + iStride[6]] + pPred[-1 + iStride[7]] * 3 + 2) >> 2); | ||
| 634 | uiPixelFilterT[7] = bTRAvail ? ((pPred[6 - kiStride] + (pPred[7 - kiStride] << 1) + pPred[8 - kiStride] + 2) >> 2) : (( | ||
| 635 | pPred[6 - kiStride] + pPred[7 - kiStride] * 3 + 2) >> 2); | ||
| 636 | |||
| 637 | for (i = 0; i < 8; i++) { // y | ||
| 638 | // 8-98, x < y-1 | ||
| 639 | for (j = 0; j < (i - 1); j++) { | ||
| 640 | pPred[j + iStride[i]] = (uiPixelFilterL[i - j - 2] + (uiPixelFilterL[i - j - 1] << 1) + uiPixelFilterL[i - j] + 2) >> 2; | ||
| 641 | } | ||
| 642 | // 8-98, special case, x == y-1 | ||
| 643 | if (i >= 1) { | ||
| 644 | j = i - 1; | ||
| 645 | pPred[j + iStride[i]] = (uiPixelFilterTL + (uiPixelFilterL[0] << 1) + uiPixelFilterL[1] + 2) >> 2; | ||
| 646 | } | ||
| 647 | // 8-99, x==y | ||
| 648 | j = i; | ||
| 649 | pPred[j + iStride[i]] = (uiPixelFilterT[0] + (uiPixelFilterTL << 1) + uiPixelFilterL[0] + 2) >> 2; | ||
| 650 | // 8-97, special case, x == y+1 | ||
| 651 | if (i < 7) { | ||
| 652 | j = i + 1; | ||
| 653 | pPred[j + iStride[i]] = (uiPixelFilterTL + (uiPixelFilterT[0] << 1) + uiPixelFilterT[1] + 2) >> 2; | ||
| 654 | } | ||
| 655 | for (j = i + 2; j < 8; j++) { // 8-97, x > y+1 | ||
| 656 | pPred[j + iStride[i]] = (uiPixelFilterT[j - i - 2] + (uiPixelFilterT[j - i - 1] << 1) + uiPixelFilterT[j - i] + 2) >> 2; | ||
| 657 | } | ||
| 658 | } | ||
| 659 | } | ||
| 660 | |||
| 661 | /*vertical pLeft*/ | ||
| 662 | void WelsI8x8LumaPredVL_c (uint8_t* pPred, const int32_t kiStride, bool bTLAvail, bool bTRAvail) { | ||
| 663 | // Top and Top-right available | ||
| 664 | int32_t iStride[8]; | ||
| 665 | uint8_t uiPixelFilterT[16]; | ||
| 666 | int32_t i, j; | ||
| 667 | |||
| 668 | for (iStride[0] = 0, i = 1; i < 8; i++) { | ||
| 669 | iStride[i] = iStride[i - 1] + kiStride; | ||
| 670 | } | ||
| 671 | |||
| 672 | uiPixelFilterT[0] = bTLAvail ? ((pPred[-1 - kiStride] + (pPred[-kiStride] << 1) + pPred[1 - kiStride] + 2) >> 2) : (( | ||
| 673 | pPred[-kiStride] * 3 + pPred[1 - kiStride] + 2) >> 2); | ||
| 674 | for (i = 1; i < 15; i++) { | ||
| 675 | uiPixelFilterT[i] = ((pPred[i - 1 - kiStride] + (pPred[i - kiStride] << 1) + pPred[i + 1 - kiStride] + 2) >> 2); | ||
| 676 | } | ||
| 677 | uiPixelFilterT[15] = ((pPred[14 - kiStride] + pPred[15 - kiStride] * 3 + 2) >> 2); | ||
| 678 | |||
| 679 | for (i = 0; i < 8; i++) { // y | ||
| 680 | if ((i & 0x01) == 0) { // 8-108 | ||
| 681 | for (j = 0; j < 8; j++) { // x | ||
| 682 | pPred[j + iStride[i]] = (uiPixelFilterT[j + (i >> 1)] + uiPixelFilterT[j + (i >> 1) + 1] + 1) >> 1; | ||
| 683 | } | ||
| 684 | } else { // 8-109 | ||
| 685 | for (j = 0; j < 8; j++) { // x | ||
| 686 | pPred[j + iStride[i]] = (uiPixelFilterT[j + (i >> 1)] + (uiPixelFilterT[j + (i >> 1) + 1] << 1) + uiPixelFilterT[j + | ||
| 687 | (i >> 1) + 2] + 2) >> 2; | ||
| 688 | } | ||
| 689 | } | ||
| 690 | } | ||
| 691 | } | ||
| 692 | |||
| 693 | /*vertical pLeft*/ | ||
| 694 | void WelsI8x8LumaPredVLTop_c (uint8_t* pPred, const int32_t kiStride, bool bTLAvail, bool bTRAvail) { | ||
| 695 | // Top available and Top-right unavailable | ||
| 696 | int32_t iStride[8]; | ||
| 697 | uint8_t uiPixelFilterT[16]; | ||
| 698 | int32_t i, j; | ||
| 699 | |||
| 700 | for (iStride[0] = 0, i = 1; i < 8; i++) { | ||
| 701 | iStride[i] = iStride[i - 1] + kiStride; | ||
| 702 | } | ||
| 703 | |||
| 704 | uiPixelFilterT[0] = bTLAvail ? ((pPred[-1 - kiStride] + (pPred[-kiStride] << 1) + pPred[1 - kiStride] + 2) >> 2) : (( | ||
| 705 | pPred[-kiStride] * 3 + pPred[1 - kiStride] + 2) >> 2); | ||
| 706 | for (i = 1; i < 7; i++) { | ||
| 707 | uiPixelFilterT[i] = ((pPred[i - 1 - kiStride] + (pPred[i - kiStride] << 1) + pPred[i + 1 - kiStride] + 2) >> 2); | ||
| 708 | } | ||
| 709 | // p[x, -1] x=8...15 are replaced with p[7, -1] | ||
| 710 | uiPixelFilterT[7] = ((pPred[6 - kiStride] + pPred[7 - kiStride] * 3 + 2) >> 2); | ||
| 711 | for (i = 8; i < 16; i++) { | ||
| 712 | uiPixelFilterT[i] = pPred[7 - kiStride]; | ||
| 713 | } | ||
| 714 | |||
| 715 | for (i = 0; i < 8; i++) { // y | ||
| 716 | if ((i & 0x01) == 0) { // 8-108 | ||
| 717 | for (j = 0; j < 8; j++) { // x | ||
| 718 | pPred[j + iStride[i]] = (uiPixelFilterT[j + (i >> 1)] + uiPixelFilterT[j + (i >> 1) + 1] + 1) >> 1; | ||
| 719 | } | ||
| 720 | } else { // 8-109 | ||
| 721 | for (j = 0; j < 8; j++) { // x | ||
| 722 | pPred[j + iStride[i]] = (uiPixelFilterT[j + (i >> 1)] + (uiPixelFilterT[j + (i >> 1) + 1] << 1) + uiPixelFilterT[j + | ||
| 723 | (i >> 1) + 2] + 2) >> 2; | ||
| 724 | } | ||
| 725 | } | ||
| 726 | } | ||
| 727 | } | ||
| 728 | |||
| 729 | /*vertical right*/ | ||
| 730 | void WelsI8x8LumaPredVR_c (uint8_t* pPred, const int32_t kiStride, bool bTLAvail, bool bTRAvail) { | ||
| 731 | // The TopLeft, Top, Left are always available under this mode | ||
| 732 | int32_t iStride[8]; | ||
| 733 | uint8_t uiPixelFilterTL; | ||
| 734 | uint8_t uiPixelFilterL[8]; | ||
| 735 | uint8_t uiPixelFilterT[8]; | ||
| 736 | int32_t i, j; | ||
| 737 | int32_t izVR, izVRDiv; | ||
| 738 | |||
| 739 | for (iStride[0] = 0, i = 1; i < 8; i++) { | ||
| 740 | iStride[i] = iStride[i - 1] + kiStride; | ||
| 741 | } | ||
| 742 | |||
| 743 | uiPixelFilterTL = (pPred[-1] + (pPred[-1 - kiStride] << 1) + pPred[-kiStride] + 2) >> 2; | ||
| 744 | |||
| 745 | uiPixelFilterL[0] = ((pPred[-1 - kiStride] + (pPred[-1] << 1) + pPred[-1 + iStride[1]] + 2) >> 2); | ||
| 746 | uiPixelFilterT[0] = ((pPred[-1 - kiStride] + (pPred[-kiStride] << 1) + pPred[1 - kiStride] + 2) >> 2); | ||
| 747 | for (i = 1; i < 7; i++) { | ||
| 748 | uiPixelFilterL[i] = ((pPred[-1 + iStride[i - 1]] + (pPred[-1 + iStride[i]] << 1) + pPred[-1 + iStride[i + 1]] + 2) >> | ||
| 749 | 2); | ||
| 750 | uiPixelFilterT[i] = ((pPred[i - 1 - kiStride] + (pPred[i - kiStride] << 1) + pPred[i + 1 - kiStride] + 2) >> 2); | ||
| 751 | } | ||
| 752 | uiPixelFilterL[7] = ((pPred[-1 + iStride[6]] + pPred[-1 + iStride[7]] * 3 + 2) >> 2); | ||
| 753 | uiPixelFilterT[7] = bTRAvail ? ((pPred[6 - kiStride] + (pPred[7 - kiStride] << 1) + pPred[8 - kiStride] + 2) >> 2) : (( | ||
| 754 | pPred[6 - kiStride] + pPred[7 - kiStride] * 3 + 2) >> 2); | ||
| 755 | |||
| 756 | for (i = 0; i < 8; i++) { // y | ||
| 757 | for (j = 0; j < 8; j++) { // x | ||
| 758 | izVR = (j << 1) - i; // 2 * x - y | ||
| 759 | izVRDiv = j - (i >> 1); | ||
| 760 | if (izVR >= 0) { | ||
| 761 | if ((izVR & 0x01) == 0) { // 8-100 | ||
| 762 | if (izVRDiv > 0) { | ||
| 763 | pPred[j + iStride[i]] = (uiPixelFilterT[izVRDiv - 1] + uiPixelFilterT[izVRDiv] + 1) >> 1; | ||
| 764 | } else { | ||
| 765 | pPred[j + iStride[i]] = (uiPixelFilterTL + uiPixelFilterT[0] + 1) >> 1; | ||
| 766 | } | ||
| 767 | } else { // 8-101 | ||
| 768 | if (izVRDiv > 1) { | ||
| 769 | pPred[j + iStride[i]] = (uiPixelFilterT[izVRDiv - 2] + (uiPixelFilterT[izVRDiv - 1] << 1) + uiPixelFilterT[izVRDiv] + 2) | ||
| 770 | >> 2; | ||
| 771 | } else { | ||
| 772 | pPred[j + iStride[i]] = (uiPixelFilterTL + (uiPixelFilterT[0] << 1) + uiPixelFilterT[1] + 2) >> 2; | ||
| 773 | } | ||
| 774 | } | ||
| 775 | } else if (izVR == -1) { // 8-102 | ||
| 776 | pPred[j + iStride[i]] = (uiPixelFilterL[0] + (uiPixelFilterTL << 1) + uiPixelFilterT[0] + 2) >> 2; | ||
| 777 | } else if (izVR < -2) { // 8-103 | ||
| 778 | pPred[j + iStride[i]] = (uiPixelFilterL[-izVR - 1] + (uiPixelFilterL[-izVR - 2] << 1) + uiPixelFilterL[-izVR - 3] + 2) | ||
| 779 | >> 2; | ||
| 780 | } else { // izVR==-2, 8-103, special case | ||
| 781 | pPred[j + iStride[i]] = (uiPixelFilterL[1] + (uiPixelFilterL[0] << 1) + uiPixelFilterTL + 2) >> 2; | ||
| 782 | } | ||
| 783 | } | ||
| 784 | } | ||
| 785 | } | ||
| 786 | |||
| 787 | /*horizontal up*/ | ||
| 788 | void WelsI8x8LumaPredHU_c (uint8_t* pPred, const int32_t kiStride, bool bTLAvail, bool bTRAvail) { | ||
| 789 | int32_t iStride[8]; | ||
| 790 | uint8_t uiPixelFilterL[8]; | ||
| 791 | int32_t i, j; | ||
| 792 | int32_t izHU; | ||
| 793 | |||
| 794 | for (iStride[0] = 0, i = 1; i < 8; i++) { | ||
| 795 | iStride[i] = iStride[i - 1] + kiStride; | ||
| 796 | } | ||
| 797 | |||
| 798 | uiPixelFilterL[0] = bTLAvail ? ((pPred[-1 - kiStride] + (pPred[-1] << 1) + pPred[-1 + iStride[1]] + 2) >> 2) : (( | ||
| 799 | pPred[-1] * 3 + pPred[-1 + iStride[1]] + 2) >> 2); | ||
| 800 | for (i = 1; i < 7; i++) { | ||
| 801 | uiPixelFilterL[i] = ((pPred[-1 + iStride[i - 1]] + (pPred[-1 + iStride[i]] << 1) + pPred[-1 + iStride[i + 1]] + 2) >> | ||
| 802 | 2); | ||
| 803 | } | ||
| 804 | uiPixelFilterL[7] = ((pPred[-1 + iStride[6]] + pPred[-1 + iStride[7]] * 3 + 2) >> 2); | ||
| 805 | |||
| 806 | for (i = 0; i < 8; i++) { // y | ||
| 807 | for (j = 0; j < 8; j++) { // x | ||
| 808 | izHU = j + (i << 1); // x + 2 * y | ||
| 809 | if (izHU < 13) { | ||
| 810 | if ((izHU & 0x01) == 0) { // 8-110 | ||
| 811 | pPred[j + iStride[i]] = (uiPixelFilterL[izHU >> 1] + uiPixelFilterL[1 + (izHU >> 1)] + 1) >> 1; | ||
| 812 | } else { // 8-111 | ||
| 813 | pPred[j + iStride[i]] = (uiPixelFilterL[izHU >> 1] + (uiPixelFilterL[1 + (izHU >> 1)] << 1) + uiPixelFilterL[2 + | ||
| 814 | (izHU >> 1)] + 2) >> 2; | ||
| 815 | } | ||
| 816 | } else if (izHU == 13) { // 8-112 | ||
| 817 | pPred[j + iStride[i]] = (uiPixelFilterL[6] + 3 * uiPixelFilterL[7] + 2) >> 2; | ||
| 818 | } else { // 8-113 | ||
| 819 | pPred[j + iStride[i]] = uiPixelFilterL[7]; | ||
| 820 | } | ||
| 821 | } | ||
| 822 | } | ||
| 823 | } | ||
| 824 | |||
| 825 | /*horizontal down*/ | ||
| 826 | void WelsI8x8LumaPredHD_c (uint8_t* pPred, const int32_t kiStride, bool bTLAvail, bool bTRAvail) { | ||
| 827 | // The TopLeft, Top, Left are all available under this mode | ||
| 828 | int32_t iStride[8]; | ||
| 829 | uint8_t uiPixelFilterTL; | ||
| 830 | uint8_t uiPixelFilterL[8]; | ||
| 831 | uint8_t uiPixelFilterT[8]; | ||
| 832 | int32_t i, j; | ||
| 833 | int32_t izHD, izHDDiv; | ||
| 834 | |||
| 835 | for (iStride[0] = 0, i = 1; i < 8; i++) { | ||
| 836 | iStride[i] = iStride[i - 1] + kiStride; | ||
| 837 | } | ||
| 838 | |||
| 839 | uiPixelFilterTL = (pPred[-1] + (pPred[-1 - kiStride] << 1) + pPred[-kiStride] + 2) >> 2; | ||
| 840 | |||
| 841 | uiPixelFilterL[0] = ((pPred[-1 - kiStride] + (pPred[-1] << 1) + pPred[-1 + iStride[1]] + 2) >> 2); | ||
| 842 | uiPixelFilterT[0] = ((pPred[-1 - kiStride] + (pPred[-kiStride] << 1) + pPred[1 - kiStride] + 2) >> 2); | ||
| 843 | for (i = 1; i < 7; i++) { | ||
| 844 | uiPixelFilterL[i] = ((pPred[-1 + iStride[i - 1]] + (pPred[-1 + iStride[i]] << 1) + pPred[-1 + iStride[i + 1]] + 2) >> | ||
| 845 | 2); | ||
| 846 | uiPixelFilterT[i] = ((pPred[i - 1 - kiStride] + (pPred[i - kiStride] << 1) + pPred[i + 1 - kiStride] + 2) >> 2); | ||
| 847 | } | ||
| 848 | uiPixelFilterL[7] = ((pPred[-1 + iStride[6]] + pPred[-1 + iStride[7]] * 3 + 2) >> 2); | ||
| 849 | uiPixelFilterT[7] = bTRAvail ? ((pPred[6 - kiStride] + (pPred[7 - kiStride] << 1) + pPred[8 - kiStride] + 2) >> 2) : (( | ||
| 850 | pPred[6 - kiStride] + pPred[7 - kiStride] * 3 + 2) >> 2); | ||
| 851 | |||
| 852 | for (i = 0; i < 8; i++) { // y | ||
| 853 | for (j = 0; j < 8; j++) { // x | ||
| 854 | izHD = (i << 1) - j; // 2*y - x | ||
| 855 | izHDDiv = i - (j >> 1); | ||
| 856 | if (izHD >= 0) { | ||
| 857 | if ((izHD & 0x01) == 0) { // 8-104 | ||
| 858 | if (izHDDiv == 0) { | ||
| 859 | pPred[j + iStride[i]] = (uiPixelFilterTL + uiPixelFilterL[0] + 1) >> 1; | ||
| 860 | } else { | ||
| 861 | pPred[j + iStride[i]] = (uiPixelFilterL[izHDDiv - 1] + uiPixelFilterL[izHDDiv] + 1) >> 1; | ||
| 862 | } | ||
| 863 | } else { // 8-105 | ||
| 864 | if (izHDDiv == 1) { | ||
| 865 | pPred[j + iStride[i]] = (uiPixelFilterTL + (uiPixelFilterL[0] << 1) + uiPixelFilterL[1] + 2) >> 2; | ||
| 866 | } else { | ||
| 867 | pPred[j + iStride[i]] = (uiPixelFilterL[izHDDiv - 2] + (uiPixelFilterL[izHDDiv - 1] << 1) + uiPixelFilterL[izHDDiv] + 2) | ||
| 868 | >> 2; | ||
| 869 | } | ||
| 870 | } | ||
| 871 | } else if (izHD == -1) { // 8-106 | ||
| 872 | pPred[j + iStride[i]] = (uiPixelFilterL[0] + (uiPixelFilterTL << 1) + uiPixelFilterT[0] + 2) >> 2; | ||
| 873 | } else if (izHD < -2) { // 8-107 | ||
| 874 | pPred[j + iStride[i]] = (uiPixelFilterT[-izHD - 1] + (uiPixelFilterT[-izHD - 2] << 1) + uiPixelFilterT[-izHD - 3] + 2) | ||
| 875 | >> 2; | ||
| 876 | } else { // 8-107 special case, izHD==-2 | ||
| 877 | pPred[j + iStride[i]] = (uiPixelFilterT[1] + (uiPixelFilterT[0] << 1) + uiPixelFilterTL + 2) >> 2; | ||
| 878 | } | ||
| 879 | } | ||
| 880 | } | ||
| 881 | } | ||
| 882 | |||
| 883 | |||
| 383 | void WelsIChromaPredV_c (uint8_t* pPred, const int32_t kiStride) { | 884 | void WelsIChromaPredV_c (uint8_t* pPred, const int32_t kiStride) { |
| 384 | const uint64_t kuiVal64 = LD64A8 (&pPred[-kiStride]); | 885 | const uint64_t kuiVal64 = LD64A8 (&pPred[-kiStride]); |
| 385 | const int32_t kiStride2 = kiStride << 1; | 886 | const int32_t kiStride2 = kiStride << 1; |