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/>.
20 #include "qemu-common.h"
21 #include "qemu-spice.h"
22 #include "qemu-timer.h"
23 #include "qemu-queue.h"
28 #include "spice-display.h"
32 static void __attribute__((format(printf
,2,3)))
33 dprint(int level
, const char *fmt
, ...)
39 vfprintf(stderr
, fmt
, args
);
44 int qemu_spice_rect_is_empty(const QXLRect
* r
)
46 return r
->top
== r
->bottom
|| r
->left
== r
->right
;
49 void qemu_spice_rect_union(QXLRect
*dest
, const QXLRect
*r
)
51 if (qemu_spice_rect_is_empty(r
)) {
55 if (qemu_spice_rect_is_empty(dest
)) {
60 dest
->top
= MIN(dest
->top
, r
->top
);
61 dest
->left
= MIN(dest
->left
, r
->left
);
62 dest
->bottom
= MAX(dest
->bottom
, r
->bottom
);
63 dest
->right
= MAX(dest
->right
, r
->right
);
67 * Called from spice server thread context (via interface_get_command).
68 * We do *not* hold the global qemu mutex here, so extra care is needed
69 * when calling qemu functions. Qemu interfaces used:
70 * - pflib (is re-entrant).
71 * - qemu_malloc (underlying glibc malloc is re-entrant).
73 SimpleSpiceUpdate
*qemu_spice_create_update(SimpleSpiceDisplay
*ssd
)
75 SimpleSpiceUpdate
*update
;
76 QXLDrawable
*drawable
;
82 if (qemu_spice_rect_is_empty(&ssd
->dirty
)) {
86 pthread_mutex_lock(&ssd
->lock
);
87 dprint(2, "%s: lr %d -> %d, tb -> %d -> %d\n", __FUNCTION__
,
88 ssd
->dirty
.left
, ssd
->dirty
.right
,
89 ssd
->dirty
.top
, ssd
->dirty
.bottom
);
91 update
= qemu_mallocz(sizeof(*update
));
92 drawable
= &update
->drawable
;
93 image
= &update
->image
;
94 cmd
= &update
->ext
.cmd
;
96 bw
= ssd
->dirty
.right
- ssd
->dirty
.left
;
97 bh
= ssd
->dirty
.bottom
- ssd
->dirty
.top
;
98 update
->bitmap
= qemu_malloc(bw
* bh
* 4);
100 drawable
->bbox
= ssd
->dirty
;
101 drawable
->clip
.type
= SPICE_CLIP_TYPE_NONE
;
102 drawable
->effect
= QXL_EFFECT_OPAQUE
;
103 drawable
->release_info
.id
= (intptr_t)update
;
104 drawable
->type
= QXL_DRAW_COPY
;
105 drawable
->surfaces_dest
[0] = -1;
106 drawable
->surfaces_dest
[1] = -1;
107 drawable
->surfaces_dest
[2] = -1;
109 drawable
->u
.copy
.rop_descriptor
= SPICE_ROPD_OP_PUT
;
110 drawable
->u
.copy
.src_bitmap
= (intptr_t)image
;
111 drawable
->u
.copy
.src_area
.right
= bw
;
112 drawable
->u
.copy
.src_area
.bottom
= bh
;
114 QXL_SET_IMAGE_ID(image
, QXL_IMAGE_GROUP_DEVICE
, ssd
->unique
++);
115 image
->descriptor
.type
= SPICE_IMAGE_TYPE_BITMAP
;
116 image
->bitmap
.flags
= QXL_BITMAP_DIRECT
| QXL_BITMAP_TOP_DOWN
;
117 image
->bitmap
.stride
= bw
* 4;
118 image
->descriptor
.width
= image
->bitmap
.x
= bw
;
119 image
->descriptor
.height
= image
->bitmap
.y
= bh
;
120 image
->bitmap
.data
= (intptr_t)(update
->bitmap
);
121 image
->bitmap
.palette
= 0;
122 image
->bitmap
.format
= SPICE_BITMAP_FMT_32BIT
;
124 if (ssd
->conv
== NULL
) {
125 PixelFormat dst
= qemu_default_pixelformat(32);
126 ssd
->conv
= qemu_pf_conv_get(&dst
, &ssd
->ds
->surface
->pf
);
130 src
= ds_get_data(ssd
->ds
) +
131 ssd
->dirty
.top
* ds_get_linesize(ssd
->ds
) +
132 ssd
->dirty
.left
* ds_get_bytes_per_pixel(ssd
->ds
);
133 dst
= update
->bitmap
;
134 for (by
= 0; by
< bh
; by
++) {
135 qemu_pf_conv_run(ssd
->conv
, dst
, src
, bw
);
136 src
+= ds_get_linesize(ssd
->ds
);
137 dst
+= image
->bitmap
.stride
;
140 cmd
->type
= QXL_CMD_DRAW
;
141 cmd
->data
= (intptr_t)drawable
;
143 memset(&ssd
->dirty
, 0, sizeof(ssd
->dirty
));
144 pthread_mutex_unlock(&ssd
->lock
);
149 * Called from spice server thread context (via interface_release_ressource)
150 * We do *not* hold the global qemu mutex here, so extra care is needed
151 * when calling qemu functions. Qemu interfaces used:
152 * - qemu_free (underlying glibc free is re-entrant).
154 void qemu_spice_destroy_update(SimpleSpiceDisplay
*sdpy
, SimpleSpiceUpdate
*update
)
156 qemu_free(update
->bitmap
);
160 void qemu_spice_create_host_memslot(SimpleSpiceDisplay
*ssd
)
162 QXLDevMemSlot memslot
;
164 dprint(1, "%s:\n", __FUNCTION__
);
166 memset(&memslot
, 0, sizeof(memslot
));
167 memslot
.slot_group_id
= MEMSLOT_GROUP_HOST
;
168 memslot
.virt_end
= ~0;
169 ssd
->worker
->add_memslot(ssd
->worker
, &memslot
);
172 void qemu_spice_create_host_primary(SimpleSpiceDisplay
*ssd
)
174 QXLDevSurfaceCreate surface
;
176 dprint(1, "%s: %dx%d\n", __FUNCTION__
,
177 ds_get_width(ssd
->ds
), ds_get_height(ssd
->ds
));
179 surface
.format
= SPICE_SURFACE_FMT_32_xRGB
;
180 surface
.width
= ds_get_width(ssd
->ds
);
181 surface
.height
= ds_get_height(ssd
->ds
);
182 surface
.stride
= -surface
.width
* 4;
183 surface
.mouse_mode
= true;
186 surface
.mem
= (intptr_t)ssd
->buf
;
187 surface
.group_id
= MEMSLOT_GROUP_HOST
;
188 ssd
->worker
->create_primary_surface(ssd
->worker
, 0, &surface
);
191 void qemu_spice_destroy_host_primary(SimpleSpiceDisplay
*ssd
)
193 dprint(1, "%s:\n", __FUNCTION__
);
195 ssd
->worker
->destroy_primary_surface(ssd
->worker
, 0);
198 void qemu_spice_vm_change_state_handler(void *opaque
, int running
, int reason
)
200 SimpleSpiceDisplay
*ssd
= opaque
;
203 ssd
->worker
->start(ssd
->worker
);
205 ssd
->worker
->stop(ssd
->worker
);
207 ssd
->running
= running
;
210 /* display listener callbacks */
212 void qemu_spice_display_update(SimpleSpiceDisplay
*ssd
,
213 int x
, int y
, int w
, int h
)
217 dprint(2, "%s: x %d y %d w %d h %d\n", __FUNCTION__
, x
, y
, w
, h
);
218 update_area
.left
= x
,
219 update_area
.right
= x
+ w
;
221 update_area
.bottom
= y
+ h
;
223 pthread_mutex_lock(&ssd
->lock
);
224 if (qemu_spice_rect_is_empty(&ssd
->dirty
)) {
227 qemu_spice_rect_union(&ssd
->dirty
, &update_area
);
228 pthread_mutex_unlock(&ssd
->lock
);
231 void qemu_spice_display_resize(SimpleSpiceDisplay
*ssd
)
233 dprint(1, "%s:\n", __FUNCTION__
);
235 pthread_mutex_lock(&ssd
->lock
);
236 memset(&ssd
->dirty
, 0, sizeof(ssd
->dirty
));
237 qemu_pf_conv_put(ssd
->conv
);
239 pthread_mutex_unlock(&ssd
->lock
);
241 qemu_spice_destroy_host_primary(ssd
);
242 qemu_spice_create_host_primary(ssd
);
244 pthread_mutex_lock(&ssd
->lock
);
245 memset(&ssd
->dirty
, 0, sizeof(ssd
->dirty
));
247 pthread_mutex_unlock(&ssd
->lock
);
250 void qemu_spice_display_refresh(SimpleSpiceDisplay
*ssd
)
252 dprint(3, "%s:\n", __FUNCTION__
);
256 ssd
->worker
->wakeup(ssd
->worker
);
257 dprint(2, "%s: notify\n", __FUNCTION__
);
261 /* spice display interface callbacks */
263 static void interface_attach_worker(QXLInstance
*sin
, QXLWorker
*qxl_worker
)
265 SimpleSpiceDisplay
*ssd
= container_of(sin
, SimpleSpiceDisplay
, qxl
);
267 dprint(1, "%s:\n", __FUNCTION__
);
268 ssd
->worker
= qxl_worker
;
271 static void interface_set_compression_level(QXLInstance
*sin
, int level
)
273 dprint(1, "%s:\n", __FUNCTION__
);
277 static void interface_set_mm_time(QXLInstance
*sin
, uint32_t mm_time
)
279 dprint(3, "%s:\n", __FUNCTION__
);
283 static void interface_get_init_info(QXLInstance
*sin
, QXLDevInitInfo
*info
)
285 SimpleSpiceDisplay
*ssd
= container_of(sin
, SimpleSpiceDisplay
, qxl
);
287 info
->memslot_gen_bits
= MEMSLOT_GENERATION_BITS
;
288 info
->memslot_id_bits
= MEMSLOT_SLOT_BITS
;
289 info
->num_memslots
= NUM_MEMSLOTS
;
290 info
->num_memslots_groups
= NUM_MEMSLOTS_GROUPS
;
291 info
->internal_groupslot_id
= 0;
292 info
->qxl_ram_size
= ssd
->bufsize
;
293 info
->n_surfaces
= NUM_SURFACES
;
296 static int interface_get_command(QXLInstance
*sin
, struct QXLCommandExt
*ext
)
298 SimpleSpiceDisplay
*ssd
= container_of(sin
, SimpleSpiceDisplay
, qxl
);
299 SimpleSpiceUpdate
*update
;
301 dprint(3, "%s:\n", __FUNCTION__
);
302 update
= qemu_spice_create_update(ssd
);
303 if (update
== NULL
) {
310 static int interface_req_cmd_notification(QXLInstance
*sin
)
312 dprint(1, "%s:\n", __FUNCTION__
);
316 static void interface_release_resource(QXLInstance
*sin
,
317 struct QXLReleaseInfoExt ext
)
319 SimpleSpiceDisplay
*ssd
= container_of(sin
, SimpleSpiceDisplay
, qxl
);
322 dprint(2, "%s:\n", __FUNCTION__
);
324 qemu_spice_destroy_update(ssd
, (void*)id
);
327 static int interface_get_cursor_command(QXLInstance
*sin
, struct QXLCommandExt
*ext
)
329 dprint(3, "%s:\n", __FUNCTION__
);
333 static int interface_req_cursor_notification(QXLInstance
*sin
)
335 dprint(1, "%s:\n", __FUNCTION__
);
339 static void interface_notify_update(QXLInstance
*sin
, uint32_t update_id
)
341 fprintf(stderr
, "%s: abort()\n", __FUNCTION__
);
345 static int interface_flush_resources(QXLInstance
*sin
)
347 fprintf(stderr
, "%s: abort()\n", __FUNCTION__
);
352 static const QXLInterface dpy_interface
= {
353 .base
.type
= SPICE_INTERFACE_QXL
,
354 .base
.description
= "qemu simple display",
355 .base
.major_version
= SPICE_INTERFACE_QXL_MAJOR
,
356 .base
.minor_version
= SPICE_INTERFACE_QXL_MINOR
,
358 .attache_worker
= interface_attach_worker
,
359 .set_compression_level
= interface_set_compression_level
,
360 .set_mm_time
= interface_set_mm_time
,
361 .get_init_info
= interface_get_init_info
,
363 /* the callbacks below are called from spice server thread context */
364 .get_command
= interface_get_command
,
365 .req_cmd_notification
= interface_req_cmd_notification
,
366 .release_resource
= interface_release_resource
,
367 .get_cursor_command
= interface_get_cursor_command
,
368 .req_cursor_notification
= interface_req_cursor_notification
,
369 .notify_update
= interface_notify_update
,
370 .flush_resources
= interface_flush_resources
,
373 static SimpleSpiceDisplay sdpy
;
375 static void display_update(struct DisplayState
*ds
, int x
, int y
, int w
, int h
)
377 qemu_spice_display_update(&sdpy
, x
, y
, w
, h
);
380 static void display_resize(struct DisplayState
*ds
)
382 qemu_spice_display_resize(&sdpy
);
385 static void display_refresh(struct DisplayState
*ds
)
387 qemu_spice_display_refresh(&sdpy
);
390 static DisplayChangeListener display_listener
= {
391 .dpy_update
= display_update
,
392 .dpy_resize
= display_resize
,
393 .dpy_refresh
= display_refresh
,
396 void qemu_spice_display_init(DisplayState
*ds
)
398 assert(sdpy
.ds
== NULL
);
400 sdpy
.bufsize
= (16 * 1024 * 1024);
401 sdpy
.buf
= qemu_malloc(sdpy
.bufsize
);
402 pthread_mutex_init(&sdpy
.lock
, NULL
);
403 register_displaychangelistener(ds
, &display_listener
);
405 sdpy
.qxl
.base
.sif
= &dpy_interface
.base
;
406 qemu_spice_add_interface(&sdpy
.qxl
.base
);
409 qemu_add_vm_change_state_handler(qemu_spice_vm_change_state_handler
, &sdpy
);
410 qemu_spice_create_host_memslot(&sdpy
);
411 qemu_spice_create_host_primary(&sdpy
);