ati_2d_blt uses a mixture of locals and direct register access of needed
state. This assigns all values derived from register state to local
variables. It prepares the function for a larger refactor that removes
the dependency on the full device and direct register access entirely.
Signed-off-by: Chad Jablonski <chad@jablonski.xyz>
---
hw/display/ati_2d.c | 97 ++++++++++++++++++++++++---------------------
1 file changed, 52 insertions(+), 45 deletions(-)
diff --git a/hw/display/ati_2d.c b/hw/display/ati_2d.c
index e8b9bf5f70..618aedc3da 100644
--- a/hw/display/ati_2d.c
+++ b/hw/display/ati_2d.c
@@ -65,10 +65,20 @@ void ati_2d_blt(ATIVGAState *s)
{
/* FIXME it is probably more complex than this and may need to be */
/* rewritten but for now as a start just to get some output: */
- unsigned dst_x = (s->regs.dp_cntl & DST_X_LEFT_TO_RIGHT ?
- s->regs.dst_x : s->regs.dst_x + 1 - s->regs.dst_width);
- unsigned dst_y = (s->regs.dp_cntl & DST_Y_TOP_TO_BOTTOM ?
- s->regs.dst_y : s->regs.dst_y + 1 - s->regs.dst_height);
+ bool use_pixman_fill = s->use_pixman & BIT(0);
+ bool use_pixman_blt = s->use_pixman & BIT(1);
+ int rop3 = s->regs.dp_mix & GMC_ROP3_MASK;
+ bool left_to_right = s->regs.dp_cntl & DST_X_LEFT_TO_RIGHT;
+ bool top_to_bottom = s->regs.dp_cntl & DST_Y_TOP_TO_BOTTOM;
+ uint32_t frgd_clr = s->regs.dp_brush_frgd_clr;
+ uint8_t *palette = s->vga.palette;
+ unsigned dst_offset = s->regs.dst_offset;
+ unsigned dst_width = s->regs.dst_width;
+ unsigned dst_height = s->regs.dst_height;
+ unsigned dst_x = (left_to_right ?
+ s->regs.dst_x : s->regs.dst_x + 1 - dst_width);
+ unsigned dst_y = (top_to_bottom ?
+ s->regs.dst_y : s->regs.dst_y + 1 - dst_height);
int bpp = ati_bpp_from_datatype(s);
if (!bpp) {
qemu_log_mask(LOG_GUEST_ERROR, "Invalid bpp\n");
@@ -79,7 +89,7 @@ void ati_2d_blt(ATIVGAState *s)
qemu_log_mask(LOG_GUEST_ERROR, "Zero dest pitch\n");
return;
}
- uint8_t *dst_bits = s->vga.vram_ptr + s->regs.dst_offset;
+ uint8_t *dst_bits = s->vga.vram_ptr + dst_offset;
if (s->dev_id == PCI_DEVICE_ID_ATI_RAGE128_PF) {
dst_bits += s->regs.crtc_offset & 0x07ffffff;
@@ -88,26 +98,25 @@ void ati_2d_blt(ATIVGAState *s)
int dst_stride_words = dst_stride / sizeof(uint32_t);
uint8_t *end = s->vga.vram_ptr + s->vga.vram_size;
if (dst_x > 0x3fff || dst_y > 0x3fff || dst_bits >= end
- || dst_bits + dst_x
- + (dst_y + s->regs.dst_height) * dst_stride >= end) {
+ || dst_bits + dst_x + (dst_y + dst_height) * dst_stride >= end) {
qemu_log_mask(LOG_UNIMP, "blt outside vram not implemented\n");
return;
}
DPRINTF("%d %d %d, %d %d %d, (%d,%d) -> (%d,%d) %dx%d %c %c\n",
- s->regs.src_offset, s->regs.dst_offset, s->regs.default_offset,
- s->regs.src_pitch, s->regs.dst_pitch, s->regs.default_pitch,
+ s->regs.src_offset, dst_offset, s->regs.default_offset,
+ s->regs.src_pitch, dst_stride, s->regs.default_pitch,
s->regs.src_x, s->regs.src_y, dst_x, dst_y,
- s->regs.dst_width, s->regs.dst_height,
- (s->regs.dp_cntl & DST_X_LEFT_TO_RIGHT ? '>' : '<'),
- (s->regs.dp_cntl & DST_Y_TOP_TO_BOTTOM ? 'v' : '^'));
- switch (s->regs.dp_mix & GMC_ROP3_MASK) {
+ dst_width, dst_height,
+ (left_to_right ? '>' : '<'),
+ (top_to_bottom ? 'v' : '^'));
+ switch (rop3) {
case ROP3_SRCCOPY:
{
bool fallback = false;
- unsigned src_x = (s->regs.dp_cntl & DST_X_LEFT_TO_RIGHT ?
- s->regs.src_x : s->regs.src_x + 1 - s->regs.dst_width);
- unsigned src_y = (s->regs.dp_cntl & DST_Y_TOP_TO_BOTTOM ?
- s->regs.src_y : s->regs.src_y + 1 - s->regs.dst_height);
+ unsigned src_x = (left_to_right ?
+ s->regs.src_x : s->regs.src_x + 1 - dst_width);
+ unsigned src_y = (top_to_bottom ?
+ s->regs.src_y : s->regs.src_y + 1 - dst_height);
int src_stride = s->regs.src_pitch;
if (!src_stride) {
qemu_log_mask(LOG_GUEST_ERROR, "Zero source pitch\n");
@@ -122,7 +131,7 @@ void ati_2d_blt(ATIVGAState *s)
int src_stride_words = src_stride / sizeof(uint32_t);
if (src_x > 0x3fff || src_y > 0x3fff || src_bits >= end
|| src_bits + src_x
- + (src_y + s->regs.dst_height) * src_stride >= end) {
+ + (src_y + dst_height) * src_stride >= end) {
qemu_log_mask(LOG_UNIMP, "blt outside vram not implemented\n");
return;
}
@@ -130,30 +139,28 @@ void ati_2d_blt(ATIVGAState *s)
DPRINTF("pixman_blt(%p, %p, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n",
src_bits, dst_bits, src_stride_words, dst_stride_words,
bpp, bpp, src_x, src_y, dst_x, dst_y,
- s->regs.dst_width, s->regs.dst_height);
+ dst_width, dst_height);
#ifdef CONFIG_PIXMAN
- if ((s->use_pixman & BIT(1)) &&
- s->regs.dp_cntl & DST_X_LEFT_TO_RIGHT &&
- s->regs.dp_cntl & DST_Y_TOP_TO_BOTTOM) {
+ if (use_pixman_blt && left_to_right && top_to_bottom) {
fallback = !pixman_blt((uint32_t *)src_bits, (uint32_t *)dst_bits,
src_stride_words, dst_stride_words, bpp, bpp,
src_x, src_y, dst_x, dst_y,
- s->regs.dst_width, s->regs.dst_height);
- } else if (s->use_pixman & BIT(1)) {
+ dst_width, dst_height);
+ } else if (use_pixman_blt) {
/* FIXME: We only really need a temporary if src and dst overlap */
- int llb = s->regs.dst_width * (bpp / 8);
+ int llb = dst_width * (bpp / 8);
int tmp_stride = DIV_ROUND_UP(llb, sizeof(uint32_t));
uint32_t *tmp = g_malloc(tmp_stride * sizeof(uint32_t) *
- s->regs.dst_height);
+ dst_height);
fallback = !pixman_blt((uint32_t *)src_bits, tmp,
src_stride_words, tmp_stride, bpp, bpp,
src_x, src_y, 0, 0,
- s->regs.dst_width, s->regs.dst_height);
+ dst_width, dst_height);
if (!fallback) {
fallback = !pixman_blt(tmp, (uint32_t *)dst_bits,
tmp_stride, dst_stride_words, bpp, bpp,
0, 0, dst_x, dst_y,
- s->regs.dst_width, s->regs.dst_height);
+ dst_width, dst_height);
}
g_free(tmp);
} else
@@ -163,17 +170,17 @@ void ati_2d_blt(ATIVGAState *s)
}
if (fallback) {
unsigned int y, i, j, bypp = bpp / 8;
- for (y = 0; y < s->regs.dst_height; y++) {
+ for (y = 0; y < dst_height; y++) {
i = dst_x * bypp;
j = src_x * bypp;
- if (s->regs.dp_cntl & DST_Y_TOP_TO_BOTTOM) {
+ if (top_to_bottom) {
i += (dst_y + y) * dst_stride;
j += (src_y + y) * src_stride;
} else {
- i += (dst_y + s->regs.dst_height - 1 - y) * dst_stride;
- j += (src_y + s->regs.dst_height - 1 - y) * src_stride;
+ i += (dst_y + dst_height - 1 - y) * dst_stride;
+ j += (src_y + dst_height - 1 - y) * src_stride;
}
- memmove(&dst_bits[i], &src_bits[j], s->regs.dst_width * bypp);
+ memmove(&dst_bits[i], &src_bits[j], dst_width * bypp);
}
}
break;
@@ -184,34 +191,34 @@ void ati_2d_blt(ATIVGAState *s)
{
uint32_t filler = 0;
- switch (s->regs.dp_mix & GMC_ROP3_MASK) {
+ switch (rop3) {
case ROP3_PATCOPY:
- filler = s->regs.dp_brush_frgd_clr;
+ filler = frgd_clr;
break;
case ROP3_BLACKNESS:
- filler = 0xffUL << 24 | rgb_to_pixel32(s->vga.palette[0],
- s->vga.palette[1], s->vga.palette[2]);
+ filler = 0xffUL << 24 | rgb_to_pixel32(palette[0], palette[1],
+ palette[2]);
break;
case ROP3_WHITENESS:
- filler = 0xffUL << 24 | rgb_to_pixel32(s->vga.palette[3],
- s->vga.palette[4], s->vga.palette[5]);
+ filler = 0xffUL << 24 | rgb_to_pixel32(palette[3], palette[4],
+ palette[5]);
break;
}
DPRINTF("pixman_fill(%p, %d, %d, %d, %d, %d, %d, %x)\n",
dst_bits, dst_stride_words, bpp, dst_x, dst_y,
- s->regs.dst_width, s->regs.dst_height, filler);
+ dst_width, dst_height, filler);
#ifdef CONFIG_PIXMAN
- if (!(s->use_pixman & BIT(0)) ||
+ if (!use_pixman_fill ||
!pixman_fill((uint32_t *)dst_bits, dst_stride_words, bpp, dst_x,
- dst_y, s->regs.dst_width, s->regs.dst_height, filler))
+ dst_y, dst_width, dst_height, filler))
#endif
{
/* fallback when pixman failed or we don't want to call it */
unsigned int x, y, i, bypp = bpp / 8;
- for (y = 0; y < s->regs.dst_height; y++) {
+ for (y = 0; y < dst_height; y++) {
i = dst_x * bypp + (dst_y + y) * dst_stride;
- for (x = 0; x < s->regs.dst_width; x++, i += bypp) {
+ for (x = 0; x < dst_width; x++, i += bypp) {
stn_he_p(&dst_bits[i], bypp, filler);
}
}
@@ -220,7 +227,7 @@ void ati_2d_blt(ATIVGAState *s)
}
default:
qemu_log_mask(LOG_UNIMP, "Unimplemented ati_2d blt op %x\n",
- (s->regs.dp_mix & GMC_ROP3_MASK) >> 16);
+ rop3 >> 16);
return;
}
--
2.52.0