2 * Copyright (C) 2010 Red Hat, Inc.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License as
6 * published by the Free Software Foundation; either version 2 or
7 * (at your option) version 3 of the License.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, see <http://www.gnu.org/licenses/>.
18 #include "qemu/osdep.h"
19 #include "ui/qemu-spice.h"
20 #include "qemu/timer.h"
21 #include "qemu/option.h"
22 #include "qemu/queue.h"
23 #include "ui/console.h"
24 #include "sysemu/sysemu.h"
27 #include "ui/spice-display.h"
31 int qemu_spice_rect_is_empty(const QXLRect
* r
)
33 return r
->top
== r
->bottom
|| r
->left
== r
->right
;
36 void qemu_spice_rect_union(QXLRect
*dest
, const QXLRect
*r
)
38 if (qemu_spice_rect_is_empty(r
)) {
42 if (qemu_spice_rect_is_empty(dest
)) {
47 dest
->top
= MIN(dest
->top
, r
->top
);
48 dest
->left
= MIN(dest
->left
, r
->left
);
49 dest
->bottom
= MAX(dest
->bottom
, r
->bottom
);
50 dest
->right
= MAX(dest
->right
, r
->right
);
53 QXLCookie
*qxl_cookie_new(int type
, uint64_t io
)
57 cookie
= g_malloc0(sizeof(*cookie
));
63 void qemu_spice_add_memslot(SimpleSpiceDisplay
*ssd
, QXLDevMemSlot
*memslot
,
66 trace_qemu_spice_add_memslot(ssd
->qxl
.id
, memslot
->slot_id
,
67 memslot
->virt_start
, memslot
->virt_end
,
70 if (async
!= QXL_SYNC
) {
71 spice_qxl_add_memslot_async(&ssd
->qxl
, memslot
,
72 (uintptr_t)qxl_cookie_new(QXL_COOKIE_TYPE_IO
,
73 QXL_IO_MEMSLOT_ADD_ASYNC
));
75 spice_qxl_add_memslot(&ssd
->qxl
, memslot
);
79 void qemu_spice_del_memslot(SimpleSpiceDisplay
*ssd
, uint32_t gid
, uint32_t sid
)
81 trace_qemu_spice_del_memslot(ssd
->qxl
.id
, gid
, sid
);
82 spice_qxl_del_memslot(&ssd
->qxl
, gid
, sid
);
85 void qemu_spice_create_primary_surface(SimpleSpiceDisplay
*ssd
, uint32_t id
,
86 QXLDevSurfaceCreate
*surface
,
89 trace_qemu_spice_create_primary_surface(ssd
->qxl
.id
, id
, surface
, async
);
90 if (async
!= QXL_SYNC
) {
91 spice_qxl_create_primary_surface_async(&ssd
->qxl
, id
, surface
,
92 (uintptr_t)qxl_cookie_new(QXL_COOKIE_TYPE_IO
,
93 QXL_IO_CREATE_PRIMARY_ASYNC
));
95 spice_qxl_create_primary_surface(&ssd
->qxl
, id
, surface
);
99 void qemu_spice_destroy_primary_surface(SimpleSpiceDisplay
*ssd
,
100 uint32_t id
, qxl_async_io async
)
102 trace_qemu_spice_destroy_primary_surface(ssd
->qxl
.id
, id
, async
);
103 if (async
!= QXL_SYNC
) {
104 spice_qxl_destroy_primary_surface_async(&ssd
->qxl
, id
,
105 (uintptr_t)qxl_cookie_new(QXL_COOKIE_TYPE_IO
,
106 QXL_IO_DESTROY_PRIMARY_ASYNC
));
108 spice_qxl_destroy_primary_surface(&ssd
->qxl
, id
);
112 void qemu_spice_wakeup(SimpleSpiceDisplay
*ssd
)
114 trace_qemu_spice_wakeup(ssd
->qxl
.id
);
115 spice_qxl_wakeup(&ssd
->qxl
);
118 static void qemu_spice_create_one_update(SimpleSpiceDisplay
*ssd
,
121 SimpleSpiceUpdate
*update
;
122 QXLDrawable
*drawable
;
126 struct timespec time_space
;
127 pixman_image_t
*dest
;
129 trace_qemu_spice_create_update(
130 rect
->left
, rect
->right
,
131 rect
->top
, rect
->bottom
);
133 update
= g_malloc0(sizeof(*update
));
134 drawable
= &update
->drawable
;
135 image
= &update
->image
;
136 cmd
= &update
->ext
.cmd
;
138 bw
= rect
->right
- rect
->left
;
139 bh
= rect
->bottom
- rect
->top
;
140 update
->bitmap
= g_malloc(bw
* bh
* 4);
142 drawable
->bbox
= *rect
;
143 drawable
->clip
.type
= SPICE_CLIP_TYPE_NONE
;
144 drawable
->effect
= QXL_EFFECT_OPAQUE
;
145 drawable
->release_info
.id
= (uintptr_t)(&update
->ext
);
146 drawable
->type
= QXL_DRAW_COPY
;
147 drawable
->surfaces_dest
[0] = -1;
148 drawable
->surfaces_dest
[1] = -1;
149 drawable
->surfaces_dest
[2] = -1;
150 clock_gettime(CLOCK_MONOTONIC
, &time_space
);
151 /* time in milliseconds from epoch. */
152 drawable
->mm_time
= time_space
.tv_sec
* 1000
153 + time_space
.tv_nsec
/ 1000 / 1000;
155 drawable
->u
.copy
.rop_descriptor
= SPICE_ROPD_OP_PUT
;
156 drawable
->u
.copy
.src_bitmap
= (uintptr_t)image
;
157 drawable
->u
.copy
.src_area
.right
= bw
;
158 drawable
->u
.copy
.src_area
.bottom
= bh
;
160 QXL_SET_IMAGE_ID(image
, QXL_IMAGE_GROUP_DEVICE
, ssd
->unique
++);
161 image
->descriptor
.type
= SPICE_IMAGE_TYPE_BITMAP
;
162 image
->bitmap
.flags
= QXL_BITMAP_DIRECT
| QXL_BITMAP_TOP_DOWN
;
163 image
->bitmap
.stride
= bw
* 4;
164 image
->descriptor
.width
= image
->bitmap
.x
= bw
;
165 image
->descriptor
.height
= image
->bitmap
.y
= bh
;
166 image
->bitmap
.data
= (uintptr_t)(update
->bitmap
);
167 image
->bitmap
.palette
= 0;
168 image
->bitmap
.format
= SPICE_BITMAP_FMT_32BIT
;
170 dest
= pixman_image_create_bits(PIXMAN_LE_x8r8g8b8
, bw
, bh
,
171 (void *)update
->bitmap
, bw
* 4);
172 pixman_image_composite(PIXMAN_OP_SRC
, ssd
->surface
, NULL
, ssd
->mirror
,
173 rect
->left
, rect
->top
, 0, 0,
174 rect
->left
, rect
->top
, bw
, bh
);
175 pixman_image_composite(PIXMAN_OP_SRC
, ssd
->mirror
, NULL
, dest
,
176 rect
->left
, rect
->top
, 0, 0,
178 pixman_image_unref(dest
);
180 cmd
->type
= QXL_CMD_DRAW
;
181 cmd
->data
= (uintptr_t)drawable
;
183 QTAILQ_INSERT_TAIL(&ssd
->updates
, update
, next
);
186 static void qemu_spice_create_update(SimpleSpiceDisplay
*ssd
)
188 static const int blksize
= 32;
189 int blocks
= DIV_ROUND_UP(surface_width(ssd
->ds
), blksize
);
190 int dirty_top
[blocks
];
191 int y
, yoff1
, yoff2
, x
, xoff
, blk
, bw
;
192 int bpp
= surface_bytes_per_pixel(ssd
->ds
);
193 uint8_t *guest
, *mirror
;
195 if (qemu_spice_rect_is_empty(&ssd
->dirty
)) {
199 for (blk
= 0; blk
< blocks
; blk
++) {
203 guest
= surface_data(ssd
->ds
);
204 mirror
= (void *)pixman_image_get_data(ssd
->mirror
);
205 for (y
= ssd
->dirty
.top
; y
< ssd
->dirty
.bottom
; y
++) {
206 yoff1
= y
* surface_stride(ssd
->ds
);
207 yoff2
= y
* pixman_image_get_stride(ssd
->mirror
);
208 for (x
= ssd
->dirty
.left
; x
< ssd
->dirty
.right
; x
+= blksize
) {
211 bw
= MIN(blksize
, ssd
->dirty
.right
- x
);
212 if (memcmp(guest
+ yoff1
+ xoff
,
213 mirror
+ yoff2
+ xoff
,
215 if (dirty_top
[blk
] != -1) {
217 .top
= dirty_top
[blk
],
222 qemu_spice_create_one_update(ssd
, &update
);
226 if (dirty_top
[blk
] == -1) {
233 for (x
= ssd
->dirty
.left
; x
< ssd
->dirty
.right
; x
+= blksize
) {
235 bw
= MIN(blksize
, ssd
->dirty
.right
- x
);
236 if (dirty_top
[blk
] != -1) {
238 .top
= dirty_top
[blk
],
239 .bottom
= ssd
->dirty
.bottom
,
243 qemu_spice_create_one_update(ssd
, &update
);
248 memset(&ssd
->dirty
, 0, sizeof(ssd
->dirty
));
251 static SimpleSpiceCursor
*
252 qemu_spice_create_cursor_update(SimpleSpiceDisplay
*ssd
,
256 size_t size
= c
? c
->width
* c
->height
* 4 : 0;
257 SimpleSpiceCursor
*update
;
262 update
= g_malloc0(sizeof(*update
) + size
);
264 cursor
= &update
->cursor
;
265 cmd
= &update
->ext
.cmd
;
268 ccmd
->type
= QXL_CURSOR_SET
;
269 ccmd
->u
.set
.position
.x
= ssd
->ptr_x
+ ssd
->hot_x
;
270 ccmd
->u
.set
.position
.y
= ssd
->ptr_y
+ ssd
->hot_y
;
271 ccmd
->u
.set
.visible
= true;
272 ccmd
->u
.set
.shape
= (uintptr_t)cursor
;
273 cursor
->header
.unique
= ssd
->unique
++;
274 cursor
->header
.type
= SPICE_CURSOR_TYPE_ALPHA
;
275 cursor
->header
.width
= c
->width
;
276 cursor
->header
.height
= c
->height
;
277 cursor
->header
.hot_spot_x
= c
->hot_x
;
278 cursor
->header
.hot_spot_y
= c
->hot_y
;
279 cursor
->data_size
= size
;
280 cursor
->chunk
.data_size
= size
;
281 memcpy(cursor
->chunk
.data
, c
->data
, size
);
283 ccmd
->type
= QXL_CURSOR_HIDE
;
285 ccmd
->type
= QXL_CURSOR_MOVE
;
286 ccmd
->u
.position
.x
= ssd
->ptr_x
+ ssd
->hot_x
;
287 ccmd
->u
.position
.y
= ssd
->ptr_y
+ ssd
->hot_y
;
289 ccmd
->release_info
.id
= (uintptr_t)(&update
->ext
);
291 cmd
->type
= QXL_CMD_CURSOR
;
292 cmd
->data
= (uintptr_t)ccmd
;
298 * Called from spice server thread context (via interface_release_resource)
299 * We do *not* hold the global qemu mutex here, so extra care is needed
300 * when calling qemu functions. QEMU interfaces used:
301 * - g_free (underlying glibc free is re-entrant).
303 void qemu_spice_destroy_update(SimpleSpiceDisplay
*sdpy
, SimpleSpiceUpdate
*update
)
305 g_free(update
->bitmap
);
309 void qemu_spice_create_host_memslot(SimpleSpiceDisplay
*ssd
)
311 QXLDevMemSlot memslot
;
313 memset(&memslot
, 0, sizeof(memslot
));
314 memslot
.slot_group_id
= MEMSLOT_GROUP_HOST
;
315 memslot
.virt_end
= ~0;
316 qemu_spice_add_memslot(ssd
, &memslot
, QXL_SYNC
);
319 void qemu_spice_create_host_primary(SimpleSpiceDisplay
*ssd
)
321 QXLDevSurfaceCreate surface
;
322 uint64_t surface_size
;
324 memset(&surface
, 0, sizeof(surface
));
326 surface_size
= (uint64_t) surface_width(ssd
->ds
) *
327 surface_height(ssd
->ds
) * 4;
328 assert(surface_size
> 0);
329 assert(surface_size
< INT_MAX
);
330 if (ssd
->bufsize
< surface_size
) {
331 ssd
->bufsize
= surface_size
;
333 ssd
->buf
= g_malloc(ssd
->bufsize
);
336 surface
.format
= SPICE_SURFACE_FMT_32_xRGB
;
337 surface
.width
= surface_width(ssd
->ds
);
338 surface
.height
= surface_height(ssd
->ds
);
339 surface
.stride
= -surface
.width
* 4;
340 surface
.mouse_mode
= true;
343 surface
.mem
= (uintptr_t)ssd
->buf
;
344 surface
.group_id
= MEMSLOT_GROUP_HOST
;
346 qemu_spice_create_primary_surface(ssd
, 0, &surface
, QXL_SYNC
);
349 void qemu_spice_destroy_host_primary(SimpleSpiceDisplay
*ssd
)
351 qemu_spice_destroy_primary_surface(ssd
, 0, QXL_SYNC
);
354 void qemu_spice_display_init_common(SimpleSpiceDisplay
*ssd
)
356 qemu_mutex_init(&ssd
->lock
);
357 QTAILQ_INIT(&ssd
->updates
);
360 if (ssd
->num_surfaces
== 0) {
361 ssd
->num_surfaces
= 1024;
365 /* display listener callbacks */
367 void qemu_spice_display_update(SimpleSpiceDisplay
*ssd
,
368 int x
, int y
, int w
, int h
)
372 trace_qemu_spice_display_update(ssd
->qxl
.id
, x
, y
, w
, h
);
373 update_area
.left
= x
,
374 update_area
.right
= x
+ w
;
376 update_area
.bottom
= y
+ h
;
378 if (qemu_spice_rect_is_empty(&ssd
->dirty
)) {
381 qemu_spice_rect_union(&ssd
->dirty
, &update_area
);
384 void qemu_spice_display_switch(SimpleSpiceDisplay
*ssd
,
385 DisplaySurface
*surface
)
387 SimpleSpiceUpdate
*update
;
390 if (surface
&& ssd
->surface
&&
391 surface_width(surface
) == pixman_image_get_width(ssd
->surface
) &&
392 surface_height(surface
) == pixman_image_get_height(ssd
->surface
) &&
393 surface_format(surface
) == pixman_image_get_format(ssd
->surface
)) {
394 /* no-resize fast path: just swap backing store */
395 trace_qemu_spice_display_surface(ssd
->qxl
.id
,
396 surface_width(surface
),
397 surface_height(surface
),
399 qemu_mutex_lock(&ssd
->lock
);
401 pixman_image_unref(ssd
->surface
);
402 ssd
->surface
= pixman_image_ref(ssd
->ds
->image
);
403 qemu_mutex_unlock(&ssd
->lock
);
404 qemu_spice_display_update(ssd
, 0, 0,
405 surface_width(surface
),
406 surface_height(surface
));
410 /* full mode switch */
411 trace_qemu_spice_display_surface(ssd
->qxl
.id
,
412 surface
? surface_width(surface
) : 0,
413 surface
? surface_height(surface
) : 0,
416 memset(&ssd
->dirty
, 0, sizeof(ssd
->dirty
));
418 pixman_image_unref(ssd
->surface
);
420 pixman_image_unref(ssd
->mirror
);
424 qemu_mutex_lock(&ssd
->lock
);
425 need_destroy
= (ssd
->ds
!= NULL
);
427 while ((update
= QTAILQ_FIRST(&ssd
->updates
)) != NULL
) {
428 QTAILQ_REMOVE(&ssd
->updates
, update
, next
);
429 qemu_spice_destroy_update(ssd
, update
);
431 qemu_mutex_unlock(&ssd
->lock
);
433 qemu_spice_destroy_host_primary(ssd
);
436 ssd
->surface
= pixman_image_ref(ssd
->ds
->image
);
437 ssd
->mirror
= qemu_pixman_mirror_create(ssd
->ds
->format
,
439 qemu_spice_create_host_primary(ssd
);
442 memset(&ssd
->dirty
, 0, sizeof(ssd
->dirty
));
445 qemu_mutex_lock(&ssd
->lock
);
447 g_free(ssd
->ptr_define
);
448 ssd
->ptr_define
= qemu_spice_create_cursor_update(ssd
, ssd
->cursor
, 0);
450 qemu_mutex_unlock(&ssd
->lock
);
453 void qemu_spice_cursor_refresh_bh(void *opaque
)
455 SimpleSpiceDisplay
*ssd
= opaque
;
457 qemu_mutex_lock(&ssd
->lock
);
459 QEMUCursor
*c
= ssd
->cursor
;
460 assert(ssd
->dcl
.con
);
462 qemu_mutex_unlock(&ssd
->lock
);
463 dpy_cursor_define(ssd
->dcl
.con
, c
);
464 qemu_mutex_lock(&ssd
->lock
);
468 if (ssd
->mouse_x
!= -1 && ssd
->mouse_y
!= -1) {
470 assert(ssd
->dcl
.con
);
475 qemu_mutex_unlock(&ssd
->lock
);
476 dpy_mouse_set(ssd
->dcl
.con
, x
, y
, 1);
478 qemu_mutex_unlock(&ssd
->lock
);
482 void qemu_spice_display_refresh(SimpleSpiceDisplay
*ssd
)
484 graphic_hw_update(ssd
->dcl
.con
);
486 qemu_mutex_lock(&ssd
->lock
);
487 if (QTAILQ_EMPTY(&ssd
->updates
) && ssd
->ds
) {
488 qemu_spice_create_update(ssd
);
491 qemu_mutex_unlock(&ssd
->lock
);
493 trace_qemu_spice_display_refresh(ssd
->qxl
.id
, ssd
->notify
);
496 qemu_spice_wakeup(ssd
);
500 /* spice display interface callbacks */
502 static void interface_attach_worker(QXLInstance
*sin
, QXLWorker
*qxl_worker
)
507 static void interface_set_compression_level(QXLInstance
*sin
, int level
)
512 #if SPICE_NEEDS_SET_MM_TIME
513 static void interface_set_mm_time(QXLInstance
*sin
, uint32_t mm_time
)
519 static void interface_get_init_info(QXLInstance
*sin
, QXLDevInitInfo
*info
)
521 SimpleSpiceDisplay
*ssd
= container_of(sin
, SimpleSpiceDisplay
, qxl
);
523 info
->memslot_gen_bits
= MEMSLOT_GENERATION_BITS
;
524 info
->memslot_id_bits
= MEMSLOT_SLOT_BITS
;
525 info
->num_memslots
= NUM_MEMSLOTS
;
526 info
->num_memslots_groups
= NUM_MEMSLOTS_GROUPS
;
527 info
->internal_groupslot_id
= 0;
528 info
->qxl_ram_size
= 16 * 1024 * 1024;
529 info
->n_surfaces
= ssd
->num_surfaces
;
532 static int interface_get_command(QXLInstance
*sin
, QXLCommandExt
*ext
)
534 SimpleSpiceDisplay
*ssd
= container_of(sin
, SimpleSpiceDisplay
, qxl
);
535 SimpleSpiceUpdate
*update
;
538 qemu_mutex_lock(&ssd
->lock
);
539 update
= QTAILQ_FIRST(&ssd
->updates
);
540 if (update
!= NULL
) {
541 QTAILQ_REMOVE(&ssd
->updates
, update
, next
);
545 qemu_mutex_unlock(&ssd
->lock
);
550 static int interface_req_cmd_notification(QXLInstance
*sin
)
555 static void interface_release_resource(QXLInstance
*sin
,
556 QXLReleaseInfoExt rext
)
558 SimpleSpiceDisplay
*ssd
= container_of(sin
, SimpleSpiceDisplay
, qxl
);
559 SimpleSpiceUpdate
*update
;
560 SimpleSpiceCursor
*cursor
;
563 ext
= (void *)(intptr_t)(rext
.info
->id
);
564 switch (ext
->cmd
.type
) {
566 update
= container_of(ext
, SimpleSpiceUpdate
, ext
);
567 qemu_spice_destroy_update(ssd
, update
);
570 cursor
= container_of(ext
, SimpleSpiceCursor
, ext
);
574 g_assert_not_reached();
578 static int interface_get_cursor_command(QXLInstance
*sin
, QXLCommandExt
*ext
)
580 SimpleSpiceDisplay
*ssd
= container_of(sin
, SimpleSpiceDisplay
, qxl
);
583 qemu_mutex_lock(&ssd
->lock
);
584 if (ssd
->ptr_define
) {
585 *ext
= ssd
->ptr_define
->ext
;
586 ssd
->ptr_define
= NULL
;
588 } else if (ssd
->ptr_move
) {
589 *ext
= ssd
->ptr_move
->ext
;
590 ssd
->ptr_move
= NULL
;
595 qemu_mutex_unlock(&ssd
->lock
);
599 static int interface_req_cursor_notification(QXLInstance
*sin
)
604 static void interface_notify_update(QXLInstance
*sin
, uint32_t update_id
)
606 fprintf(stderr
, "%s: abort()\n", __func__
);
610 static int interface_flush_resources(QXLInstance
*sin
)
612 fprintf(stderr
, "%s: abort()\n", __func__
);
617 static void interface_update_area_complete(QXLInstance
*sin
,
619 QXLRect
*dirty
, uint32_t num_updated_rects
)
621 /* should never be called, used in qxl native mode only */
622 fprintf(stderr
, "%s: abort()\n", __func__
);
626 /* called from spice server thread context only */
627 static void interface_async_complete(QXLInstance
*sin
, uint64_t cookie_token
)
629 QXLCookie
*cookie
= (QXLCookie
*)(uintptr_t)cookie_token
;
631 switch (cookie
->type
) {
633 case QXL_COOKIE_TYPE_GL_DRAW_DONE
:
635 SimpleSpiceDisplay
*ssd
= container_of(sin
, SimpleSpiceDisplay
, qxl
);
636 qemu_bh_schedule(ssd
->gl_unblock_bh
);
639 case QXL_COOKIE_TYPE_IO
:
640 if (cookie
->io
== QXL_IO_MONITORS_CONFIG_ASYNC
) {
641 g_free(cookie
->u
.data
);
646 /* should never be called, used in qxl native mode only */
647 fprintf(stderr
, "%s: abort()\n", __func__
);
653 static void interface_set_client_capabilities(QXLInstance
*sin
,
654 uint8_t client_present
,
660 static int interface_client_monitors_config(QXLInstance
*sin
,
661 VDAgentMonitorsConfig
*mc
)
663 SimpleSpiceDisplay
*ssd
= container_of(sin
, SimpleSpiceDisplay
, qxl
);
667 if (!dpy_ui_info_supported(ssd
->dcl
.con
)) {
668 return 0; /* == not supported by guest */
675 memset(&info
, 0, sizeof(info
));
677 if (mc
->num_of_monitors
== 1) {
679 * New spice-server version which filters the list of monitors
680 * to only include those that belong to our display channel.
682 * single-head configuration (where filtering doesn't matter)
683 * takes this code path too.
685 info
.width
= mc
->monitors
[0].width
;
686 info
.height
= mc
->monitors
[0].height
;
689 * Old spice-server which gives us all monitors, so we have to
690 * figure ourself which entry we need. Array index is the
691 * channel_id, which is the qemu console index, see
692 * qemu_spice_add_display_interface().
694 head
= qemu_console_get_index(ssd
->dcl
.con
);
695 if (mc
->num_of_monitors
> head
) {
696 info
.width
= mc
->monitors
[head
].width
;
697 info
.height
= mc
->monitors
[head
].height
;
701 trace_qemu_spice_ui_info(ssd
->qxl
.id
, info
.width
, info
.height
);
702 dpy_set_ui_info(ssd
->dcl
.con
, &info
);
706 static const QXLInterface dpy_interface
= {
707 .base
.type
= SPICE_INTERFACE_QXL
,
708 .base
.description
= "qemu simple display",
709 .base
.major_version
= SPICE_INTERFACE_QXL_MAJOR
,
710 .base
.minor_version
= SPICE_INTERFACE_QXL_MINOR
,
712 .attache_worker
= interface_attach_worker
,
713 .set_compression_level
= interface_set_compression_level
,
714 #if SPICE_NEEDS_SET_MM_TIME
715 .set_mm_time
= interface_set_mm_time
,
717 .get_init_info
= interface_get_init_info
,
719 /* the callbacks below are called from spice server thread context */
720 .get_command
= interface_get_command
,
721 .req_cmd_notification
= interface_req_cmd_notification
,
722 .release_resource
= interface_release_resource
,
723 .get_cursor_command
= interface_get_cursor_command
,
724 .req_cursor_notification
= interface_req_cursor_notification
,
725 .notify_update
= interface_notify_update
,
726 .flush_resources
= interface_flush_resources
,
727 .async_complete
= interface_async_complete
,
728 .update_area_complete
= interface_update_area_complete
,
729 .set_client_capabilities
= interface_set_client_capabilities
,
730 .client_monitors_config
= interface_client_monitors_config
,
733 static void display_update(DisplayChangeListener
*dcl
,
734 int x
, int y
, int w
, int h
)
736 SimpleSpiceDisplay
*ssd
= container_of(dcl
, SimpleSpiceDisplay
, dcl
);
737 qemu_spice_display_update(ssd
, x
, y
, w
, h
);
740 static void display_switch(DisplayChangeListener
*dcl
,
741 DisplaySurface
*surface
)
743 SimpleSpiceDisplay
*ssd
= container_of(dcl
, SimpleSpiceDisplay
, dcl
);
744 qemu_spice_display_switch(ssd
, surface
);
747 static void display_refresh(DisplayChangeListener
*dcl
)
749 SimpleSpiceDisplay
*ssd
= container_of(dcl
, SimpleSpiceDisplay
, dcl
);
750 qemu_spice_display_refresh(ssd
);
753 static void display_mouse_set(DisplayChangeListener
*dcl
,
754 int x
, int y
, int on
)
756 SimpleSpiceDisplay
*ssd
= container_of(dcl
, SimpleSpiceDisplay
, dcl
);
758 qemu_mutex_lock(&ssd
->lock
);
761 g_free(ssd
->ptr_move
);
762 ssd
->ptr_move
= qemu_spice_create_cursor_update(ssd
, NULL
, on
);
763 qemu_mutex_unlock(&ssd
->lock
);
764 qemu_spice_wakeup(ssd
);
767 static void display_mouse_define(DisplayChangeListener
*dcl
,
770 SimpleSpiceDisplay
*ssd
= container_of(dcl
, SimpleSpiceDisplay
, dcl
);
772 qemu_mutex_lock(&ssd
->lock
);
774 cursor_put(ssd
->cursor
);
776 ssd
->hot_x
= c
->hot_x
;
777 ssd
->hot_y
= c
->hot_y
;
778 g_free(ssd
->ptr_move
);
779 ssd
->ptr_move
= NULL
;
780 g_free(ssd
->ptr_define
);
781 ssd
->ptr_define
= qemu_spice_create_cursor_update(ssd
, c
, 0);
782 qemu_mutex_unlock(&ssd
->lock
);
783 qemu_spice_wakeup(ssd
);
786 static const DisplayChangeListenerOps display_listener_ops
= {
788 .dpy_gfx_update
= display_update
,
789 .dpy_gfx_switch
= display_switch
,
790 .dpy_gfx_check_format
= qemu_pixman_check_format
,
791 .dpy_refresh
= display_refresh
,
792 .dpy_mouse_set
= display_mouse_set
,
793 .dpy_cursor_define
= display_mouse_define
,
798 static void qemu_spice_gl_monitor_config(SimpleSpiceDisplay
*ssd
,
799 int x
, int y
, int w
, int h
)
801 QXLMonitorsConfig
*config
;
804 config
= g_malloc0(sizeof(QXLMonitorsConfig
) + sizeof(QXLHead
));
806 config
->max_allowed
= 1;
807 config
->heads
[0].x
= x
;
808 config
->heads
[0].y
= y
;
809 config
->heads
[0].width
= w
;
810 config
->heads
[0].height
= h
;
811 cookie
= qxl_cookie_new(QXL_COOKIE_TYPE_IO
,
812 QXL_IO_MONITORS_CONFIG_ASYNC
);
813 cookie
->u
.data
= config
;
815 spice_qxl_monitors_config_async(&ssd
->qxl
,
821 static void qemu_spice_gl_block(SimpleSpiceDisplay
*ssd
, bool block
)
826 timeout
= qemu_clock_get_ms(QEMU_CLOCK_REALTIME
);
827 timeout
+= 1000; /* one sec */
828 timer_mod(ssd
->gl_unblock_timer
, timeout
);
830 timer_del(ssd
->gl_unblock_timer
);
832 graphic_hw_gl_block(ssd
->dcl
.con
, block
);
835 static void qemu_spice_gl_unblock_bh(void *opaque
)
837 SimpleSpiceDisplay
*ssd
= opaque
;
839 qemu_spice_gl_block(ssd
, false);
842 static void qemu_spice_gl_block_timer(void *opaque
)
844 warn_report("spice: no gl-draw-done within one second");
847 static void spice_gl_refresh(DisplayChangeListener
*dcl
)
849 SimpleSpiceDisplay
*ssd
= container_of(dcl
, SimpleSpiceDisplay
, dcl
);
852 if (!ssd
->ds
|| qemu_console_is_gl_blocked(ssd
->dcl
.con
)) {
856 graphic_hw_update(dcl
->con
);
857 if (ssd
->gl_updates
&& ssd
->have_surface
) {
858 qemu_spice_gl_block(ssd
, true);
859 cookie
= (uintptr_t)qxl_cookie_new(QXL_COOKIE_TYPE_GL_DRAW_DONE
, 0);
860 spice_qxl_gl_draw_async(&ssd
->qxl
, 0, 0,
861 surface_width(ssd
->ds
),
862 surface_height(ssd
->ds
),
868 static void spice_gl_update(DisplayChangeListener
*dcl
,
869 int x
, int y
, int w
, int h
)
871 SimpleSpiceDisplay
*ssd
= container_of(dcl
, SimpleSpiceDisplay
, dcl
);
873 surface_gl_update_texture(ssd
->gls
, ssd
->ds
, x
, y
, w
, h
);
877 static void spice_gl_switch(DisplayChangeListener
*dcl
,
878 struct DisplaySurface
*new_surface
)
880 SimpleSpiceDisplay
*ssd
= container_of(dcl
, SimpleSpiceDisplay
, dcl
);
881 EGLint stride
, fourcc
;
885 surface_gl_destroy_texture(ssd
->gls
, ssd
->ds
);
887 ssd
->ds
= new_surface
;
889 surface_gl_create_texture(ssd
->gls
, ssd
->ds
);
890 fd
= egl_get_fd_for_texture(ssd
->ds
->texture
,
894 surface_gl_destroy_texture(ssd
->gls
, ssd
->ds
);
898 trace_qemu_spice_gl_surface(ssd
->qxl
.id
,
899 surface_width(ssd
->ds
),
900 surface_height(ssd
->ds
),
903 /* note: spice server will close the fd */
904 spice_qxl_gl_scanout(&ssd
->qxl
, fd
,
905 surface_width(ssd
->ds
),
906 surface_height(ssd
->ds
),
907 stride
, fourcc
, false);
908 ssd
->have_surface
= true;
909 ssd
->have_scanout
= false;
911 qemu_spice_gl_monitor_config(ssd
, 0, 0,
912 surface_width(ssd
->ds
),
913 surface_height(ssd
->ds
));
917 static QEMUGLContext
qemu_spice_gl_create_context(DisplayChangeListener
*dcl
,
918 QEMUGLParams
*params
)
920 eglMakeCurrent(qemu_egl_display
, EGL_NO_SURFACE
, EGL_NO_SURFACE
,
922 return qemu_egl_create_context(dcl
, params
);
925 static void qemu_spice_gl_scanout_disable(DisplayChangeListener
*dcl
)
927 SimpleSpiceDisplay
*ssd
= container_of(dcl
, SimpleSpiceDisplay
, dcl
);
929 trace_qemu_spice_gl_scanout_disable(ssd
->qxl
.id
);
930 spice_qxl_gl_scanout(&ssd
->qxl
, -1, 0, 0, 0, 0, false);
931 qemu_spice_gl_monitor_config(ssd
, 0, 0, 0, 0);
932 ssd
->have_surface
= false;
933 ssd
->have_scanout
= false;
936 static void qemu_spice_gl_scanout_texture(DisplayChangeListener
*dcl
,
939 uint32_t backing_width
,
940 uint32_t backing_height
,
941 uint32_t x
, uint32_t y
,
942 uint32_t w
, uint32_t h
)
944 SimpleSpiceDisplay
*ssd
= container_of(dcl
, SimpleSpiceDisplay
, dcl
);
945 EGLint stride
= 0, fourcc
= 0;
949 fd
= egl_get_fd_for_texture(tex_id
, &stride
, &fourcc
, NULL
);
951 fprintf(stderr
, "%s: failed to get fd for texture\n", __func__
);
954 trace_qemu_spice_gl_scanout_texture(ssd
->qxl
.id
, w
, h
, fourcc
);
956 /* note: spice server will close the fd */
957 spice_qxl_gl_scanout(&ssd
->qxl
, fd
, backing_width
, backing_height
,
958 stride
, fourcc
, y_0_top
);
959 qemu_spice_gl_monitor_config(ssd
, x
, y
, w
, h
);
960 ssd
->have_surface
= false;
961 ssd
->have_scanout
= true;
964 static void qemu_spice_gl_scanout_dmabuf(DisplayChangeListener
*dcl
,
967 SimpleSpiceDisplay
*ssd
= container_of(dcl
, SimpleSpiceDisplay
, dcl
);
969 ssd
->guest_dmabuf
= dmabuf
;
970 ssd
->guest_dmabuf_refresh
= true;
972 ssd
->have_surface
= false;
973 ssd
->have_scanout
= true;
976 static void qemu_spice_gl_cursor_dmabuf(DisplayChangeListener
*dcl
,
977 QemuDmaBuf
*dmabuf
, bool have_hot
,
978 uint32_t hot_x
, uint32_t hot_y
)
980 SimpleSpiceDisplay
*ssd
= container_of(dcl
, SimpleSpiceDisplay
, dcl
);
982 ssd
->have_hot
= have_hot
;
986 trace_qemu_spice_gl_cursor(ssd
->qxl
.id
, dmabuf
!= NULL
, have_hot
);
988 egl_dmabuf_import_texture(dmabuf
);
989 if (!dmabuf
->texture
) {
992 egl_fb_setup_for_tex(&ssd
->cursor_fb
, dmabuf
->width
, dmabuf
->height
,
993 dmabuf
->texture
, false);
995 egl_fb_destroy(&ssd
->cursor_fb
);
999 static void qemu_spice_gl_cursor_position(DisplayChangeListener
*dcl
,
1000 uint32_t pos_x
, uint32_t pos_y
)
1002 SimpleSpiceDisplay
*ssd
= container_of(dcl
, SimpleSpiceDisplay
, dcl
);
1004 qemu_mutex_lock(&ssd
->lock
);
1007 qemu_mutex_unlock(&ssd
->lock
);
1010 static void qemu_spice_gl_release_dmabuf(DisplayChangeListener
*dcl
,
1013 SimpleSpiceDisplay
*ssd
= container_of(dcl
, SimpleSpiceDisplay
, dcl
);
1015 if (ssd
->guest_dmabuf
== dmabuf
) {
1016 ssd
->guest_dmabuf
= NULL
;
1017 ssd
->guest_dmabuf_refresh
= false;
1019 egl_dmabuf_release_texture(dmabuf
);
1022 static void qemu_spice_gl_update(DisplayChangeListener
*dcl
,
1023 uint32_t x
, uint32_t y
, uint32_t w
, uint32_t h
)
1025 SimpleSpiceDisplay
*ssd
= container_of(dcl
, SimpleSpiceDisplay
, dcl
);
1026 EGLint stride
= 0, fourcc
= 0;
1027 bool render_cursor
= false;
1028 bool y_0_top
= false; /* FIXME */
1032 if (!ssd
->have_scanout
) {
1036 if (ssd
->cursor_fb
.texture
) {
1037 render_cursor
= true;
1039 if (ssd
->render_cursor
!= render_cursor
) {
1040 ssd
->render_cursor
= render_cursor
;
1041 ssd
->guest_dmabuf_refresh
= true;
1042 egl_fb_destroy(&ssd
->blit_fb
);
1045 if (ssd
->guest_dmabuf_refresh
) {
1046 QemuDmaBuf
*dmabuf
= ssd
->guest_dmabuf
;
1047 if (render_cursor
) {
1048 egl_dmabuf_import_texture(dmabuf
);
1049 if (!dmabuf
->texture
) {
1053 /* source framebuffer */
1054 egl_fb_setup_for_tex(&ssd
->guest_fb
,
1055 dmabuf
->width
, dmabuf
->height
,
1056 dmabuf
->texture
, false);
1058 /* dest framebuffer */
1059 if (ssd
->blit_fb
.width
!= dmabuf
->width
||
1060 ssd
->blit_fb
.height
!= dmabuf
->height
) {
1061 trace_qemu_spice_gl_render_dmabuf(ssd
->qxl
.id
, dmabuf
->width
,
1063 egl_fb_destroy(&ssd
->blit_fb
);
1064 egl_fb_setup_new_tex(&ssd
->blit_fb
,
1065 dmabuf
->width
, dmabuf
->height
);
1066 fd
= egl_get_fd_for_texture(ssd
->blit_fb
.texture
,
1067 &stride
, &fourcc
, NULL
);
1068 spice_qxl_gl_scanout(&ssd
->qxl
, fd
,
1069 dmabuf
->width
, dmabuf
->height
,
1070 stride
, fourcc
, false);
1073 trace_qemu_spice_gl_forward_dmabuf(ssd
->qxl
.id
,
1074 dmabuf
->width
, dmabuf
->height
);
1075 /* note: spice server will close the fd, so hand over a dup */
1076 spice_qxl_gl_scanout(&ssd
->qxl
, dup(dmabuf
->fd
),
1077 dmabuf
->width
, dmabuf
->height
,
1078 dmabuf
->stride
, dmabuf
->fourcc
,
1081 qemu_spice_gl_monitor_config(ssd
, 0, 0, dmabuf
->width
, dmabuf
->height
);
1082 ssd
->guest_dmabuf_refresh
= false;
1085 if (render_cursor
) {
1087 qemu_mutex_lock(&ssd
->lock
);
1090 qemu_mutex_unlock(&ssd
->lock
);
1091 egl_texture_blit(ssd
->gls
, &ssd
->blit_fb
, &ssd
->guest_fb
,
1093 egl_texture_blend(ssd
->gls
, &ssd
->blit_fb
, &ssd
->cursor_fb
,
1094 !y_0_top
, x
, y
, 1.0, 1.0);
1098 trace_qemu_spice_gl_update(ssd
->qxl
.id
, w
, h
, x
, y
);
1099 qemu_spice_gl_block(ssd
, true);
1100 cookie
= (uintptr_t)qxl_cookie_new(QXL_COOKIE_TYPE_GL_DRAW_DONE
, 0);
1101 spice_qxl_gl_draw_async(&ssd
->qxl
, x
, y
, w
, h
, cookie
);
1104 static const DisplayChangeListenerOps display_listener_gl_ops
= {
1105 .dpy_name
= "spice-egl",
1106 .dpy_gfx_update
= spice_gl_update
,
1107 .dpy_gfx_switch
= spice_gl_switch
,
1108 .dpy_gfx_check_format
= console_gl_check_format
,
1109 .dpy_refresh
= spice_gl_refresh
,
1110 .dpy_mouse_set
= display_mouse_set
,
1111 .dpy_cursor_define
= display_mouse_define
,
1113 .dpy_gl_ctx_create
= qemu_spice_gl_create_context
,
1114 .dpy_gl_ctx_destroy
= qemu_egl_destroy_context
,
1115 .dpy_gl_ctx_make_current
= qemu_egl_make_context_current
,
1116 .dpy_gl_ctx_get_current
= qemu_egl_get_current_context
,
1118 .dpy_gl_scanout_disable
= qemu_spice_gl_scanout_disable
,
1119 .dpy_gl_scanout_texture
= qemu_spice_gl_scanout_texture
,
1120 .dpy_gl_scanout_dmabuf
= qemu_spice_gl_scanout_dmabuf
,
1121 .dpy_gl_cursor_dmabuf
= qemu_spice_gl_cursor_dmabuf
,
1122 .dpy_gl_cursor_position
= qemu_spice_gl_cursor_position
,
1123 .dpy_gl_release_dmabuf
= qemu_spice_gl_release_dmabuf
,
1124 .dpy_gl_update
= qemu_spice_gl_update
,
1127 #endif /* HAVE_SPICE_GL */
1129 static void qemu_spice_display_init_one(QemuConsole
*con
)
1131 SimpleSpiceDisplay
*ssd
= g_new0(SimpleSpiceDisplay
, 1);
1133 qemu_spice_display_init_common(ssd
);
1135 ssd
->dcl
.ops
= &display_listener_ops
;
1136 #ifdef HAVE_SPICE_GL
1138 ssd
->dcl
.ops
= &display_listener_gl_ops
;
1139 ssd
->gl_unblock_bh
= qemu_bh_new(qemu_spice_gl_unblock_bh
, ssd
);
1140 ssd
->gl_unblock_timer
= timer_new_ms(QEMU_CLOCK_REALTIME
,
1141 qemu_spice_gl_block_timer
, ssd
);
1142 ssd
->gls
= qemu_gl_init_shader();
1143 ssd
->have_surface
= false;
1144 ssd
->have_scanout
= false;
1149 ssd
->qxl
.base
.sif
= &dpy_interface
.base
;
1150 qemu_spice_add_display_interface(&ssd
->qxl
, con
);
1152 #if SPICE_SERVER_VERSION >= 0x000e02 /* release 0.14.2 */
1153 char device_address
[256] = "";
1154 if (qemu_spice_fill_device_address(con
, device_address
, 256)) {
1155 spice_qxl_set_device_info(&ssd
->qxl
,
1157 qemu_console_get_head(con
),
1162 qemu_spice_create_host_memslot(ssd
);
1164 register_displaychangelistener(&ssd
->dcl
);
1167 void qemu_spice_display_init(void)
1169 QemuOptsList
*olist
= qemu_find_opts("spice");
1170 QemuOpts
*opts
= QTAILQ_FIRST(&olist
->head
);
1171 QemuConsole
*spice_con
, *con
;
1175 str
= qemu_opt_get(opts
, "display");
1177 int head
= qemu_opt_get_number(opts
, "head", 0);
1180 spice_con
= qemu_console_lookup_by_device_name(str
, head
, &err
);
1182 error_report("Failed to lookup display/head");
1190 con
= qemu_console_lookup_by_index(i
);
1191 if (!con
|| !qemu_console_is_graphic(con
)) {
1194 if (qemu_spice_have_display_interface(con
)) {
1197 if (spice_con
!= NULL
&& spice_con
!= con
) {
1200 qemu_spice_display_init_one(con
);