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