dbus-listener.c (14528B)
1 /* 2 * QEMU DBus display console 3 * 4 * Copyright (c) 2021 Marc-André Lureau <marcandre.lureau@redhat.com> 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a copy 7 * of this software and associated documentation files (the "Software"), to deal 8 * in the Software without restriction, including without limitation the rights 9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 * copies of the Software, and to permit persons to whom the Software is 11 * furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included in 14 * all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22 * THE SOFTWARE. 23 */ 24 #include "qemu/osdep.h" 25 #include "sysemu/sysemu.h" 26 #include "dbus.h" 27 #include <gio/gunixfdlist.h> 28 29 #include "ui/shader.h" 30 #include "ui/egl-helpers.h" 31 #include "ui/egl-context.h" 32 #include "trace.h" 33 34 struct _DBusDisplayListener { 35 GObject parent; 36 37 char *bus_name; 38 DBusDisplayConsole *console; 39 GDBusConnection *conn; 40 41 QemuDBusDisplay1Listener *proxy; 42 43 DisplayChangeListener dcl; 44 DisplaySurface *ds; 45 int gl_updates; 46 }; 47 48 G_DEFINE_TYPE(DBusDisplayListener, dbus_display_listener, G_TYPE_OBJECT) 49 50 static void dbus_update_gl_cb(GObject *source_object, 51 GAsyncResult *res, 52 gpointer user_data) 53 { 54 g_autoptr(GError) err = NULL; 55 DBusDisplayListener *ddl = user_data; 56 57 if (!qemu_dbus_display1_listener_call_update_dmabuf_finish(ddl->proxy, 58 res, &err)) { 59 error_report("Failed to call update: %s", err->message); 60 } 61 62 graphic_hw_gl_block(ddl->dcl.con, false); 63 g_object_unref(ddl); 64 } 65 66 static void dbus_call_update_gl(DBusDisplayListener *ddl, 67 int x, int y, int w, int h) 68 { 69 graphic_hw_gl_block(ddl->dcl.con, true); 70 glFlush(); 71 qemu_dbus_display1_listener_call_update_dmabuf(ddl->proxy, 72 x, y, w, h, 73 G_DBUS_CALL_FLAGS_NONE, 74 DBUS_DEFAULT_TIMEOUT, NULL, 75 dbus_update_gl_cb, 76 g_object_ref(ddl)); 77 } 78 79 static void dbus_scanout_disable(DisplayChangeListener *dcl) 80 { 81 DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl); 82 83 ddl->ds = NULL; 84 qemu_dbus_display1_listener_call_disable( 85 ddl->proxy, G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); 86 } 87 88 static void dbus_scanout_dmabuf(DisplayChangeListener *dcl, 89 QemuDmaBuf *dmabuf) 90 { 91 DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl); 92 g_autoptr(GError) err = NULL; 93 g_autoptr(GUnixFDList) fd_list = NULL; 94 95 fd_list = g_unix_fd_list_new(); 96 if (g_unix_fd_list_append(fd_list, dmabuf->fd, &err) != 0) { 97 error_report("Failed to setup dmabuf fdlist: %s", err->message); 98 return; 99 } 100 101 qemu_dbus_display1_listener_call_scanout_dmabuf( 102 ddl->proxy, 103 g_variant_new_handle(0), 104 dmabuf->width, 105 dmabuf->height, 106 dmabuf->stride, 107 dmabuf->fourcc, 108 dmabuf->modifier, 109 dmabuf->y0_top, 110 G_DBUS_CALL_FLAGS_NONE, 111 -1, 112 fd_list, 113 NULL, NULL, NULL); 114 } 115 116 static void dbus_scanout_texture(DisplayChangeListener *dcl, 117 uint32_t tex_id, 118 bool backing_y_0_top, 119 uint32_t backing_width, 120 uint32_t backing_height, 121 uint32_t x, uint32_t y, 122 uint32_t w, uint32_t h) 123 { 124 QemuDmaBuf dmabuf = { 125 .width = backing_width, 126 .height = backing_height, 127 .y0_top = backing_y_0_top, 128 }; 129 130 assert(tex_id); 131 dmabuf.fd = egl_get_fd_for_texture( 132 tex_id, (EGLint *)&dmabuf.stride, 133 (EGLint *)&dmabuf.fourcc, 134 &dmabuf.modifier); 135 if (dmabuf.fd < 0) { 136 error_report("%s: failed to get fd for texture", __func__); 137 return; 138 } 139 140 dbus_scanout_dmabuf(dcl, &dmabuf); 141 close(dmabuf.fd); 142 } 143 144 static void dbus_cursor_dmabuf(DisplayChangeListener *dcl, 145 QemuDmaBuf *dmabuf, bool have_hot, 146 uint32_t hot_x, uint32_t hot_y) 147 { 148 DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl); 149 DisplaySurface *ds; 150 GVariant *v_data = NULL; 151 egl_fb cursor_fb; 152 153 if (!dmabuf) { 154 qemu_dbus_display1_listener_call_mouse_set( 155 ddl->proxy, 0, 0, false, 156 G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); 157 return; 158 } 159 160 egl_dmabuf_import_texture(dmabuf); 161 if (!dmabuf->texture) { 162 return; 163 } 164 egl_fb_setup_for_tex(&cursor_fb, dmabuf->width, dmabuf->height, 165 dmabuf->texture, false); 166 ds = qemu_create_displaysurface(dmabuf->width, dmabuf->height); 167 egl_fb_read(ds, &cursor_fb); 168 169 v_data = g_variant_new_from_data( 170 G_VARIANT_TYPE("ay"), 171 surface_data(ds), 172 surface_width(ds) * surface_height(ds) * 4, 173 TRUE, 174 (GDestroyNotify)qemu_free_displaysurface, 175 ds); 176 qemu_dbus_display1_listener_call_cursor_define( 177 ddl->proxy, 178 surface_width(ds), 179 surface_height(ds), 180 hot_x, 181 hot_y, 182 v_data, 183 G_DBUS_CALL_FLAGS_NONE, 184 -1, 185 NULL, 186 NULL, 187 NULL); 188 } 189 190 static void dbus_cursor_position(DisplayChangeListener *dcl, 191 uint32_t pos_x, uint32_t pos_y) 192 { 193 DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl); 194 195 qemu_dbus_display1_listener_call_mouse_set( 196 ddl->proxy, pos_x, pos_y, true, 197 G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); 198 } 199 200 static void dbus_release_dmabuf(DisplayChangeListener *dcl, 201 QemuDmaBuf *dmabuf) 202 { 203 dbus_scanout_disable(dcl); 204 } 205 206 static void dbus_scanout_update(DisplayChangeListener *dcl, 207 uint32_t x, uint32_t y, 208 uint32_t w, uint32_t h) 209 { 210 DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl); 211 212 dbus_call_update_gl(ddl, x, y, w, h); 213 } 214 215 static void dbus_gl_refresh(DisplayChangeListener *dcl) 216 { 217 DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl); 218 219 graphic_hw_update(dcl->con); 220 221 if (!ddl->ds || qemu_console_is_gl_blocked(ddl->dcl.con)) { 222 return; 223 } 224 225 if (ddl->gl_updates) { 226 dbus_call_update_gl(ddl, 0, 0, 227 surface_width(ddl->ds), surface_height(ddl->ds)); 228 ddl->gl_updates = 0; 229 } 230 } 231 232 static void dbus_refresh(DisplayChangeListener *dcl) 233 { 234 graphic_hw_update(dcl->con); 235 } 236 237 static void dbus_gl_gfx_update(DisplayChangeListener *dcl, 238 int x, int y, int w, int h) 239 { 240 DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl); 241 242 ddl->gl_updates++; 243 } 244 245 static void dbus_gfx_update(DisplayChangeListener *dcl, 246 int x, int y, int w, int h) 247 { 248 DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl); 249 pixman_image_t *img; 250 GVariant *v_data; 251 size_t stride; 252 253 assert(ddl->ds); 254 stride = w * DIV_ROUND_UP(PIXMAN_FORMAT_BPP(surface_format(ddl->ds)), 8); 255 256 trace_dbus_update(x, y, w, h); 257 258 if (x == 0 && y == 0 && w == surface_width(ddl->ds) && h == surface_height(ddl->ds)) { 259 v_data = g_variant_new_from_data( 260 G_VARIANT_TYPE("ay"), 261 surface_data(ddl->ds), 262 surface_stride(ddl->ds) * surface_height(ddl->ds), 263 TRUE, 264 (GDestroyNotify)pixman_image_unref, 265 pixman_image_ref(ddl->ds->image)); 266 qemu_dbus_display1_listener_call_scanout( 267 ddl->proxy, 268 surface_width(ddl->ds), 269 surface_height(ddl->ds), 270 surface_stride(ddl->ds), 271 surface_format(ddl->ds), 272 v_data, 273 G_DBUS_CALL_FLAGS_NONE, 274 DBUS_DEFAULT_TIMEOUT, NULL, NULL, NULL); 275 return; 276 } 277 278 /* make a copy, since gvariant only handles linear data */ 279 img = pixman_image_create_bits(surface_format(ddl->ds), 280 w, h, NULL, stride); 281 pixman_image_composite(PIXMAN_OP_SRC, ddl->ds->image, NULL, img, 282 x, y, 0, 0, 0, 0, w, h); 283 284 v_data = g_variant_new_from_data( 285 G_VARIANT_TYPE("ay"), 286 pixman_image_get_data(img), 287 pixman_image_get_stride(img) * h, 288 TRUE, 289 (GDestroyNotify)pixman_image_unref, 290 img); 291 qemu_dbus_display1_listener_call_update(ddl->proxy, 292 x, y, w, h, pixman_image_get_stride(img), pixman_image_get_format(img), 293 v_data, 294 G_DBUS_CALL_FLAGS_NONE, 295 DBUS_DEFAULT_TIMEOUT, NULL, NULL, NULL); 296 } 297 298 static void dbus_gl_gfx_switch(DisplayChangeListener *dcl, 299 struct DisplaySurface *new_surface) 300 { 301 DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl); 302 303 ddl->ds = new_surface; 304 if (ddl->ds) { 305 int width = surface_width(ddl->ds); 306 int height = surface_height(ddl->ds); 307 308 /* TODO: lazy send dmabuf (there are unnecessary sent otherwise) */ 309 dbus_scanout_texture(&ddl->dcl, ddl->ds->texture, false, 310 width, height, 0, 0, width, height); 311 } 312 } 313 314 static void dbus_gfx_switch(DisplayChangeListener *dcl, 315 struct DisplaySurface *new_surface) 316 { 317 DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl); 318 319 ddl->ds = new_surface; 320 if (!ddl->ds) { 321 /* why not call disable instead? */ 322 return; 323 } 324 } 325 326 static void dbus_mouse_set(DisplayChangeListener *dcl, 327 int x, int y, int on) 328 { 329 DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl); 330 331 qemu_dbus_display1_listener_call_mouse_set( 332 ddl->proxy, x, y, on, G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); 333 } 334 335 static void dbus_cursor_define(DisplayChangeListener *dcl, 336 QEMUCursor *c) 337 { 338 DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl); 339 GVariant *v_data = NULL; 340 341 cursor_get(c); 342 v_data = g_variant_new_from_data( 343 G_VARIANT_TYPE("ay"), 344 c->data, 345 c->width * c->height * 4, 346 TRUE, 347 (GDestroyNotify)cursor_put, 348 c); 349 350 qemu_dbus_display1_listener_call_cursor_define( 351 ddl->proxy, 352 c->width, 353 c->height, 354 c->hot_x, 355 c->hot_y, 356 v_data, 357 G_DBUS_CALL_FLAGS_NONE, 358 -1, 359 NULL, 360 NULL, 361 NULL); 362 } 363 364 const DisplayChangeListenerOps dbus_gl_dcl_ops = { 365 .dpy_name = "dbus-gl", 366 .dpy_gfx_update = dbus_gl_gfx_update, 367 .dpy_gfx_switch = dbus_gl_gfx_switch, 368 .dpy_gfx_check_format = console_gl_check_format, 369 .dpy_refresh = dbus_gl_refresh, 370 .dpy_mouse_set = dbus_mouse_set, 371 .dpy_cursor_define = dbus_cursor_define, 372 373 .dpy_gl_scanout_disable = dbus_scanout_disable, 374 .dpy_gl_scanout_texture = dbus_scanout_texture, 375 .dpy_gl_scanout_dmabuf = dbus_scanout_dmabuf, 376 .dpy_gl_cursor_dmabuf = dbus_cursor_dmabuf, 377 .dpy_gl_cursor_position = dbus_cursor_position, 378 .dpy_gl_release_dmabuf = dbus_release_dmabuf, 379 .dpy_gl_update = dbus_scanout_update, 380 }; 381 382 const DisplayChangeListenerOps dbus_dcl_ops = { 383 .dpy_name = "dbus", 384 .dpy_gfx_update = dbus_gfx_update, 385 .dpy_gfx_switch = dbus_gfx_switch, 386 .dpy_refresh = dbus_refresh, 387 .dpy_mouse_set = dbus_mouse_set, 388 .dpy_cursor_define = dbus_cursor_define, 389 }; 390 391 static void 392 dbus_display_listener_dispose(GObject *object) 393 { 394 DBusDisplayListener *ddl = DBUS_DISPLAY_LISTENER(object); 395 396 unregister_displaychangelistener(&ddl->dcl); 397 g_clear_object(&ddl->conn); 398 g_clear_pointer(&ddl->bus_name, g_free); 399 g_clear_object(&ddl->proxy); 400 401 G_OBJECT_CLASS(dbus_display_listener_parent_class)->dispose(object); 402 } 403 404 static void 405 dbus_display_listener_constructed(GObject *object) 406 { 407 DBusDisplayListener *ddl = DBUS_DISPLAY_LISTENER(object); 408 409 if (display_opengl) { 410 ddl->dcl.ops = &dbus_gl_dcl_ops; 411 } else { 412 ddl->dcl.ops = &dbus_dcl_ops; 413 } 414 415 G_OBJECT_CLASS(dbus_display_listener_parent_class)->constructed(object); 416 } 417 418 static void 419 dbus_display_listener_class_init(DBusDisplayListenerClass *klass) 420 { 421 GObjectClass *object_class = G_OBJECT_CLASS(klass); 422 423 object_class->dispose = dbus_display_listener_dispose; 424 object_class->constructed = dbus_display_listener_constructed; 425 } 426 427 static void 428 dbus_display_listener_init(DBusDisplayListener *ddl) 429 { 430 } 431 432 const char * 433 dbus_display_listener_get_bus_name(DBusDisplayListener *ddl) 434 { 435 return ddl->bus_name ?: "p2p"; 436 } 437 438 DBusDisplayConsole * 439 dbus_display_listener_get_console(DBusDisplayListener *ddl) 440 { 441 return ddl->console; 442 } 443 444 DBusDisplayListener * 445 dbus_display_listener_new(const char *bus_name, 446 GDBusConnection *conn, 447 DBusDisplayConsole *console) 448 { 449 DBusDisplayListener *ddl; 450 QemuConsole *con; 451 g_autoptr(GError) err = NULL; 452 453 ddl = g_object_new(DBUS_DISPLAY_TYPE_LISTENER, NULL); 454 ddl->proxy = 455 qemu_dbus_display1_listener_proxy_new_sync(conn, 456 G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START, 457 NULL, 458 "/org/qemu/Display1/Listener", 459 NULL, 460 &err); 461 if (!ddl->proxy) { 462 error_report("Failed to setup proxy: %s", err->message); 463 g_object_unref(conn); 464 g_object_unref(ddl); 465 return NULL; 466 } 467 468 ddl->bus_name = g_strdup(bus_name); 469 ddl->conn = conn; 470 ddl->console = console; 471 472 con = qemu_console_lookup_by_index(dbus_display_console_get_index(console)); 473 assert(con); 474 ddl->dcl.con = con; 475 register_displaychangelistener(&ddl->dcl); 476 477 return ddl; 478 }