[qemu.git] / ui / spice-display.c

/*
 * Copyright (C) 2010 Red Hat, Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 or
 * (at your option) version 3 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

#include "qemu-common.h"
#include "qemu-spice.h"
#include "qemu-timer.h"
#include "qemu-queue.h"
#include "monitor.h"
#include "console.h"
#include "sysemu.h"

#include "spice-display.h"

static int debug = 0;

static void GCC_FMT_ATTR(2, 3) dprint(int level, const char *fmt, ...)
{
    va_list args;

    if (level <= debug) {
        va_start(args, fmt);
        vfprintf(stderr, fmt, args);
        va_end(args);
    }
}

int qemu_spice_rect_is_empty(const QXLRect* r)
{
    return r->top == r->bottom || r->left == r->right;
}

void qemu_spice_rect_union(QXLRect *dest, const QXLRect *r)
{
    if (qemu_spice_rect_is_empty(r)) {
        return;
    }

    if (qemu_spice_rect_is_empty(dest)) {
        *dest = *r;
        return;
    }

    dest->top = MIN(dest->top, r->top);
    dest->left = MIN(dest->left, r->left);
    dest->bottom = MAX(dest->bottom, r->bottom);
    dest->right = MAX(dest->right, r->right);
}

void qemu_spice_add_memslot(SimpleSpiceDisplay *ssd, QXLDevMemSlot *memslot,
                            qxl_async_io async)
{
    if (async != QXL_SYNC) {
#if SPICE_INTERFACE_QXL_MINOR >= 1
        spice_qxl_add_memslot_async(&ssd->qxl, memslot, 0);
#else
        abort();
#endif
    } else {
        ssd->worker->add_memslot(ssd->worker, memslot);
    }
}

void qemu_spice_del_memslot(SimpleSpiceDisplay *ssd, uint32_t gid, uint32_t sid)
{
    ssd->worker->del_memslot(ssd->worker, gid, sid);
}

void qemu_spice_create_primary_surface(SimpleSpiceDisplay *ssd, uint32_t id,
                                       QXLDevSurfaceCreate *surface,
                                       qxl_async_io async)
{
    if (async != QXL_SYNC) {
#if SPICE_INTERFACE_QXL_MINOR >= 1
        spice_qxl_create_primary_surface_async(&ssd->qxl, id, surface, 0);
#else
        abort();
#endif
    } else {
        ssd->worker->create_primary_surface(ssd->worker, id, surface);
    }
}


void qemu_spice_destroy_primary_surface(SimpleSpiceDisplay *ssd,
                                        uint32_t id, qxl_async_io async)
{
    if (async != QXL_SYNC) {
#if SPICE_INTERFACE_QXL_MINOR >= 1
        spice_qxl_destroy_primary_surface_async(&ssd->qxl, id, 0);
#else
        abort();
#endif
    } else {
        ssd->worker->destroy_primary_surface(ssd->worker, id);
    }
}

void qemu_spice_wakeup(SimpleSpiceDisplay *ssd)
{
    ssd->worker->wakeup(ssd->worker);
}

void qemu_spice_start(SimpleSpiceDisplay *ssd)
{
    ssd->worker->start(ssd->worker);
}

void qemu_spice_stop(SimpleSpiceDisplay *ssd)
{
    ssd->worker->stop(ssd->worker);
}

static SimpleSpiceUpdate *qemu_spice_create_update(SimpleSpiceDisplay *ssd)
{
    SimpleSpiceUpdate *update;
    QXLDrawable *drawable;
    QXLImage *image;
    QXLCommand *cmd;
    uint8_t *src, *dst;
    int by, bw, bh;
    struct timespec time_space;

    if (qemu_spice_rect_is_empty(&ssd->dirty)) {
        return NULL;
    };

    dprint(2, "%s: lr %d -> %d,  tb -> %d -> %d\n", __FUNCTION__,
           ssd->dirty.left, ssd->dirty.right,
           ssd->dirty.top, ssd->dirty.bottom);

    update   = g_malloc0(sizeof(*update));
    drawable = &update->drawable;
    image    = &update->image;
    cmd      = &update->ext.cmd;

    bw       = ssd->dirty.right - ssd->dirty.left;
    bh       = ssd->dirty.bottom - ssd->dirty.top;
    update->bitmap = g_malloc(bw * bh * 4);

    drawable->bbox            = ssd->dirty;
    drawable->clip.type       = SPICE_CLIP_TYPE_NONE;
    drawable->effect          = QXL_EFFECT_OPAQUE;
    drawable->release_info.id = (intptr_t)update;
    drawable->type            = QXL_DRAW_COPY;
    drawable->surfaces_dest[0] = -1;
    drawable->surfaces_dest[1] = -1;
    drawable->surfaces_dest[2] = -1;
    clock_gettime(CLOCK_MONOTONIC, &time_space);
    /* time in milliseconds from epoch. */
    drawable->mm_time = time_space.tv_sec * 1000
                      + time_space.tv_nsec / 1000 / 1000;

    drawable->u.copy.rop_descriptor  = SPICE_ROPD_OP_PUT;
    drawable->u.copy.src_bitmap      = (intptr_t)image;
    drawable->u.copy.src_area.right  = bw;
    drawable->u.copy.src_area.bottom = bh;

    QXL_SET_IMAGE_ID(image, QXL_IMAGE_GROUP_DEVICE, ssd->unique++);
    image->descriptor.type   = SPICE_IMAGE_TYPE_BITMAP;
    image->bitmap.flags      = QXL_BITMAP_DIRECT | QXL_BITMAP_TOP_DOWN;
    image->bitmap.stride     = bw * 4;
    image->descriptor.width  = image->bitmap.x = bw;
    image->descriptor.height = image->bitmap.y = bh;
    image->bitmap.data = (intptr_t)(update->bitmap);
    image->bitmap.palette = 0;
    image->bitmap.format = SPICE_BITMAP_FMT_32BIT;

    if (ssd->conv == NULL) {
        PixelFormat dst = qemu_default_pixelformat(32);
        ssd->conv = qemu_pf_conv_get(&dst, &ssd->ds->surface->pf);
        assert(ssd->conv);
    }

    src = ds_get_data(ssd->ds) +
        ssd->dirty.top * ds_get_linesize(ssd->ds) +
        ssd->dirty.left * ds_get_bytes_per_pixel(ssd->ds);
    dst = update->bitmap;
    for (by = 0; by < bh; by++) {
        qemu_pf_conv_run(ssd->conv, dst, src, bw);
        src += ds_get_linesize(ssd->ds);
        dst += image->bitmap.stride;
    }

    cmd->type = QXL_CMD_DRAW;
    cmd->data = (intptr_t)drawable;

    memset(&ssd->dirty, 0, sizeof(ssd->dirty));
    return update;
}

/*
 * Called from spice server thread context (via interface_release_ressource)
 * We do *not* hold the global qemu mutex here, so extra care is needed
 * when calling qemu functions.  Qemu interfaces used:
 *    - g_free (underlying glibc free is re-entrant).
 */
void qemu_spice_destroy_update(SimpleSpiceDisplay *sdpy, SimpleSpiceUpdate *update)
{
    g_free(update->bitmap);
    g_free(update);
}

void qemu_spice_create_host_memslot(SimpleSpiceDisplay *ssd)
{
    QXLDevMemSlot memslot;

    dprint(1, "%s:\n", __FUNCTION__);

    memset(&memslot, 0, sizeof(memslot));
    memslot.slot_group_id = MEMSLOT_GROUP_HOST;
    memslot.virt_end = ~0;
    qemu_spice_add_memslot(ssd, &memslot, QXL_SYNC);
}

void qemu_spice_create_host_primary(SimpleSpiceDisplay *ssd)
{
    QXLDevSurfaceCreate surface;

    dprint(1, "%s: %dx%d\n", __FUNCTION__,
           ds_get_width(ssd->ds), ds_get_height(ssd->ds));

    surface.format     = SPICE_SURFACE_FMT_32_xRGB;
    surface.width      = ds_get_width(ssd->ds);
    surface.height     = ds_get_height(ssd->ds);
    surface.stride     = -surface.width * 4;
    surface.mouse_mode = true;
    surface.flags      = 0;
    surface.type       = 0;
    surface.mem        = (intptr_t)ssd->buf;
    surface.group_id   = MEMSLOT_GROUP_HOST;

    qemu_spice_create_primary_surface(ssd, 0, &surface, QXL_SYNC);
}

void qemu_spice_destroy_host_primary(SimpleSpiceDisplay *ssd)
{
    dprint(1, "%s:\n", __FUNCTION__);

    qemu_spice_destroy_primary_surface(ssd, 0, QXL_SYNC);
}

void qemu_spice_vm_change_state_handler(void *opaque, int running,
                                        RunState state)
{
    SimpleSpiceDisplay *ssd = opaque;

    if (running) {
        ssd->running = true;
        qemu_spice_start(ssd);
    } else {
        qemu_spice_stop(ssd);
        ssd->running = false;
    }
}

void qemu_spice_display_init_common(SimpleSpiceDisplay *ssd, DisplayState *ds)
{
    ssd->ds = ds;
    qemu_mutex_init(&ssd->lock);
    ssd->mouse_x = -1;
    ssd->mouse_y = -1;
    ssd->bufsize = (16 * 1024 * 1024);
    ssd->buf = g_malloc(ssd->bufsize);
}

/* display listener callbacks */

void qemu_spice_display_update(SimpleSpiceDisplay *ssd,
                               int x, int y, int w, int h)
{
    QXLRect update_area;

    dprint(2, "%s: x %d y %d w %d h %d\n", __FUNCTION__, x, y, w, h);
    update_area.left = x,
    update_area.right = x + w;
    update_area.top = y;
    update_area.bottom = y + h;

    if (qemu_spice_rect_is_empty(&ssd->dirty)) {
        ssd->notify++;
    }
    qemu_spice_rect_union(&ssd->dirty, &update_area);
}

void qemu_spice_display_resize(SimpleSpiceDisplay *ssd)
{
    dprint(1, "%s:\n", __FUNCTION__);

    memset(&ssd->dirty, 0, sizeof(ssd->dirty));
    qemu_pf_conv_put(ssd->conv);
    ssd->conv = NULL;

    qemu_mutex_lock(&ssd->lock);
    if (ssd->update != NULL) {
        qemu_spice_destroy_update(ssd, ssd->update);
        ssd->update = NULL;
    }
    qemu_mutex_unlock(&ssd->lock);
    qemu_spice_destroy_host_primary(ssd);
    qemu_spice_create_host_primary(ssd);

    memset(&ssd->dirty, 0, sizeof(ssd->dirty));
    ssd->notify++;
}

void qemu_spice_display_refresh(SimpleSpiceDisplay *ssd)
{
    dprint(3, "%s:\n", __FUNCTION__);
    vga_hw_update();

    qemu_mutex_lock(&ssd->lock);
    if (ssd->update == NULL) {
        ssd->update = qemu_spice_create_update(ssd);
        ssd->notify++;
    }
    if (ssd->cursor) {
        ssd->ds->cursor_define(ssd->cursor);
        cursor_put(ssd->cursor);
        ssd->cursor = NULL;
    }
    if (ssd->mouse_x != -1 && ssd->mouse_y != -1) {
        ssd->ds->mouse_set(ssd->mouse_x, ssd->mouse_y, 1);
        ssd->mouse_x = -1;
        ssd->mouse_y = -1;
    }
    qemu_mutex_unlock(&ssd->lock);

    if (ssd->notify) {
        ssd->notify = 0;
        qemu_spice_wakeup(ssd);
        dprint(2, "%s: notify\n", __FUNCTION__);
    }
}

/* spice display interface callbacks */

static void interface_attach_worker(QXLInstance *sin, QXLWorker *qxl_worker)
{
    SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);

    dprint(1, "%s:\n", __FUNCTION__);
    ssd->worker = qxl_worker;
}

static void interface_set_compression_level(QXLInstance *sin, int level)
{
    dprint(1, "%s:\n", __FUNCTION__);
    /* nothing to do */
}

static void interface_set_mm_time(QXLInstance *sin, uint32_t mm_time)
{
    dprint(3, "%s:\n", __FUNCTION__);
    /* nothing to do */
}

static void interface_get_init_info(QXLInstance *sin, QXLDevInitInfo *info)
{
    SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);

    info->memslot_gen_bits = MEMSLOT_GENERATION_BITS;
    info->memslot_id_bits  = MEMSLOT_SLOT_BITS;
    info->num_memslots = NUM_MEMSLOTS;
    info->num_memslots_groups = NUM_MEMSLOTS_GROUPS;
    info->internal_groupslot_id = 0;
    info->qxl_ram_size = ssd->bufsize;
    info->n_surfaces = NUM_SURFACES;
}

static int interface_get_command(QXLInstance *sin, struct QXLCommandExt *ext)
{
    SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
    SimpleSpiceUpdate *update;
    int ret = false;

    dprint(3, "%s:\n", __FUNCTION__);

    qemu_mutex_lock(&ssd->lock);
    if (ssd->update != NULL) {
        update = ssd->update;
        ssd->update = NULL;
        *ext = update->ext;
        ret = true;
    }
    qemu_mutex_unlock(&ssd->lock);

    return ret;
}

static int interface_req_cmd_notification(QXLInstance *sin)
{
    dprint(1, "%s:\n", __FUNCTION__);
    return 1;
}

static void interface_release_resource(QXLInstance *sin,
                                       struct QXLReleaseInfoExt ext)
{
    SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
    uintptr_t id;

    dprint(2, "%s:\n", __FUNCTION__);
    id = ext.info->id;
    qemu_spice_destroy_update(ssd, (void*)id);
}

static int interface_get_cursor_command(QXLInstance *sin, struct QXLCommandExt *ext)
{
    dprint(3, "%s:\n", __FUNCTION__);
    return false;
}

static int interface_req_cursor_notification(QXLInstance *sin)
{
    dprint(1, "%s:\n", __FUNCTION__);
    return 1;
}

static void interface_notify_update(QXLInstance *sin, uint32_t update_id)
{
    fprintf(stderr, "%s: abort()\n", __FUNCTION__);
    abort();
}

static int interface_flush_resources(QXLInstance *sin)
{
    fprintf(stderr, "%s: abort()\n", __FUNCTION__);
    abort();
    return 0;
}

static const QXLInterface dpy_interface = {
    .base.type               = SPICE_INTERFACE_QXL,
    .base.description        = "qemu simple display",
    .base.major_version      = SPICE_INTERFACE_QXL_MAJOR,
    .base.minor_version      = SPICE_INTERFACE_QXL_MINOR,

    .attache_worker          = interface_attach_worker,
    .set_compression_level   = interface_set_compression_level,
    .set_mm_time             = interface_set_mm_time,
    .get_init_info           = interface_get_init_info,

    /* the callbacks below are called from spice server thread context */
    .get_command             = interface_get_command,
    .req_cmd_notification    = interface_req_cmd_notification,
    .release_resource        = interface_release_resource,
    .get_cursor_command      = interface_get_cursor_command,
    .req_cursor_notification = interface_req_cursor_notification,
    .notify_update           = interface_notify_update,
    .flush_resources         = interface_flush_resources,
};

static SimpleSpiceDisplay sdpy;

static void display_update(struct DisplayState *ds, int x, int y, int w, int h)
{
    qemu_spice_display_update(&sdpy, x, y, w, h);
}

static void display_resize(struct DisplayState *ds)
{
    qemu_spice_display_resize(&sdpy);
}

static void display_refresh(struct DisplayState *ds)
{
    qemu_spice_display_refresh(&sdpy);
}

static DisplayChangeListener display_listener = {
    .dpy_update  = display_update,
    .dpy_resize  = display_resize,
    .dpy_refresh = display_refresh,
};

void qemu_spice_display_init(DisplayState *ds)
{
    assert(sdpy.ds == NULL);
    qemu_spice_display_init_common(&sdpy, ds);
    register_displaychangelistener(ds, &display_listener);

    sdpy.qxl.base.sif = &dpy_interface.base;
    qemu_spice_add_interface(&sdpy.qxl.base);
    assert(sdpy.worker);

    qemu_add_vm_change_state_handler(qemu_spice_vm_change_state_handler, &sdpy);
    qemu_spice_create_host_memslot(&sdpy);
    qemu_spice_create_host_primary(&sdpy);
}
Commit	Line	Data
a3e22260 GH	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
a3e22260 GH	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
2c80e423	30	static void GCC_FMT_ATTR(2, 3) dprint(int level, const char *fmt, ...)
a3e22260 GH	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
5ff4e36c AL	63	void qemu_spice_add_memslot(SimpleSpiceDisplay ssd, QXLDevMemSlot memslot,
5ff4e36c AL	64	qxl_async_io async)
5c59d118	65	{
5ff4e36c AL	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	}
5c59d118 GH	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,
5ff4e36c AL	83	QXLDevSurfaceCreate *surface,
5ff4e36c AL	84	qxl_async_io async)
5c59d118	85	{
5ff4e36c AL	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	}
5c59d118 GH	95	}
5c59d118 GH	96
5ff4e36c AL	97
	98	void qemu_spice_destroy_primary_surface(SimpleSpiceDisplay *ssd,
	99	uint32_t id, qxl_async_io async)
5c59d118	100	{
5ff4e36c AL	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	}
5c59d118 GH	110	}
5c59d118 GH	111
5c59d118 GH	112	void qemu_spice_wakeup(SimpleSpiceDisplay *ssd)
	113	{
	114	ssd->worker->wakeup(ssd->worker);
	115	}
	116
5c59d118 GH	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
e0c64d08	127	static SimpleSpiceUpdate qemu_spice_create_update(SimpleSpiceDisplay ssd)
a3e22260 GH	128	{
	129	SimpleSpiceUpdate *update;
	130	QXLDrawable *drawable;
	131	QXLImage *image;
	132	QXLCommand *cmd;
	133	uint8_t src, dst;
	134	int by, bw, bh;
22795174	135	struct timespec time_space;
a3e22260 GH	136
	137	if (qemu_spice_rect_is_empty(&ssd->dirty)) {
	138	return NULL;
	139	};
	140
a3e22260 GH	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
7267c094	145	update = g_malloc0(sizeof(*update));
a3e22260 GH	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;
7267c094	152	update->bitmap = g_malloc(bw * bh * 4);
a3e22260 GH	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;
22795174 AL	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;
a3e22260 GH	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));
a3e22260 GH	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:
7267c094	209	* - g_free (underlying glibc free is re-entrant).
a3e22260 GH	210	*/
	211	void qemu_spice_destroy_update(SimpleSpiceDisplay sdpy, SimpleSpiceUpdate update)
	212	{
7267c094 AL	213	g_free(update->bitmap);
7267c094 AL	214	g_free(update);
a3e22260 GH	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;
5ff4e36c	226	qemu_spice_add_memslot(ssd, &memslot, QXL_SYNC);
a3e22260 GH	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;
869564a9	240	surface.mouse_mode = true;
a3e22260 GH	241	surface.flags = 0;
	242	surface.type = 0;
	243	surface.mem = (intptr_t)ssd->buf;
	244	surface.group_id = MEMSLOT_GROUP_HOST;
7466bc49	245
5ff4e36c	246	qemu_spice_create_primary_surface(ssd, 0, &surface, QXL_SYNC);
a3e22260 GH	247	}
	248
	249	void qemu_spice_destroy_host_primary(SimpleSpiceDisplay *ssd)
	250	{
	251	dprint(1, "%s:\n", __FUNCTION__);
	252
5ff4e36c	253	qemu_spice_destroy_primary_surface(ssd, 0, QXL_SYNC);
a3e22260 GH	254	}
a3e22260 GH	255
1dfb4dd9 LC	256	void qemu_spice_vm_change_state_handler(void *opaque, int running,
1dfb4dd9 LC	257	RunState state)
a3e22260 GH	258	{
	259	SimpleSpiceDisplay *ssd = opaque;
	260
	261	if (running) {
7e79cf40	262	ssd->running = true;
5c59d118	263	qemu_spice_start(ssd);
a3e22260	264	} else {
5c59d118	265	qemu_spice_stop(ssd);
7e79cf40	266	ssd->running = false;
a3e22260	267	}
a3e22260 GH	268	}
a3e22260 GH	269
a963f876 GH	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);
7267c094	277	ssd->buf = g_malloc(ssd->bufsize);
a963f876 GH	278	}
a963f876 GH	279
a3e22260 GH	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
a3e22260 GH	293	if (qemu_spice_rect_is_empty(&ssd->dirty)) {
	294	ssd->notify++;
	295	}
	296	qemu_spice_rect_union(&ssd->dirty, &update_area);
a3e22260 GH	297	}
	298
	299	void qemu_spice_display_resize(SimpleSpiceDisplay *ssd)
	300	{
	301	dprint(1, "%s:\n", __FUNCTION__);
	302
a3e22260 GH	303	memset(&ssd->dirty, 0, sizeof(ssd->dirty));
	304	qemu_pf_conv_put(ssd->conv);
	305	ssd->conv = NULL;
a3e22260	306
e0c64d08 GH	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);
a3e22260 GH	313	qemu_spice_destroy_host_primary(ssd);
	314	qemu_spice_create_host_primary(ssd);
	315
a3e22260 GH	316	memset(&ssd->dirty, 0, sizeof(ssd->dirty));
a3e22260 GH	317	ssd->notify++;
a3e22260 GH	318	}
	319
	320	void qemu_spice_display_refresh(SimpleSpiceDisplay *ssd)
	321	{
	322	dprint(3, "%s:\n", __FUNCTION__);
	323	vga_hw_update();
e0c64d08 GH	324
	325	qemu_mutex_lock(&ssd->lock);
	326	if (ssd->update == NULL) {
	327	ssd->update = qemu_spice_create_update(ssd);
	328	ssd->notify++;
	329	}
07536094 GH	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	}
e0c64d08 GH	340	qemu_mutex_unlock(&ssd->lock);
e0c64d08 GH	341
a3e22260 GH	342	if (ssd->notify) {
a3e22260 GH	343	ssd->notify = 0;
5c59d118	344	qemu_spice_wakeup(ssd);
a3e22260 GH	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;
e0c64d08	388	int ret = false;
a3e22260 GH	389
a3e22260 GH	390	dprint(3, "%s:\n", __FUNCTION__);
e0c64d08 GH	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;
a3e22260	398	}
e0c64d08 GH	399	qemu_mutex_unlock(&ssd->lock);
	400
	401	return ret;
a3e22260 GH	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);
a963f876	493	qemu_spice_display_init_common(&sdpy, ds);
a3e22260 GH	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	}