1 /* 2 * QEMU graphical console 3 * 4 * Copyright (c) 2004 Fabrice Bellard 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 25 #include "qemu/osdep.h" 26 #include "ui/console.h" 27 #include "hw/qdev-core.h" 28 #include "qapi/error.h" 29 #include "qapi/qapi-commands-ui.h" 30 #include "qapi/visitor.h" 31 #include "qemu/coroutine.h" 32 #include "qemu/error-report.h" 33 #include "qemu/main-loop.h" 34 #include "qemu/module.h" 35 #include "qemu/option.h" 36 #include "chardev/char.h" 37 #include "trace.h" 38 #include "exec/memory.h" 39 #include "qom/object.h" 40 41 #include "console-priv.h" 42 43 OBJECT_DEFINE_ABSTRACT_TYPE(QemuConsole, qemu_console, QEMU_CONSOLE, OBJECT) 44 45 typedef struct QemuGraphicConsole { 46 QemuConsole parent; 47 48 Object *device; 49 uint32_t head; 50 51 QEMUCursor *cursor; 52 int cursor_x, cursor_y, cursor_on; 53 } QemuGraphicConsole; 54 55 typedef QemuConsoleClass QemuGraphicConsoleClass; 56 57 OBJECT_DEFINE_TYPE(QemuGraphicConsole, qemu_graphic_console, QEMU_GRAPHIC_CONSOLE, QEMU_CONSOLE) 58 59 struct DisplayState { 60 QEMUTimer *gui_timer; 61 uint64_t last_update; 62 uint64_t update_interval; 63 bool refreshing; 64 65 QLIST_HEAD(, DisplayChangeListener) listeners; 66 }; 67 68 static DisplayState *display_state; 69 static QemuConsole *active_console; 70 static QTAILQ_HEAD(, QemuConsole) consoles = 71 QTAILQ_HEAD_INITIALIZER(consoles); 72 73 static void dpy_refresh(DisplayState *s); 74 static DisplayState *get_alloc_displaystate(void); 75 static bool displaychangelistener_has_dmabuf(DisplayChangeListener *dcl); 76 static bool console_compatible_with(QemuConsole *con, 77 DisplayChangeListener *dcl, Error **errp); 78 static QemuConsole *qemu_graphic_console_lookup_unused(void); 79 static void dpy_set_ui_info_timer(void *opaque); 80 81 static void gui_update(void *opaque) 82 { 83 uint64_t interval = GUI_REFRESH_INTERVAL_IDLE; 84 uint64_t dcl_interval; 85 DisplayState *ds = opaque; 86 DisplayChangeListener *dcl; 87 88 ds->refreshing = true; 89 dpy_refresh(ds); 90 ds->refreshing = false; 91 92 QLIST_FOREACH(dcl, &ds->listeners, next) { 93 dcl_interval = dcl->update_interval ? 94 dcl->update_interval : GUI_REFRESH_INTERVAL_DEFAULT; 95 if (interval > dcl_interval) { 96 interval = dcl_interval; 97 } 98 } 99 if (ds->update_interval != interval) { 100 ds->update_interval = interval; 101 trace_console_refresh(interval); 102 } 103 ds->last_update = qemu_clock_get_ms(QEMU_CLOCK_REALTIME); 104 timer_mod(ds->gui_timer, ds->last_update + interval); 105 } 106 107 static void gui_setup_refresh(DisplayState *ds) 108 { 109 DisplayChangeListener *dcl; 110 bool need_timer = false; 111 112 QLIST_FOREACH(dcl, &ds->listeners, next) { 113 if (dcl->ops->dpy_refresh != NULL) { 114 need_timer = true; 115 } 116 } 117 118 if (need_timer && ds->gui_timer == NULL) { 119 ds->gui_timer = timer_new_ms(QEMU_CLOCK_REALTIME, gui_update, ds); 120 timer_mod(ds->gui_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME)); 121 } 122 if (!need_timer && ds->gui_timer != NULL) { 123 timer_free(ds->gui_timer); 124 ds->gui_timer = NULL; 125 } 126 } 127 128 void graphic_hw_update_done(QemuConsole *con) 129 { 130 if (con) { 131 qemu_co_enter_all(&con->dump_queue, NULL); 132 } 133 } 134 135 void graphic_hw_update(QemuConsole *con) 136 { 137 bool async = false; 138 con = con ? con : active_console; 139 if (!con) { 140 return; 141 } 142 if (con->hw_ops->gfx_update) { 143 con->hw_ops->gfx_update(con->hw); 144 async = con->hw_ops->gfx_update_async; 145 } 146 if (!async) { 147 graphic_hw_update_done(con); 148 } 149 } 150 151 static void graphic_hw_update_bh(void *con) 152 { 153 graphic_hw_update(con); 154 } 155 156 void qemu_console_co_wait_update(QemuConsole *con) 157 { 158 if (qemu_co_queue_empty(&con->dump_queue)) { 159 /* Defer the update, it will restart the pending coroutines */ 160 aio_bh_schedule_oneshot(qemu_get_aio_context(), 161 graphic_hw_update_bh, con); 162 } 163 qemu_co_queue_wait(&con->dump_queue, NULL); 164 165 } 166 167 static void graphic_hw_gl_unblock_timer(void *opaque) 168 { 169 warn_report("console: no gl-unblock within one second"); 170 } 171 172 void graphic_hw_gl_block(QemuConsole *con, bool block) 173 { 174 uint64_t timeout; 175 assert(con != NULL); 176 177 if (block) { 178 con->gl_block++; 179 } else { 180 con->gl_block--; 181 } 182 assert(con->gl_block >= 0); 183 if (!con->hw_ops->gl_block) { 184 return; 185 } 186 if ((block && con->gl_block != 1) || (!block && con->gl_block != 0)) { 187 return; 188 } 189 con->hw_ops->gl_block(con->hw, block); 190 191 if (block) { 192 timeout = qemu_clock_get_ms(QEMU_CLOCK_REALTIME); 193 timeout += 1000; /* one sec */ 194 timer_mod(con->gl_unblock_timer, timeout); 195 } else { 196 timer_del(con->gl_unblock_timer); 197 } 198 } 199 200 int qemu_console_get_window_id(QemuConsole *con) 201 { 202 return con->window_id; 203 } 204 205 void qemu_console_set_window_id(QemuConsole *con, int window_id) 206 { 207 con->window_id = window_id; 208 } 209 210 void graphic_hw_invalidate(QemuConsole *con) 211 { 212 if (!con) { 213 con = active_console; 214 } 215 if (con && con->hw_ops->invalidate) { 216 con->hw_ops->invalidate(con->hw); 217 } 218 } 219 220 void graphic_hw_text_update(QemuConsole *con, console_ch_t *chardata) 221 { 222 if (!con) { 223 con = active_console; 224 } 225 if (con && con->hw_ops->text_update) { 226 con->hw_ops->text_update(con->hw, chardata); 227 } 228 } 229 230 static void displaychangelistener_gfx_switch(DisplayChangeListener *dcl, 231 struct DisplaySurface *new_surface, 232 bool update) 233 { 234 if (dcl->ops->dpy_gfx_switch) { 235 dcl->ops->dpy_gfx_switch(dcl, new_surface); 236 } 237 238 if (update && dcl->ops->dpy_gfx_update) { 239 dcl->ops->dpy_gfx_update(dcl, 0, 0, 240 surface_width(new_surface), 241 surface_height(new_surface)); 242 } 243 } 244 245 static void dpy_gfx_create_texture(QemuConsole *con, DisplaySurface *surface) 246 { 247 if (con->gl && con->gl->ops->dpy_gl_ctx_create_texture) { 248 con->gl->ops->dpy_gl_ctx_create_texture(con->gl, surface); 249 } 250 } 251 252 static void dpy_gfx_destroy_texture(QemuConsole *con, DisplaySurface *surface) 253 { 254 if (con->gl && con->gl->ops->dpy_gl_ctx_destroy_texture) { 255 con->gl->ops->dpy_gl_ctx_destroy_texture(con->gl, surface); 256 } 257 } 258 259 static void dpy_gfx_update_texture(QemuConsole *con, DisplaySurface *surface, 260 int x, int y, int w, int h) 261 { 262 if (con->gl && con->gl->ops->dpy_gl_ctx_update_texture) { 263 con->gl->ops->dpy_gl_ctx_update_texture(con->gl, surface, x, y, w, h); 264 } 265 } 266 267 static void displaychangelistener_display_console(DisplayChangeListener *dcl, 268 QemuConsole *con, 269 Error **errp) 270 { 271 static const char nodev[] = 272 "This VM has no graphic display device."; 273 static DisplaySurface *dummy; 274 275 if (!con || !console_compatible_with(con, dcl, errp)) { 276 if (!dummy) { 277 dummy = qemu_create_placeholder_surface(640, 480, nodev); 278 } 279 if (con) { 280 dpy_gfx_create_texture(con, dummy); 281 } 282 displaychangelistener_gfx_switch(dcl, dummy, TRUE); 283 return; 284 } 285 286 dpy_gfx_create_texture(con, con->surface); 287 displaychangelistener_gfx_switch(dcl, con->surface, 288 con->scanout.kind == SCANOUT_SURFACE); 289 290 if (con->scanout.kind == SCANOUT_DMABUF && 291 displaychangelistener_has_dmabuf(dcl)) { 292 dcl->ops->dpy_gl_scanout_dmabuf(dcl, con->scanout.dmabuf); 293 } else if (con->scanout.kind == SCANOUT_TEXTURE && 294 dcl->ops->dpy_gl_scanout_texture) { 295 dcl->ops->dpy_gl_scanout_texture(dcl, 296 con->scanout.texture.backing_id, 297 con->scanout.texture.backing_y_0_top, 298 con->scanout.texture.backing_width, 299 con->scanout.texture.backing_height, 300 con->scanout.texture.x, 301 con->scanout.texture.y, 302 con->scanout.texture.width, 303 con->scanout.texture.height, 304 con->scanout.texture.d3d_tex2d); 305 } 306 } 307 308 void console_select(unsigned int index) 309 { 310 DisplayChangeListener *dcl; 311 QemuConsole *s; 312 313 trace_console_select(index); 314 s = qemu_console_lookup_by_index(index); 315 if (s) { 316 DisplayState *ds = s->ds; 317 318 active_console = s; 319 QLIST_FOREACH (dcl, &ds->listeners, next) { 320 if (dcl->con != NULL) { 321 continue; 322 } 323 displaychangelistener_display_console(dcl, s, NULL); 324 } 325 326 if (QEMU_IS_TEXT_CONSOLE(s)) { 327 qemu_text_console_select(QEMU_TEXT_CONSOLE(s)); 328 } 329 } 330 } 331 332 void qemu_text_console_put_keysym(QemuTextConsole *s, int keysym) 333 { 334 if (!s) { 335 if (!QEMU_IS_TEXT_CONSOLE(active_console)) { 336 return; 337 } 338 s = QEMU_TEXT_CONSOLE(active_console); 339 } 340 341 qemu_text_console_handle_keysym(s, keysym); 342 } 343 344 static const int qcode_to_keysym[Q_KEY_CODE__MAX] = { 345 [Q_KEY_CODE_UP] = QEMU_KEY_UP, 346 [Q_KEY_CODE_DOWN] = QEMU_KEY_DOWN, 347 [Q_KEY_CODE_RIGHT] = QEMU_KEY_RIGHT, 348 [Q_KEY_CODE_LEFT] = QEMU_KEY_LEFT, 349 [Q_KEY_CODE_HOME] = QEMU_KEY_HOME, 350 [Q_KEY_CODE_END] = QEMU_KEY_END, 351 [Q_KEY_CODE_PGUP] = QEMU_KEY_PAGEUP, 352 [Q_KEY_CODE_PGDN] = QEMU_KEY_PAGEDOWN, 353 [Q_KEY_CODE_DELETE] = QEMU_KEY_DELETE, 354 [Q_KEY_CODE_TAB] = QEMU_KEY_TAB, 355 [Q_KEY_CODE_BACKSPACE] = QEMU_KEY_BACKSPACE, 356 }; 357 358 static const int ctrl_qcode_to_keysym[Q_KEY_CODE__MAX] = { 359 [Q_KEY_CODE_UP] = QEMU_KEY_CTRL_UP, 360 [Q_KEY_CODE_DOWN] = QEMU_KEY_CTRL_DOWN, 361 [Q_KEY_CODE_RIGHT] = QEMU_KEY_CTRL_RIGHT, 362 [Q_KEY_CODE_LEFT] = QEMU_KEY_CTRL_LEFT, 363 [Q_KEY_CODE_HOME] = QEMU_KEY_CTRL_HOME, 364 [Q_KEY_CODE_END] = QEMU_KEY_CTRL_END, 365 [Q_KEY_CODE_PGUP] = QEMU_KEY_CTRL_PAGEUP, 366 [Q_KEY_CODE_PGDN] = QEMU_KEY_CTRL_PAGEDOWN, 367 }; 368 369 bool qemu_text_console_put_qcode(QemuTextConsole *s, int qcode, bool ctrl) 370 { 371 int keysym; 372 373 keysym = ctrl ? ctrl_qcode_to_keysym[qcode] : qcode_to_keysym[qcode]; 374 if (keysym == 0) { 375 return false; 376 } 377 qemu_text_console_put_keysym(s, keysym); 378 return true; 379 } 380 381 void qemu_text_console_put_string(QemuTextConsole *s, const char *str, int len) 382 { 383 int i; 384 385 for (i = 0; i < len && str[i]; i++) { 386 qemu_text_console_put_keysym(s, str[i]); 387 } 388 } 389 390 static void 391 qemu_console_register(QemuConsole *c) 392 { 393 int i; 394 395 if (!active_console || (!QEMU_IS_GRAPHIC_CONSOLE(active_console) && 396 QEMU_IS_GRAPHIC_CONSOLE(c))) { 397 active_console = c; 398 } 399 400 if (QTAILQ_EMPTY(&consoles)) { 401 c->index = 0; 402 QTAILQ_INSERT_TAIL(&consoles, c, next); 403 } else if (!QEMU_IS_GRAPHIC_CONSOLE(c) || phase_check(PHASE_MACHINE_READY)) { 404 QemuConsole *last = QTAILQ_LAST(&consoles); 405 c->index = last->index + 1; 406 QTAILQ_INSERT_TAIL(&consoles, c, next); 407 } else { 408 /* 409 * HACK: Put graphical consoles before text consoles. 410 * 411 * Only do that for coldplugged devices. After initial device 412 * initialization we will not renumber the consoles any more. 413 */ 414 QemuConsole *it = QTAILQ_FIRST(&consoles); 415 416 while (QTAILQ_NEXT(it, next) != NULL && QEMU_IS_GRAPHIC_CONSOLE(it)) { 417 it = QTAILQ_NEXT(it, next); 418 } 419 if (QEMU_IS_GRAPHIC_CONSOLE(it)) { 420 /* have no text consoles */ 421 c->index = it->index + 1; 422 QTAILQ_INSERT_AFTER(&consoles, it, c, next); 423 } else { 424 c->index = it->index; 425 QTAILQ_INSERT_BEFORE(it, c, next); 426 /* renumber text consoles */ 427 for (i = c->index + 1; it != NULL; it = QTAILQ_NEXT(it, next), i++) { 428 it->index = i; 429 } 430 } 431 } 432 } 433 434 static void 435 qemu_console_finalize(Object *obj) 436 { 437 QemuConsole *c = QEMU_CONSOLE(obj); 438 439 /* TODO: check this code path, and unregister from consoles */ 440 g_clear_pointer(&c->surface, qemu_free_displaysurface); 441 g_clear_pointer(&c->gl_unblock_timer, timer_free); 442 g_clear_pointer(&c->ui_timer, timer_free); 443 } 444 445 static void 446 qemu_console_class_init(ObjectClass *oc, void *data) 447 { 448 } 449 450 static void 451 qemu_console_init(Object *obj) 452 { 453 QemuConsole *c = QEMU_CONSOLE(obj); 454 DisplayState *ds = get_alloc_displaystate(); 455 456 qemu_co_queue_init(&c->dump_queue); 457 c->ds = ds; 458 c->window_id = -1; 459 c->ui_timer = timer_new_ms(QEMU_CLOCK_REALTIME, 460 dpy_set_ui_info_timer, c); 461 qemu_console_register(c); 462 } 463 464 static void 465 qemu_graphic_console_finalize(Object *obj) 466 { 467 QemuGraphicConsole *c = QEMU_GRAPHIC_CONSOLE(obj); 468 469 g_clear_pointer(&c->device, object_unref); 470 } 471 472 static void 473 qemu_graphic_console_prop_get_head(Object *obj, Visitor *v, const char *name, 474 void *opaque, Error **errp) 475 { 476 QemuGraphicConsole *c = QEMU_GRAPHIC_CONSOLE(obj); 477 478 visit_type_uint32(v, name, &c->head, errp); 479 } 480 481 static void 482 qemu_graphic_console_class_init(ObjectClass *oc, void *data) 483 { 484 object_class_property_add_link(oc, "device", TYPE_DEVICE, 485 offsetof(QemuGraphicConsole, device), 486 object_property_allow_set_link, 487 OBJ_PROP_LINK_STRONG); 488 object_class_property_add(oc, "head", "uint32", 489 qemu_graphic_console_prop_get_head, 490 NULL, NULL, NULL); 491 } 492 493 static void 494 qemu_graphic_console_init(Object *obj) 495 { 496 } 497 498 #ifdef WIN32 499 void qemu_displaysurface_win32_set_handle(DisplaySurface *surface, 500 HANDLE h, uint32_t offset) 501 { 502 assert(!surface->handle); 503 504 surface->handle = h; 505 surface->handle_offset = offset; 506 } 507 508 static void 509 win32_pixman_image_destroy(pixman_image_t *image, void *data) 510 { 511 DisplaySurface *surface = data; 512 513 if (!surface->handle) { 514 return; 515 } 516 517 assert(surface->handle_offset == 0); 518 519 qemu_win32_map_free( 520 pixman_image_get_data(surface->image), 521 surface->handle, 522 &error_warn 523 ); 524 } 525 #endif 526 527 DisplaySurface *qemu_create_displaysurface(int width, int height) 528 { 529 DisplaySurface *surface; 530 void *bits = NULL; 531 #ifdef WIN32 532 HANDLE handle = NULL; 533 #endif 534 535 trace_displaysurface_create(width, height); 536 537 #ifdef WIN32 538 bits = qemu_win32_map_alloc(width * height * 4, &handle, &error_abort); 539 #endif 540 541 surface = qemu_create_displaysurface_from( 542 width, height, 543 PIXMAN_x8r8g8b8, 544 width * 4, bits 545 ); 546 surface->flags = QEMU_ALLOCATED_FLAG; 547 548 #ifdef WIN32 549 qemu_displaysurface_win32_set_handle(surface, handle, 0); 550 #endif 551 return surface; 552 } 553 554 DisplaySurface *qemu_create_displaysurface_from(int width, int height, 555 pixman_format_code_t format, 556 int linesize, uint8_t *data) 557 { 558 DisplaySurface *surface = g_new0(DisplaySurface, 1); 559 560 trace_displaysurface_create_from(surface, width, height, format); 561 surface->image = pixman_image_create_bits(format, 562 width, height, 563 (void *)data, linesize); 564 assert(surface->image != NULL); 565 #ifdef WIN32 566 pixman_image_set_destroy_function(surface->image, 567 win32_pixman_image_destroy, surface); 568 #endif 569 570 return surface; 571 } 572 573 DisplaySurface *qemu_create_displaysurface_pixman(pixman_image_t *image) 574 { 575 DisplaySurface *surface = g_new0(DisplaySurface, 1); 576 577 trace_displaysurface_create_pixman(surface); 578 surface->image = pixman_image_ref(image); 579 580 return surface; 581 } 582 583 DisplaySurface *qemu_create_placeholder_surface(int w, int h, 584 const char *msg) 585 { 586 DisplaySurface *surface = qemu_create_displaysurface(w, h); 587 #ifdef CONFIG_PIXMAN 588 pixman_color_t bg = QEMU_PIXMAN_COLOR_BLACK; 589 pixman_color_t fg = QEMU_PIXMAN_COLOR_GRAY; 590 pixman_image_t *glyph; 591 int len, x, y, i; 592 593 len = strlen(msg); 594 x = (w / FONT_WIDTH - len) / 2; 595 y = (h / FONT_HEIGHT - 1) / 2; 596 for (i = 0; i < len; i++) { 597 glyph = qemu_pixman_glyph_from_vgafont(FONT_HEIGHT, vgafont16, msg[i]); 598 qemu_pixman_glyph_render(glyph, surface->image, &fg, &bg, 599 x+i, y, FONT_WIDTH, FONT_HEIGHT); 600 qemu_pixman_image_unref(glyph); 601 } 602 #endif 603 surface->flags |= QEMU_PLACEHOLDER_FLAG; 604 return surface; 605 } 606 607 void qemu_free_displaysurface(DisplaySurface *surface) 608 { 609 if (surface == NULL) { 610 return; 611 } 612 trace_displaysurface_free(surface); 613 qemu_pixman_image_unref(surface->image); 614 g_free(surface); 615 } 616 617 bool console_has_gl(QemuConsole *con) 618 { 619 return con->gl != NULL; 620 } 621 622 static bool displaychangelistener_has_dmabuf(DisplayChangeListener *dcl) 623 { 624 if (dcl->ops->dpy_has_dmabuf) { 625 return dcl->ops->dpy_has_dmabuf(dcl); 626 } 627 628 if (dcl->ops->dpy_gl_scanout_dmabuf) { 629 return true; 630 } 631 632 return false; 633 } 634 635 static bool console_compatible_with(QemuConsole *con, 636 DisplayChangeListener *dcl, Error **errp) 637 { 638 int flags; 639 640 flags = con->hw_ops->get_flags ? con->hw_ops->get_flags(con->hw) : 0; 641 642 if (console_has_gl(con) && 643 !con->gl->ops->dpy_gl_ctx_is_compatible_dcl(con->gl, dcl)) { 644 error_setg(errp, "Display %s is incompatible with the GL context", 645 dcl->ops->dpy_name); 646 return false; 647 } 648 649 if (flags & GRAPHIC_FLAGS_GL && 650 !console_has_gl(con)) { 651 error_setg(errp, "The console requires a GL context."); 652 return false; 653 654 } 655 656 if (flags & GRAPHIC_FLAGS_DMABUF && 657 !displaychangelistener_has_dmabuf(dcl)) { 658 error_setg(errp, "The console requires display DMABUF support."); 659 return false; 660 } 661 662 return true; 663 } 664 665 void console_handle_touch_event(QemuConsole *con, 666 struct touch_slot touch_slots[INPUT_EVENT_SLOTS_MAX], 667 uint64_t num_slot, 668 int width, int height, 669 double x, double y, 670 InputMultiTouchType type, 671 Error **errp) 672 { 673 struct touch_slot *slot; 674 bool needs_sync = false; 675 int update; 676 int i; 677 678 if (num_slot >= INPUT_EVENT_SLOTS_MAX) { 679 error_setg(errp, 680 "Unexpected touch slot number: % " PRId64" >= %d", 681 num_slot, INPUT_EVENT_SLOTS_MAX); 682 return; 683 } 684 685 slot = &touch_slots[num_slot]; 686 slot->x = x; 687 slot->y = y; 688 689 if (type == INPUT_MULTI_TOUCH_TYPE_BEGIN) { 690 slot->tracking_id = num_slot; 691 } 692 693 for (i = 0; i < INPUT_EVENT_SLOTS_MAX; ++i) { 694 if (i == num_slot) { 695 update = type; 696 } else { 697 update = INPUT_MULTI_TOUCH_TYPE_UPDATE; 698 } 699 700 slot = &touch_slots[i]; 701 702 if (slot->tracking_id == -1) { 703 continue; 704 } 705 706 if (update == INPUT_MULTI_TOUCH_TYPE_END) { 707 slot->tracking_id = -1; 708 qemu_input_queue_mtt(con, update, i, slot->tracking_id); 709 needs_sync = true; 710 } else { 711 qemu_input_queue_mtt(con, update, i, slot->tracking_id); 712 qemu_input_queue_btn(con, INPUT_BUTTON_TOUCH, true); 713 qemu_input_queue_mtt_abs(con, 714 INPUT_AXIS_X, (int) slot->x, 715 0, width, 716 i, slot->tracking_id); 717 qemu_input_queue_mtt_abs(con, 718 INPUT_AXIS_Y, (int) slot->y, 719 0, height, 720 i, slot->tracking_id); 721 needs_sync = true; 722 } 723 } 724 725 if (needs_sync) { 726 qemu_input_event_sync(); 727 } 728 } 729 730 void qemu_console_set_display_gl_ctx(QemuConsole *con, DisplayGLCtx *gl) 731 { 732 /* display has opengl support */ 733 assert(con); 734 if (con->gl) { 735 error_report("The console already has an OpenGL context."); 736 exit(1); 737 } 738 con->gl = gl; 739 } 740 741 static void 742 dcl_set_graphic_cursor(DisplayChangeListener *dcl, QemuGraphicConsole *con) 743 { 744 if (con && con->cursor && dcl->ops->dpy_cursor_define) { 745 dcl->ops->dpy_cursor_define(dcl, con->cursor); 746 } 747 if (con && dcl->ops->dpy_mouse_set) { 748 dcl->ops->dpy_mouse_set(dcl, con->cursor_x, con->cursor_y, con->cursor_on); 749 } 750 } 751 752 void register_displaychangelistener(DisplayChangeListener *dcl) 753 { 754 QemuConsole *con; 755 756 assert(!dcl->ds); 757 758 trace_displaychangelistener_register(dcl, dcl->ops->dpy_name); 759 dcl->ds = get_alloc_displaystate(); 760 QLIST_INSERT_HEAD(&dcl->ds->listeners, dcl, next); 761 gui_setup_refresh(dcl->ds); 762 if (dcl->con) { 763 dcl->con->dcls++; 764 con = dcl->con; 765 } else { 766 con = active_console; 767 } 768 displaychangelistener_display_console(dcl, con, dcl->con ? &error_fatal : NULL); 769 if (QEMU_IS_GRAPHIC_CONSOLE(con)) { 770 dcl_set_graphic_cursor(dcl, QEMU_GRAPHIC_CONSOLE(con)); 771 } 772 qemu_text_console_update_cursor(); 773 } 774 775 void update_displaychangelistener(DisplayChangeListener *dcl, 776 uint64_t interval) 777 { 778 DisplayState *ds = dcl->ds; 779 780 dcl->update_interval = interval; 781 if (!ds->refreshing && ds->update_interval > interval) { 782 timer_mod(ds->gui_timer, ds->last_update + interval); 783 } 784 } 785 786 void unregister_displaychangelistener(DisplayChangeListener *dcl) 787 { 788 DisplayState *ds = dcl->ds; 789 trace_displaychangelistener_unregister(dcl, dcl->ops->dpy_name); 790 if (dcl->con) { 791 dcl->con->dcls--; 792 } 793 QLIST_REMOVE(dcl, next); 794 dcl->ds = NULL; 795 gui_setup_refresh(ds); 796 } 797 798 static void dpy_set_ui_info_timer(void *opaque) 799 { 800 QemuConsole *con = opaque; 801 uint32_t head = qemu_console_get_head(con); 802 803 con->hw_ops->ui_info(con->hw, head, &con->ui_info); 804 } 805 806 bool dpy_ui_info_supported(const QemuConsole *con) 807 { 808 if (con == NULL) { 809 con = active_console; 810 } 811 if (con == NULL) { 812 return false; 813 } 814 815 return con->hw_ops->ui_info != NULL; 816 } 817 818 const QemuUIInfo *dpy_get_ui_info(const QemuConsole *con) 819 { 820 assert(dpy_ui_info_supported(con)); 821 822 if (con == NULL) { 823 con = active_console; 824 } 825 826 return &con->ui_info; 827 } 828 829 int dpy_set_ui_info(QemuConsole *con, QemuUIInfo *info, bool delay) 830 { 831 if (con == NULL) { 832 con = active_console; 833 } 834 835 if (!dpy_ui_info_supported(con)) { 836 return -1; 837 } 838 if (memcmp(&con->ui_info, info, sizeof(con->ui_info)) == 0) { 839 /* nothing changed -- ignore */ 840 return 0; 841 } 842 843 /* 844 * Typically we get a flood of these as the user resizes the window. 845 * Wait until the dust has settled (one second without updates), then 846 * go notify the guest. 847 */ 848 con->ui_info = *info; 849 timer_mod(con->ui_timer, 850 qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + (delay ? 1000 : 0)); 851 return 0; 852 } 853 854 void dpy_gfx_update(QemuConsole *con, int x, int y, int w, int h) 855 { 856 DisplayState *s = con->ds; 857 DisplayChangeListener *dcl; 858 int width = qemu_console_get_width(con, x + w); 859 int height = qemu_console_get_height(con, y + h); 860 861 x = MAX(x, 0); 862 y = MAX(y, 0); 863 x = MIN(x, width); 864 y = MIN(y, height); 865 w = MIN(w, width - x); 866 h = MIN(h, height - y); 867 868 if (!qemu_console_is_visible(con)) { 869 return; 870 } 871 dpy_gfx_update_texture(con, con->surface, x, y, w, h); 872 QLIST_FOREACH(dcl, &s->listeners, next) { 873 if (con != (dcl->con ? dcl->con : active_console)) { 874 continue; 875 } 876 if (dcl->ops->dpy_gfx_update) { 877 dcl->ops->dpy_gfx_update(dcl, x, y, w, h); 878 } 879 } 880 } 881 882 void dpy_gfx_update_full(QemuConsole *con) 883 { 884 int w = qemu_console_get_width(con, 0); 885 int h = qemu_console_get_height(con, 0); 886 887 dpy_gfx_update(con, 0, 0, w, h); 888 } 889 890 void dpy_gfx_replace_surface(QemuConsole *con, 891 DisplaySurface *surface) 892 { 893 static const char placeholder_msg[] = "Display output is not active."; 894 DisplayState *s = con->ds; 895 DisplaySurface *old_surface = con->surface; 896 DisplaySurface *new_surface = surface; 897 DisplayChangeListener *dcl; 898 int width; 899 int height; 900 901 if (!surface) { 902 if (old_surface) { 903 width = surface_width(old_surface); 904 height = surface_height(old_surface); 905 } else { 906 width = 640; 907 height = 480; 908 } 909 910 new_surface = qemu_create_placeholder_surface(width, height, placeholder_msg); 911 } 912 913 assert(old_surface != new_surface); 914 915 con->scanout.kind = SCANOUT_SURFACE; 916 con->surface = new_surface; 917 dpy_gfx_create_texture(con, new_surface); 918 QLIST_FOREACH(dcl, &s->listeners, next) { 919 if (con != (dcl->con ? dcl->con : active_console)) { 920 continue; 921 } 922 displaychangelistener_gfx_switch(dcl, new_surface, surface ? FALSE : TRUE); 923 } 924 dpy_gfx_destroy_texture(con, old_surface); 925 qemu_free_displaysurface(old_surface); 926 } 927 928 bool dpy_gfx_check_format(QemuConsole *con, 929 pixman_format_code_t format) 930 { 931 DisplayChangeListener *dcl; 932 DisplayState *s = con->ds; 933 934 QLIST_FOREACH(dcl, &s->listeners, next) { 935 if (dcl->con && dcl->con != con) { 936 /* dcl bound to another console -> skip */ 937 continue; 938 } 939 if (dcl->ops->dpy_gfx_check_format) { 940 if (!dcl->ops->dpy_gfx_check_format(dcl, format)) { 941 return false; 942 } 943 } else { 944 /* default is to allow native 32 bpp only */ 945 if (format != qemu_default_pixman_format(32, true)) { 946 return false; 947 } 948 } 949 } 950 return true; 951 } 952 953 static void dpy_refresh(DisplayState *s) 954 { 955 DisplayChangeListener *dcl; 956 957 QLIST_FOREACH(dcl, &s->listeners, next) { 958 if (dcl->ops->dpy_refresh) { 959 dcl->ops->dpy_refresh(dcl); 960 } 961 } 962 } 963 964 void dpy_text_cursor(QemuConsole *con, int x, int y) 965 { 966 DisplayState *s = con->ds; 967 DisplayChangeListener *dcl; 968 969 if (!qemu_console_is_visible(con)) { 970 return; 971 } 972 QLIST_FOREACH(dcl, &s->listeners, next) { 973 if (con != (dcl->con ? dcl->con : active_console)) { 974 continue; 975 } 976 if (dcl->ops->dpy_text_cursor) { 977 dcl->ops->dpy_text_cursor(dcl, x, y); 978 } 979 } 980 } 981 982 void dpy_text_update(QemuConsole *con, int x, int y, int w, int h) 983 { 984 DisplayState *s = con->ds; 985 DisplayChangeListener *dcl; 986 987 if (!qemu_console_is_visible(con)) { 988 return; 989 } 990 QLIST_FOREACH(dcl, &s->listeners, next) { 991 if (con != (dcl->con ? dcl->con : active_console)) { 992 continue; 993 } 994 if (dcl->ops->dpy_text_update) { 995 dcl->ops->dpy_text_update(dcl, x, y, w, h); 996 } 997 } 998 } 999 1000 void dpy_text_resize(QemuConsole *con, int w, int h) 1001 { 1002 DisplayState *s = con->ds; 1003 DisplayChangeListener *dcl; 1004 1005 if (!qemu_console_is_visible(con)) { 1006 return; 1007 } 1008 QLIST_FOREACH(dcl, &s->listeners, next) { 1009 if (con != (dcl->con ? dcl->con : active_console)) { 1010 continue; 1011 } 1012 if (dcl->ops->dpy_text_resize) { 1013 dcl->ops->dpy_text_resize(dcl, w, h); 1014 } 1015 } 1016 } 1017 1018 void dpy_mouse_set(QemuConsole *c, int x, int y, int on) 1019 { 1020 QemuGraphicConsole *con = QEMU_GRAPHIC_CONSOLE(c); 1021 DisplayState *s = c->ds; 1022 DisplayChangeListener *dcl; 1023 1024 con->cursor_x = x; 1025 con->cursor_y = y; 1026 con->cursor_on = on; 1027 if (!qemu_console_is_visible(c)) { 1028 return; 1029 } 1030 QLIST_FOREACH(dcl, &s->listeners, next) { 1031 if (c != (dcl->con ? dcl->con : active_console)) { 1032 continue; 1033 } 1034 if (dcl->ops->dpy_mouse_set) { 1035 dcl->ops->dpy_mouse_set(dcl, x, y, on); 1036 } 1037 } 1038 } 1039 1040 void dpy_cursor_define(QemuConsole *c, QEMUCursor *cursor) 1041 { 1042 QemuGraphicConsole *con = QEMU_GRAPHIC_CONSOLE(c); 1043 DisplayState *s = c->ds; 1044 DisplayChangeListener *dcl; 1045 1046 cursor_unref(con->cursor); 1047 con->cursor = cursor_ref(cursor); 1048 if (!qemu_console_is_visible(c)) { 1049 return; 1050 } 1051 QLIST_FOREACH(dcl, &s->listeners, next) { 1052 if (c != (dcl->con ? dcl->con : active_console)) { 1053 continue; 1054 } 1055 if (dcl->ops->dpy_cursor_define) { 1056 dcl->ops->dpy_cursor_define(dcl, cursor); 1057 } 1058 } 1059 } 1060 1061 bool dpy_cursor_define_supported(QemuConsole *con) 1062 { 1063 DisplayState *s = con->ds; 1064 DisplayChangeListener *dcl; 1065 1066 QLIST_FOREACH(dcl, &s->listeners, next) { 1067 if (dcl->ops->dpy_cursor_define) { 1068 return true; 1069 } 1070 } 1071 return false; 1072 } 1073 1074 QEMUGLContext dpy_gl_ctx_create(QemuConsole *con, 1075 struct QEMUGLParams *qparams) 1076 { 1077 assert(con->gl); 1078 return con->gl->ops->dpy_gl_ctx_create(con->gl, qparams); 1079 } 1080 1081 void dpy_gl_ctx_destroy(QemuConsole *con, QEMUGLContext ctx) 1082 { 1083 assert(con->gl); 1084 con->gl->ops->dpy_gl_ctx_destroy(con->gl, ctx); 1085 } 1086 1087 int dpy_gl_ctx_make_current(QemuConsole *con, QEMUGLContext ctx) 1088 { 1089 assert(con->gl); 1090 return con->gl->ops->dpy_gl_ctx_make_current(con->gl, ctx); 1091 } 1092 1093 void dpy_gl_scanout_disable(QemuConsole *con) 1094 { 1095 DisplayState *s = con->ds; 1096 DisplayChangeListener *dcl; 1097 1098 if (con->scanout.kind != SCANOUT_SURFACE) { 1099 con->scanout.kind = SCANOUT_NONE; 1100 } 1101 QLIST_FOREACH(dcl, &s->listeners, next) { 1102 if (con != (dcl->con ? dcl->con : active_console)) { 1103 continue; 1104 } 1105 if (dcl->ops->dpy_gl_scanout_disable) { 1106 dcl->ops->dpy_gl_scanout_disable(dcl); 1107 } 1108 } 1109 } 1110 1111 void dpy_gl_scanout_texture(QemuConsole *con, 1112 uint32_t backing_id, 1113 bool backing_y_0_top, 1114 uint32_t backing_width, 1115 uint32_t backing_height, 1116 uint32_t x, uint32_t y, 1117 uint32_t width, uint32_t height, 1118 void *d3d_tex2d) 1119 { 1120 DisplayState *s = con->ds; 1121 DisplayChangeListener *dcl; 1122 1123 con->scanout.kind = SCANOUT_TEXTURE; 1124 con->scanout.texture = (ScanoutTexture) { 1125 backing_id, backing_y_0_top, backing_width, backing_height, 1126 x, y, width, height, d3d_tex2d, 1127 }; 1128 QLIST_FOREACH(dcl, &s->listeners, next) { 1129 if (con != (dcl->con ? dcl->con : active_console)) { 1130 continue; 1131 } 1132 if (dcl->ops->dpy_gl_scanout_texture) { 1133 dcl->ops->dpy_gl_scanout_texture(dcl, backing_id, 1134 backing_y_0_top, 1135 backing_width, backing_height, 1136 x, y, width, height, 1137 d3d_tex2d); 1138 } 1139 } 1140 } 1141 1142 void dpy_gl_scanout_dmabuf(QemuConsole *con, 1143 QemuDmaBuf *dmabuf) 1144 { 1145 DisplayState *s = con->ds; 1146 DisplayChangeListener *dcl; 1147 1148 con->scanout.kind = SCANOUT_DMABUF; 1149 con->scanout.dmabuf = dmabuf; 1150 QLIST_FOREACH(dcl, &s->listeners, next) { 1151 if (con != (dcl->con ? dcl->con : active_console)) { 1152 continue; 1153 } 1154 if (dcl->ops->dpy_gl_scanout_dmabuf) { 1155 dcl->ops->dpy_gl_scanout_dmabuf(dcl, dmabuf); 1156 } 1157 } 1158 } 1159 1160 void dpy_gl_cursor_dmabuf(QemuConsole *con, QemuDmaBuf *dmabuf, 1161 bool have_hot, uint32_t hot_x, uint32_t hot_y) 1162 { 1163 DisplayState *s = con->ds; 1164 DisplayChangeListener *dcl; 1165 1166 QLIST_FOREACH(dcl, &s->listeners, next) { 1167 if (con != (dcl->con ? dcl->con : active_console)) { 1168 continue; 1169 } 1170 if (dcl->ops->dpy_gl_cursor_dmabuf) { 1171 dcl->ops->dpy_gl_cursor_dmabuf(dcl, dmabuf, 1172 have_hot, hot_x, hot_y); 1173 } 1174 } 1175 } 1176 1177 void dpy_gl_cursor_position(QemuConsole *con, 1178 uint32_t pos_x, uint32_t pos_y) 1179 { 1180 DisplayState *s = con->ds; 1181 DisplayChangeListener *dcl; 1182 1183 QLIST_FOREACH(dcl, &s->listeners, next) { 1184 if (con != (dcl->con ? dcl->con : active_console)) { 1185 continue; 1186 } 1187 if (dcl->ops->dpy_gl_cursor_position) { 1188 dcl->ops->dpy_gl_cursor_position(dcl, pos_x, pos_y); 1189 } 1190 } 1191 } 1192 1193 void dpy_gl_release_dmabuf(QemuConsole *con, 1194 QemuDmaBuf *dmabuf) 1195 { 1196 DisplayState *s = con->ds; 1197 DisplayChangeListener *dcl; 1198 1199 QLIST_FOREACH(dcl, &s->listeners, next) { 1200 if (con != (dcl->con ? dcl->con : active_console)) { 1201 continue; 1202 } 1203 if (dcl->ops->dpy_gl_release_dmabuf) { 1204 dcl->ops->dpy_gl_release_dmabuf(dcl, dmabuf); 1205 } 1206 } 1207 } 1208 1209 void dpy_gl_update(QemuConsole *con, 1210 uint32_t x, uint32_t y, uint32_t w, uint32_t h) 1211 { 1212 DisplayState *s = con->ds; 1213 DisplayChangeListener *dcl; 1214 1215 assert(con->gl); 1216 1217 graphic_hw_gl_block(con, true); 1218 QLIST_FOREACH(dcl, &s->listeners, next) { 1219 if (con != (dcl->con ? dcl->con : active_console)) { 1220 continue; 1221 } 1222 if (dcl->ops->dpy_gl_update) { 1223 dcl->ops->dpy_gl_update(dcl, x, y, w, h); 1224 } 1225 } 1226 graphic_hw_gl_block(con, false); 1227 } 1228 1229 /***********************************************************/ 1230 /* register display */ 1231 1232 /* console.c internal use only */ 1233 static DisplayState *get_alloc_displaystate(void) 1234 { 1235 if (!display_state) { 1236 display_state = g_new0(DisplayState, 1); 1237 } 1238 return display_state; 1239 } 1240 1241 /* 1242 * Called by main(), after creating QemuConsoles 1243 * and before initializing ui (sdl/vnc/...). 1244 */ 1245 DisplayState *init_displaystate(void) 1246 { 1247 gchar *name; 1248 QemuConsole *con; 1249 1250 QTAILQ_FOREACH(con, &consoles, next) { 1251 /* Hook up into the qom tree here (not in object_new()), once 1252 * all QemuConsoles are created and the order / numbering 1253 * doesn't change any more */ 1254 name = g_strdup_printf("console[%d]", con->index); 1255 object_property_add_child(container_get(object_get_root(), "/backend"), 1256 name, OBJECT(con)); 1257 g_free(name); 1258 } 1259 1260 return display_state; 1261 } 1262 1263 void graphic_console_set_hwops(QemuConsole *con, 1264 const GraphicHwOps *hw_ops, 1265 void *opaque) 1266 { 1267 con->hw_ops = hw_ops; 1268 con->hw = opaque; 1269 } 1270 1271 QemuConsole *graphic_console_init(DeviceState *dev, uint32_t head, 1272 const GraphicHwOps *hw_ops, 1273 void *opaque) 1274 { 1275 static const char noinit[] = 1276 "Guest has not initialized the display (yet)."; 1277 int width = 640; 1278 int height = 480; 1279 QemuConsole *s; 1280 DisplaySurface *surface; 1281 1282 s = qemu_graphic_console_lookup_unused(); 1283 if (s) { 1284 trace_console_gfx_reuse(s->index); 1285 width = qemu_console_get_width(s, 0); 1286 height = qemu_console_get_height(s, 0); 1287 } else { 1288 trace_console_gfx_new(); 1289 s = (QemuConsole *)object_new(TYPE_QEMU_GRAPHIC_CONSOLE); 1290 } 1291 QEMU_GRAPHIC_CONSOLE(s)->head = head; 1292 graphic_console_set_hwops(s, hw_ops, opaque); 1293 if (dev) { 1294 object_property_set_link(OBJECT(s), "device", OBJECT(dev), 1295 &error_abort); 1296 } 1297 1298 surface = qemu_create_placeholder_surface(width, height, noinit); 1299 dpy_gfx_replace_surface(s, surface); 1300 s->gl_unblock_timer = timer_new_ms(QEMU_CLOCK_REALTIME, 1301 graphic_hw_gl_unblock_timer, s); 1302 return s; 1303 } 1304 1305 static const GraphicHwOps unused_ops = { 1306 /* no callbacks */ 1307 }; 1308 1309 void graphic_console_close(QemuConsole *con) 1310 { 1311 static const char unplugged[] = 1312 "Guest display has been unplugged"; 1313 DisplaySurface *surface; 1314 int width = qemu_console_get_width(con, 640); 1315 int height = qemu_console_get_height(con, 480); 1316 1317 trace_console_gfx_close(con->index); 1318 object_property_set_link(OBJECT(con), "device", NULL, &error_abort); 1319 graphic_console_set_hwops(con, &unused_ops, NULL); 1320 1321 if (con->gl) { 1322 dpy_gl_scanout_disable(con); 1323 } 1324 surface = qemu_create_placeholder_surface(width, height, unplugged); 1325 dpy_gfx_replace_surface(con, surface); 1326 } 1327 1328 QemuConsole *qemu_console_lookup_by_index(unsigned int index) 1329 { 1330 QemuConsole *con; 1331 1332 QTAILQ_FOREACH(con, &consoles, next) { 1333 if (con->index == index) { 1334 return con; 1335 } 1336 } 1337 return NULL; 1338 } 1339 1340 QemuConsole *qemu_console_lookup_by_device(DeviceState *dev, uint32_t head) 1341 { 1342 QemuConsole *con; 1343 Object *obj; 1344 uint32_t h; 1345 1346 QTAILQ_FOREACH(con, &consoles, next) { 1347 obj = object_property_get_link(OBJECT(con), 1348 "device", &error_abort); 1349 if (DEVICE(obj) != dev) { 1350 continue; 1351 } 1352 h = object_property_get_uint(OBJECT(con), 1353 "head", &error_abort); 1354 if (h != head) { 1355 continue; 1356 } 1357 return con; 1358 } 1359 return NULL; 1360 } 1361 1362 QemuConsole *qemu_console_lookup_by_device_name(const char *device_id, 1363 uint32_t head, Error **errp) 1364 { 1365 DeviceState *dev; 1366 QemuConsole *con; 1367 1368 dev = qdev_find_recursive(sysbus_get_default(), device_id); 1369 if (dev == NULL) { 1370 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, 1371 "Device '%s' not found", device_id); 1372 return NULL; 1373 } 1374 1375 con = qemu_console_lookup_by_device(dev, head); 1376 if (con == NULL) { 1377 error_setg(errp, "Device %s (head %d) is not bound to a QemuConsole", 1378 device_id, head); 1379 return NULL; 1380 } 1381 1382 return con; 1383 } 1384 1385 static QemuConsole *qemu_graphic_console_lookup_unused(void) 1386 { 1387 QemuConsole *con; 1388 Object *obj; 1389 1390 QTAILQ_FOREACH(con, &consoles, next) { 1391 if (!QEMU_IS_GRAPHIC_CONSOLE(con) || con->hw_ops != &unused_ops) { 1392 continue; 1393 } 1394 obj = object_property_get_link(OBJECT(con), 1395 "device", &error_abort); 1396 if (obj != NULL) { 1397 continue; 1398 } 1399 return con; 1400 } 1401 return NULL; 1402 } 1403 1404 QEMUCursor *qemu_console_get_cursor(QemuConsole *con) 1405 { 1406 if (con == NULL) { 1407 con = active_console; 1408 } 1409 return QEMU_IS_GRAPHIC_CONSOLE(con) ? QEMU_GRAPHIC_CONSOLE(con)->cursor : NULL; 1410 } 1411 1412 bool qemu_console_is_visible(QemuConsole *con) 1413 { 1414 return (con == active_console) || (con->dcls > 0); 1415 } 1416 1417 bool qemu_console_is_graphic(QemuConsole *con) 1418 { 1419 if (con == NULL) { 1420 con = active_console; 1421 } 1422 return con && QEMU_IS_GRAPHIC_CONSOLE(con); 1423 } 1424 1425 bool qemu_console_is_fixedsize(QemuConsole *con) 1426 { 1427 if (con == NULL) { 1428 con = active_console; 1429 } 1430 return con && (QEMU_IS_GRAPHIC_CONSOLE(con) || QEMU_IS_FIXED_TEXT_CONSOLE(con)); 1431 } 1432 1433 bool qemu_console_is_gl_blocked(QemuConsole *con) 1434 { 1435 assert(con != NULL); 1436 return con->gl_block; 1437 } 1438 1439 static bool qemu_graphic_console_is_multihead(QemuGraphicConsole *c) 1440 { 1441 QemuConsole *con; 1442 1443 QTAILQ_FOREACH(con, &consoles, next) { 1444 QemuGraphicConsole *candidate; 1445 1446 if (!QEMU_IS_GRAPHIC_CONSOLE(con)) { 1447 continue; 1448 } 1449 1450 candidate = QEMU_GRAPHIC_CONSOLE(con); 1451 if (candidate->device != c->device) { 1452 continue; 1453 } 1454 1455 if (candidate->head != c->head) { 1456 return true; 1457 } 1458 } 1459 return false; 1460 } 1461 1462 char *qemu_console_get_label(QemuConsole *con) 1463 { 1464 if (QEMU_IS_GRAPHIC_CONSOLE(con)) { 1465 QemuGraphicConsole *c = QEMU_GRAPHIC_CONSOLE(con); 1466 if (c->device) { 1467 DeviceState *dev; 1468 bool multihead; 1469 1470 dev = DEVICE(c->device); 1471 multihead = qemu_graphic_console_is_multihead(c); 1472 if (multihead) { 1473 return g_strdup_printf("%s.%d", dev->id ? 1474 dev->id : 1475 object_get_typename(c->device), 1476 c->head); 1477 } else { 1478 return g_strdup_printf("%s", dev->id ? 1479 dev->id : 1480 object_get_typename(c->device)); 1481 } 1482 } 1483 return g_strdup("VGA"); 1484 } else if (QEMU_IS_TEXT_CONSOLE(con)) { 1485 const char *label = qemu_text_console_get_label(QEMU_TEXT_CONSOLE(con)); 1486 if (label) { 1487 return g_strdup(label); 1488 } 1489 } 1490 1491 return g_strdup_printf("vc%d", con->index); 1492 } 1493 1494 int qemu_console_get_index(QemuConsole *con) 1495 { 1496 if (con == NULL) { 1497 con = active_console; 1498 } 1499 return con ? con->index : -1; 1500 } 1501 1502 uint32_t qemu_console_get_head(QemuConsole *con) 1503 { 1504 if (con == NULL) { 1505 con = active_console; 1506 } 1507 if (con == NULL) { 1508 return -1; 1509 } 1510 if (QEMU_IS_GRAPHIC_CONSOLE(con)) { 1511 return QEMU_GRAPHIC_CONSOLE(con)->head; 1512 } 1513 return 0; 1514 } 1515 1516 int qemu_console_get_width(QemuConsole *con, int fallback) 1517 { 1518 if (con == NULL) { 1519 con = active_console; 1520 } 1521 if (con == NULL) { 1522 return fallback; 1523 } 1524 switch (con->scanout.kind) { 1525 case SCANOUT_DMABUF: 1526 return con->scanout.dmabuf->width; 1527 case SCANOUT_TEXTURE: 1528 return con->scanout.texture.width; 1529 case SCANOUT_SURFACE: 1530 return surface_width(con->surface); 1531 default: 1532 return fallback; 1533 } 1534 } 1535 1536 int qemu_console_get_height(QemuConsole *con, int fallback) 1537 { 1538 if (con == NULL) { 1539 con = active_console; 1540 } 1541 if (con == NULL) { 1542 return fallback; 1543 } 1544 switch (con->scanout.kind) { 1545 case SCANOUT_DMABUF: 1546 return con->scanout.dmabuf->height; 1547 case SCANOUT_TEXTURE: 1548 return con->scanout.texture.height; 1549 case SCANOUT_SURFACE: 1550 return surface_height(con->surface); 1551 default: 1552 return fallback; 1553 } 1554 } 1555 1556 int qemu_invalidate_text_consoles(void) 1557 { 1558 QemuConsole *s; 1559 int count = 0; 1560 1561 QTAILQ_FOREACH(s, &consoles, next) { 1562 if (qemu_console_is_graphic(s) || 1563 !qemu_console_is_visible(s)) { 1564 continue; 1565 } 1566 count++; 1567 graphic_hw_invalidate(s); 1568 } 1569 1570 return count; 1571 } 1572 1573 void qemu_console_resize(QemuConsole *s, int width, int height) 1574 { 1575 DisplaySurface *surface = qemu_console_surface(s); 1576 1577 assert(QEMU_IS_GRAPHIC_CONSOLE(s)); 1578 1579 if ((s->scanout.kind != SCANOUT_SURFACE || 1580 (surface && surface->flags & QEMU_ALLOCATED_FLAG)) && 1581 qemu_console_get_width(s, -1) == width && 1582 qemu_console_get_height(s, -1) == height) { 1583 return; 1584 } 1585 1586 surface = qemu_create_displaysurface(width, height); 1587 dpy_gfx_replace_surface(s, surface); 1588 } 1589 1590 DisplaySurface *qemu_console_surface(QemuConsole *console) 1591 { 1592 switch (console->scanout.kind) { 1593 case SCANOUT_SURFACE: 1594 return console->surface; 1595 default: 1596 return NULL; 1597 } 1598 } 1599 1600 PixelFormat qemu_default_pixelformat(int bpp) 1601 { 1602 pixman_format_code_t fmt = qemu_default_pixman_format(bpp, true); 1603 PixelFormat pf = qemu_pixelformat_from_pixman(fmt); 1604 return pf; 1605 } 1606 1607 static QemuDisplay *dpys[DISPLAY_TYPE__MAX]; 1608 1609 void qemu_display_register(QemuDisplay *ui) 1610 { 1611 assert(ui->type < DISPLAY_TYPE__MAX); 1612 dpys[ui->type] = ui; 1613 } 1614 1615 bool qemu_display_find_default(DisplayOptions *opts) 1616 { 1617 static DisplayType prio[] = { 1618 #if defined(CONFIG_GTK) 1619 DISPLAY_TYPE_GTK, 1620 #endif 1621 #if defined(CONFIG_SDL) 1622 DISPLAY_TYPE_SDL, 1623 #endif 1624 #if defined(CONFIG_COCOA) 1625 DISPLAY_TYPE_COCOA 1626 #endif 1627 }; 1628 int i; 1629 1630 for (i = 0; i < (int)ARRAY_SIZE(prio); i++) { 1631 if (dpys[prio[i]] == NULL) { 1632 Error *local_err = NULL; 1633 int rv = ui_module_load(DisplayType_str(prio[i]), &local_err); 1634 if (rv < 0) { 1635 error_report_err(local_err); 1636 } 1637 } 1638 if (dpys[prio[i]] == NULL) { 1639 continue; 1640 } 1641 opts->type = prio[i]; 1642 return true; 1643 } 1644 return false; 1645 } 1646 1647 void qemu_display_early_init(DisplayOptions *opts) 1648 { 1649 assert(opts->type < DISPLAY_TYPE__MAX); 1650 if (opts->type == DISPLAY_TYPE_NONE) { 1651 return; 1652 } 1653 if (dpys[opts->type] == NULL) { 1654 Error *local_err = NULL; 1655 int rv = ui_module_load(DisplayType_str(opts->type), &local_err); 1656 if (rv < 0) { 1657 error_report_err(local_err); 1658 } 1659 } 1660 if (dpys[opts->type] == NULL) { 1661 error_report("Display '%s' is not available.", 1662 DisplayType_str(opts->type)); 1663 exit(1); 1664 } 1665 if (dpys[opts->type]->early_init) { 1666 dpys[opts->type]->early_init(opts); 1667 } 1668 } 1669 1670 void qemu_display_init(DisplayState *ds, DisplayOptions *opts) 1671 { 1672 assert(opts->type < DISPLAY_TYPE__MAX); 1673 if (opts->type == DISPLAY_TYPE_NONE) { 1674 return; 1675 } 1676 assert(dpys[opts->type] != NULL); 1677 dpys[opts->type]->init(ds, opts); 1678 } 1679 1680 const char *qemu_display_get_vc(DisplayOptions *opts) 1681 { 1682 assert(opts->type < DISPLAY_TYPE__MAX); 1683 if (opts->type == DISPLAY_TYPE_NONE) { 1684 return NULL; 1685 } 1686 assert(dpys[opts->type] != NULL); 1687 if (dpys[opts->type]->vc) { 1688 return dpys[opts->type]->vc; 1689 } else { 1690 #ifdef CONFIG_PIXMAN 1691 return "vc:80Cx24C"; 1692 #endif 1693 } 1694 return NULL; 1695 } 1696 1697 void qemu_display_help(void) 1698 { 1699 int idx; 1700 1701 printf("Available display backend types:\n"); 1702 printf("none\n"); 1703 for (idx = DISPLAY_TYPE_NONE; idx < DISPLAY_TYPE__MAX; idx++) { 1704 if (!dpys[idx]) { 1705 Error *local_err = NULL; 1706 int rv = ui_module_load(DisplayType_str(idx), &local_err); 1707 if (rv < 0) { 1708 error_report_err(local_err); 1709 } 1710 } 1711 if (dpys[idx]) { 1712 printf("%s\n", DisplayType_str(dpys[idx]->type)); 1713 } 1714 } 1715 } 1716