![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to spice-display.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / ui|
Return to spice-display.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / ui |
1.1 root 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: */
17:
18: #include "qemu-common.h"
19: #include "qemu-spice.h"
20: #include "qemu-timer.h"
21: #include "qemu-queue.h"
22: #include "monitor.h"
23: #include "console.h"
24: #include "sysemu.h"
25:
26: #include "spice-display.h"
27:
28: static int debug = 0;
29:
30: static void GCC_FMT_ATTR(2, 3) dprint(int level, const char *fmt, ...)
31: {
32: va_list args;
33:
34: if (level <= debug) {
35: va_start(args, fmt);
36: vfprintf(stderr, fmt, args);
37: va_end(args);
38: }
39: }
40:
41: int qemu_spice_rect_is_empty(const QXLRect* r)
42: {
43: return r->top == r->bottom || r->left == r->right;
44: }
45:
46: void qemu_spice_rect_union(QXLRect *dest, const QXLRect *r)
47: {
48: if (qemu_spice_rect_is_empty(r)) {
49: return;
50: }
51:
52: if (qemu_spice_rect_is_empty(dest)) {
53: *dest = *r;
54: return;
55: }
56:
57: dest->top = MIN(dest->top, r->top);
58: dest->left = MIN(dest->left, r->left);
59: dest->bottom = MAX(dest->bottom, r->bottom);
60: dest->right = MAX(dest->right, r->right);
61: }
62:
1.1.1.3 ! root 63: void qemu_spice_add_memslot(SimpleSpiceDisplay *ssd, QXLDevMemSlot *memslot,
! 64: qxl_async_io async)
! 65: {
! 66: if (async != QXL_SYNC) {
! 67: #if SPICE_INTERFACE_QXL_MINOR >= 1
! 68: spice_qxl_add_memslot_async(&ssd->qxl, memslot, 0);
! 69: #else
! 70: abort();
! 71: #endif
! 72: } else {
! 73: ssd->worker->add_memslot(ssd->worker, memslot);
! 74: }
! 75: }
! 76:
! 77: void qemu_spice_del_memslot(SimpleSpiceDisplay *ssd, uint32_t gid, uint32_t sid)
! 78: {
! 79: ssd->worker->del_memslot(ssd->worker, gid, sid);
! 80: }
! 81:
! 82: void qemu_spice_create_primary_surface(SimpleSpiceDisplay *ssd, uint32_t id,
! 83: QXLDevSurfaceCreate *surface,
! 84: qxl_async_io async)
! 85: {
! 86: if (async != QXL_SYNC) {
! 87: #if SPICE_INTERFACE_QXL_MINOR >= 1
! 88: spice_qxl_create_primary_surface_async(&ssd->qxl, id, surface, 0);
! 89: #else
! 90: abort();
! 91: #endif
! 92: } else {
! 93: ssd->worker->create_primary_surface(ssd->worker, id, surface);
! 94: }
! 95: }
! 96:
! 97:
! 98: void qemu_spice_destroy_primary_surface(SimpleSpiceDisplay *ssd,
! 99: uint32_t id, qxl_async_io async)
! 100: {
! 101: if (async != QXL_SYNC) {
! 102: #if SPICE_INTERFACE_QXL_MINOR >= 1
! 103: spice_qxl_destroy_primary_surface_async(&ssd->qxl, id, 0);
! 104: #else
! 105: abort();
! 106: #endif
! 107: } else {
! 108: ssd->worker->destroy_primary_surface(ssd->worker, id);
! 109: }
! 110: }
! 111:
! 112: void qemu_spice_wakeup(SimpleSpiceDisplay *ssd)
! 113: {
! 114: ssd->worker->wakeup(ssd->worker);
! 115: }
! 116:
! 117: void qemu_spice_start(SimpleSpiceDisplay *ssd)
! 118: {
! 119: ssd->worker->start(ssd->worker);
! 120: }
! 121:
! 122: void qemu_spice_stop(SimpleSpiceDisplay *ssd)
! 123: {
! 124: ssd->worker->stop(ssd->worker);
! 125: }
! 126:
1.1.1.2 root 127: static SimpleSpiceUpdate *qemu_spice_create_update(SimpleSpiceDisplay *ssd)
1.1 root 128: {
129: SimpleSpiceUpdate *update;
130: QXLDrawable *drawable;
131: QXLImage *image;
132: QXLCommand *cmd;
133: uint8_t *src, *dst;
134: int by, bw, bh;
1.1.1.2 root 135: struct timespec time_space;
1.1 root 136:
137: if (qemu_spice_rect_is_empty(&ssd->dirty)) {
138: return NULL;
139: };
140:
141: dprint(2, "%s: lr %d -> %d, tb -> %d -> %d\n", __FUNCTION__,
142: ssd->dirty.left, ssd->dirty.right,
143: ssd->dirty.top, ssd->dirty.bottom);
144:
1.1.1.3 ! root 145: update = g_malloc0(sizeof(*update));
1.1 root 146: drawable = &update->drawable;
147: image = &update->image;
148: cmd = &update->ext.cmd;
149:
150: bw = ssd->dirty.right - ssd->dirty.left;
151: bh = ssd->dirty.bottom - ssd->dirty.top;
1.1.1.3 ! root 152: update->bitmap = g_malloc(bw * bh * 4);
1.1 root 153:
154: drawable->bbox = ssd->dirty;
155: drawable->clip.type = SPICE_CLIP_TYPE_NONE;
156: drawable->effect = QXL_EFFECT_OPAQUE;
157: drawable->release_info.id = (intptr_t)update;
158: drawable->type = QXL_DRAW_COPY;
159: drawable->surfaces_dest[0] = -1;
160: drawable->surfaces_dest[1] = -1;
161: drawable->surfaces_dest[2] = -1;
1.1.1.2 root 162: clock_gettime(CLOCK_MONOTONIC, &time_space);
163: /* time in milliseconds from epoch. */
164: drawable->mm_time = time_space.tv_sec * 1000
165: + time_space.tv_nsec / 1000 / 1000;
1.1 root 166:
167: drawable->u.copy.rop_descriptor = SPICE_ROPD_OP_PUT;
168: drawable->u.copy.src_bitmap = (intptr_t)image;
169: drawable->u.copy.src_area.right = bw;
170: drawable->u.copy.src_area.bottom = bh;
171:
172: QXL_SET_IMAGE_ID(image, QXL_IMAGE_GROUP_DEVICE, ssd->unique++);
173: image->descriptor.type = SPICE_IMAGE_TYPE_BITMAP;
174: image->bitmap.flags = QXL_BITMAP_DIRECT | QXL_BITMAP_TOP_DOWN;
175: image->bitmap.stride = bw * 4;
176: image->descriptor.width = image->bitmap.x = bw;
177: image->descriptor.height = image->bitmap.y = bh;
178: image->bitmap.data = (intptr_t)(update->bitmap);
179: image->bitmap.palette = 0;
180: image->bitmap.format = SPICE_BITMAP_FMT_32BIT;
181:
182: if (ssd->conv == NULL) {
183: PixelFormat dst = qemu_default_pixelformat(32);
184: ssd->conv = qemu_pf_conv_get(&dst, &ssd->ds->surface->pf);
185: assert(ssd->conv);
186: }
187:
188: src = ds_get_data(ssd->ds) +
189: ssd->dirty.top * ds_get_linesize(ssd->ds) +
190: ssd->dirty.left * ds_get_bytes_per_pixel(ssd->ds);
191: dst = update->bitmap;
192: for (by = 0; by < bh; by++) {
193: qemu_pf_conv_run(ssd->conv, dst, src, bw);
194: src += ds_get_linesize(ssd->ds);
195: dst += image->bitmap.stride;
196: }
197:
198: cmd->type = QXL_CMD_DRAW;
199: cmd->data = (intptr_t)drawable;
200:
201: memset(&ssd->dirty, 0, sizeof(ssd->dirty));
202: return update;
203: }
204:
205: /*
206: * Called from spice server thread context (via interface_release_ressource)
207: * We do *not* hold the global qemu mutex here, so extra care is needed
208: * when calling qemu functions. Qemu interfaces used:
1.1.1.3 ! root 209: * - g_free (underlying glibc free is re-entrant).
1.1 root 210: */
211: void qemu_spice_destroy_update(SimpleSpiceDisplay *sdpy, SimpleSpiceUpdate *update)
212: {
1.1.1.3 ! root 213: g_free(update->bitmap);
! 214: g_free(update);
1.1 root 215: }
216:
217: void qemu_spice_create_host_memslot(SimpleSpiceDisplay *ssd)
218: {
219: QXLDevMemSlot memslot;
220:
221: dprint(1, "%s:\n", __FUNCTION__);
222:
223: memset(&memslot, 0, sizeof(memslot));
224: memslot.slot_group_id = MEMSLOT_GROUP_HOST;
225: memslot.virt_end = ~0;
1.1.1.3 ! root 226: qemu_spice_add_memslot(ssd, &memslot, QXL_SYNC);
1.1 root 227: }
228:
229: void qemu_spice_create_host_primary(SimpleSpiceDisplay *ssd)
230: {
231: QXLDevSurfaceCreate surface;
232:
233: dprint(1, "%s: %dx%d\n", __FUNCTION__,
234: ds_get_width(ssd->ds), ds_get_height(ssd->ds));
235:
236: surface.format = SPICE_SURFACE_FMT_32_xRGB;
237: surface.width = ds_get_width(ssd->ds);
238: surface.height = ds_get_height(ssd->ds);
239: surface.stride = -surface.width * 4;
240: surface.mouse_mode = true;
241: surface.flags = 0;
242: surface.type = 0;
243: surface.mem = (intptr_t)ssd->buf;
244: surface.group_id = MEMSLOT_GROUP_HOST;
245:
1.1.1.3 ! root 246: qemu_spice_create_primary_surface(ssd, 0, &surface, QXL_SYNC);
1.1 root 247: }
248:
249: void qemu_spice_destroy_host_primary(SimpleSpiceDisplay *ssd)
250: {
251: dprint(1, "%s:\n", __FUNCTION__);
252:
1.1.1.3 ! root 253: qemu_spice_destroy_primary_surface(ssd, 0, QXL_SYNC);
1.1 root 254: }
255:
1.1.1.3 ! root 256: void qemu_spice_vm_change_state_handler(void *opaque, int running,
! 257: RunState state)
1.1 root 258: {
259: SimpleSpiceDisplay *ssd = opaque;
260:
261: if (running) {
1.1.1.3 ! root 262: ssd->running = true;
! 263: qemu_spice_start(ssd);
1.1 root 264: } else {
1.1.1.3 ! root 265: qemu_spice_stop(ssd);
! 266: ssd->running = false;
1.1 root 267: }
1.1.1.3 ! root 268: }
! 269:
! 270: void qemu_spice_display_init_common(SimpleSpiceDisplay *ssd, DisplayState *ds)
! 271: {
! 272: ssd->ds = ds;
! 273: qemu_mutex_init(&ssd->lock);
! 274: ssd->mouse_x = -1;
! 275: ssd->mouse_y = -1;
! 276: ssd->bufsize = (16 * 1024 * 1024);
! 277: ssd->buf = g_malloc(ssd->bufsize);
1.1 root 278: }
279:
280: /* display listener callbacks */
281:
282: void qemu_spice_display_update(SimpleSpiceDisplay *ssd,
283: int x, int y, int w, int h)
284: {
285: QXLRect update_area;
286:
287: dprint(2, "%s: x %d y %d w %d h %d\n", __FUNCTION__, x, y, w, h);
288: update_area.left = x,
289: update_area.right = x + w;
290: update_area.top = y;
291: update_area.bottom = y + h;
292:
293: if (qemu_spice_rect_is_empty(&ssd->dirty)) {
294: ssd->notify++;
295: }
296: qemu_spice_rect_union(&ssd->dirty, &update_area);
297: }
298:
299: void qemu_spice_display_resize(SimpleSpiceDisplay *ssd)
300: {
301: dprint(1, "%s:\n", __FUNCTION__);
302:
303: memset(&ssd->dirty, 0, sizeof(ssd->dirty));
304: qemu_pf_conv_put(ssd->conv);
305: ssd->conv = NULL;
306:
1.1.1.2 root 307: qemu_mutex_lock(&ssd->lock);
308: if (ssd->update != NULL) {
309: qemu_spice_destroy_update(ssd, ssd->update);
310: ssd->update = NULL;
311: }
312: qemu_mutex_unlock(&ssd->lock);
1.1 root 313: qemu_spice_destroy_host_primary(ssd);
314: qemu_spice_create_host_primary(ssd);
315:
316: memset(&ssd->dirty, 0, sizeof(ssd->dirty));
317: ssd->notify++;
318: }
319:
320: void qemu_spice_display_refresh(SimpleSpiceDisplay *ssd)
321: {
322: dprint(3, "%s:\n", __FUNCTION__);
323: vga_hw_update();
1.1.1.2 root 324:
325: qemu_mutex_lock(&ssd->lock);
326: if (ssd->update == NULL) {
327: ssd->update = qemu_spice_create_update(ssd);
328: ssd->notify++;
329: }
330: if (ssd->cursor) {
331: ssd->ds->cursor_define(ssd->cursor);
332: cursor_put(ssd->cursor);
333: ssd->cursor = NULL;
334: }
335: if (ssd->mouse_x != -1 && ssd->mouse_y != -1) {
336: ssd->ds->mouse_set(ssd->mouse_x, ssd->mouse_y, 1);
337: ssd->mouse_x = -1;
338: ssd->mouse_y = -1;
339: }
340: qemu_mutex_unlock(&ssd->lock);
341:
1.1 root 342: if (ssd->notify) {
343: ssd->notify = 0;
1.1.1.3 ! root 344: qemu_spice_wakeup(ssd);
1.1 root 345: dprint(2, "%s: notify\n", __FUNCTION__);
346: }
347: }
348:
349: /* spice display interface callbacks */
350:
351: static void interface_attach_worker(QXLInstance *sin, QXLWorker *qxl_worker)
352: {
353: SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
354:
355: dprint(1, "%s:\n", __FUNCTION__);
356: ssd->worker = qxl_worker;
357: }
358:
359: static void interface_set_compression_level(QXLInstance *sin, int level)
360: {
361: dprint(1, "%s:\n", __FUNCTION__);
362: /* nothing to do */
363: }
364:
365: static void interface_set_mm_time(QXLInstance *sin, uint32_t mm_time)
366: {
367: dprint(3, "%s:\n", __FUNCTION__);
368: /* nothing to do */
369: }
370:
371: static void interface_get_init_info(QXLInstance *sin, QXLDevInitInfo *info)
372: {
373: SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
374:
375: info->memslot_gen_bits = MEMSLOT_GENERATION_BITS;
376: info->memslot_id_bits = MEMSLOT_SLOT_BITS;
377: info->num_memslots = NUM_MEMSLOTS;
378: info->num_memslots_groups = NUM_MEMSLOTS_GROUPS;
379: info->internal_groupslot_id = 0;
380: info->qxl_ram_size = ssd->bufsize;
381: info->n_surfaces = NUM_SURFACES;
382: }
383:
384: static int interface_get_command(QXLInstance *sin, struct QXLCommandExt *ext)
385: {
386: SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
387: SimpleSpiceUpdate *update;
1.1.1.2 root 388: int ret = false;
1.1 root 389:
390: dprint(3, "%s:\n", __FUNCTION__);
1.1.1.2 root 391:
392: qemu_mutex_lock(&ssd->lock);
393: if (ssd->update != NULL) {
394: update = ssd->update;
395: ssd->update = NULL;
396: *ext = update->ext;
397: ret = true;
1.1 root 398: }
1.1.1.2 root 399: qemu_mutex_unlock(&ssd->lock);
400:
401: return ret;
1.1 root 402: }
403:
404: static int interface_req_cmd_notification(QXLInstance *sin)
405: {
406: dprint(1, "%s:\n", __FUNCTION__);
407: return 1;
408: }
409:
410: static void interface_release_resource(QXLInstance *sin,
411: struct QXLReleaseInfoExt ext)
412: {
413: SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
414: uintptr_t id;
415:
416: dprint(2, "%s:\n", __FUNCTION__);
417: id = ext.info->id;
418: qemu_spice_destroy_update(ssd, (void*)id);
419: }
420:
421: static int interface_get_cursor_command(QXLInstance *sin, struct QXLCommandExt *ext)
422: {
423: dprint(3, "%s:\n", __FUNCTION__);
424: return false;
425: }
426:
427: static int interface_req_cursor_notification(QXLInstance *sin)
428: {
429: dprint(1, "%s:\n", __FUNCTION__);
430: return 1;
431: }
432:
433: static void interface_notify_update(QXLInstance *sin, uint32_t update_id)
434: {
435: fprintf(stderr, "%s: abort()\n", __FUNCTION__);
436: abort();
437: }
438:
439: static int interface_flush_resources(QXLInstance *sin)
440: {
441: fprintf(stderr, "%s: abort()\n", __FUNCTION__);
442: abort();
443: return 0;
444: }
445:
446: static const QXLInterface dpy_interface = {
447: .base.type = SPICE_INTERFACE_QXL,
448: .base.description = "qemu simple display",
449: .base.major_version = SPICE_INTERFACE_QXL_MAJOR,
450: .base.minor_version = SPICE_INTERFACE_QXL_MINOR,
451:
452: .attache_worker = interface_attach_worker,
453: .set_compression_level = interface_set_compression_level,
454: .set_mm_time = interface_set_mm_time,
455: .get_init_info = interface_get_init_info,
456:
457: /* the callbacks below are called from spice server thread context */
458: .get_command = interface_get_command,
459: .req_cmd_notification = interface_req_cmd_notification,
460: .release_resource = interface_release_resource,
461: .get_cursor_command = interface_get_cursor_command,
462: .req_cursor_notification = interface_req_cursor_notification,
463: .notify_update = interface_notify_update,
464: .flush_resources = interface_flush_resources,
465: };
466:
467: static SimpleSpiceDisplay sdpy;
468:
469: static void display_update(struct DisplayState *ds, int x, int y, int w, int h)
470: {
471: qemu_spice_display_update(&sdpy, x, y, w, h);
472: }
473:
474: static void display_resize(struct DisplayState *ds)
475: {
476: qemu_spice_display_resize(&sdpy);
477: }
478:
479: static void display_refresh(struct DisplayState *ds)
480: {
481: qemu_spice_display_refresh(&sdpy);
482: }
483:
484: static DisplayChangeListener display_listener = {
485: .dpy_update = display_update,
486: .dpy_resize = display_resize,
487: .dpy_refresh = display_refresh,
488: };
489:
490: void qemu_spice_display_init(DisplayState *ds)
491: {
492: assert(sdpy.ds == NULL);
1.1.1.3 ! root 493: qemu_spice_display_init_common(&sdpy, ds);
1.1 root 494: register_displaychangelistener(ds, &display_listener);
495:
496: sdpy.qxl.base.sif = &dpy_interface.base;
497: qemu_spice_add_interface(&sdpy.qxl.base);
498: assert(sdpy.worker);
499:
500: qemu_add_vm_change_state_handler(qemu_spice_vm_change_state_handler, &sdpy);
501: qemu_spice_create_host_memslot(&sdpy);
502: qemu_spice_create_host_primary(&sdpy);
503: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.