1611 |
|
* Install graphics acceleration |
1612 |
|
*/ |
1613 |
|
|
1614 |
< |
#if 0 |
1615 |
< |
// Rectangle filling/inversion |
1616 |
< |
static void accl_fillrect8(accl_params *p) |
1614 |
> |
// Rectangle inversion |
1615 |
> |
template< int bpp > |
1616 |
> |
static inline void do_invrect(uint8 *dest, uint32 length) |
1617 |
|
{ |
1618 |
< |
D(bug("accl_fillrect8\n")); |
1618 |
> |
#define INVERT_1(PTR, OFS) ((uint8 *)(PTR))[OFS] = ~((uint8 *)(PTR))[OFS] |
1619 |
> |
#define INVERT_2(PTR, OFS) ((uint16 *)(PTR))[OFS] = ~((uint16 *)(PTR))[OFS] |
1620 |
> |
#define INVERT_4(PTR, OFS) ((uint32 *)(PTR))[OFS] = ~((uint32 *)(PTR))[OFS] |
1621 |
> |
#define INVERT_8(PTR, OFS) ((uint64 *)(PTR))[OFS] = ~((uint64 *)(PTR))[OFS] |
1622 |
> |
|
1623 |
> |
#ifndef UNALIGNED_PROFITABLE |
1624 |
> |
// Align on 16-bit boundaries |
1625 |
> |
if (bpp < 16 && (((uintptr)dest) & 1)) { |
1626 |
> |
INVERT_1(dest, 0); |
1627 |
> |
dest += 1; length -= 1; |
1628 |
> |
} |
1629 |
|
|
1630 |
< |
// Get filling parameters |
1631 |
< |
int16 dest_X = p->dest_rect[1] - p->dest_bounds[1]; |
1632 |
< |
int16 dest_Y = p->dest_rect[0] - p->dest_bounds[0]; |
1633 |
< |
int16 dest_X_max = p->dest_rect[3] - p->dest_bounds[1] - 1; |
1634 |
< |
int16 dest_Y_max = p->dest_rect[2] - p->dest_bounds[0] - 1; |
1635 |
< |
uint8 color = p->pen_mode == 8 ? p->fore_pen : p->back_pen; |
1626 |
< |
D(bug(" dest X %d, dest Y %d\n", dest_X, dest_Y)); |
1627 |
< |
D(bug(" dest X max %d, dest Y max %d\n", dest_X_max, dest_Y_max)); |
1630 |
> |
// Align on 32-bit boundaries |
1631 |
> |
if (bpp < 32 && (((uintptr)dest) & 2)) { |
1632 |
> |
INVERT_2(dest, 0); |
1633 |
> |
dest += 2; length -= 2; |
1634 |
> |
} |
1635 |
> |
#endif |
1636 |
|
|
1637 |
< |
// And perform the fill |
1638 |
< |
fillrect8_hook(dest_X, dest_Y, dest_X_max, dest_Y_max, color); |
1639 |
< |
} |
1637 |
> |
// Invert 8-byte words |
1638 |
> |
if (length >= 8) { |
1639 |
> |
const int r = (length / 8) % 8; |
1640 |
> |
dest += r * 8; |
1641 |
> |
|
1642 |
> |
int n = ((length / 8) + 7) / 8; |
1643 |
> |
switch (r) { |
1644 |
> |
case 0: do { |
1645 |
> |
dest += 64; |
1646 |
> |
INVERT_8(dest, -8); |
1647 |
> |
case 7: INVERT_8(dest, -7); |
1648 |
> |
case 6: INVERT_8(dest, -6); |
1649 |
> |
case 5: INVERT_8(dest, -5); |
1650 |
> |
case 4: INVERT_8(dest, -4); |
1651 |
> |
case 3: INVERT_8(dest, -3); |
1652 |
> |
case 2: INVERT_8(dest, -2); |
1653 |
> |
case 1: INVERT_8(dest, -1); |
1654 |
> |
} while (--n > 0); |
1655 |
> |
} |
1656 |
> |
} |
1657 |
|
|
1658 |
< |
static void accl_fillrect32(accl_params *p) |
1659 |
< |
{ |
1660 |
< |
D(bug("accl_fillrect32\n")); |
1658 |
> |
// 32-bit cell to invert? |
1659 |
> |
if (length & 4) { |
1660 |
> |
INVERT_4(dest, 0); |
1661 |
> |
if (bpp <= 16) |
1662 |
> |
dest += 4; |
1663 |
> |
} |
1664 |
|
|
1665 |
< |
// Get filling parameters |
1666 |
< |
int16 dest_X = p->dest_rect[1] - p->dest_bounds[1]; |
1667 |
< |
int16 dest_Y = p->dest_rect[0] - p->dest_bounds[0]; |
1668 |
< |
int16 dest_X_max = p->dest_rect[3] - p->dest_bounds[1] - 1; |
1669 |
< |
int16 dest_Y_max = p->dest_rect[2] - p->dest_bounds[0] - 1; |
1670 |
< |
uint32 color = p->pen_mode == 8 ? p->fore_pen : p->back_pen; |
1643 |
< |
D(bug(" dest X %d, dest Y %d\n", dest_X, dest_Y)); |
1644 |
< |
D(bug(" dest X max %d, dest Y max %d\n", dest_X_max, dest_Y_max)); |
1665 |
> |
// 16-bit cell to invert? |
1666 |
> |
if (bpp <= 16 && (length & 2)) { |
1667 |
> |
INVERT_2(dest, 0); |
1668 |
> |
if (bpp <= 8) |
1669 |
> |
dest += 2; |
1670 |
> |
} |
1671 |
|
|
1672 |
< |
// And perform the fill |
1673 |
< |
fillrect32_hook(dest_X, dest_Y, dest_X_max, dest_Y_max, color); |
1672 |
> |
// 8-bit cell to invert? |
1673 |
> |
if (bpp <= 8 && (length & 1)) |
1674 |
> |
INVERT_1(dest, 0); |
1675 |
> |
|
1676 |
> |
#undef INVERT_1 |
1677 |
> |
#undef INVERT_2 |
1678 |
> |
#undef INVERT_4 |
1679 |
> |
#undef INVERT_8 |
1680 |
|
} |
1681 |
|
|
1682 |
< |
static void accl_invrect(accl_params *p) |
1682 |
> |
void NQD_invrect(uint32 p) |
1683 |
|
{ |
1684 |
< |
D(bug("accl_invrect\n")); |
1684 |
> |
D(bug("accl_invrect %08x\n", p)); |
1685 |
|
|
1686 |
|
// Get inversion parameters |
1687 |
< |
int16 dest_X = p->dest_rect[1] - p->dest_bounds[1]; |
1688 |
< |
int16 dest_Y = p->dest_rect[0] - p->dest_bounds[0]; |
1689 |
< |
int16 dest_X_max = p->dest_rect[3] - p->dest_bounds[1] - 1; |
1690 |
< |
int16 dest_Y_max = p->dest_rect[2] - p->dest_bounds[0] - 1; |
1687 |
> |
int16 dest_X = (int16)ReadMacInt16(p + acclDestRect + 2) - (int16)ReadMacInt16(p + acclDestBoundsRect + 2); |
1688 |
> |
int16 dest_Y = (int16)ReadMacInt16(p + acclDestRect + 0) - (int16)ReadMacInt16(p + acclDestBoundsRect + 0); |
1689 |
> |
int16 width = (int16)ReadMacInt16(p + acclDestRect + 6) - (int16)ReadMacInt16(p + acclDestRect + 2); |
1690 |
> |
int16 height = (int16)ReadMacInt16(p + acclDestRect + 4) - (int16)ReadMacInt16(p + acclDestRect + 0); |
1691 |
|
D(bug(" dest X %d, dest Y %d\n", dest_X, dest_Y)); |
1692 |
< |
D(bug(" dest X max %d, dest Y max %d\n", dest_X_max, dest_Y_max)); |
1692 |
> |
D(bug(" width %d, height %d, bytes_per_row %d\n", width, height, (int32)ReadMacInt32(p + acclDestRowBytes))); |
1693 |
|
|
1694 |
|
//!!?? pen_mode == 14 |
1695 |
|
|
1696 |
|
// And perform the inversion |
1697 |
< |
invrect_hook(dest_X, dest_Y, dest_X_max, dest_Y_max); |
1697 |
> |
const int bpp = bytes_per_pixel(ReadMacInt32(p + acclDestPixelSize)); |
1698 |
> |
const int dest_row_bytes = (int32)ReadMacInt32(p + acclDestRowBytes); |
1699 |
> |
uint8 *dest = Mac2HostAddr(ReadMacInt32(p + acclDestBaseAddr) + (dest_Y * dest_row_bytes) + (dest_X * bpp)); |
1700 |
> |
width *= bpp; |
1701 |
> |
switch (bpp) { |
1702 |
> |
case 1: |
1703 |
> |
for (int i = 0; i < height; i++) { |
1704 |
> |
do_invrect<8>(dest, width); |
1705 |
> |
dest += dest_row_bytes; |
1706 |
> |
} |
1707 |
> |
break; |
1708 |
> |
case 2: |
1709 |
> |
for (int i = 0; i < height; i++) { |
1710 |
> |
do_invrect<16>(dest, width); |
1711 |
> |
dest += dest_row_bytes; |
1712 |
> |
} |
1713 |
> |
break; |
1714 |
> |
case 4: |
1715 |
> |
for (int i = 0; i < height; i++) { |
1716 |
> |
do_invrect<32>(dest, width); |
1717 |
> |
dest += dest_row_bytes; |
1718 |
> |
} |
1719 |
> |
break; |
1720 |
> |
} |
1721 |
> |
} |
1722 |
> |
|
1723 |
> |
// Rectangle filling |
1724 |
> |
template< int bpp > |
1725 |
> |
static inline void do_fillrect(uint8 *dest, uint32 color, uint32 length) |
1726 |
> |
{ |
1727 |
> |
#define FILL_1(PTR, OFS, VAL) ((uint8 *)(PTR))[OFS] = (VAL) |
1728 |
> |
#define FILL_2(PTR, OFS, VAL) ((uint16 *)(PTR))[OFS] = (VAL) |
1729 |
> |
#define FILL_4(PTR, OFS, VAL) ((uint32 *)(PTR))[OFS] = (VAL) |
1730 |
> |
#define FILL_8(PTR, OFS, VAL) ((uint64 *)(PTR))[OFS] = (VAL) |
1731 |
> |
|
1732 |
> |
#ifndef UNALIGNED_PROFITABLE |
1733 |
> |
// Align on 16-bit boundaries |
1734 |
> |
if (bpp < 16 && (((uintptr)dest) & 1)) { |
1735 |
> |
FILL_1(dest, 0, color); |
1736 |
> |
dest += 1; length -= 1; |
1737 |
> |
} |
1738 |
> |
|
1739 |
> |
// Align on 32-bit boundaries |
1740 |
> |
if (bpp < 32 && (((uintptr)dest) & 2)) { |
1741 |
> |
FILL_2(dest, 0, color); |
1742 |
> |
dest += 2; length -= 2; |
1743 |
> |
} |
1744 |
> |
#endif |
1745 |
> |
|
1746 |
> |
// Fill 8-byte words |
1747 |
> |
if (length >= 8) { |
1748 |
> |
const uint64 c = (((uint64)color) << 32) | color; |
1749 |
> |
const int r = (length / 8) % 8; |
1750 |
> |
dest += r * 8; |
1751 |
> |
|
1752 |
> |
int n = ((length / 8) + 7) / 8; |
1753 |
> |
switch (r) { |
1754 |
> |
case 0: do { |
1755 |
> |
dest += 64; |
1756 |
> |
FILL_8(dest, -8, c); |
1757 |
> |
case 7: FILL_8(dest, -7, c); |
1758 |
> |
case 6: FILL_8(dest, -6, c); |
1759 |
> |
case 5: FILL_8(dest, -5, c); |
1760 |
> |
case 4: FILL_8(dest, -4, c); |
1761 |
> |
case 3: FILL_8(dest, -3, c); |
1762 |
> |
case 2: FILL_8(dest, -2, c); |
1763 |
> |
case 1: FILL_8(dest, -1, c); |
1764 |
> |
} while (--n > 0); |
1765 |
> |
} |
1766 |
> |
} |
1767 |
> |
|
1768 |
> |
// 32-bit cell to fill? |
1769 |
> |
if (length & 4) { |
1770 |
> |
FILL_4(dest, 0, color); |
1771 |
> |
if (bpp <= 16) |
1772 |
> |
dest += 4; |
1773 |
> |
} |
1774 |
> |
|
1775 |
> |
// 16-bit cell to fill? |
1776 |
> |
if (bpp <= 16 && (length & 2)) { |
1777 |
> |
FILL_2(dest, 0, color); |
1778 |
> |
if (bpp <= 8) |
1779 |
> |
dest += 2; |
1780 |
> |
} |
1781 |
> |
|
1782 |
> |
// 8-bit cell to fill? |
1783 |
> |
if (bpp <= 8 && (length & 1)) |
1784 |
> |
FILL_1(dest, 0, color); |
1785 |
> |
|
1786 |
> |
#undef FILL_1 |
1787 |
> |
#undef FILL_2 |
1788 |
> |
#undef FILL_4 |
1789 |
> |
#undef FILL_8 |
1790 |
> |
} |
1791 |
> |
|
1792 |
> |
void NQD_fillrect(uint32 p) |
1793 |
> |
{ |
1794 |
> |
D(bug("accl_fillrect %08x\n", p)); |
1795 |
> |
|
1796 |
> |
// Get filling parameters |
1797 |
> |
int16 dest_X = (int16)ReadMacInt16(p + acclDestRect + 2) - (int16)ReadMacInt16(p + acclDestBoundsRect + 2); |
1798 |
> |
int16 dest_Y = (int16)ReadMacInt16(p + acclDestRect + 0) - (int16)ReadMacInt16(p + acclDestBoundsRect + 0); |
1799 |
> |
int16 width = (int16)ReadMacInt16(p + acclDestRect + 6) - (int16)ReadMacInt16(p + acclDestRect + 2); |
1800 |
> |
int16 height = (int16)ReadMacInt16(p + acclDestRect + 4) - (int16)ReadMacInt16(p + acclDestRect + 0); |
1801 |
> |
uint32 color = ReadMacInt32(p + acclPenMode) == 8 ? ReadMacInt32(p + acclForePen) : ReadMacInt32(p + acclBackPen); |
1802 |
> |
D(bug(" dest X %d, dest Y %d\n", dest_X, dest_Y)); |
1803 |
> |
D(bug(" width %d, height %d\n", width, height)); |
1804 |
> |
D(bug(" bytes_per_row %d color %08x\n", (int32)ReadMacInt32(p + acclDestRowBytes), color)); |
1805 |
> |
|
1806 |
> |
// And perform the fill |
1807 |
> |
const int bpp = bytes_per_pixel(ReadMacInt32(p + acclDestPixelSize)); |
1808 |
> |
const int dest_row_bytes = (int32)ReadMacInt32(p + acclDestRowBytes); |
1809 |
> |
uint8 *dest = Mac2HostAddr(ReadMacInt32(p + acclDestBaseAddr) + (dest_Y * dest_row_bytes) + (dest_X * bpp)); |
1810 |
> |
width *= bpp; |
1811 |
> |
switch (bpp) { |
1812 |
> |
case 1: |
1813 |
> |
for (int i = 0; i < height; i++) { |
1814 |
> |
memset(dest, color, width); |
1815 |
> |
dest += dest_row_bytes; |
1816 |
> |
} |
1817 |
> |
break; |
1818 |
> |
case 2: |
1819 |
> |
for (int i = 0; i < height; i++) { |
1820 |
> |
do_fillrect<16>(dest, color, width); |
1821 |
> |
dest += dest_row_bytes; |
1822 |
> |
} |
1823 |
> |
break; |
1824 |
> |
case 4: |
1825 |
> |
for (int i = 0; i < height; i++) { |
1826 |
> |
do_fillrect<32>(dest, color, width); |
1827 |
> |
dest += dest_row_bytes; |
1828 |
> |
} |
1829 |
> |
break; |
1830 |
> |
} |
1831 |
|
} |
1832 |
|
|
1833 |
< |
static bool accl_fillrect_hook(accl_params *p) |
1833 |
> |
bool NQD_fillrect_hook(uint32 p) |
1834 |
|
{ |
1835 |
< |
D(bug("accl_fillrect_hook %p\n", p)); |
1835 |
> |
D(bug("accl_fillrect_hook %08x\n", p)); |
1836 |
|
|
1837 |
|
// Check if we can accelerate this fillrect |
1838 |
< |
if (p->dest_base_addr == screen_base && ((uint32 *)p)[0x284 >> 2] != 0 && display_type == DIS_SCREEN) { |
1839 |
< |
if (p->transfer_mode == 8) { |
1838 |
> |
if (ReadMacInt32(p + 0x284) != 0 && ReadMacInt32(p + acclDestPixelSize) >= 8) { |
1839 |
> |
const int transfer_mode = ReadMacInt32(p + acclTransferMode); |
1840 |
> |
if (transfer_mode == 8) { |
1841 |
|
// Fill |
1842 |
< |
if (p->dest_pixel_size == 8 && fillrect8_hook != NULL) { |
1843 |
< |
p->draw_proc = accl_fillrect8; |
1844 |
< |
return true; |
1845 |
< |
} else if (p->dest_pixel_size == 32 && fillrect32_hook != NULL) { |
1680 |
< |
p->draw_proc = accl_fillrect32; |
1681 |
< |
return true; |
1682 |
< |
} |
1683 |
< |
} else if (p->transfer_mode == 10 && invrect_hook != NULL) { |
1842 |
> |
WriteMacInt32(p + acclDrawProc, NativeTVECT(NATIVE_FILLRECT)); |
1843 |
> |
return true; |
1844 |
> |
} |
1845 |
> |
else if (transfer_mode == 10) { |
1846 |
|
// Invert |
1847 |
< |
p->draw_proc = accl_invrect; |
1847 |
> |
WriteMacInt32(p + acclDrawProc, NativeTVECT(NATIVE_INVRECT)); |
1848 |
|
return true; |
1849 |
|
} |
1850 |
|
} |
1851 |
|
return false; |
1852 |
|
} |
1853 |
|
|
1692 |
– |
static struct accl_hook_info fillrect_hook_info = {accl_fillrect_hook, accl_sync_hook, ACCL_FILLRECT}; |
1693 |
– |
#endif |
1694 |
– |
|
1854 |
|
// Rectangle blitting |
1855 |
|
// TODO: optimize for VOSF and target pixmap == screen |
1856 |
< |
void NQD_bitblt(uint32 arg) |
1856 |
> |
void NQD_bitblt(uint32 p) |
1857 |
|
{ |
1858 |
< |
D(bug("accl_bitblt %08x\n", arg)); |
1700 |
< |
accl_params *p = (accl_params *)arg; |
1858 |
> |
D(bug("accl_bitblt %08x\n", p)); |
1859 |
|
|
1860 |
|
// Get blitting parameters |
1861 |
< |
int16 src_X = p->src_rect[1] - p->src_bounds[1]; |
1862 |
< |
int16 src_Y = p->src_rect[0] - p->src_bounds[0]; |
1863 |
< |
int16 dest_X = p->dest_rect[1] - p->dest_bounds[1]; |
1864 |
< |
int16 dest_Y = p->dest_rect[0] - p->dest_bounds[0]; |
1865 |
< |
int16 width = p->dest_rect[3] - p->dest_rect[1]; |
1866 |
< |
int16 height = p->dest_rect[2] - p->dest_rect[0]; |
1867 |
< |
D(bug(" src addr %08x, dest addr %08x\n", p->src_base_addr, p->dest_base_addr)); |
1861 |
> |
int16 src_X = (int16)ReadMacInt16(p + acclSrcRect + 2) - (int16)ReadMacInt16(p + acclSrcBoundsRect + 2); |
1862 |
> |
int16 src_Y = (int16)ReadMacInt16(p + acclSrcRect + 0) - (int16)ReadMacInt16(p + acclSrcBoundsRect + 0); |
1863 |
> |
int16 dest_X = (int16)ReadMacInt16(p + acclDestRect + 2) - (int16)ReadMacInt16(p + acclDestBoundsRect + 2); |
1864 |
> |
int16 dest_Y = (int16)ReadMacInt16(p + acclDestRect + 0) - (int16)ReadMacInt16(p + acclDestBoundsRect + 0); |
1865 |
> |
int16 width = (int16)ReadMacInt16(p + acclDestRect + 6) - (int16)ReadMacInt16(p + acclDestRect + 2); |
1866 |
> |
int16 height = (int16)ReadMacInt16(p + acclDestRect + 4) - (int16)ReadMacInt16(p + acclDestRect + 0); |
1867 |
> |
D(bug(" src addr %08x, dest addr %08x\n", ReadMacInt32(p + acclSrcBaseAddr), ReadMacInt32(p + acclDestBaseAddr))); |
1868 |
|
D(bug(" src X %d, src Y %d, dest X %d, dest Y %d\n", src_X, src_Y, dest_X, dest_Y)); |
1869 |
|
D(bug(" width %d, height %d\n", width, height)); |
1870 |
|
|
1871 |
|
// And perform the blit |
1872 |
< |
const int bpp = bytes_per_pixel(p->src_pixel_size); |
1872 |
> |
const int bpp = bytes_per_pixel(ReadMacInt32(p + acclSrcPixelSize)); |
1873 |
|
width *= bpp; |
1874 |
< |
if (p->src_row_bytes > 0) { |
1875 |
< |
const int src_row_bytes = p->src_row_bytes; |
1876 |
< |
const int dst_row_bytes = p->dest_row_bytes; |
1877 |
< |
uint8 *src = (uint8 *)p->src_base_addr + (src_Y * src_row_bytes) + (src_X * bpp); |
1878 |
< |
uint8 *dst = (uint8 *)p->dest_base_addr + (dest_Y * dst_row_bytes) + (dest_X * bpp); |
1874 |
> |
if ((int32)ReadMacInt32(p + acclSrcRowBytes) > 0) { |
1875 |
> |
const int src_row_bytes = (int32)ReadMacInt32(p + acclSrcRowBytes); |
1876 |
> |
const int dst_row_bytes = (int32)ReadMacInt32(p + acclDestRowBytes); |
1877 |
> |
uint8 *src = Mac2HostAddr(ReadMacInt32(p + acclSrcBaseAddr) + (src_Y * src_row_bytes) + (src_X * bpp)); |
1878 |
> |
uint8 *dst = Mac2HostAddr(ReadMacInt32(p + acclDestBaseAddr) + (dest_Y * dst_row_bytes) + (dest_X * bpp)); |
1879 |
|
for (int i = 0; i < height; i++) { |
1880 |
|
memcpy(dst, src, width); |
1881 |
|
src += src_row_bytes; |
1883 |
|
} |
1884 |
|
} |
1885 |
|
else { |
1886 |
< |
const int src_row_bytes = -p->src_row_bytes; |
1887 |
< |
const int dst_row_bytes = -p->dest_row_bytes; |
1888 |
< |
uint8 *src = (uint8 *)p->src_base_addr + ((src_Y + height - 1) * src_row_bytes) + (src_X * bpp); |
1889 |
< |
uint8 *dst = (uint8 *)p->dest_base_addr + ((dest_Y + height - 1) * dst_row_bytes) + (dest_X * bpp); |
1886 |
> |
const int src_row_bytes = -(int32)ReadMacInt32(p + acclSrcRowBytes); |
1887 |
> |
const int dst_row_bytes = -(int32)ReadMacInt32(p + acclDestRowBytes); |
1888 |
> |
uint8 *src = Mac2HostAddr(ReadMacInt32(p + acclSrcBaseAddr) + ((src_Y + height - 1) * src_row_bytes) + (src_X * bpp)); |
1889 |
> |
uint8 *dst = Mac2HostAddr(ReadMacInt32(p + acclDestBaseAddr) + ((dest_Y + height - 1) * dst_row_bytes) + (dest_X * bpp)); |
1890 |
|
for (int i = height - 1; i >= 0; i--) { |
1891 |
|
memcpy(dst, src, width); |
1892 |
|
src -= src_row_bytes; |
1895 |
|
} |
1896 |
|
} |
1897 |
|
|
1898 |
< |
bool NQD_bitblt_hook(uint32 arg) |
1898 |
> |
/* |
1899 |
> |
BitBlt transfer modes: |
1900 |
> |
0 : srcCopy |
1901 |
> |
1 : srcOr |
1902 |
> |
2 : srcXor |
1903 |
> |
3 : srcBic |
1904 |
> |
4 : notSrcCopy |
1905 |
> |
5 : notSrcOr |
1906 |
> |
6 : notSrcXor |
1907 |
> |
7 : notSrcBic |
1908 |
> |
32 : blend |
1909 |
> |
33 : addPin |
1910 |
> |
34 : addOver |
1911 |
> |
35 : subPin |
1912 |
> |
36 : transparent |
1913 |
> |
37 : adMax |
1914 |
> |
38 : subOver |
1915 |
> |
39 : adMin |
1916 |
> |
50 : hilite |
1917 |
> |
*/ |
1918 |
> |
|
1919 |
> |
bool NQD_bitblt_hook(uint32 p) |
1920 |
|
{ |
1921 |
< |
D(bug("accl_draw_hook %08x\n", arg)); |
1743 |
< |
accl_params *p = (accl_params *)arg; |
1921 |
> |
D(bug("accl_draw_hook %08x\n", p)); |
1922 |
|
|
1923 |
|
// Check if we can accelerate this bitblt |
1924 |
< |
if (((uint32 *)p)[0x18 >> 2] + ((uint32 *)p)[0x128 >> 2] == 0 && |
1925 |
< |
((uint32 *)p)[0x130 >> 2] == 0 && |
1926 |
< |
p->src_pixel_size >= 8 && p->src_pixel_size == p->dest_pixel_size && |
1927 |
< |
((p->src_row_bytes ^ p->dest_row_bytes) >> 31) == 0 && |
1928 |
< |
p->transfer_mode == 0 && |
1929 |
< |
((uint32 *)p)[0x15c >> 2] > 0) { |
1924 |
> |
if (ReadMacInt32(p + 0x018) + ReadMacInt32(p + 0x128) == 0 && |
1925 |
> |
ReadMacInt32(p + 0x130) == 0 && |
1926 |
> |
ReadMacInt32(p + acclSrcPixelSize) >= 8 && |
1927 |
> |
ReadMacInt32(p + acclSrcPixelSize) == ReadMacInt32(p + acclDestPixelSize) && |
1928 |
> |
(ReadMacInt32(p + acclSrcRowBytes) ^ ReadMacInt32(p + acclDestRowBytes)) >= 0 && // same sign? |
1929 |
> |
ReadMacInt32(p + acclTransferMode) == 0 && // srcCopy? |
1930 |
> |
ReadMacInt32(p + 0x15c) > 0) { |
1931 |
|
|
1932 |
|
// Yes, set function pointer |
1933 |
< |
p->draw_proc = NativeTVECT(NATIVE_BITBLT); |
1933 |
> |
WriteMacInt32(p + acclDrawProc, NativeTVECT(NATIVE_BITBLT)); |
1934 |
|
return true; |
1935 |
|
} |
1936 |
|
return false; |
1945 |
|
|
1946 |
|
void VideoInstallAccel(void) |
1947 |
|
{ |
1948 |
+ |
// Temporary hack until it's fixed for e.g. little-endian & 64-bit platforms |
1949 |
+ |
#ifndef __powerpc__ |
1950 |
+ |
return; |
1951 |
+ |
#endif |
1952 |
+ |
|
1953 |
|
// Install acceleration hooks |
1954 |
|
if (PrefsFindBool("gfxaccel")) { |
1955 |
|
D(bug("Video: Installing acceleration hooks\n")); |
1960 |
|
WriteMacInt32(base + 0, NativeTVECT(NATIVE_BITBLT_HOOK)); |
1961 |
|
WriteMacInt32(base + 4, NativeTVECT(NATIVE_SYNC_HOOK)); |
1962 |
|
WriteMacInt32(base + 8, ACCL_BITBLT); |
1779 |
– |
#if defined(__powerpc__) // Temporary hack until it's fixed for e.g. little-endian & 64-bit platforms |
1963 |
|
NQDMisc(6, bitblt_hook_info.ptr()); |
1781 |
– |
#endif |
1964 |
|
|
1965 |
< |
// NQDMisc(6, &fillrect_hook_info); |
1965 |
> |
SheepVar fillrect_hook_info(sizeof(accl_hook_info)); |
1966 |
> |
base = fillrect_hook_info.addr(); |
1967 |
> |
WriteMacInt32(base + 0, NativeTVECT(NATIVE_FILLRECT_HOOK)); |
1968 |
> |
WriteMacInt32(base + 4, NativeTVECT(NATIVE_SYNC_HOOK)); |
1969 |
> |
WriteMacInt32(base + 8, ACCL_FILLRECT); |
1970 |
> |
NQDMisc(6, fillrect_hook_info.ptr()); |
1971 |
|
} |
1972 |
|
} |
1973 |
|
|