mirrors/qemu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ui/console: Use qemu_dmabuf_get_..() helpers instead

Browse Source 
This commit updates all instances where fields within the QemuDmaBuf
struct are directly accessed, replacing them with calls to these new
helper functions.

v6: fix typos in helper names in ui/spice-display.c

v7: removed prefix, "dpy_gl_" from all helpers

v8: Introduction of helpers was removed as those were already added
    by the previous commit

v11: -- Use new qemu_dmabuf_close() instead of close(qemu_dmabuf_get_fd()).
        (Daniel P. Berrangé <berrange@redhat.com>)
     -- Use new qemu_dmabuf_dup_fd() instead of dup(qemu_dmabuf_get_fd()).
        (Daniel P. Berrangé <berrange@redhat.com>)

Suggested-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Cc: Philippe Mathieu-Daudé <philmd@linaro.org>
Cc: Daniel P. Berrangé <berrange@redhat.com>
Cc: Vivek Kasireddy <vivek.kasireddy@intel.com>
Signed-off-by: Dongwon Kim <dongwon.kim@intel.com>
Message-Id: <20240508175403.3399895-4-dongwon.kim@intel.com>
This commit is contained in:
Dongwon Kim 2024-05-08 10:54:00 -07:00 committed by Marc-André Lureau
parent 6e6ae491da
commit 6779a3076f
12 changed files with 181 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
hw/display/vhost-user-gpu.c
View File

@ -262,10 +262,7 @@ vhost_user_gpu_handle_display(VhostUserGPU *g, VhostUserGpuMsg *msg)
g->parent_obj.enable = 1; g->parent_obj.enable = 1;
con = g->parent_obj.scanout[m->scanout_id].con; con = g->parent_obj.scanout[m->scanout_id].con;
dmabuf = &g->dmabuf[m->scanout_id]; dmabuf = &g->dmabuf[m->scanout_id];
if (dmabuf->fd >= 0) { qemu_dmabuf_close(dmabuf);
close(dmabuf->fd);
dmabuf->fd = -1;
}
dpy_gl_release_dmabuf(con, dmabuf); dpy_gl_release_dmabuf(con, dmabuf);
if (fd == -1) { if (fd == -1) {
dpy_gl_scanout_disable(con); dpy_gl_scanout_disable(con);

7
hw/display/virtio-gpu-udmabuf.c
View File

@ -206,6 +206,7 @@ int virtio_gpu_update_dmabuf(VirtIOGPU *g,
{ {
struct virtio_gpu_scanout *scanout = &g->parent_obj.scanout[scanout_id]; struct virtio_gpu_scanout *scanout = &g->parent_obj.scanout[scanout_id];
VGPUDMABuf *new_primary, *old_primary = NULL; VGPUDMABuf *new_primary, *old_primary = NULL;
uint32_t width, height;
new_primary = virtio_gpu_create_dmabuf(g, scanout_id, res, fb, r); new_primary = virtio_gpu_create_dmabuf(g, scanout_id, res, fb, r);
if (!new_primary) { if (!new_primary) {
@ -216,10 +217,10 @@ int virtio_gpu_update_dmabuf(VirtIOGPU *g,
old_primary = g->dmabuf.primary[scanout_id]; old_primary = g->dmabuf.primary[scanout_id];
} }
width = qemu_dmabuf_get_width(&new_primary->buf);
height = qemu_dmabuf_get_height(&new_primary->buf);
g->dmabuf.primary[scanout_id] = new_primary; g->dmabuf.primary[scanout_id] = new_primary;
qemu_console_resize(scanout->con, qemu_console_resize(scanout->con, width, height);
new_primary->buf.width,
new_primary->buf.height);
dpy_gl_scanout_dmabuf(scanout->con, &new_primary->buf); dpy_gl_scanout_dmabuf(scanout->con, &new_primary->buf);
if (old_primary) { if (old_primary) {

12
hw/vfio/display.c
View File

@ -260,8 +260,9 @@ static VFIODMABuf *vfio_display_get_dmabuf(VFIOPCIDevice *vdev,
static void vfio_display_free_one_dmabuf(VFIODisplay *dpy, VFIODMABuf *dmabuf) static void vfio_display_free_one_dmabuf(VFIODisplay *dpy, VFIODMABuf *dmabuf)
{ {
QTAILQ_REMOVE(&dpy->dmabuf.bufs, dmabuf, next); QTAILQ_REMOVE(&dpy->dmabuf.bufs, dmabuf, next);
qemu_dmabuf_close(&dmabuf->buf);
dpy_gl_release_dmabuf(dpy->con, &dmabuf->buf); dpy_gl_release_dmabuf(dpy->con, &dmabuf->buf);
close(dmabuf->buf.fd);
g_free(dmabuf); g_free(dmabuf);
} }
@ -286,6 +287,7 @@ static void vfio_display_dmabuf_update(void *opaque)
VFIOPCIDevice *vdev = opaque; VFIOPCIDevice *vdev = opaque;
VFIODisplay *dpy = vdev->dpy; VFIODisplay *dpy = vdev->dpy;
VFIODMABuf *primary, *cursor; VFIODMABuf *primary, *cursor;
uint32_t width, height;
bool free_bufs = false, new_cursor = false; bool free_bufs = false, new_cursor = false;
primary = vfio_display_get_dmabuf(vdev, DRM_PLANE_TYPE_PRIMARY); primary = vfio_display_get_dmabuf(vdev, DRM_PLANE_TYPE_PRIMARY);
@ -296,10 +298,12 @@ static void vfio_display_dmabuf_update(void *opaque)
return; return;
} }
width = qemu_dmabuf_get_width(&primary->buf);
height = qemu_dmabuf_get_height(&primary->buf);
if (dpy->dmabuf.primary != primary) { if (dpy->dmabuf.primary != primary) {
dpy->dmabuf.primary = primary; dpy->dmabuf.primary = primary;
qemu_console_resize(dpy->con, qemu_console_resize(dpy->con, width, height);
primary->buf.width, primary->buf.height);
dpy_gl_scanout_dmabuf(dpy->con, &primary->buf); dpy_gl_scanout_dmabuf(dpy->con, &primary->buf);
free_bufs = true; free_bufs = true;
} }
@ -328,7 +332,7 @@ static void vfio_display_dmabuf_update(void *opaque)
cursor->pos_updates = 0; cursor->pos_updates = 0;
} }
dpy_gl_update(dpy->con, 0, 0, primary->buf.width, primary->buf.height); dpy_gl_update(dpy->con, 0, 0, width, height);
if (free_bufs) { if (free_bufs) {
vfio_display_free_dmabufs(vdev); vfio_display_free_dmabufs(vdev);

4
ui/console.c
View File

@ -1459,7 +1459,7 @@ int qemu_console_get_width(QemuConsole *con, int fallback)
} }
switch (con->scanout.kind) { switch (con->scanout.kind) {
case SCANOUT_DMABUF: case SCANOUT_DMABUF:
return con->scanout.dmabuf->width; return qemu_dmabuf_get_width(con->scanout.dmabuf);
case SCANOUT_TEXTURE: case SCANOUT_TEXTURE:
return con->scanout.texture.width; return con->scanout.texture.width;
case SCANOUT_SURFACE: case SCANOUT_SURFACE:
@ -1476,7 +1476,7 @@ int qemu_console_get_height(QemuConsole *con, int fallback)
} }
switch (con->scanout.kind) { switch (con->scanout.kind) {
case SCANOUT_DMABUF: case SCANOUT_DMABUF:
return con->scanout.dmabuf->height; return qemu_dmabuf_get_height(con->scanout.dmabuf);
case SCANOUT_TEXTURE: case SCANOUT_TEXTURE:
return con->scanout.texture.height; return con->scanout.texture.height;
case SCANOUT_SURFACE: case SCANOUT_SURFACE:

9
ui/dbus-console.c
View File

@ -110,11 +110,14 @@ static void
dbus_gl_scanout_dmabuf(DisplayChangeListener *dcl, dbus_gl_scanout_dmabuf(DisplayChangeListener *dcl,
QemuDmaBuf *dmabuf) QemuDmaBuf *dmabuf)
{ {
uint32_t width, height;
DBusDisplayConsole *ddc = container_of(dcl, DBusDisplayConsole, dcl); DBusDisplayConsole *ddc = container_of(dcl, DBusDisplayConsole, dcl);
dbus_display_console_set_size(ddc, width = qemu_dmabuf_get_width(dmabuf);
dmabuf->width, height = qemu_dmabuf_get_height(dmabuf);
dmabuf->height);
dbus_display_console_set_size(ddc, width, height);
} }
static void static void

43
ui/dbus-listener.c
View File

@ -278,29 +278,33 @@ static void dbus_scanout_dmabuf(DisplayChangeListener *dcl,
DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl); DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
g_autoptr(GError) err = NULL; g_autoptr(GError) err = NULL;
g_autoptr(GUnixFDList) fd_list = NULL; g_autoptr(GUnixFDList) fd_list = NULL;
int fd;
uint32_t width, height, stride, fourcc;
uint64_t modifier;
bool y0_top;
fd = qemu_dmabuf_get_fd(dmabuf);
fd_list = g_unix_fd_list_new(); fd_list = g_unix_fd_list_new();
if (g_unix_fd_list_append(fd_list, dmabuf->fd, &err) != 0) { if (g_unix_fd_list_append(fd_list, fd, &err) != 0) {
error_report("Failed to setup dmabuf fdlist: %s", err->message); error_report("Failed to setup dmabuf fdlist: %s", err->message);
return; return;
} }
ddl_discard_pending_messages(ddl); ddl_discard_pending_messages(ddl);
width = qemu_dmabuf_get_width(dmabuf);
height = qemu_dmabuf_get_height(dmabuf);
stride = qemu_dmabuf_get_stride(dmabuf);
fourcc = qemu_dmabuf_get_fourcc(dmabuf);
modifier = qemu_dmabuf_get_modifier(dmabuf);
y0_top = qemu_dmabuf_get_y0_top(dmabuf);
/* FIXME: add missing x/y/w/h support */ /* FIXME: add missing x/y/w/h support */
qemu_dbus_display1_listener_call_scanout_dmabuf( qemu_dbus_display1_listener_call_scanout_dmabuf(
ddl->proxy, ddl->proxy, g_variant_new_handle(0),
g_variant_new_handle(0), width, height, stride, fourcc, modifier,
dmabuf->width, y0_top, G_DBUS_CALL_FLAGS_NONE,
dmabuf->height, -1, fd_list, NULL, NULL, NULL);
dmabuf->stride,
dmabuf->fourcc,
dmabuf->modifier,
dmabuf->y0_top,
G_DBUS_CALL_FLAGS_NONE,
-1,
fd_list,
NULL, NULL, NULL);
} }
#endif /* GBM */ #endif /* GBM */
#endif /* OPENGL */ #endif /* OPENGL */
@ -488,6 +492,7 @@ static void dbus_cursor_dmabuf(DisplayChangeListener *dcl,
DisplaySurface *ds; DisplaySurface *ds;
GVariant *v_data = NULL; GVariant *v_data = NULL;
egl_fb cursor_fb = EGL_FB_INIT; egl_fb cursor_fb = EGL_FB_INIT;
uint32_t width, height, texture;
if (!dmabuf) { if (!dmabuf) {
qemu_dbus_display1_listener_call_mouse_set( qemu_dbus_display1_listener_call_mouse_set(
@ -497,12 +502,16 @@ static void dbus_cursor_dmabuf(DisplayChangeListener *dcl,
} }
egl_dmabuf_import_texture(dmabuf); egl_dmabuf_import_texture(dmabuf);
if (!dmabuf->texture) { texture = qemu_dmabuf_get_texture(dmabuf);
if (!texture) {
return; return;
} }
egl_fb_setup_for_tex(&cursor_fb, dmabuf->width, dmabuf->height,
dmabuf->texture, false); width = qemu_dmabuf_get_width(dmabuf);
ds = qemu_create_displaysurface(dmabuf->width, dmabuf->height); height = qemu_dmabuf_get_height(dmabuf);
egl_fb_setup_for_tex(&cursor_fb, width, height, texture, false);
ds = qemu_create_displaysurface(width, height);
egl_fb_read(ds, &cursor_fb); egl_fb_read(ds, &cursor_fb);
v_data = g_variant_new_from_data( v_data = g_variant_new_from_data(

23
ui/egl-headless.c
View File

@ -85,29 +85,38 @@ static void egl_scanout_texture(DisplayChangeListener *dcl,
static void egl_scanout_dmabuf(DisplayChangeListener *dcl, static void egl_scanout_dmabuf(DisplayChangeListener *dcl,
QemuDmaBuf *dmabuf) QemuDmaBuf *dmabuf)
{ {
uint32_t width, height, texture;
egl_dmabuf_import_texture(dmabuf); egl_dmabuf_import_texture(dmabuf);
if (!dmabuf->texture) { texture = qemu_dmabuf_get_texture(dmabuf);
if (!texture) {
return; return;
} }
egl_scanout_texture(dcl, dmabuf->texture, width = qemu_dmabuf_get_width(dmabuf);
false, dmabuf->width, dmabuf->height, height = qemu_dmabuf_get_height(dmabuf);
0, 0, dmabuf->width, dmabuf->height, NULL);
egl_scanout_texture(dcl, texture, false, width, height, 0, 0,
width, height, NULL);
} }
static void egl_cursor_dmabuf(DisplayChangeListener *dcl, static void egl_cursor_dmabuf(DisplayChangeListener *dcl,
QemuDmaBuf *dmabuf, bool have_hot, QemuDmaBuf *dmabuf, bool have_hot,
uint32_t hot_x, uint32_t hot_y) uint32_t hot_x, uint32_t hot_y)
{ {
uint32_t width, height, texture;
egl_dpy *edpy = container_of(dcl, egl_dpy, dcl); egl_dpy *edpy = container_of(dcl, egl_dpy, dcl);
if (dmabuf) { if (dmabuf) {
egl_dmabuf_import_texture(dmabuf); egl_dmabuf_import_texture(dmabuf);
if (!dmabuf->texture) { texture = qemu_dmabuf_get_texture(dmabuf);
if (!texture) {
return; return;
} }
egl_fb_setup_for_tex(&edpy->cursor_fb, dmabuf->width, dmabuf->height,
dmabuf->texture, false); width = qemu_dmabuf_get_width(dmabuf);
height = qemu_dmabuf_get_height(dmabuf);
egl_fb_setup_for_tex(&edpy->cursor_fb, width, height, texture, false);
} else { } else {
egl_fb_destroy(&edpy->cursor_fb); egl_fb_destroy(&edpy->cursor_fb);
} }

47
ui/egl-helpers.c
View File

@ -146,10 +146,10 @@ void egl_fb_blit(egl_fb *dst, egl_fb *src, bool flip)
glViewport(0, 0, dst->width, dst->height); glViewport(0, 0, dst->width, dst->height);
if (src->dmabuf) { if (src->dmabuf) {
x1 = src->dmabuf->x; x1 = qemu_dmabuf_get_x(src->dmabuf);
y1 = src->dmabuf->y; y1 = qemu_dmabuf_get_y(src->dmabuf);
w = src->dmabuf->width; w = qemu_dmabuf_get_width(src->dmabuf);
h = src->dmabuf->height; h = qemu_dmabuf_get_height(src->dmabuf);
} }
w = (x1 + w) > src->width ? src->width - x1 : w; w = (x1 + w) > src->width ? src->width - x1 : w;
@ -308,30 +308,33 @@ void egl_dmabuf_import_texture(QemuDmaBuf *dmabuf)
EGLImageKHR image = EGL_NO_IMAGE_KHR; EGLImageKHR image = EGL_NO_IMAGE_KHR;
EGLint attrs[64]; EGLint attrs[64];
int i = 0; int i = 0;
uint64_t modifier;
uint32_t texture = qemu_dmabuf_get_texture(dmabuf);
if (dmabuf->texture != 0) { if (texture != 0) {
return; return;
} }
attrs[i++] = EGL_WIDTH; attrs[i++] = EGL_WIDTH;
attrs[i++] = dmabuf->backing_width; attrs[i++] = qemu_dmabuf_get_backing_width(dmabuf);
attrs[i++] = EGL_HEIGHT; attrs[i++] = EGL_HEIGHT;
attrs[i++] = dmabuf->backing_height; attrs[i++] = qemu_dmabuf_get_backing_height(dmabuf);
attrs[i++] = EGL_LINUX_DRM_FOURCC_EXT; attrs[i++] = EGL_LINUX_DRM_FOURCC_EXT;
attrs[i++] = dmabuf->fourcc; attrs[i++] = qemu_dmabuf_get_fourcc(dmabuf);
attrs[i++] = EGL_DMA_BUF_PLANE0_FD_EXT; attrs[i++] = EGL_DMA_BUF_PLANE0_FD_EXT;
attrs[i++] = dmabuf->fd; attrs[i++] = qemu_dmabuf_get_fd(dmabuf);
attrs[i++] = EGL_DMA_BUF_PLANE0_PITCH_EXT; attrs[i++] = EGL_DMA_BUF_PLANE0_PITCH_EXT;
attrs[i++] = dmabuf->stride; attrs[i++] = qemu_dmabuf_get_stride(dmabuf);
attrs[i++] = EGL_DMA_BUF_PLANE0_OFFSET_EXT; attrs[i++] = EGL_DMA_BUF_PLANE0_OFFSET_EXT;
attrs[i++] = 0; attrs[i++] = 0;
#ifdef EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT #ifdef EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT
if (dmabuf->modifier) { modifier = qemu_dmabuf_get_modifier(dmabuf);
if (modifier) {
attrs[i++] = EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT; attrs[i++] = EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT;
attrs[i++] = (dmabuf->modifier >> 0) & 0xffffffff; attrs[i++] = (modifier >> 0) & 0xffffffff;
attrs[i++] = EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT; attrs[i++] = EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT;
attrs[i++] = (dmabuf->modifier >> 32) & 0xffffffff; attrs[i++] = (modifier >> 32) & 0xffffffff;
} }
#endif #endif
attrs[i++] = EGL_NONE; attrs[i++] = EGL_NONE;
@ -346,7 +349,8 @@ void egl_dmabuf_import_texture(QemuDmaBuf *dmabuf)
} }
glGenTextures(1, &dmabuf->texture); glGenTextures(1, &dmabuf->texture);
glBindTexture(GL_TEXTURE_2D, dmabuf->texture); texture = qemu_dmabuf_get_texture(dmabuf);
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
@ -356,11 +360,14 @@ void egl_dmabuf_import_texture(QemuDmaBuf *dmabuf)
void egl_dmabuf_release_texture(QemuDmaBuf *dmabuf) void egl_dmabuf_release_texture(QemuDmaBuf *dmabuf)
{ {
if (dmabuf->texture == 0) { uint32_t texture;
texture = qemu_dmabuf_get_texture(dmabuf);
if (texture == 0) {
return; return;
} }
glDeleteTextures(1, &dmabuf->texture); glDeleteTextures(1, &texture);
dmabuf->texture = 0; dmabuf->texture = 0;
} }
@ -382,10 +389,12 @@ void egl_dmabuf_create_sync(QemuDmaBuf *dmabuf)
void egl_dmabuf_create_fence(QemuDmaBuf *dmabuf) void egl_dmabuf_create_fence(QemuDmaBuf *dmabuf)
{ {
if (dmabuf->sync) { void *sync = qemu_dmabuf_get_sync(dmabuf);
if (sync) {
dmabuf->fence_fd = eglDupNativeFenceFDANDROID(qemu_egl_display, dmabuf->fence_fd = eglDupNativeFenceFDANDROID(qemu_egl_display,
dmabuf->sync); sync);
eglDestroySyncKHR(qemu_egl_display, dmabuf->sync); eglDestroySyncKHR(qemu_egl_display, sync);
dmabuf->sync = NULL; dmabuf->sync = NULL;
} }
} }

48
ui/gtk-egl.c
View File

@ -70,6 +70,7 @@ void gd_egl_draw(VirtualConsole *vc)
QemuDmaBuf *dmabuf = vc->gfx.guest_fb.dmabuf; QemuDmaBuf *dmabuf = vc->gfx.guest_fb.dmabuf;
#endif #endif
int ww, wh, ws; int ww, wh, ws;
int fence_fd;
if (!vc->gfx.gls) { if (!vc->gfx.gls) {
return; return;
@ -83,7 +84,7 @@ void gd_egl_draw(VirtualConsole *vc)
if (vc->gfx.scanout_mode) { if (vc->gfx.scanout_mode) {
#ifdef CONFIG_GBM #ifdef CONFIG_GBM
if (dmabuf) { if (dmabuf) {
if (!dmabuf->draw_submitted) { if (!qemu_dmabuf_get_draw_submitted(dmabuf)) {
return; return;
} else { } else {
dmabuf->draw_submitted = false; dmabuf->draw_submitted = false;
@ -99,8 +100,9 @@ void gd_egl_draw(VirtualConsole *vc)
#ifdef CONFIG_GBM #ifdef CONFIG_GBM
if (dmabuf) { if (dmabuf) {
egl_dmabuf_create_fence(dmabuf); egl_dmabuf_create_fence(dmabuf);
if (dmabuf->fence_fd >= 0) { fence_fd = qemu_dmabuf_get_fence_fd(dmabuf);
qemu_set_fd_handler(dmabuf->fence_fd, gd_hw_gl_flushed, NULL, vc); if (fence_fd >= 0) {
qemu_set_fd_handler(fence_fd, gd_hw_gl_flushed, NULL, vc);
return; return;
} }
graphic_hw_gl_block(vc->gfx.dcl.con, false); graphic_hw_gl_block(vc->gfx.dcl.con, false);
@ -149,7 +151,8 @@ void gd_egl_refresh(DisplayChangeListener *dcl)
gd_update_monitor_refresh_rate( gd_update_monitor_refresh_rate(
vc, vc->window ? vc->window : vc->gfx.drawing_area); vc, vc->window ? vc->window : vc->gfx.drawing_area);
if (vc->gfx.guest_fb.dmabuf && vc->gfx.guest_fb.dmabuf->draw_submitted) { if (vc->gfx.guest_fb.dmabuf &&
qemu_dmabuf_get_draw_submitted(vc->gfx.guest_fb.dmabuf)) {
gd_egl_draw(vc); gd_egl_draw(vc);
return; return;
} }
@ -265,22 +268,30 @@ void gd_egl_scanout_dmabuf(DisplayChangeListener *dcl,
{ {
#ifdef CONFIG_GBM #ifdef CONFIG_GBM
VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl); VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
uint32_t x, y, width, height, backing_width, backing_height, texture;
bool y0_top;
eglMakeCurrent(qemu_egl_display, vc->gfx.esurface, eglMakeCurrent(qemu_egl_display, vc->gfx.esurface,
vc->gfx.esurface, vc->gfx.ectx); vc->gfx.esurface, vc->gfx.ectx);
egl_dmabuf_import_texture(dmabuf); egl_dmabuf_import_texture(dmabuf);
if (!dmabuf->texture) { texture = qemu_dmabuf_get_texture(dmabuf);
if (!texture) {
return; return;
} }
gd_egl_scanout_texture(dcl, dmabuf->texture, x = qemu_dmabuf_get_x(dmabuf);
dmabuf->y0_top, y = qemu_dmabuf_get_y(dmabuf);
dmabuf->backing_width, dmabuf->backing_height, width = qemu_dmabuf_get_width(dmabuf);
dmabuf->x, dmabuf->y, dmabuf->width, height = qemu_dmabuf_get_height(dmabuf);
dmabuf->height, NULL); backing_width = qemu_dmabuf_get_backing_width(dmabuf);
backing_height = qemu_dmabuf_get_backing_height(dmabuf);
y0_top = qemu_dmabuf_get_y0_top(dmabuf);
if (dmabuf->allow_fences) { gd_egl_scanout_texture(dcl, texture, y0_top, backing_width, backing_height,
x, y, width, height, NULL);
if (qemu_dmabuf_get_allow_fences(dmabuf)) {
vc->gfx.guest_fb.dmabuf = dmabuf; vc->gfx.guest_fb.dmabuf = dmabuf;
} }
#endif #endif
@ -292,15 +303,19 @@ void gd_egl_cursor_dmabuf(DisplayChangeListener *dcl,
{ {
#ifdef CONFIG_GBM #ifdef CONFIG_GBM
VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl); VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
uint32_t backing_width, backing_height, texture;
if (dmabuf) { if (dmabuf) {
egl_dmabuf_import_texture(dmabuf); egl_dmabuf_import_texture(dmabuf);
if (!dmabuf->texture) { texture = qemu_dmabuf_get_texture(dmabuf);
if (!texture) {
return; return;
} }
egl_fb_setup_for_tex(&vc->gfx.cursor_fb,
dmabuf->backing_width, dmabuf->backing_height, backing_width = qemu_dmabuf_get_backing_width(dmabuf);
dmabuf->texture, false); backing_height = qemu_dmabuf_get_backing_height(dmabuf);
egl_fb_setup_for_tex(&vc->gfx.cursor_fb, backing_width, backing_height,
texture, false);
} else { } else {
egl_fb_destroy(&vc->gfx.cursor_fb); egl_fb_destroy(&vc->gfx.cursor_fb);
} }
@ -364,7 +379,8 @@ void gd_egl_flush(DisplayChangeListener *dcl,
VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl); VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
GtkWidget *area = vc->gfx.drawing_area; GtkWidget *area = vc->gfx.drawing_area;
if (vc->gfx.guest_fb.dmabuf && !vc->gfx.guest_fb.dmabuf->draw_submitted) { if (vc->gfx.guest_fb.dmabuf &&
!qemu_dmabuf_get_draw_submitted(vc->gfx.guest_fb.dmabuf)) {
graphic_hw_gl_block(vc->gfx.dcl.con, true); graphic_hw_gl_block(vc->gfx.dcl.con, true);
vc->gfx.guest_fb.dmabuf->draw_submitted = true; vc->gfx.guest_fb.dmabuf->draw_submitted = true;
gtk_egl_set_scanout_mode(vc, true); gtk_egl_set_scanout_mode(vc, true);

37
ui/gtk-gl-area.c
View File

@ -60,7 +60,7 @@ void gd_gl_area_draw(VirtualConsole *vc)
#ifdef CONFIG_GBM #ifdef CONFIG_GBM
if (dmabuf) { if (dmabuf) {
if (!dmabuf->draw_submitted) { if (!qemu_dmabuf_get_draw_submitted(dmabuf)) {
return; return;
} else { } else {
dmabuf->draw_submitted = false; dmabuf->draw_submitted = false;
@ -85,9 +85,11 @@ void gd_gl_area_draw(VirtualConsole *vc)
glFlush(); glFlush();
#ifdef CONFIG_GBM #ifdef CONFIG_GBM
if (dmabuf) { if (dmabuf) {
int fence_fd;
egl_dmabuf_create_fence(dmabuf); egl_dmabuf_create_fence(dmabuf);
if (dmabuf->fence_fd >= 0) { fence_fd = qemu_dmabuf_get_fence_fd(dmabuf);
qemu_set_fd_handler(dmabuf->fence_fd, gd_hw_gl_flushed, NULL, vc); if (fence_fd >= 0) {
qemu_set_fd_handler(fence_fd, gd_hw_gl_flushed, NULL, vc);
return; return;
} }
graphic_hw_gl_block(vc->gfx.dcl.con, false); graphic_hw_gl_block(vc->gfx.dcl.con, false);
@ -125,7 +127,8 @@ void gd_gl_area_refresh(DisplayChangeListener *dcl)
gd_update_monitor_refresh_rate(vc, vc->window ? vc->window : vc->gfx.drawing_area); gd_update_monitor_refresh_rate(vc, vc->window ? vc->window : vc->gfx.drawing_area);
if (vc->gfx.guest_fb.dmabuf && vc->gfx.guest_fb.dmabuf->draw_submitted) { if (vc->gfx.guest_fb.dmabuf &&
qemu_dmabuf_get_draw_submitted(vc->gfx.guest_fb.dmabuf)) {
gd_gl_area_draw(vc); gd_gl_area_draw(vc);
return; return;
} }
@ -286,7 +289,8 @@ void gd_gl_area_scanout_flush(DisplayChangeListener *dcl,
{ {
VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl); VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
if (vc->gfx.guest_fb.dmabuf && !vc->gfx.guest_fb.dmabuf->draw_submitted) { if (vc->gfx.guest_fb.dmabuf &&
!qemu_dmabuf_get_draw_submitted(vc->gfx.guest_fb.dmabuf)) {
graphic_hw_gl_block(vc->gfx.dcl.con, true); graphic_hw_gl_block(vc->gfx.dcl.con, true);
vc->gfx.guest_fb.dmabuf->draw_submitted = true; vc->gfx.guest_fb.dmabuf->draw_submitted = true;
gtk_gl_area_set_scanout_mode(vc, true); gtk_gl_area_set_scanout_mode(vc, true);
@ -299,20 +303,29 @@ void gd_gl_area_scanout_dmabuf(DisplayChangeListener *dcl,
{ {
#ifdef CONFIG_GBM #ifdef CONFIG_GBM
VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl); VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
uint32_t x, y, width, height, backing_width, backing_height, texture;
bool y0_top;
gtk_gl_area_make_current(GTK_GL_AREA(vc->gfx.drawing_area)); gtk_gl_area_make_current(GTK_GL_AREA(vc->gfx.drawing_area));
egl_dmabuf_import_texture(dmabuf); egl_dmabuf_import_texture(dmabuf);
if (!dmabuf->texture) { texture = qemu_dmabuf_get_texture(dmabuf);
if (!texture) {
return; return;
} }
gd_gl_area_scanout_texture(dcl, dmabuf->texture, x = qemu_dmabuf_get_x(dmabuf);
dmabuf->y0_top, y = qemu_dmabuf_get_y(dmabuf);
dmabuf->backing_width, dmabuf->backing_height, width = qemu_dmabuf_get_width(dmabuf);
dmabuf->x, dmabuf->y, dmabuf->width, height = qemu_dmabuf_get_height(dmabuf);
dmabuf->height, NULL); backing_width = qemu_dmabuf_get_backing_width(dmabuf);
backing_height = qemu_dmabuf_get_backing_height(dmabuf);
y0_top = qemu_dmabuf_get_y0_top(dmabuf);
if (dmabuf->allow_fences) { gd_gl_area_scanout_texture(dcl, texture, y0_top,
backing_width, backing_height,
x, y, width, height, NULL);
if (qemu_dmabuf_get_allow_fences(dmabuf)) {
vc->gfx.guest_fb.dmabuf = dmabuf; vc->gfx.guest_fb.dmabuf = dmabuf;
} }
#endif #endif

6
ui/gtk.c
View File

@ -596,10 +596,12 @@ void gd_hw_gl_flushed(void *vcon)
{ {
VirtualConsole *vc = vcon; VirtualConsole *vc = vcon;
QemuDmaBuf *dmabuf = vc->gfx.guest_fb.dmabuf; QemuDmaBuf *dmabuf = vc->gfx.guest_fb.dmabuf;
int fence_fd;
if (dmabuf->fence_fd >= 0) { if (dmabuf->fence_fd >= 0) {
qemu_set_fd_handler(dmabuf->fence_fd, NULL, NULL, NULL); fence_fd = qemu_dmabuf_get_fence_fd(dmabuf);
close(dmabuf->fence_fd); qemu_set_fd_handler(fence_fd, NULL, NULL, NULL);
close(fence_fd);
dmabuf->fence_fd = -1; dmabuf->fence_fd = -1;
graphic_hw_gl_block(vc->gfx.dcl.con, false); graphic_hw_gl_block(vc->gfx.dcl.con, false);
} }

50
ui/spice-display.c
View File

@ -976,6 +976,7 @@ static void qemu_spice_gl_cursor_dmabuf(DisplayChangeListener *dcl,
uint32_t hot_x, uint32_t hot_y) uint32_t hot_x, uint32_t hot_y)
{ {
SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl); SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
uint32_t width, height, texture;
ssd->have_hot = have_hot; ssd->have_hot = have_hot;
ssd->hot_x = hot_x; ssd->hot_x = hot_x;
@ -984,11 +985,13 @@ static void qemu_spice_gl_cursor_dmabuf(DisplayChangeListener *dcl,
trace_qemu_spice_gl_cursor(ssd->qxl.id, dmabuf != NULL, have_hot); trace_qemu_spice_gl_cursor(ssd->qxl.id, dmabuf != NULL, have_hot);
if (dmabuf) { if (dmabuf) {
egl_dmabuf_import_texture(dmabuf); egl_dmabuf_import_texture(dmabuf);
if (!dmabuf->texture) { texture = qemu_dmabuf_get_texture(dmabuf);
if (!texture) {
return; return;
} }
egl_fb_setup_for_tex(&ssd->cursor_fb, dmabuf->width, dmabuf->height, width = qemu_dmabuf_get_width(dmabuf);
dmabuf->texture, false); height = qemu_dmabuf_get_height(dmabuf);
egl_fb_setup_for_tex(&ssd->cursor_fb, width, height, texture, false);
} else { } else {
egl_fb_destroy(&ssd->cursor_fb); egl_fb_destroy(&ssd->cursor_fb);
} }
@ -1026,6 +1029,7 @@ static void qemu_spice_gl_update(DisplayChangeListener *dcl,
bool y_0_top = false; /* FIXME */ bool y_0_top = false; /* FIXME */
uint64_t cookie; uint64_t cookie;
int fd; int fd;
uint32_t width, height, texture;
if (!ssd->have_scanout) { if (!ssd->have_scanout) {
return; return;
@ -1042,41 +1046,45 @@ static void qemu_spice_gl_update(DisplayChangeListener *dcl,
if (ssd->guest_dmabuf_refresh) { if (ssd->guest_dmabuf_refresh) {
QemuDmaBuf *dmabuf = ssd->guest_dmabuf; QemuDmaBuf *dmabuf = ssd->guest_dmabuf;
width = qemu_dmabuf_get_width(dmabuf);
height = qemu_dmabuf_get_height(dmabuf);
if (render_cursor) { if (render_cursor) {
egl_dmabuf_import_texture(dmabuf); egl_dmabuf_import_texture(dmabuf);
if (!dmabuf->texture) { texture = qemu_dmabuf_get_texture(dmabuf);
if (!texture) {
return; return;
} }
/* source framebuffer */ /* source framebuffer */
egl_fb_setup_for_tex(&ssd->guest_fb, egl_fb_setup_for_tex(&ssd->guest_fb, width, height,
dmabuf->width, dmabuf->height, texture, false);
dmabuf->texture, false);
/* dest framebuffer */ /* dest framebuffer */
if (ssd->blit_fb.width != dmabuf->width || if (ssd->blit_fb.width != width ||
ssd->blit_fb.height != dmabuf->height) { ssd->blit_fb.height != height) {
trace_qemu_spice_gl_render_dmabuf(ssd->qxl.id, dmabuf->width, trace_qemu_spice_gl_render_dmabuf(ssd->qxl.id, width,
dmabuf->height); height);
egl_fb_destroy(&ssd->blit_fb); egl_fb_destroy(&ssd->blit_fb);
egl_fb_setup_new_tex(&ssd->blit_fb, egl_fb_setup_new_tex(&ssd->blit_fb,
dmabuf->width, dmabuf->height); width, height);
fd = egl_get_fd_for_texture(ssd->blit_fb.texture, fd = egl_get_fd_for_texture(ssd->blit_fb.texture,
&stride, &fourcc, NULL); &stride, &fourcc, NULL);
spice_qxl_gl_scanout(&ssd->qxl, fd, spice_qxl_gl_scanout(&ssd->qxl, fd, width, height,
dmabuf->width, dmabuf->height,
stride, fourcc, false); stride, fourcc, false);
} }
} else { } else {
trace_qemu_spice_gl_forward_dmabuf(ssd->qxl.id, stride = qemu_dmabuf_get_stride(dmabuf);
dmabuf->width, dmabuf->height); fourcc = qemu_dmabuf_get_fourcc(dmabuf);
y_0_top = qemu_dmabuf_get_y0_top(dmabuf);
fd = qemu_dmabuf_dup_fd(dmabuf);
trace_qemu_spice_gl_forward_dmabuf(ssd->qxl.id, width, height);
/* note: spice server will close the fd, so hand over a dup */ /* note: spice server will close the fd, so hand over a dup */
spice_qxl_gl_scanout(&ssd->qxl, dup(dmabuf->fd), spice_qxl_gl_scanout(&ssd->qxl, fd, width, height,
dmabuf->width, dmabuf->height, stride, fourcc, y_0_top);
dmabuf->stride, dmabuf->fourcc,
dmabuf->y0_top);
} }
qemu_spice_gl_monitor_config(ssd, 0, 0, dmabuf->width, dmabuf->height); qemu_spice_gl_monitor_config(ssd, 0, 0, width, height);
ssd->guest_dmabuf_refresh = false; ssd->guest_dmabuf_refresh = false;
} }