Merge remote-tracking branch 'remotes/bonzini-gitlab/tags/for-upstream' into staging
[qemu/ar7.git] / ui / spice-display.c
blobd22781a23d06760cb84aefb17ee834ea9341efb7
1 /*
2  * Copyright (C) 2010 Red Hat, Inc.
3  *
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.
8  *
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.
13  *
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/>.
16  */
18 #include "qemu/osdep.h"
19 #include "ui/qemu-spice.h"
20 #include "qemu/timer.h"
21 #include "qemu/lockable.h"
22 #include "qemu/main-loop.h"
23 #include "qemu/option.h"
24 #include "qemu/queue.h"
25 #include "ui/console.h"
26 #include "trace.h"
28 #include "ui/spice-display.h"
30 bool spice_opengl;
32 int qemu_spice_rect_is_empty(const QXLRect* r)
34     return r->top == r->bottom || r->left == r->right;
37 void qemu_spice_rect_union(QXLRect *dest, const QXLRect *r)
39     if (qemu_spice_rect_is_empty(r)) {
40         return;
41     }
43     if (qemu_spice_rect_is_empty(dest)) {
44         *dest = *r;
45         return;
46     }
48     dest->top = MIN(dest->top, r->top);
49     dest->left = MIN(dest->left, r->left);
50     dest->bottom = MAX(dest->bottom, r->bottom);
51     dest->right = MAX(dest->right, r->right);
54 QXLCookie *qxl_cookie_new(int type, uint64_t io)
56     QXLCookie *cookie;
58     cookie = g_malloc0(sizeof(*cookie));
59     cookie->type = type;
60     cookie->io = io;
61     return cookie;
64 void qemu_spice_add_memslot(SimpleSpiceDisplay *ssd, QXLDevMemSlot *memslot,
65                             qxl_async_io async)
67     trace_qemu_spice_add_memslot(ssd->qxl.id, memslot->slot_id,
68                                 memslot->virt_start, memslot->virt_end,
69                                 async);
71     if (async != QXL_SYNC) {
72         spice_qxl_add_memslot_async(&ssd->qxl, memslot,
73                 (uintptr_t)qxl_cookie_new(QXL_COOKIE_TYPE_IO,
74                                           QXL_IO_MEMSLOT_ADD_ASYNC));
75     } else {
76         spice_qxl_add_memslot(&ssd->qxl, memslot);
77     }
80 void qemu_spice_del_memslot(SimpleSpiceDisplay *ssd, uint32_t gid, uint32_t sid)
82     trace_qemu_spice_del_memslot(ssd->qxl.id, gid, sid);
83     spice_qxl_del_memslot(&ssd->qxl, gid, sid);
86 void qemu_spice_create_primary_surface(SimpleSpiceDisplay *ssd, uint32_t id,
87                                        QXLDevSurfaceCreate *surface,
88                                        qxl_async_io async)
90     trace_qemu_spice_create_primary_surface(ssd->qxl.id, id, surface, async);
91     if (async != QXL_SYNC) {
92         spice_qxl_create_primary_surface_async(&ssd->qxl, id, surface,
93                 (uintptr_t)qxl_cookie_new(QXL_COOKIE_TYPE_IO,
94                                           QXL_IO_CREATE_PRIMARY_ASYNC));
95     } else {
96         spice_qxl_create_primary_surface(&ssd->qxl, id, surface);
97     }
100 void qemu_spice_destroy_primary_surface(SimpleSpiceDisplay *ssd,
101                                         uint32_t id, qxl_async_io async)
103     trace_qemu_spice_destroy_primary_surface(ssd->qxl.id, id, async);
104     if (async != QXL_SYNC) {
105         spice_qxl_destroy_primary_surface_async(&ssd->qxl, id,
106                 (uintptr_t)qxl_cookie_new(QXL_COOKIE_TYPE_IO,
107                                           QXL_IO_DESTROY_PRIMARY_ASYNC));
108     } else {
109         spice_qxl_destroy_primary_surface(&ssd->qxl, id);
110     }
113 void qemu_spice_wakeup(SimpleSpiceDisplay *ssd)
115     trace_qemu_spice_wakeup(ssd->qxl.id);
116     spice_qxl_wakeup(&ssd->qxl);
119 static void qemu_spice_create_one_update(SimpleSpiceDisplay *ssd,
120                                          QXLRect *rect)
122     SimpleSpiceUpdate *update;
123     QXLDrawable *drawable;
124     QXLImage *image;
125     QXLCommand *cmd;
126     int bw, bh;
127     struct timespec time_space;
128     pixman_image_t *dest;
130     trace_qemu_spice_create_update(
131            rect->left, rect->right,
132            rect->top, rect->bottom);
134     update   = g_malloc0(sizeof(*update));
135     drawable = &update->drawable;
136     image    = &update->image;
137     cmd      = &update->ext.cmd;
139     bw       = rect->right - rect->left;
140     bh       = rect->bottom - rect->top;
141     update->bitmap = g_malloc(bw * bh * 4);
143     drawable->bbox            = *rect;
144     drawable->clip.type       = SPICE_CLIP_TYPE_NONE;
145     drawable->effect          = QXL_EFFECT_OPAQUE;
146     drawable->release_info.id = (uintptr_t)(&update->ext);
147     drawable->type            = QXL_DRAW_COPY;
148     drawable->surfaces_dest[0] = -1;
149     drawable->surfaces_dest[1] = -1;
150     drawable->surfaces_dest[2] = -1;
151     clock_gettime(CLOCK_MONOTONIC, &time_space);
152     /* time in milliseconds from epoch. */
153     drawable->mm_time = time_space.tv_sec * 1000
154                       + time_space.tv_nsec / 1000 / 1000;
156     drawable->u.copy.rop_descriptor  = SPICE_ROPD_OP_PUT;
157     drawable->u.copy.src_bitmap      = (uintptr_t)image;
158     drawable->u.copy.src_area.right  = bw;
159     drawable->u.copy.src_area.bottom = bh;
161     QXL_SET_IMAGE_ID(image, QXL_IMAGE_GROUP_DEVICE, ssd->unique++);
162     image->descriptor.type   = SPICE_IMAGE_TYPE_BITMAP;
163     image->bitmap.flags      = QXL_BITMAP_DIRECT | QXL_BITMAP_TOP_DOWN;
164     image->bitmap.stride     = bw * 4;
165     image->descriptor.width  = image->bitmap.x = bw;
166     image->descriptor.height = image->bitmap.y = bh;
167     image->bitmap.data = (uintptr_t)(update->bitmap);
168     image->bitmap.palette = 0;
169     image->bitmap.format = SPICE_BITMAP_FMT_32BIT;
171     dest = pixman_image_create_bits(PIXMAN_LE_x8r8g8b8, bw, bh,
172                                     (void *)update->bitmap, bw * 4);
173     pixman_image_composite(PIXMAN_OP_SRC, ssd->surface, NULL, ssd->mirror,
174                            rect->left, rect->top, 0, 0,
175                            rect->left, rect->top, bw, bh);
176     pixman_image_composite(PIXMAN_OP_SRC, ssd->mirror, NULL, dest,
177                            rect->left, rect->top, 0, 0,
178                            0, 0, bw, bh);
179     pixman_image_unref(dest);
181     cmd->type = QXL_CMD_DRAW;
182     cmd->data = (uintptr_t)drawable;
184     QTAILQ_INSERT_TAIL(&ssd->updates, update, next);
187 static void qemu_spice_create_update(SimpleSpiceDisplay *ssd)
189     static const int blksize = 32;
190     int blocks = DIV_ROUND_UP(surface_width(ssd->ds), blksize);
191     int dirty_top[blocks];
192     int y, yoff1, yoff2, x, xoff, blk, bw;
193     int bpp = surface_bytes_per_pixel(ssd->ds);
194     uint8_t *guest, *mirror;
196     if (qemu_spice_rect_is_empty(&ssd->dirty)) {
197         return;
198     };
200     for (blk = 0; blk < blocks; blk++) {
201         dirty_top[blk] = -1;
202     }
204     guest = surface_data(ssd->ds);
205     mirror = (void *)pixman_image_get_data(ssd->mirror);
206     for (y = ssd->dirty.top; y < ssd->dirty.bottom; y++) {
207         yoff1 = y * surface_stride(ssd->ds);
208         yoff2 = y * pixman_image_get_stride(ssd->mirror);
209         for (x = ssd->dirty.left; x < ssd->dirty.right; x += blksize) {
210             xoff = x * bpp;
211             blk = x / blksize;
212             bw = MIN(blksize, ssd->dirty.right - x);
213             if (memcmp(guest + yoff1 + xoff,
214                        mirror + yoff2 + xoff,
215                        bw * bpp) == 0) {
216                 if (dirty_top[blk] != -1) {
217                     QXLRect update = {
218                         .top    = dirty_top[blk],
219                         .bottom = y,
220                         .left   = x,
221                         .right  = x + bw,
222                     };
223                     qemu_spice_create_one_update(ssd, &update);
224                     dirty_top[blk] = -1;
225                 }
226             } else {
227                 if (dirty_top[blk] == -1) {
228                     dirty_top[blk] = y;
229                 }
230             }
231         }
232     }
234     for (x = ssd->dirty.left; x < ssd->dirty.right; x += blksize) {
235         blk = x / blksize;
236         bw = MIN(blksize, ssd->dirty.right - x);
237         if (dirty_top[blk] != -1) {
238             QXLRect update = {
239                 .top    = dirty_top[blk],
240                 .bottom = ssd->dirty.bottom,
241                 .left   = x,
242                 .right  = x + bw,
243             };
244             qemu_spice_create_one_update(ssd, &update);
245             dirty_top[blk] = -1;
246         }
247     }
249     memset(&ssd->dirty, 0, sizeof(ssd->dirty));
252 static SimpleSpiceCursor*
253 qemu_spice_create_cursor_update(SimpleSpiceDisplay *ssd,
254                                 QEMUCursor *c,
255                                 int on)
257     size_t size = c ? c->width * c->height * 4 : 0;
258     SimpleSpiceCursor *update;
259     QXLCursorCmd *ccmd;
260     QXLCursor *cursor;
261     QXLCommand *cmd;
263     update   = g_malloc0(sizeof(*update) + size);
264     ccmd     = &update->cmd;
265     cursor   = &update->cursor;
266     cmd      = &update->ext.cmd;
268     if (c) {
269         ccmd->type = QXL_CURSOR_SET;
270         ccmd->u.set.position.x = ssd->ptr_x + ssd->hot_x;
271         ccmd->u.set.position.y = ssd->ptr_y + ssd->hot_y;
272         ccmd->u.set.visible    = true;
273         ccmd->u.set.shape      = (uintptr_t)cursor;
274         cursor->header.unique     = ssd->unique++;
275         cursor->header.type       = SPICE_CURSOR_TYPE_ALPHA;
276         cursor->header.width      = c->width;
277         cursor->header.height     = c->height;
278         cursor->header.hot_spot_x = c->hot_x;
279         cursor->header.hot_spot_y = c->hot_y;
280         cursor->data_size         = size;
281         cursor->chunk.data_size   = size;
282         memcpy(cursor->chunk.data, c->data, size);
283     } else if (!on) {
284         ccmd->type = QXL_CURSOR_HIDE;
285     } else {
286         ccmd->type = QXL_CURSOR_MOVE;
287         ccmd->u.position.x = ssd->ptr_x + ssd->hot_x;
288         ccmd->u.position.y = ssd->ptr_y + ssd->hot_y;
289     }
290     ccmd->release_info.id = (uintptr_t)(&update->ext);
292     cmd->type = QXL_CMD_CURSOR;
293     cmd->data = (uintptr_t)ccmd;
295     return update;
299  * Called from spice server thread context (via interface_release_resource)
300  * We do *not* hold the global qemu mutex here, so extra care is needed
301  * when calling qemu functions.  QEMU interfaces used:
302  *    - g_free (underlying glibc free is re-entrant).
303  */
304 void qemu_spice_destroy_update(SimpleSpiceDisplay *sdpy, SimpleSpiceUpdate *update)
306     g_free(update->bitmap);
307     g_free(update);
310 void qemu_spice_create_host_memslot(SimpleSpiceDisplay *ssd)
312     QXLDevMemSlot memslot;
314     memset(&memslot, 0, sizeof(memslot));
315     memslot.slot_group_id = MEMSLOT_GROUP_HOST;
316     memslot.virt_end = ~0;
317     qemu_spice_add_memslot(ssd, &memslot, QXL_SYNC);
320 void qemu_spice_create_host_primary(SimpleSpiceDisplay *ssd)
322     QXLDevSurfaceCreate surface;
323     uint64_t surface_size;
325     memset(&surface, 0, sizeof(surface));
327     surface_size = (uint64_t) surface_width(ssd->ds) *
328         surface_height(ssd->ds) * 4;
329     assert(surface_size > 0);
330     assert(surface_size < INT_MAX);
331     if (ssd->bufsize < surface_size) {
332         ssd->bufsize = surface_size;
333         g_free(ssd->buf);
334         ssd->buf = g_malloc(ssd->bufsize);
335     }
337     surface.format     = SPICE_SURFACE_FMT_32_xRGB;
338     surface.width      = surface_width(ssd->ds);
339     surface.height     = surface_height(ssd->ds);
340     surface.stride     = -surface.width * 4;
341     surface.mouse_mode = true;
342     surface.flags      = 0;
343     surface.type       = 0;
344     surface.mem        = (uintptr_t)ssd->buf;
345     surface.group_id   = MEMSLOT_GROUP_HOST;
347     qemu_spice_create_primary_surface(ssd, 0, &surface, QXL_SYNC);
350 void qemu_spice_destroy_host_primary(SimpleSpiceDisplay *ssd)
352     qemu_spice_destroy_primary_surface(ssd, 0, QXL_SYNC);
355 void qemu_spice_display_init_common(SimpleSpiceDisplay *ssd)
357     qemu_mutex_init(&ssd->lock);
358     QTAILQ_INIT(&ssd->updates);
359     ssd->mouse_x = -1;
360     ssd->mouse_y = -1;
361     if (ssd->num_surfaces == 0) {
362         ssd->num_surfaces = 1024;
363     }
366 /* display listener callbacks */
368 void qemu_spice_display_update(SimpleSpiceDisplay *ssd,
369                                int x, int y, int w, int h)
371     QXLRect update_area;
373     trace_qemu_spice_display_update(ssd->qxl.id, x, y, w, h);
374     update_area.left = x,
375     update_area.right = x + w;
376     update_area.top = y;
377     update_area.bottom = y + h;
379     if (qemu_spice_rect_is_empty(&ssd->dirty)) {
380         ssd->notify++;
381     }
382     qemu_spice_rect_union(&ssd->dirty, &update_area);
385 void qemu_spice_display_switch(SimpleSpiceDisplay *ssd,
386                                DisplaySurface *surface)
388     SimpleSpiceUpdate *update;
389     bool need_destroy;
391     if (ssd->surface &&
392         surface_width(surface) == pixman_image_get_width(ssd->surface) &&
393         surface_height(surface) == pixman_image_get_height(ssd->surface) &&
394         surface_format(surface) == pixman_image_get_format(ssd->surface)) {
395         /* no-resize fast path: just swap backing store */
396         trace_qemu_spice_display_surface(ssd->qxl.id,
397                                          surface_width(surface),
398                                          surface_height(surface),
399                                          true);
400         qemu_mutex_lock(&ssd->lock);
401         ssd->ds = surface;
402         pixman_image_unref(ssd->surface);
403         ssd->surface = pixman_image_ref(ssd->ds->image);
404         qemu_mutex_unlock(&ssd->lock);
405         qemu_spice_display_update(ssd, 0, 0,
406                                   surface_width(surface),
407                                   surface_height(surface));
408         return;
409     }
411     /* full mode switch */
412     trace_qemu_spice_display_surface(ssd->qxl.id,
413                                      surface_width(surface),
414                                      surface_height(surface),
415                                      false);
417     memset(&ssd->dirty, 0, sizeof(ssd->dirty));
418     if (ssd->surface) {
419         pixman_image_unref(ssd->surface);
420         ssd->surface = NULL;
421         pixman_image_unref(ssd->mirror);
422         ssd->mirror = NULL;
423     }
425     qemu_mutex_lock(&ssd->lock);
426     need_destroy = (ssd->ds != NULL);
427     ssd->ds = surface;
428     while ((update = QTAILQ_FIRST(&ssd->updates)) != NULL) {
429         QTAILQ_REMOVE(&ssd->updates, update, next);
430         qemu_spice_destroy_update(ssd, update);
431     }
432     qemu_mutex_unlock(&ssd->lock);
433     if (need_destroy) {
434         qemu_spice_destroy_host_primary(ssd);
435     }
436     if (ssd->ds) {
437         ssd->surface = pixman_image_ref(ssd->ds->image);
438         ssd->mirror  = qemu_pixman_mirror_create(ssd->ds->format,
439                                                  ssd->ds->image);
440         qemu_spice_create_host_primary(ssd);
441     }
443     memset(&ssd->dirty, 0, sizeof(ssd->dirty));
444     ssd->notify++;
446     qemu_mutex_lock(&ssd->lock);
447     if (ssd->cursor) {
448         g_free(ssd->ptr_define);
449         ssd->ptr_define = qemu_spice_create_cursor_update(ssd, ssd->cursor, 0);
450     }
451     qemu_mutex_unlock(&ssd->lock);
454 void qemu_spice_cursor_refresh_bh(void *opaque)
456     SimpleSpiceDisplay *ssd = opaque;
458     qemu_mutex_lock(&ssd->lock);
459     if (ssd->cursor) {
460         QEMUCursor *c = ssd->cursor;
461         assert(ssd->dcl.con);
462         cursor_get(c);
463         qemu_mutex_unlock(&ssd->lock);
464         dpy_cursor_define(ssd->dcl.con, c);
465         qemu_mutex_lock(&ssd->lock);
466         cursor_put(c);
467     }
469     if (ssd->mouse_x != -1 && ssd->mouse_y != -1) {
470         int x, y;
471         assert(ssd->dcl.con);
472         x = ssd->mouse_x;
473         y = ssd->mouse_y;
474         ssd->mouse_x = -1;
475         ssd->mouse_y = -1;
476         qemu_mutex_unlock(&ssd->lock);
477         dpy_mouse_set(ssd->dcl.con, x, y, 1);
478     } else {
479         qemu_mutex_unlock(&ssd->lock);
480     }
483 void qemu_spice_display_refresh(SimpleSpiceDisplay *ssd)
485     graphic_hw_update(ssd->dcl.con);
487     WITH_QEMU_LOCK_GUARD(&ssd->lock) {
488         if (QTAILQ_EMPTY(&ssd->updates) && ssd->ds) {
489             qemu_spice_create_update(ssd);
490             ssd->notify++;
491         }
492     }
494     trace_qemu_spice_display_refresh(ssd->qxl.id, ssd->notify);
495     if (ssd->notify) {
496         ssd->notify = 0;
497         qemu_spice_wakeup(ssd);
498     }
501 /* spice display interface callbacks */
503 static void interface_attach_worker(QXLInstance *sin, QXLWorker *qxl_worker)
505     /* nothing to do */
508 static void interface_set_compression_level(QXLInstance *sin, int level)
510     /* nothing to do */
513 #if SPICE_NEEDS_SET_MM_TIME
514 static void interface_set_mm_time(QXLInstance *sin, uint32_t mm_time)
516     /* nothing to do */
518 #endif
520 static void interface_get_init_info(QXLInstance *sin, QXLDevInitInfo *info)
522     SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
524     info->memslot_gen_bits = MEMSLOT_GENERATION_BITS;
525     info->memslot_id_bits  = MEMSLOT_SLOT_BITS;
526     info->num_memslots = NUM_MEMSLOTS;
527     info->num_memslots_groups = NUM_MEMSLOTS_GROUPS;
528     info->internal_groupslot_id = 0;
529     info->qxl_ram_size = 16 * 1024 * 1024;
530     info->n_surfaces = ssd->num_surfaces;
533 static int interface_get_command(QXLInstance *sin, QXLCommandExt *ext)
535     SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
536     SimpleSpiceUpdate *update;
537     int ret = false;
539     qemu_mutex_lock(&ssd->lock);
540     update = QTAILQ_FIRST(&ssd->updates);
541     if (update != NULL) {
542         QTAILQ_REMOVE(&ssd->updates, update, next);
543         *ext = update->ext;
544         ret = true;
545     }
546     qemu_mutex_unlock(&ssd->lock);
548     return ret;
551 static int interface_req_cmd_notification(QXLInstance *sin)
553     return 1;
556 static void interface_release_resource(QXLInstance *sin,
557                                        QXLReleaseInfoExt rext)
559     SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
560     SimpleSpiceUpdate *update;
561     SimpleSpiceCursor *cursor;
562     QXLCommandExt *ext;
564     ext = (void *)(intptr_t)(rext.info->id);
565     switch (ext->cmd.type) {
566     case QXL_CMD_DRAW:
567         update = container_of(ext, SimpleSpiceUpdate, ext);
568         qemu_spice_destroy_update(ssd, update);
569         break;
570     case QXL_CMD_CURSOR:
571         cursor = container_of(ext, SimpleSpiceCursor, ext);
572         g_free(cursor);
573         break;
574     default:
575         g_assert_not_reached();
576     }
579 static int interface_get_cursor_command(QXLInstance *sin, QXLCommandExt *ext)
581     SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
582     int ret;
584     QEMU_LOCK_GUARD(&ssd->lock);
585     if (ssd->ptr_define) {
586         *ext = ssd->ptr_define->ext;
587         ssd->ptr_define = NULL;
588         ret = true;
589     } else if (ssd->ptr_move) {
590         *ext = ssd->ptr_move->ext;
591         ssd->ptr_move = NULL;
592         ret = true;
593     } else {
594         ret = false;
595     }
596     return ret;
599 static int interface_req_cursor_notification(QXLInstance *sin)
601     return 1;
604 static void interface_notify_update(QXLInstance *sin, uint32_t update_id)
606     fprintf(stderr, "%s: abort()\n", __func__);
607     abort();
610 static int interface_flush_resources(QXLInstance *sin)
612     fprintf(stderr, "%s: abort()\n", __func__);
613     abort();
614     return 0;
617 static void interface_update_area_complete(QXLInstance *sin,
618         uint32_t surface_id,
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__);
623     abort();
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) {
632 #ifdef HAVE_SPICE_GL
633     case QXL_COOKIE_TYPE_GL_DRAW_DONE:
634     {
635         SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
636         qemu_bh_schedule(ssd->gl_unblock_bh);
637         break;
638     }
639     case QXL_COOKIE_TYPE_IO:
640         if (cookie->io == QXL_IO_MONITORS_CONFIG_ASYNC) {
641             g_free(cookie->u.data);
642         }
643         break;
644 #endif
645     default:
646         /* should never be called, used in qxl native mode only */
647         fprintf(stderr, "%s: abort()\n", __func__);
648         abort();
649     }
650     g_free(cookie);
653 static void interface_set_client_capabilities(QXLInstance *sin,
654                                               uint8_t client_present,
655                                               uint8_t caps[58])
657     /* nothing to do */
660 static int interface_client_monitors_config(QXLInstance *sin,
661                                             VDAgentMonitorsConfig *mc)
663     SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
664     QemuUIInfo info;
665     int head;
667     if (!dpy_ui_info_supported(ssd->dcl.con)) {
668         return 0; /* == not supported by guest */
669     }
671     if (!mc) {
672         return 1;
673     }
675     info = *dpy_get_ui_info(ssd->dcl.con);
677     head = qemu_console_get_index(ssd->dcl.con);
678     if (mc->num_of_monitors > head) {
679         info.width  = mc->monitors[head].width;
680         info.height = mc->monitors[head].height;
681 #if SPICE_SERVER_VERSION >= 0x000e04 /* release 0.14.4 */
682         if (mc->flags & VD_AGENT_CONFIG_MONITORS_FLAG_PHYSICAL_SIZE) {
683             VDAgentMonitorMM *mm = (void *)&mc->monitors[mc->num_of_monitors];
684             info.width_mm = mm[head].width;
685             info.height_mm = mm[head].height;
686         }
687 #endif
688     }
690     trace_qemu_spice_ui_info(ssd->qxl.id, info.width, info.height);
691     dpy_set_ui_info(ssd->dcl.con, &info);
692     return 1;
695 static const QXLInterface dpy_interface = {
696     .base.type               = SPICE_INTERFACE_QXL,
697     .base.description        = "qemu simple display",
698     .base.major_version      = SPICE_INTERFACE_QXL_MAJOR,
699     .base.minor_version      = SPICE_INTERFACE_QXL_MINOR,
701     .attache_worker          = interface_attach_worker,
702     .set_compression_level   = interface_set_compression_level,
703 #if SPICE_NEEDS_SET_MM_TIME
704     .set_mm_time             = interface_set_mm_time,
705 #endif
706     .get_init_info           = interface_get_init_info,
708     /* the callbacks below are called from spice server thread context */
709     .get_command             = interface_get_command,
710     .req_cmd_notification    = interface_req_cmd_notification,
711     .release_resource        = interface_release_resource,
712     .get_cursor_command      = interface_get_cursor_command,
713     .req_cursor_notification = interface_req_cursor_notification,
714     .notify_update           = interface_notify_update,
715     .flush_resources         = interface_flush_resources,
716     .async_complete          = interface_async_complete,
717     .update_area_complete    = interface_update_area_complete,
718     .set_client_capabilities = interface_set_client_capabilities,
719     .client_monitors_config  = interface_client_monitors_config,
722 static void display_update(DisplayChangeListener *dcl,
723                            int x, int y, int w, int h)
725     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
726     qemu_spice_display_update(ssd, x, y, w, h);
729 static void display_switch(DisplayChangeListener *dcl,
730                            DisplaySurface *surface)
732     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
733     qemu_spice_display_switch(ssd, surface);
736 static void display_refresh(DisplayChangeListener *dcl)
738     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
739     qemu_spice_display_refresh(ssd);
742 static void display_mouse_set(DisplayChangeListener *dcl,
743                               int x, int y, int on)
745     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
747     qemu_mutex_lock(&ssd->lock);
748     ssd->ptr_x = x;
749     ssd->ptr_y = y;
750     g_free(ssd->ptr_move);
751     ssd->ptr_move = qemu_spice_create_cursor_update(ssd, NULL, on);
752     qemu_mutex_unlock(&ssd->lock);
753     qemu_spice_wakeup(ssd);
756 static void display_mouse_define(DisplayChangeListener *dcl,
757                                  QEMUCursor *c)
759     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
761     qemu_mutex_lock(&ssd->lock);
762     cursor_get(c);
763     cursor_put(ssd->cursor);
764     ssd->cursor = c;
765     ssd->hot_x = c->hot_x;
766     ssd->hot_y = c->hot_y;
767     g_free(ssd->ptr_move);
768     ssd->ptr_move = NULL;
769     g_free(ssd->ptr_define);
770     ssd->ptr_define = qemu_spice_create_cursor_update(ssd, c, 0);
771     qemu_mutex_unlock(&ssd->lock);
772     qemu_spice_wakeup(ssd);
775 static const DisplayChangeListenerOps display_listener_ops = {
776     .dpy_name             = "spice",
777     .dpy_gfx_update       = display_update,
778     .dpy_gfx_switch       = display_switch,
779     .dpy_gfx_check_format = qemu_pixman_check_format,
780     .dpy_refresh          = display_refresh,
781     .dpy_mouse_set        = display_mouse_set,
782     .dpy_cursor_define    = display_mouse_define,
785 #ifdef HAVE_SPICE_GL
787 static void qemu_spice_gl_monitor_config(SimpleSpiceDisplay *ssd,
788                                          int x, int y, int w, int h)
790     QXLMonitorsConfig *config;
791     QXLCookie *cookie;
793     config = g_malloc0(sizeof(QXLMonitorsConfig) + sizeof(QXLHead));
794     config->count = 1;
795     config->max_allowed = 1;
796     config->heads[0].x = x;
797     config->heads[0].y = y;
798     config->heads[0].width = w;
799     config->heads[0].height = h;
800     cookie = qxl_cookie_new(QXL_COOKIE_TYPE_IO,
801                             QXL_IO_MONITORS_CONFIG_ASYNC);
802     cookie->u.data = config;
804     spice_qxl_monitors_config_async(&ssd->qxl,
805                                     (uintptr_t)config,
806                                     MEMSLOT_GROUP_HOST,
807                                     (uintptr_t)cookie);
810 static void qemu_spice_gl_block(SimpleSpiceDisplay *ssd, bool block)
812     uint64_t timeout;
814     if (block) {
815         timeout = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
816         timeout += 1000; /* one sec */
817         timer_mod(ssd->gl_unblock_timer, timeout);
818     } else {
819         timer_del(ssd->gl_unblock_timer);
820     }
821     graphic_hw_gl_block(ssd->dcl.con, block);
824 static void qemu_spice_gl_unblock_bh(void *opaque)
826     SimpleSpiceDisplay *ssd = opaque;
828     qemu_spice_gl_block(ssd, false);
829     graphic_hw_gl_flushed(ssd->dcl.con);
832 static void qemu_spice_gl_block_timer(void *opaque)
834     warn_report("spice: no gl-draw-done within one second");
837 static void spice_gl_refresh(DisplayChangeListener *dcl)
839     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
840     uint64_t cookie;
842     if (!ssd->ds || qemu_console_is_gl_blocked(ssd->dcl.con)) {
843         return;
844     }
846     graphic_hw_update(dcl->con);
847     if (ssd->gl_updates && ssd->have_surface) {
848         qemu_spice_gl_block(ssd, true);
849         glFlush();
850         cookie = (uintptr_t)qxl_cookie_new(QXL_COOKIE_TYPE_GL_DRAW_DONE, 0);
851         spice_qxl_gl_draw_async(&ssd->qxl, 0, 0,
852                                 surface_width(ssd->ds),
853                                 surface_height(ssd->ds),
854                                 cookie);
855         ssd->gl_updates = 0;
856     }
859 static void spice_gl_update(DisplayChangeListener *dcl,
860                             int x, int y, int w, int h)
862     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
864     surface_gl_update_texture(ssd->gls, ssd->ds, x, y, w, h);
865     ssd->gl_updates++;
868 static void spice_gl_switch(DisplayChangeListener *dcl,
869                             struct DisplaySurface *new_surface)
871     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
872     EGLint stride, fourcc;
873     int fd;
875     if (ssd->ds) {
876         surface_gl_destroy_texture(ssd->gls, ssd->ds);
877     }
878     ssd->ds = new_surface;
879     if (ssd->ds) {
880         surface_gl_create_texture(ssd->gls, ssd->ds);
881         fd = egl_get_fd_for_texture(ssd->ds->texture,
882                                     &stride, &fourcc,
883                                     NULL);
884         if (fd < 0) {
885             surface_gl_destroy_texture(ssd->gls, ssd->ds);
886             return;
887         }
889         trace_qemu_spice_gl_surface(ssd->qxl.id,
890                                     surface_width(ssd->ds),
891                                     surface_height(ssd->ds),
892                                     fourcc);
894         /* note: spice server will close the fd */
895         spice_qxl_gl_scanout(&ssd->qxl, fd,
896                              surface_width(ssd->ds),
897                              surface_height(ssd->ds),
898                              stride, fourcc, false);
899         ssd->have_surface = true;
900         ssd->have_scanout = false;
902         qemu_spice_gl_monitor_config(ssd, 0, 0,
903                                      surface_width(ssd->ds),
904                                      surface_height(ssd->ds));
905     }
908 static QEMUGLContext qemu_spice_gl_create_context(DisplayChangeListener *dcl,
909                                                   QEMUGLParams *params)
911     eglMakeCurrent(qemu_egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE,
912                    qemu_egl_rn_ctx);
913     return qemu_egl_create_context(dcl, params);
916 static void qemu_spice_gl_scanout_disable(DisplayChangeListener *dcl)
918     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
920     trace_qemu_spice_gl_scanout_disable(ssd->qxl.id);
921     spice_qxl_gl_scanout(&ssd->qxl, -1, 0, 0, 0, 0, false);
922     qemu_spice_gl_monitor_config(ssd, 0, 0, 0, 0);
923     ssd->have_surface = false;
924     ssd->have_scanout = false;
927 static void qemu_spice_gl_scanout_texture(DisplayChangeListener *dcl,
928                                           uint32_t tex_id,
929                                           bool y_0_top,
930                                           uint32_t backing_width,
931                                           uint32_t backing_height,
932                                           uint32_t x, uint32_t y,
933                                           uint32_t w, uint32_t h)
935     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
936     EGLint stride = 0, fourcc = 0;
937     int fd = -1;
939     assert(tex_id);
940     fd = egl_get_fd_for_texture(tex_id, &stride, &fourcc, NULL);
941     if (fd < 0) {
942         fprintf(stderr, "%s: failed to get fd for texture\n", __func__);
943         return;
944     }
945     trace_qemu_spice_gl_scanout_texture(ssd->qxl.id, w, h, fourcc);
947     /* note: spice server will close the fd */
948     spice_qxl_gl_scanout(&ssd->qxl, fd, backing_width, backing_height,
949                          stride, fourcc, y_0_top);
950     qemu_spice_gl_monitor_config(ssd, x, y, w, h);
951     ssd->have_surface = false;
952     ssd->have_scanout = true;
955 static void qemu_spice_gl_scanout_dmabuf(DisplayChangeListener *dcl,
956                                          QemuDmaBuf *dmabuf)
958     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
960     ssd->guest_dmabuf = dmabuf;
961     ssd->guest_dmabuf_refresh = true;
963     ssd->have_surface = false;
964     ssd->have_scanout = true;
967 static void qemu_spice_gl_cursor_dmabuf(DisplayChangeListener *dcl,
968                                         QemuDmaBuf *dmabuf, bool have_hot,
969                                         uint32_t hot_x, uint32_t hot_y)
971     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
973     ssd->have_hot = have_hot;
974     ssd->hot_x = hot_x;
975     ssd->hot_y = hot_y;
977     trace_qemu_spice_gl_cursor(ssd->qxl.id, dmabuf != NULL, have_hot);
978     if (dmabuf) {
979         egl_dmabuf_import_texture(dmabuf);
980         if (!dmabuf->texture) {
981             return;
982         }
983         egl_fb_setup_for_tex(&ssd->cursor_fb, dmabuf->width, dmabuf->height,
984                              dmabuf->texture, false);
985     } else {
986         egl_fb_destroy(&ssd->cursor_fb);
987     }
990 static void qemu_spice_gl_cursor_position(DisplayChangeListener *dcl,
991                                           uint32_t pos_x, uint32_t pos_y)
993     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
995     qemu_mutex_lock(&ssd->lock);
996     ssd->ptr_x = pos_x;
997     ssd->ptr_y = pos_y;
998     qemu_mutex_unlock(&ssd->lock);
1001 static void qemu_spice_gl_release_dmabuf(DisplayChangeListener *dcl,
1002                                          QemuDmaBuf *dmabuf)
1004     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
1006     if (ssd->guest_dmabuf == dmabuf) {
1007         ssd->guest_dmabuf = NULL;
1008         ssd->guest_dmabuf_refresh = false;
1009     }
1010     egl_dmabuf_release_texture(dmabuf);
1013 static void qemu_spice_gl_update(DisplayChangeListener *dcl,
1014                                  uint32_t x, uint32_t y, uint32_t w, uint32_t h)
1016     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
1017     EGLint stride = 0, fourcc = 0;
1018     bool render_cursor = false;
1019     bool y_0_top = false; /* FIXME */
1020     uint64_t cookie;
1021     int fd;
1023     if (!ssd->have_scanout) {
1024         return;
1025     }
1027     if (ssd->cursor_fb.texture) {
1028         render_cursor = true;
1029     }
1030     if (ssd->render_cursor != render_cursor) {
1031         ssd->render_cursor = render_cursor;
1032         ssd->guest_dmabuf_refresh = true;
1033         egl_fb_destroy(&ssd->blit_fb);
1034     }
1036     if (ssd->guest_dmabuf_refresh) {
1037         QemuDmaBuf *dmabuf = ssd->guest_dmabuf;
1038         if (render_cursor) {
1039             egl_dmabuf_import_texture(dmabuf);
1040             if (!dmabuf->texture) {
1041                 return;
1042             }
1044             /* source framebuffer */
1045             egl_fb_setup_for_tex(&ssd->guest_fb,
1046                                  dmabuf->width, dmabuf->height,
1047                                  dmabuf->texture, false);
1049             /* dest framebuffer */
1050             if (ssd->blit_fb.width  != dmabuf->width ||
1051                 ssd->blit_fb.height != dmabuf->height) {
1052                 trace_qemu_spice_gl_render_dmabuf(ssd->qxl.id, dmabuf->width,
1053                                                   dmabuf->height);
1054                 egl_fb_destroy(&ssd->blit_fb);
1055                 egl_fb_setup_new_tex(&ssd->blit_fb,
1056                                      dmabuf->width, dmabuf->height);
1057                 fd = egl_get_fd_for_texture(ssd->blit_fb.texture,
1058                                             &stride, &fourcc, NULL);
1059                 spice_qxl_gl_scanout(&ssd->qxl, fd,
1060                                      dmabuf->width, dmabuf->height,
1061                                      stride, fourcc, false);
1062             }
1063         } else {
1064             trace_qemu_spice_gl_forward_dmabuf(ssd->qxl.id,
1065                                                dmabuf->width, dmabuf->height);
1066             /* note: spice server will close the fd, so hand over a dup */
1067             spice_qxl_gl_scanout(&ssd->qxl, dup(dmabuf->fd),
1068                                  dmabuf->width, dmabuf->height,
1069                                  dmabuf->stride, dmabuf->fourcc,
1070                                  dmabuf->y0_top);
1071         }
1072         qemu_spice_gl_monitor_config(ssd, 0, 0, dmabuf->width, dmabuf->height);
1073         ssd->guest_dmabuf_refresh = false;
1074     }
1076     if (render_cursor) {
1077         int x, y;
1078         qemu_mutex_lock(&ssd->lock);
1079         x = ssd->ptr_x;
1080         y = ssd->ptr_y;
1081         qemu_mutex_unlock(&ssd->lock);
1082         egl_texture_blit(ssd->gls, &ssd->blit_fb, &ssd->guest_fb,
1083                          !y_0_top);
1084         egl_texture_blend(ssd->gls, &ssd->blit_fb, &ssd->cursor_fb,
1085                           !y_0_top, x, y, 1.0, 1.0);
1086         glFlush();
1087     }
1089     trace_qemu_spice_gl_update(ssd->qxl.id, w, h, x, y);
1090     qemu_spice_gl_block(ssd, true);
1091     glFlush();
1092     cookie = (uintptr_t)qxl_cookie_new(QXL_COOKIE_TYPE_GL_DRAW_DONE, 0);
1093     spice_qxl_gl_draw_async(&ssd->qxl, x, y, w, h, cookie);
1096 static const DisplayChangeListenerOps display_listener_gl_ops = {
1097     .dpy_name                = "spice-egl",
1098     .dpy_gfx_update          = spice_gl_update,
1099     .dpy_gfx_switch          = spice_gl_switch,
1100     .dpy_gfx_check_format    = console_gl_check_format,
1101     .dpy_refresh             = spice_gl_refresh,
1102     .dpy_mouse_set           = display_mouse_set,
1103     .dpy_cursor_define       = display_mouse_define,
1105     .dpy_gl_ctx_create       = qemu_spice_gl_create_context,
1106     .dpy_gl_ctx_destroy      = qemu_egl_destroy_context,
1107     .dpy_gl_ctx_make_current = qemu_egl_make_context_current,
1109     .dpy_gl_scanout_disable  = qemu_spice_gl_scanout_disable,
1110     .dpy_gl_scanout_texture  = qemu_spice_gl_scanout_texture,
1111     .dpy_gl_scanout_dmabuf   = qemu_spice_gl_scanout_dmabuf,
1112     .dpy_gl_cursor_dmabuf    = qemu_spice_gl_cursor_dmabuf,
1113     .dpy_gl_cursor_position  = qemu_spice_gl_cursor_position,
1114     .dpy_gl_release_dmabuf   = qemu_spice_gl_release_dmabuf,
1115     .dpy_gl_update           = qemu_spice_gl_update,
1118 #endif /* HAVE_SPICE_GL */
1120 static void qemu_spice_display_init_one(QemuConsole *con)
1122     SimpleSpiceDisplay *ssd = g_new0(SimpleSpiceDisplay, 1);
1124     qemu_spice_display_init_common(ssd);
1126     ssd->dcl.ops = &display_listener_ops;
1127 #ifdef HAVE_SPICE_GL
1128     if (spice_opengl) {
1129         ssd->dcl.ops = &display_listener_gl_ops;
1130         ssd->gl_unblock_bh = qemu_bh_new(qemu_spice_gl_unblock_bh, ssd);
1131         ssd->gl_unblock_timer = timer_new_ms(QEMU_CLOCK_REALTIME,
1132                                              qemu_spice_gl_block_timer, ssd);
1133         ssd->gls = qemu_gl_init_shader();
1134         ssd->have_surface = false;
1135         ssd->have_scanout = false;
1136     }
1137 #endif
1138     ssd->dcl.con = con;
1140     ssd->qxl.base.sif = &dpy_interface.base;
1141     qemu_spice_add_display_interface(&ssd->qxl, con);
1143 #if SPICE_SERVER_VERSION >= 0x000e02 /* release 0.14.2 */
1144     char device_address[256] = "";
1145     if (qemu_spice_fill_device_address(con, device_address, 256)) {
1146         spice_qxl_set_device_info(&ssd->qxl,
1147                                   device_address,
1148                                   qemu_console_get_head(con),
1149                                   1);
1150     }
1151 #endif
1153     qemu_spice_create_host_memslot(ssd);
1155     register_displaychangelistener(&ssd->dcl);
1158 void qemu_spice_display_init(void)
1160     QemuOptsList *olist = qemu_find_opts("spice");
1161     QemuOpts *opts = QTAILQ_FIRST(&olist->head);
1162     QemuConsole *spice_con, *con;
1163     const char *str;
1164     int i;
1166     str = qemu_opt_get(opts, "display");
1167     if (str) {
1168         int head = qemu_opt_get_number(opts, "head", 0);
1169         Error *err = NULL;
1171         spice_con = qemu_console_lookup_by_device_name(str, head, &err);
1172         if (err) {
1173             error_report("Failed to lookup display/head");
1174             exit(1);
1175         }
1176     } else {
1177         spice_con = NULL;
1178     }
1180     for (i = 0;; i++) {
1181         con = qemu_console_lookup_by_index(i);
1182         if (!con || !qemu_console_is_graphic(con)) {
1183             break;
1184         }
1185         if (qemu_spice_have_display_interface(con)) {
1186             continue;
1187         }
1188         if (spice_con != NULL && spice_con != con) {
1189             continue;
1190         }
1191         qemu_spice_display_init_one(con);
1192     }
1194     qemu_spice_display_init_done();