* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
-#include "hw.h"
-#include "loader.h"
+#include "hw/hw.h"
+#include "hw/loader.h"
#include "ui/console.h"
-#include "pci/pci.h"
+#include "hw/pci/pci.h"
#undef VERBOSE
#define HW_RECT_ACCEL
#define HW_FILL_ACCEL
#define HW_MOUSE_ACCEL
-#include "vga_int.h"
+#include "hw/vga_int.h"
/* See http://vmware-svga.sf.net/ for some documentation on VMWare SVGA */
int new_height;
uint32_t guest;
uint32_t svgaid;
- uint32_t wred;
- uint32_t wgreen;
- uint32_t wblue;
int syncing;
MemoryRegion fifo_ram;
static inline void vmsvga_update_rect(struct vmsvga_state_s *s,
int x, int y, int w, int h)
{
+ DisplaySurface *surface = qemu_console_surface(s->vga.con);
int line;
int bypl;
int width;
fprintf(stderr, "%s: update w was < 0 (%d)\n", __func__, w);
w = 0;
}
- if (x + w > ds_get_width(s->vga.ds)) {
+ if (x + w > surface_width(surface)) {
fprintf(stderr, "%s: update width too large x: %d, w: %d\n",
__func__, x, w);
- x = MIN(x, ds_get_width(s->vga.ds));
- w = ds_get_width(s->vga.ds) - x;
+ x = MIN(x, surface_width(surface));
+ w = surface_width(surface) - x;
}
if (y < 0) {
fprintf(stderr, "%s: update h was < 0 (%d)\n", __func__, h);
h = 0;
}
- if (y + h > ds_get_height(s->vga.ds)) {
+ if (y + h > surface_height(surface)) {
fprintf(stderr, "%s: update height too large y: %d, h: %d\n",
__func__, y, h);
- y = MIN(y, ds_get_height(s->vga.ds));
- h = ds_get_height(s->vga.ds) - y;
+ y = MIN(y, surface_height(surface));
+ h = surface_height(surface) - y;
}
- bypl = ds_get_linesize(s->vga.ds);
- width = ds_get_bytes_per_pixel(s->vga.ds) * w;
- start = ds_get_bytes_per_pixel(s->vga.ds) * x + bypl * y;
+ bypl = surface_stride(surface);
+ width = surface_bytes_per_pixel(surface) * w;
+ start = surface_bytes_per_pixel(surface) * x + bypl * y;
src = s->vga.vram_ptr + start;
- dst = ds_get_data(s->vga.ds) + start;
+ dst = surface_data(surface) + start;
for (line = h; line > 0; line--, src += bypl, dst += bypl) {
memcpy(dst, src, width);
}
- dpy_gfx_update(s->vga.ds, x, y, w, h);
+ dpy_gfx_update(s->vga.con, x, y, w, h);
}
static inline void vmsvga_update_rect_delayed(struct vmsvga_state_s *s,
static inline void vmsvga_copy_rect(struct vmsvga_state_s *s,
int x0, int y0, int x1, int y1, int w, int h)
{
+ DisplaySurface *surface = qemu_console_surface(s->vga.con);
uint8_t *vram = s->vga.vram_ptr;
- int bypl = ds_get_linesize(s->vga.ds);
- int bypp = ds_get_bytes_per_pixel(s->vga.ds);
+ int bypl = surface_stride(surface);
+ int bypp = surface_bytes_per_pixel(surface);
int width = bypp * w;
int line = h;
uint8_t *ptr[2];
static inline void vmsvga_fill_rect(struct vmsvga_state_s *s,
uint32_t c, int x, int y, int w, int h)
{
- int bypl = ds_get_linesize(s->vga.ds);
- int width = ds_get_bytes_per_pixel(s->vga.ds) * w;
+ DisplaySurface *surface = qemu_console_surface(s->vga.con);
+ int bypl = surface_stride(surface);
+ int width = surface_bytes_per_pixel(surface) * w;
int line = h;
int column;
uint8_t *fst;
col[2] = c >> 16;
col[3] = c >> 24;
- fst = s->vga.vram_ptr + ds_get_bytes_per_pixel(s->vga.ds) * x + bypl * y;
+ fst = s->vga.vram_ptr + surface_bytes_per_pixel(surface) * x + bypl * y;
if (line--) {
dst = fst;
src = col;
for (column = width; column > 0; column--) {
*(dst++) = *(src++);
- if (src - col == ds_get_bytes_per_pixel(s->vga.ds)) {
+ if (src - col == surface_bytes_per_pixel(surface)) {
src = col;
}
}
qc = cursor_builtin_left_ptr();
}
- dpy_cursor_define(s->vga.ds, qc);
+ dpy_cursor_define(s->vga.con, qc);
cursor_put(qc);
}
#endif
{
uint32_t caps;
struct vmsvga_state_s *s = opaque;
+ DisplaySurface *surface = qemu_console_surface(s->vga.con);
switch (s->index) {
case SVGA_REG_ID:
return s->enable;
case SVGA_REG_WIDTH:
- return ds_get_width(s->vga.ds);
+ return surface_width(surface);
case SVGA_REG_HEIGHT:
- return ds_get_height(s->vga.ds);
+ return surface_height(surface);
case SVGA_REG_MAX_WIDTH:
return SVGA_MAX_WIDTH;
return 0x0;
case SVGA_REG_RED_MASK:
- return s->wred;
+ return surface->pf.rmask;
case SVGA_REG_GREEN_MASK:
- return s->wgreen;
+ return surface->pf.gmask;
case SVGA_REG_BLUE_MASK:
- return s->wblue;
+ return surface->pf.bmask;
case SVGA_REG_BYTES_PER_LINE:
return s->bypp * s->new_width;
caps |= SVGA_CAP_RECT_FILL;
#endif
#ifdef HW_MOUSE_ACCEL
- if (dpy_cursor_define_supported(s->vga.ds)) {
+ if (dpy_cursor_define_supported(s->vga.con)) {
caps |= SVGA_CAP_CURSOR | SVGA_CAP_CURSOR_BYPASS_2 |
SVGA_CAP_CURSOR_BYPASS;
}
s->cursor.on &= (value != SVGA_CURSOR_ON_HIDE);
#ifdef HW_MOUSE_ACCEL
if (value <= SVGA_CURSOR_ON_SHOW) {
- dpy_mouse_set(s->vga.ds, s->cursor.x, s->cursor.y, s->cursor.on);
+ dpy_mouse_set(s->vga.con, s->cursor.x, s->cursor.y, s->cursor.on);
}
#endif
break;
static inline void vmsvga_check_size(struct vmsvga_state_s *s)
{
- if (s->new_width != ds_get_width(s->vga.ds) ||
- s->new_height != ds_get_height(s->vga.ds)) {
- qemu_console_resize(s->vga.ds, s->new_width, s->new_height);
+ DisplaySurface *surface = qemu_console_surface(s->vga.con);
+
+ if (s->new_width != surface_width(surface) ||
+ s->new_height != surface_height(surface)) {
+ qemu_console_resize(s->vga.con, s->new_width, s->new_height);
s->invalidated = 1;
}
}
static void vmsvga_update_display(void *opaque)
{
struct vmsvga_state_s *s = opaque;
+ DisplaySurface *surface = qemu_console_surface(s->vga.con);
bool dirty = false;
if (!s->enable) {
if (memory_region_is_logging(&s->vga.vram)) {
vga_sync_dirty_bitmap(&s->vga);
dirty = memory_region_get_dirty(&s->vga.vram, 0,
- ds_get_linesize(s->vga.ds) * ds_get_height(s->vga.ds),
+ surface_stride(surface) * surface_height(surface),
DIRTY_MEMORY_VGA);
}
if (s->invalidated || dirty) {
s->invalidated = 0;
- memcpy(ds_get_data(s->vga.ds), s->vga.vram_ptr,
- ds_get_linesize(s->vga.ds) * ds_get_height(s->vga.ds));
- dpy_gfx_update(s->vga.ds, 0, 0,
- ds_get_width(s->vga.ds), ds_get_height(s->vga.ds));
+ memcpy(surface_data(surface), s->vga.vram_ptr,
+ surface_stride(surface) * surface_height(surface));
+ dpy_gfx_update(s->vga.con, 0, 0,
+ surface_width(surface), surface_height(surface));
}
if (dirty) {
memory_region_reset_dirty(&s->vga.vram, 0,
- ds_get_linesize(s->vga.ds) * ds_get_height(s->vga.ds),
+ surface_stride(surface) * surface_height(surface),
DIRTY_MEMORY_VGA);
}
}
Error **errp)
{
struct vmsvga_state_s *s = opaque;
+ DisplaySurface *surface = qemu_console_surface(s->vga.con);
+
if (!s->enable) {
s->vga.screen_dump(&s->vga, filename, cswitch, errp);
return;
}
- if (ds_get_bits_per_pixel(s->vga.ds) == 32) {
+ if (surface_bits_per_pixel(surface) == 32) {
DisplaySurface *ds = qemu_create_displaysurface_from(
- ds_get_width(s->vga.ds),
- ds_get_height(s->vga.ds),
+ surface_width(surface),
+ surface_height(surface),
32,
- ds_get_linesize(s->vga.ds),
- s->vga.vram_ptr);
+ surface_stride(surface),
+ s->vga.vram_ptr, false);
ppm_save(filename, ds, errp);
g_free(ds);
}
static void vmsvga_init(struct vmsvga_state_s *s,
MemoryRegion *address_space, MemoryRegion *io)
{
+ DisplaySurface *surface;
+
s->scratch_size = SVGA_SCRATCH_SIZE;
s->scratch = g_malloc(s->scratch_size * 4);
- s->vga.ds = graphic_console_init(vmsvga_update_display,
- vmsvga_invalidate_display,
- vmsvga_screen_dump,
- vmsvga_text_update, s);
-
+ s->vga.con = graphic_console_init(vmsvga_update_display,
+ vmsvga_invalidate_display,
+ vmsvga_screen_dump,
+ vmsvga_text_update, s);
+ surface = qemu_console_surface(s->vga.con);
s->fifo_size = SVGA_FIFO_SIZE;
memory_region_init_ram(&s->fifo_ram, "vmsvga.fifo", s->fifo_size);
vmstate_register(NULL, 0, &vmstate_vga_common, &s->vga);
/* Save some values here in case they are changed later.
* This is suspicious and needs more though why it is needed. */
- s->depth = ds_get_bits_per_pixel(s->vga.ds);
- s->bypp = ds_get_bytes_per_pixel(s->vga.ds);
- s->wred = ds_get_rmask(s->vga.ds);
- s->wgreen = ds_get_gmask(s->vga.ds);
- s->wblue = ds_get_bmask(s->vga.ds);
+ s->depth = surface_bits_per_pixel(surface);
+ s->bypp = surface_bytes_per_pixel(surface);
}
static uint64_t vmsvga_io_read(void *opaque, hwaddr addr, unsigned size)
projects / qemu.git / blobdiff