458 |
/* Do a diamond search around given starting point, return SAD of best */ |
/* Do a diamond search around given starting point, return SAD of best */ |
459 |
|
|
460 |
int32_t iDirection = 0; |
int32_t iDirection = 0; |
461 |
|
int32_t iDirectionBackup; |
462 |
int32_t iSAD; |
int32_t iSAD; |
463 |
VECTOR backupMV; |
VECTOR backupMV; |
464 |
|
|
472 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize, 3); |
CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize, 3); |
473 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize, 4); |
CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize, 4); |
474 |
|
|
475 |
if (iDirection) |
if (iDirection) { |
476 |
while (!iFound) { |
while (!iFound) { |
477 |
iFound = 1; |
iFound = 1; |
478 |
backupMV = *currMV; |
backupMV = *currMV; |
479 |
|
iDirectionBackup = iDirection; |
480 |
|
|
481 |
if (iDirection != 2) |
if (iDirectionBackup != 2) |
482 |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
483 |
backupMV.y, 1); |
backupMV.y, 1); |
484 |
if (iDirection != 1) |
if (iDirectionBackup != 1) |
485 |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
486 |
backupMV.y, 2); |
backupMV.y, 2); |
487 |
if (iDirection != 4) |
if (iDirectionBackup != 4) |
488 |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x, |
489 |
backupMV.y - iDiamondSize, 3); |
backupMV.y - iDiamondSize, 3); |
490 |
if (iDirection != 3) |
if (iDirectionBackup != 3) |
491 |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x, |
492 |
backupMV.y + iDiamondSize, 4); |
backupMV.y + iDiamondSize, 4); |
493 |
|
} |
494 |
} else { |
} else { |
495 |
currMV->x = start_x; |
currMV->x = start_x; |
496 |
currMV->y = start_y; |
currMV->y = start_y; |
554 |
backupMV.y + iDiamondSize, 8); |
backupMV.y + iDiamondSize, 8); |
555 |
|
|
556 |
|
|
557 |
if (iDirection) |
if (iDirection) { |
558 |
while (!iFound) { |
while (!iFound) { |
559 |
iFound = 1; |
iFound = 1; |
560 |
backupMV = *currMV; |
backupMV = *currMV; |
563 |
case 1: |
case 1: |
564 |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
565 |
backupMV.y, 1); |
backupMV.y, 1); |
566 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
567 |
backupMV.y - iDiamondSize, 5); |
backupMV.y - iDiamondSize, 5); |
568 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
569 |
backupMV.y - iDiamondSize, 7); |
backupMV.y - iDiamondSize, 7); |
570 |
break; |
break; |
571 |
case 2: |
case 2: |
572 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize, backupMV.y, |
573 |
2); |
2); |
574 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
575 |
backupMV.y + iDiamondSize, 6); |
backupMV.y + iDiamondSize, 6); |
576 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
577 |
backupMV.y + iDiamondSize, 8); |
backupMV.y + iDiamondSize, 8); |
578 |
break; |
break; |
579 |
|
|
580 |
case 3: |
case 3: |
581 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x, backupMV.y + iDiamondSize, |
582 |
4); |
4); |
583 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
584 |
backupMV.y - iDiamondSize, 7); |
backupMV.y - iDiamondSize, 7); |
585 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
586 |
backupMV.y + iDiamondSize, 8); |
backupMV.y + iDiamondSize, 8); |
587 |
break; |
break; |
588 |
|
|
589 |
case 4: |
case 4: |
590 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x, backupMV.y - iDiamondSize, |
591 |
3); |
3); |
592 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
593 |
backupMV.y - iDiamondSize, 5); |
backupMV.y - iDiamondSize, 5); |
594 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
595 |
backupMV.y + iDiamondSize, 6); |
backupMV.y + iDiamondSize, 6); |
596 |
break; |
break; |
597 |
|
|
598 |
case 5: |
case 5: |
599 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, backupMV.y, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize, backupMV.y, |
600 |
1); |
1); |
601 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x, backupMV.y - iDiamondSize, |
602 |
3); |
3); |
603 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
604 |
backupMV.y - iDiamondSize, 5); |
backupMV.y - iDiamondSize, 5); |
605 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
606 |
backupMV.y + iDiamondSize, 6); |
backupMV.y + iDiamondSize, 6); |
607 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
608 |
backupMV.y - iDiamondSize, 7); |
backupMV.y - iDiamondSize, 7); |
609 |
break; |
break; |
610 |
|
|
611 |
case 6: |
case 6: |
612 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize, backupMV.y, |
613 |
2); |
2); |
614 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x, backupMV.y - iDiamondSize, |
615 |
3); |
3); |
616 |
|
|
617 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
618 |
backupMV.y - iDiamondSize, 5); |
backupMV.y - iDiamondSize, 5); |
619 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
620 |
backupMV.y + iDiamondSize, 6); |
backupMV.y + iDiamondSize, 6); |
621 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
622 |
backupMV.y + iDiamondSize, 8); |
backupMV.y + iDiamondSize, 8); |
623 |
|
|
624 |
break; |
break; |
626 |
case 7: |
case 7: |
627 |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
628 |
backupMV.y, 1); |
backupMV.y, 1); |
629 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x, backupMV.y + iDiamondSize, |
630 |
4); |
4); |
631 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
632 |
backupMV.y - iDiamondSize, 5); |
backupMV.y - iDiamondSize, 5); |
633 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
634 |
backupMV.y - iDiamondSize, 7); |
backupMV.y - iDiamondSize, 7); |
635 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
636 |
backupMV.y + iDiamondSize, 8); |
backupMV.y + iDiamondSize, 8); |
637 |
break; |
break; |
638 |
|
|
639 |
case 8: |
case 8: |
640 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize, backupMV.y, |
641 |
2); |
2); |
642 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x, backupMV.y + iDiamondSize, |
643 |
4); |
4); |
644 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
645 |
backupMV.y + iDiamondSize, 6); |
backupMV.y + iDiamondSize, 6); |
646 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
647 |
backupMV.y - iDiamondSize, 7); |
backupMV.y - iDiamondSize, 7); |
648 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
649 |
backupMV.y + iDiamondSize, 8); |
backupMV.y + iDiamondSize, 8); |
650 |
break; |
break; |
651 |
default: |
default: |
652 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, backupMV.y, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize, backupMV.y, |
653 |
1); |
1); |
654 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize, backupMV.y, |
655 |
2); |
2); |
656 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x, backupMV.y - iDiamondSize, |
657 |
3); |
3); |
658 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x, backupMV.y + iDiamondSize, |
659 |
4); |
4); |
660 |
|
|
661 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
662 |
backupMV.y - iDiamondSize, 5); |
backupMV.y - iDiamondSize, 5); |
663 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
664 |
backupMV.y + iDiamondSize, 6); |
backupMV.y + iDiamondSize, 6); |
665 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
666 |
backupMV.y - iDiamondSize, 7); |
backupMV.y - iDiamondSize, 7); |
667 |
CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, |
CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
668 |
backupMV.y + iDiamondSize, 8); |
backupMV.y + iDiamondSize, 8); |
669 |
break; |
break; |
670 |
} |
} |
671 |
|
} |
672 |
} else { |
} else { |
673 |
currMV->x = start_x; |
currMV->x = start_x; |
674 |
currMV->y = start_y; |
currMV->y = start_y; |
1617 |
/* Do a diamond search around given starting point, return SAD of best */ |
/* Do a diamond search around given starting point, return SAD of best */ |
1618 |
|
|
1619 |
int32_t iDirection = 0; |
int32_t iDirection = 0; |
1620 |
|
int32_t iDirectionBackup; |
1621 |
int32_t iSAD; |
int32_t iSAD; |
1622 |
VECTOR backupMV; |
VECTOR backupMV; |
1623 |
|
|
1631 |
CHECK_MV8_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize, 3); |
CHECK_MV8_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize, 3); |
1632 |
CHECK_MV8_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize, 4); |
CHECK_MV8_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize, 4); |
1633 |
|
|
1634 |
if (iDirection) |
if (iDirection) { |
1635 |
while (!iFound) { |
while (!iFound) { |
1636 |
iFound = 1; |
iFound = 1; |
1637 |
backupMV = *currMV; // since iDirection!=0, this is well defined! |
backupMV = *currMV; // since iDirection!=0, this is well defined! |
1638 |
|
iDirectionBackup = iDirection; |
1639 |
|
|
1640 |
if (iDirection != 2) |
if (iDirectionBackup != 2) |
1641 |
CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
1642 |
backupMV.y, 1); |
backupMV.y, 1); |
1643 |
if (iDirection != 1) |
if (iDirectionBackup != 1) |
1644 |
CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
1645 |
backupMV.y, 2); |
backupMV.y, 2); |
1646 |
if (iDirection != 4) |
if (iDirectionBackup != 4) |
1647 |
CHECK_MV8_CANDIDATE_FOUND(backupMV.x, |
CHECK_MV8_CANDIDATE_FOUND(backupMV.x, |
1648 |
backupMV.y - iDiamondSize, 3); |
backupMV.y - iDiamondSize, 3); |
1649 |
if (iDirection != 3) |
if (iDirectionBackup != 3) |
1650 |
CHECK_MV8_CANDIDATE_FOUND(backupMV.x, |
CHECK_MV8_CANDIDATE_FOUND(backupMV.x, |
1651 |
backupMV.y + iDiamondSize, 4); |
backupMV.y + iDiamondSize, 4); |
1652 |
|
} |
1653 |
|
} else { |
1654 |
|
currMV->x = start_x; |
1655 |
|
currMV->y = start_y; |
1656 |
|
} |
1657 |
|
return iMinSAD; |
1658 |
|
} |
1659 |
|
|
1660 |
|
|
1661 |
|
|
1662 |
|
|
1663 |
|
int32_t |
1664 |
|
Square8_MainSearch(const uint8_t * const pRef, |
1665 |
|
const uint8_t * const pRefH, |
1666 |
|
const uint8_t * const pRefV, |
1667 |
|
const uint8_t * const pRefHV, |
1668 |
|
const uint8_t * const cur, |
1669 |
|
const int x, |
1670 |
|
const int y, |
1671 |
|
int32_t start_x, |
1672 |
|
int32_t start_y, |
1673 |
|
int32_t iMinSAD, |
1674 |
|
VECTOR * const currMV, |
1675 |
|
const int center_x, |
1676 |
|
const int center_y, |
1677 |
|
const int32_t min_dx, |
1678 |
|
const int32_t max_dx, |
1679 |
|
const int32_t min_dy, |
1680 |
|
const int32_t max_dy, |
1681 |
|
const int32_t iEdgedWidth, |
1682 |
|
const int32_t iDiamondSize, |
1683 |
|
const int32_t iFcode, |
1684 |
|
const int32_t iQuant, |
1685 |
|
int iFound) |
1686 |
|
{ |
1687 |
|
/* Do a square search around given starting point, return SAD of best */ |
1688 |
|
|
1689 |
|
int32_t iDirection = 0; |
1690 |
|
int32_t iSAD; |
1691 |
|
VECTOR backupMV; |
1692 |
|
|
1693 |
|
backupMV.x = start_x; |
1694 |
|
backupMV.y = start_y; |
1695 |
|
|
1696 |
|
/* It's one search with full square pattern, and new parts for all following diamonds */ |
1697 |
|
|
1698 |
|
/* new direction are extra, so 1-4 is normal diamond |
1699 |
|
537 |
1700 |
|
1*2 |
1701 |
|
648 |
1702 |
|
*/ |
1703 |
|
|
1704 |
|
CHECK_MV8_CANDIDATE_DIR(backupMV.x - iDiamondSize, backupMV.y, 1); |
1705 |
|
CHECK_MV8_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y, 2); |
1706 |
|
CHECK_MV8_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize, 3); |
1707 |
|
CHECK_MV8_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize, 4); |
1708 |
|
|
1709 |
|
CHECK_MV8_CANDIDATE_DIR(backupMV.x - iDiamondSize, |
1710 |
|
backupMV.y - iDiamondSize, 5); |
1711 |
|
CHECK_MV8_CANDIDATE_DIR(backupMV.x - iDiamondSize, |
1712 |
|
backupMV.y + iDiamondSize, 6); |
1713 |
|
CHECK_MV8_CANDIDATE_DIR(backupMV.x + iDiamondSize, |
1714 |
|
backupMV.y - iDiamondSize, 7); |
1715 |
|
CHECK_MV8_CANDIDATE_DIR(backupMV.x + iDiamondSize, |
1716 |
|
backupMV.y + iDiamondSize, 8); |
1717 |
|
|
1718 |
|
|
1719 |
|
if (iDirection) { |
1720 |
|
while (!iFound) { |
1721 |
|
iFound = 1; |
1722 |
|
backupMV = *currMV; |
1723 |
|
|
1724 |
|
switch (iDirection) { |
1725 |
|
case 1: |
1726 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
1727 |
|
backupMV.y, 1); |
1728 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
1729 |
|
backupMV.y - iDiamondSize, 5); |
1730 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
1731 |
|
backupMV.y - iDiamondSize, 7); |
1732 |
|
break; |
1733 |
|
case 2: |
1734 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize, backupMV.y, |
1735 |
|
2); |
1736 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
1737 |
|
backupMV.y + iDiamondSize, 6); |
1738 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
1739 |
|
backupMV.y + iDiamondSize, 8); |
1740 |
|
break; |
1741 |
|
|
1742 |
|
case 3: |
1743 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x, backupMV.y + iDiamondSize, |
1744 |
|
4); |
1745 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
1746 |
|
backupMV.y - iDiamondSize, 7); |
1747 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
1748 |
|
backupMV.y + iDiamondSize, 8); |
1749 |
|
break; |
1750 |
|
|
1751 |
|
case 4: |
1752 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x, backupMV.y - iDiamondSize, |
1753 |
|
3); |
1754 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
1755 |
|
backupMV.y - iDiamondSize, 5); |
1756 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
1757 |
|
backupMV.y + iDiamondSize, 6); |
1758 |
|
break; |
1759 |
|
|
1760 |
|
case 5: |
1761 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize, backupMV.y, |
1762 |
|
1); |
1763 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x, backupMV.y - iDiamondSize, |
1764 |
|
3); |
1765 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
1766 |
|
backupMV.y - iDiamondSize, 5); |
1767 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
1768 |
|
backupMV.y + iDiamondSize, 6); |
1769 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
1770 |
|
backupMV.y - iDiamondSize, 7); |
1771 |
|
break; |
1772 |
|
|
1773 |
|
case 6: |
1774 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize, backupMV.y, |
1775 |
|
2); |
1776 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x, backupMV.y - iDiamondSize, |
1777 |
|
3); |
1778 |
|
|
1779 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
1780 |
|
backupMV.y - iDiamondSize, 5); |
1781 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
1782 |
|
backupMV.y + iDiamondSize, 6); |
1783 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
1784 |
|
backupMV.y + iDiamondSize, 8); |
1785 |
|
|
1786 |
|
break; |
1787 |
|
|
1788 |
|
case 7: |
1789 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
1790 |
|
backupMV.y, 1); |
1791 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x, backupMV.y + iDiamondSize, |
1792 |
|
4); |
1793 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
1794 |
|
backupMV.y - iDiamondSize, 5); |
1795 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
1796 |
|
backupMV.y - iDiamondSize, 7); |
1797 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
1798 |
|
backupMV.y + iDiamondSize, 8); |
1799 |
|
break; |
1800 |
|
|
1801 |
|
case 8: |
1802 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize, backupMV.y, |
1803 |
|
2); |
1804 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x, backupMV.y + iDiamondSize, |
1805 |
|
4); |
1806 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
1807 |
|
backupMV.y + iDiamondSize, 6); |
1808 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
1809 |
|
backupMV.y - iDiamondSize, 7); |
1810 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
1811 |
|
backupMV.y + iDiamondSize, 8); |
1812 |
|
break; |
1813 |
|
default: |
1814 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize, backupMV.y, |
1815 |
|
1); |
1816 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize, backupMV.y, |
1817 |
|
2); |
1818 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x, backupMV.y - iDiamondSize, |
1819 |
|
3); |
1820 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x, backupMV.y + iDiamondSize, |
1821 |
|
4); |
1822 |
|
|
1823 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
1824 |
|
backupMV.y - iDiamondSize, 5); |
1825 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize, |
1826 |
|
backupMV.y + iDiamondSize, 6); |
1827 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
1828 |
|
backupMV.y - iDiamondSize, 7); |
1829 |
|
CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize, |
1830 |
|
backupMV.y + iDiamondSize, 8); |
1831 |
|
break; |
1832 |
|
} |
1833 |
|
} |
1834 |
} else { |
} else { |
1835 |
currMV->x = start_x; |
currMV->x = start_x; |
1836 |
currMV->y = start_y; |
currMV->y = start_y; |
1838 |
return iMinSAD; |
return iMinSAD; |
1839 |
} |
} |
1840 |
|
|
1841 |
|
|
1842 |
|
|
1843 |
|
|
1844 |
|
|
1845 |
int32_t |
int32_t |
1846 |
Halfpel8_Refine_c(const uint8_t * const pRef, |
Halfpel8_Refine_c(const uint8_t * const pRef, |
1847 |
const uint8_t * const pRefH, |
const uint8_t * const pRefH, |
1980 |
|
|
1981 |
// Prepare for main loop |
// Prepare for main loop |
1982 |
|
|
1983 |
// if (MotionFlags & PMV_USESQUARES8) |
if (MotionFlags & PMV_USESQUARES8) |
1984 |
// MainSearchPtr = Square8_MainSearch; |
MainSearchPtr = Square8_MainSearch; |
1985 |
// else |
else |
1986 |
|
|
1987 |
if (MotionFlags & PMV_ADVANCEDDIAMOND8) |
if (MotionFlags & PMV_ADVANCEDDIAMOND8) |
1988 |
MainSearchPtr = AdvDiamond8_MainSearch; |
MainSearchPtr = AdvDiamond8_MainSearch; |
2660 |
|
|
2661 |
// there is no EPZS^2 for inter4v at the moment |
// there is no EPZS^2 for inter4v at the moment |
2662 |
|
|
2663 |
// if (MotionFlags & PMV_USESQUARES8) |
if (MotionFlags & PMV_USESQUARES8) |
2664 |
// MainSearchPtr = Square8_MainSearch; |
MainSearchPtr = Square8_MainSearch; |
2665 |
// else |
else |
2666 |
|
|
2667 |
if (MotionFlags & PMV_ADVANCEDDIAMOND8) |
if (MotionFlags & PMV_ADVANCEDDIAMOND8) |
2668 |
MainSearchPtr = AdvDiamond8_MainSearch; |
MainSearchPtr = AdvDiamond8_MainSearch; |
3060 |
int b_sad16; /* backward (only in b-frames) search */ |
int b_sad16; /* backward (only in b-frames) search */ |
3061 |
int i_sad16; /* interpolated (both direction, b-frames only) */ |
int i_sad16; /* interpolated (both direction, b-frames only) */ |
3062 |
int d_sad16; /* direct mode (assume linear motion) */ |
int d_sad16; /* direct mode (assume linear motion) */ |
|
int dnv_sad16; /* direct mode (assume linear motion) without correction vector */ |
|
3063 |
|
|
3064 |
int best_sad; |
int best_sad; |
3065 |
|
|
3066 |
VECTOR f_predMV, b_predMV; /* there is no direct prediction */ |
VECTOR f_predMV, b_predMV; /* there is no prediction for direct mode*/ |
3067 |
VECTOR pmv_dontcare; |
VECTOR pmv_dontcare; |
3068 |
|
|
3069 |
int f_count=0; |
int f_count=0; |
3070 |
int b_count=0; |
int b_count=0; |
3071 |
int i_count=0; |
int i_count=0; |
3072 |
int d_count=0; |
int d_count=0; |
|
int dnv_count=0; |
|
3073 |
int s_count=0; |
int s_count=0; |
3074 |
|
|
3075 |
const int64_t TRB = (int32_t)time_pp - (int32_t)time_bp; |
const int64_t TRB = (int32_t)time_pp - (int32_t)time_bp; |
3076 |
const int64_t TRD = (int32_t)time_pp; |
const int64_t TRD = (int32_t)time_pp; |
3077 |
|
|
3087 |
const MACROBLOCK *f_mb = &f_mbs[i + j * mb_width]; |
const MACROBLOCK *f_mb = &f_mbs[i + j * mb_width]; |
3088 |
const MACROBLOCK *b_mb = &b_mbs[i + j * mb_width]; |
const MACROBLOCK *b_mb = &b_mbs[i + j * mb_width]; |
3089 |
|
|
3090 |
VECTOR directMV; |
mb->deltamv=zeroMV; |
|
VECTOR deltaMV=zeroMV; |
|
3091 |
|
|
3092 |
/* special case, if collocated block is SKIPed: encoding is forward(0,0) */ |
/* special case, if collocated block is SKIPed: encoding is forward(0,0) */ |
3093 |
|
|
3094 |
|
#ifndef _DISABLE_SKIP |
3095 |
if (b_mb->mode == MODE_INTER && b_mb->cbp == 0 && |
if (b_mb->mode == MODE_INTER && b_mb->cbp == 0 && |
3096 |
b_mb->mvs[0].x == 0 && b_mb->mvs[0].y == 0) { |
b_mb->mvs[0].x == 0 && b_mb->mvs[0].y == 0) { |
3097 |
mb->mode = MODE_NOT_CODED; |
mb->mode = MODE_NOT_CODED; |
3101 |
mb->b_mvs[0].y = 0; |
mb->b_mvs[0].y = 0; |
3102 |
continue; |
continue; |
3103 |
} |
} |
3104 |
|
#endif |
3105 |
|
|
3106 |
dnv_sad16 = DIRECT_PENALTY; |
d_sad16 = DIRECT_PENALTY; |
3107 |
|
|
3108 |
if (b_mb->mode == MODE_INTER4V) |
if (b_mb->mode == MODE_INTER4V) |
3109 |
{ |
{ |
3111 |
/* same method of scaling as in decoder.c, so we copy from there */ |
/* same method of scaling as in decoder.c, so we copy from there */ |
3112 |
for (k = 0; k < 4; k++) { |
for (k = 0; k < 4; k++) { |
3113 |
|
|
3114 |
directMV = b_mb->mvs[k]; |
mb->directmv[k] = b_mb->mvs[k]; |
3115 |
|
|
3116 |
mb->mvs[k].x = (int32_t) ((TRB * directMV.x) / TRD + deltaMV.x); |
mb->mvs[k].x = (int32_t) ((TRB * mb->directmv[k].x) / TRD + mb->deltamv.x); |
3117 |
mb->b_mvs[k].x = (int32_t) ((deltaMV.x == 0) |
mb->b_mvs[k].x = (int32_t) ((mb->deltamv.x == 0) |
3118 |
? ((TRB - TRD) * directMV.x) / TRD |
? ((TRB - TRD) * mb->directmv[k].x) / TRD |
3119 |
: mb->mvs[k].x - directMV.x); |
: mb->mvs[k].x - mb->directmv[k].x); |
3120 |
mb->mvs[k].y = (int32_t) ((TRB * directMV.y) / TRD + deltaMV.y); |
|
3121 |
mb->b_mvs[k].y = (int32_t) ((deltaMV.y == 0) |
mb->mvs[k].y = (int32_t) ((TRB * mb->directmv[k].y) / TRD + mb->deltamv.y); |
3122 |
? ((TRB - TRD) * directMV.y) / TRD |
mb->b_mvs[k].y = (int32_t) ((mb->directmv[k].y == 0) |
3123 |
: mb->mvs[k].y - directMV.y); |
? ((TRB - TRD) * mb->directmv[k].y) / TRD |
3124 |
|
: mb->mvs[k].y - mb->directmv[k].y); |
3125 |
|
|
3126 |
dnv_sad16 += |
d_sad16 += |
3127 |
sad8bi(frame->image.y + 2*(i+(k&1))*8 + 2*(j+(k>>1))*8*edged_width, |
sad8bi(frame->image.y + 2*(i+(k&1))*8 + 2*(j+(k>>1))*8*edged_width, |
3128 |
get_ref_mv(f_ref->y, f_refH->y, f_refV->y, f_refHV->y, |
get_ref_mv(f_ref->y, f_refH->y, f_refV->y, f_refHV->y, |
3129 |
2*(i+(k&1)), 2*(j+(k>>1)), 8, &mb->mvs[k], edged_width), |
2*(i+(k&1)), 2*(j+(k>>1)), 8, &mb->mvs[k], edged_width), |
3134 |
} |
} |
3135 |
else |
else |
3136 |
{ |
{ |
3137 |
directMV = b_mb->mvs[0]; |
mb->directmv[3] = mb->directmv[2] = mb->directmv[1] = |
3138 |
|
mb->directmv[0] = b_mb->mvs[0]; |
3139 |
|
|
3140 |
mb->mvs[0].x = (int32_t) ((TRB * directMV.x) / TRD + deltaMV.x); |
mb->mvs[0].x = (int32_t) ((TRB * mb->directmv[0].x) / TRD + mb->deltamv.x); |
3141 |
mb->b_mvs[0].x = (int32_t) ((deltaMV.x == 0) |
mb->b_mvs[0].x = (int32_t) ((mb->deltamv.x == 0) |
3142 |
? ((TRB - TRD) * directMV.x) / TRD |
? ((TRB - TRD) * mb->directmv[0].x) / TRD |
3143 |
: mb->mvs[0].x - directMV.x); |
: mb->mvs[0].x - mb->directmv[0].x); |
3144 |
mb->mvs[0].y = (int32_t) ((TRB * directMV.y) / TRD + deltaMV.y); |
|
3145 |
mb->b_mvs[0].y = (int32_t) ((deltaMV.y == 0) |
mb->mvs[0].y = (int32_t) ((TRB * mb->directmv[0].y) / TRD + mb->deltamv.y); |
3146 |
? ((TRB - TRD) * directMV.y) / TRD |
mb->b_mvs[0].y = (int32_t) ((mb->directmv[0].y == 0) |
3147 |
: mb->mvs[0].y - directMV.y); |
? ((TRB - TRD) * mb->directmv[0].y) / TRD |
3148 |
|
: mb->mvs[0].y - mb->directmv[0].y); |
3149 |
|
|
3150 |
dnv_sad16 = DIRECT_PENALTY + |
d_sad16 += sad16bi(frame->image.y + i * 16 + j * 16 * edged_width, |
|
sad16bi(frame->image.y + i * 16 + j * 16 * edged_width, |
|
3151 |
get_ref_mv(f_ref->y, f_refH->y, f_refV->y, f_refHV->y, |
get_ref_mv(f_ref->y, f_refH->y, f_refV->y, f_refHV->y, |
3152 |
i, j, 16, &mb->mvs[0], edged_width), |
i, j, 16, &mb->mvs[0], edged_width), |
3153 |
get_ref_mv(b_ref->y, b_refH->y, b_refV->y, b_refHV->y, |
get_ref_mv(b_ref->y, b_refH->y, b_refV->y, b_refHV->y, |
3154 |
i, j, 16, &mb->b_mvs[0], edged_width), |
i, j, 16, &mb->b_mvs[0], edged_width), |
3155 |
edged_width); |
edged_width); |
3156 |
|
|
|
|
|
3157 |
} |
} |
3158 |
|
d_sad16 += calc_delta_16(mb->deltamv.x, mb->deltamv.y, 1, frame->quant); |
3159 |
|
|
3160 |
// forward search |
// forward search |
3161 |
f_sad16 = SEARCH16(f_ref->y, f_refH->y, f_refV->y, f_refHV->y, |
f_sad16 = SEARCH16(f_ref->y, f_refH->y, f_refV->y, f_refHV->y, |
3162 |
&frame->image, i, j, |
&frame->image, i, j, |
3163 |
mb->mvs[0].x, mb->mvs[0].y, /* start point f_directMV */ |
mb->mvs[0].x, mb->mvs[0].y, /* start point f_directMV */ |
3164 |
f_predMV.x, f_predMV.y, /* center is f-prediction */ |
f_predMV.x, f_predMV.y, /* center is f-prediction */ |
3165 |
frame->motion_flags & (~(PMV_EARLYSTOP16|PMV_QUICKSTOP16)), |
frame->motion_flags, |
3166 |
frame->quant, frame->fcode, pParam, |
frame->quant, frame->fcode, pParam, |
3167 |
f_mbs, f_mbs, |
f_mbs, f_mbs, |
3168 |
&mb->mvs[0], &pmv_dontcare); |
&mb->mvs[0], &pmv_dontcare); |
3173 |
&frame->image, i, j, |
&frame->image, i, j, |
3174 |
mb->b_mvs[0].x, mb->b_mvs[0].y, /* start point b_directMV */ |
mb->b_mvs[0].x, mb->b_mvs[0].y, /* start point b_directMV */ |
3175 |
b_predMV.x, b_predMV.y, /* center is b-prediction */ |
b_predMV.x, b_predMV.y, /* center is b-prediction */ |
3176 |
frame->motion_flags & (~(PMV_EARLYSTOP16|PMV_QUICKSTOP16)), |
frame->motion_flags, |
3177 |
frame->quant, frame->bcode, pParam, |
frame->quant, frame->bcode, pParam, |
3178 |
b_mbs, b_mbs, |
b_mbs, b_mbs, |
3179 |
&mb->b_mvs[0], &pmv_dontcare); |
&mb->b_mvs[0], &pmv_dontcare); |
3187 |
edged_width); |
edged_width); |
3188 |
i_sad16 += calc_delta_16(mb->mvs[0].x-f_predMV.x, mb->mvs[0].y-f_predMV.y, |
i_sad16 += calc_delta_16(mb->mvs[0].x-f_predMV.x, mb->mvs[0].y-f_predMV.y, |
3189 |
frame->fcode, frame->quant); |
frame->fcode, frame->quant); |
3190 |
i_sad16 += calc_delta_16(mb->b_mvs[0].y-b_predMV.y, mb->b_mvs[0].y-b_predMV.y, |
i_sad16 += calc_delta_16(mb->b_mvs[0].x-b_predMV.x, mb->b_mvs[0].y-b_predMV.y, |
3191 |
frame->bcode, frame->quant); |
frame->bcode, frame->quant); |
3192 |
|
|
3193 |
// TODO: direct search |
// TODO: direct search |
3194 |
// predictor + delta vector in range [-32,32] (fcode=1) |
// predictor + delta vector in range [-32,32] (fcode=1) |
3195 |
|
|
3196 |
// i_sad16 = 65535; |
i_sad16 = 65535; |
3197 |
// f_sad16 = 65535; |
f_sad16 = 65535; |
3198 |
// b_sad16 = 65535; |
b_sad16 = 65535; |
3199 |
|
// d_sad16 = 65535; |
3200 |
|
|
3201 |
if (f_sad16 < b_sad16) { |
if (f_sad16 < b_sad16) { |
3202 |
best_sad = f_sad16; |
best_sad = f_sad16; |
3211 |
mb->mode = MODE_INTERPOLATE; |
mb->mode = MODE_INTERPOLATE; |
3212 |
} |
} |
3213 |
|
|
3214 |
if (dnv_sad16 < best_sad) { |
if (d_sad16 < best_sad) { |
3215 |
|
|
3216 |
if (dnv_sad16 > DIRECT_UPPERLIMIT) |
if (b_mb->mode == MODE_INTER4V) |
3217 |
{ |
{ |
|
/* if SAD value is too large, try same vector with MODE_INTERPOLATE |
|
|
instead (interpolate has residue encoding, direct mode without MV |
|
|
doesn't) |
|
3218 |
|
|
3219 |
This has to be replaced later by "real" direct mode, including delta |
/* same method of scaling as in decoder.c, so we copy from there */ |
3220 |
vector and (if needed) residue encoding |
for (k = 0; k < 4; k++) { |
|
|
|
|
*/ |
|
3221 |
|
|
3222 |
directMV = b_mb->mvs[0]; |
mb->mvs[k].x = (int32_t) ((TRB * mb->directmv[k].x) / TRD + mb->deltamv.x); |
3223 |
|
mb->b_mvs[k].x = (int32_t) ((mb->deltamv.x == 0) |
3224 |
|
? ((TRB - TRD) * mb->directmv[k].x) / TRD |
3225 |
|
: mb->mvs[k].x - mb->directmv[k].x); |
3226 |
|
|
3227 |
|
mb->mvs[k].y = (int32_t) ((TRB * mb->directmv[k].y) / TRD + mb->deltamv.y); |
3228 |
|
mb->b_mvs[k].y = (int32_t) ((mb->directmv[k].y == 0) |
3229 |
|
? ((TRB - TRD) * mb->directmv[k].y) / TRD |
3230 |
|
: mb->mvs[k].y - mb->directmv[k].y); |
3231 |
|
} |
3232 |
|
} |
3233 |
|
else |
3234 |
|
{ |
3235 |
|
mb->mvs[0].x = (int32_t) ((TRB * mb->directmv[0].x) / TRD + mb->deltamv.x); |
3236 |
|
|
3237 |
mb->mvs[0].x = (int32_t) ((TRB * directMV.x) / TRD + deltaMV.x); |
mb->b_mvs[0].x = (int32_t) ((mb->deltamv.x == 0) |
3238 |
mb->b_mvs[0].x = (int32_t) ((deltaMV.x == 0) |
? ((TRB - TRD) * mb->directmv[0].x) / TRD |
3239 |
? ((TRB - TRD) * directMV.x) / TRD |
: mb->mvs[0].x - mb->directmv[0].x); |
|
: mb->mvs[0].x - directMV.x); |
|
|
mb->mvs[0].y = (int32_t) ((TRB * directMV.y) / TRD + deltaMV.y); |
|
|
mb->b_mvs[0].y = (int32_t) ((deltaMV.y == 0) |
|
|
? ((TRB - TRD) * directMV.y) / TRD |
|
|
: mb->mvs[0].y - directMV.y); |
|
3240 |
|
|
3241 |
dnv_sad16 = |
mb->mvs[0].y = (int32_t) ((TRB * mb->directmv[0].y) / TRD + mb->deltamv.y); |
|
sad16bi(frame->image.y + i * 16 + j * 16 * edged_width, |
|
|
get_ref_mv(f_ref->y, f_refH->y, f_refV->y, f_refHV->y, |
|
|
i, j, 16, &mb->mvs[0], edged_width), |
|
|
get_ref_mv(b_ref->y, b_refH->y, b_refV->y, b_refHV->y, |
|
|
i, j, 16, &mb->b_mvs[0], edged_width), |
|
|
edged_width); |
|
|
dnv_sad16 += calc_delta_16(mb->mvs[0].x-f_predMV.x, mb->mvs[0].y-f_predMV.y, |
|
|
frame->fcode, frame->quant); |
|
|
dnv_sad16 += calc_delta_16(mb->b_mvs[0].y-b_predMV.y, mb->b_mvs[0].y-b_predMV.y, |
|
|
frame->bcode, frame->quant); |
|
3242 |
|
|
3243 |
if (dnv_sad16 < best_sad) |
mb->b_mvs[0].y = (int32_t) ((mb->directmv[0].y == 0) |
3244 |
{ |
? ((TRB - TRD) * mb->directmv[0].y) / TRD |
3245 |
best_sad = dnv_sad16; |
: mb->mvs[0].y - mb->directmv[0].y); |
|
mb->mode = MODE_INTERPOLATE; |
|
3246 |
|
|
3247 |
/* fprintf(stderr,"f_sad16 = %d, b_sad16 = %d, i_sad16 = %d, dnv_sad16 = %d\n", |
mb->mvs[3] = mb->mvs[2] = mb->mvs[1] = mb->mvs[0]; |
3248 |
f_sad16,b_sad16,i_sad16,dnv_sad16); |
mb->b_mvs[3] = mb->b_mvs[2] = mb->b_mvs[1] = mb->b_mvs[0]; |
|
*/ } |
|
|
} |
|
|
else |
|
|
{ |
|
|
best_sad = dnv_sad16; |
|
|
mb->mode = MODE_DIRECT_NONE_MV; |
|
3249 |
} |
} |
3250 |
|
|
3251 |
|
best_sad = d_sad16; |
3252 |
|
mb->mode = MODE_DIRECT; |
3253 |
|
mb->mode = MODE_INTERPOLATE; // direct mode still broken :-( |
3254 |
} |
} |
3255 |
|
|
3256 |
switch (mb->mode) |
switch (mb->mode) |
3270 |
b_predMV = mb->b_mvs[0]; |
b_predMV = mb->b_mvs[0]; |
3271 |
break; |
break; |
3272 |
case MODE_DIRECT: |
case MODE_DIRECT: |
3273 |
d_count++; break; |
d_count++; |
3274 |
case MODE_DIRECT_NONE_MV: |
break; |
|
dnv_count++; break; |
|
3275 |
default: |
default: |
3276 |
s_count++; break; |
s_count++; // ??? |
3277 |
|
break; |
3278 |
} |
} |
3279 |
|
|
3280 |
} |
} |
3281 |
} |
} |
3282 |
|
|
3283 |
#ifdef _DEBUG_BFRAME_STAT |
#ifdef _DEBUG_BFRAME_STAT |
3284 |
fprintf(stderr,"B-Stat: F: %04d B: %04d I: %04d D0: %04d D: %04d S: %04d\n", |
fprintf(stderr,"B-Stat: F: %04d B: %04d I: %04d D: %04d S: %04d\n", |
3285 |
f_count,b_count,i_count,dnv_count,d_count,s_count); |
f_count,b_count,i_count,d_count,s_count); |
3286 |
#endif |
#endif |
3287 |
|
|
3288 |
} |
} |