[mirror_qemu.git] / ui / dbus-listener.c

/*
 * QEMU DBus display console
 *
 * Copyright (c) 2021 Marc-André Lureau <marcandre.lureau@redhat.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#include "qemu/osdep.h"
#include "sysemu/sysemu.h"
#include "dbus.h"
#include <gio/gunixfdlist.h>

#include "ui/shader.h"
#include "ui/egl-helpers.h"
#include "ui/egl-context.h"
#include "trace.h"

struct _DBusDisplayListener {
    GObject parent;

    char *bus_name;
    DBusDisplayConsole *console;
    GDBusConnection *conn;

    QemuDBusDisplay1Listener *proxy;

    DisplayChangeListener dcl;
    DisplaySurface *ds;
    int gl_updates;
};

G_DEFINE_TYPE(DBusDisplayListener, dbus_display_listener, G_TYPE_OBJECT)

static void dbus_update_gl_cb(GObject *source_object,
                           GAsyncResult *res,
                           gpointer user_data)
{
    g_autoptr(GError) err = NULL;
    DBusDisplayListener *ddl = user_data;

    if (!qemu_dbus_display1_listener_call_update_dmabuf_finish(ddl->proxy,
                                                               res, &err)) {
        error_report("Failed to call update: %s", err->message);
    }

    graphic_hw_gl_block(ddl->dcl.con, false);
    g_object_unref(ddl);
}

static void dbus_call_update_gl(DBusDisplayListener *ddl,
                                int x, int y, int w, int h)
{
    graphic_hw_gl_block(ddl->dcl.con, true);
    glFlush();
    qemu_dbus_display1_listener_call_update_dmabuf(ddl->proxy,
        x, y, w, h,
        G_DBUS_CALL_FLAGS_NONE,
        DBUS_DEFAULT_TIMEOUT, NULL,
        dbus_update_gl_cb,
        g_object_ref(ddl));
}

static void dbus_scanout_disable(DisplayChangeListener *dcl)
{
    DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);

    ddl->ds = NULL;
    qemu_dbus_display1_listener_call_disable(
        ddl->proxy, G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
}

static void dbus_scanout_dmabuf(DisplayChangeListener *dcl,
                                QemuDmaBuf *dmabuf)
{
    DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
    g_autoptr(GError) err = NULL;
    g_autoptr(GUnixFDList) fd_list = NULL;

    fd_list = g_unix_fd_list_new();
    if (g_unix_fd_list_append(fd_list, dmabuf->fd, &err) != 0) {
        error_report("Failed to setup dmabuf fdlist: %s", err->message);
        return;
    }

    qemu_dbus_display1_listener_call_scanout_dmabuf(
        ddl->proxy,
        g_variant_new_handle(0),
        dmabuf->width,
        dmabuf->height,
        dmabuf->stride,
        dmabuf->fourcc,
        dmabuf->modifier,
        dmabuf->y0_top,
        G_DBUS_CALL_FLAGS_NONE,
        -1,
        fd_list,
        NULL, NULL, NULL);
}

static void dbus_scanout_texture(DisplayChangeListener *dcl,
                                 uint32_t tex_id,
                                 bool backing_y_0_top,
                                 uint32_t backing_width,
                                 uint32_t backing_height,
                                 uint32_t x, uint32_t y,
                                 uint32_t w, uint32_t h)
{
    QemuDmaBuf dmabuf = {
        .width = backing_width,
        .height = backing_height,
        .y0_top = backing_y_0_top,
    };

    assert(tex_id);
    dmabuf.fd = egl_get_fd_for_texture(
        tex_id, (EGLint *)&dmabuf.stride,
        (EGLint *)&dmabuf.fourcc,
        &dmabuf.modifier);
    if (dmabuf.fd < 0) {
        error_report("%s: failed to get fd for texture", __func__);
        return;
    }

    dbus_scanout_dmabuf(dcl, &dmabuf);
    close(dmabuf.fd);
}

static void dbus_cursor_dmabuf(DisplayChangeListener *dcl,
                               QemuDmaBuf *dmabuf, bool have_hot,
                               uint32_t hot_x, uint32_t hot_y)
{
    DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
    DisplaySurface *ds;
    GVariant *v_data = NULL;
    egl_fb cursor_fb;

    if (!dmabuf) {
        qemu_dbus_display1_listener_call_mouse_set(
            ddl->proxy, 0, 0, false,
            G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
        return;
    }

    egl_dmabuf_import_texture(dmabuf);
    if (!dmabuf->texture) {
        return;
    }
    egl_fb_setup_for_tex(&cursor_fb, dmabuf->width, dmabuf->height,
                         dmabuf->texture, false);
    ds = qemu_create_displaysurface(dmabuf->width, dmabuf->height);
    egl_fb_read(ds, &cursor_fb);

    v_data = g_variant_new_from_data(
        G_VARIANT_TYPE("ay"),
        surface_data(ds),
        surface_width(ds) * surface_height(ds) * 4,
        TRUE,
        (GDestroyNotify)qemu_free_displaysurface,
        ds);
    qemu_dbus_display1_listener_call_cursor_define(
        ddl->proxy,
        surface_width(ds),
        surface_height(ds),
        hot_x,
        hot_y,
        v_data,
        G_DBUS_CALL_FLAGS_NONE,
        -1,
        NULL,
        NULL,
        NULL);
}

static void dbus_cursor_position(DisplayChangeListener *dcl,
                                 uint32_t pos_x, uint32_t pos_y)
{
    DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);

    qemu_dbus_display1_listener_call_mouse_set(
        ddl->proxy, pos_x, pos_y, true,
        G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
}

static void dbus_release_dmabuf(DisplayChangeListener *dcl,
                                QemuDmaBuf *dmabuf)
{
    dbus_scanout_disable(dcl);
}

static void dbus_scanout_update(DisplayChangeListener *dcl,
                                uint32_t x, uint32_t y,
                                uint32_t w, uint32_t h)
{
    DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);

    dbus_call_update_gl(ddl, x, y, w, h);
}

static void dbus_gl_refresh(DisplayChangeListener *dcl)
{
    DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);

    graphic_hw_update(dcl->con);

    if (!ddl->ds || qemu_console_is_gl_blocked(ddl->dcl.con)) {
        return;
    }

    if (ddl->gl_updates) {
        dbus_call_update_gl(ddl, 0, 0,
                            surface_width(ddl->ds), surface_height(ddl->ds));
        ddl->gl_updates = 0;
    }
}

static void dbus_refresh(DisplayChangeListener *dcl)
{
    graphic_hw_update(dcl->con);
}

static void dbus_gl_gfx_update(DisplayChangeListener *dcl,
                               int x, int y, int w, int h)
{
    DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);

    ddl->gl_updates++;
}

static void dbus_gfx_update(DisplayChangeListener *dcl,
                            int x, int y, int w, int h)
{
    DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
    pixman_image_t *img;
    GVariant *v_data;
    size_t stride;

    assert(ddl->ds);
    stride = w * DIV_ROUND_UP(PIXMAN_FORMAT_BPP(surface_format(ddl->ds)), 8);

    trace_dbus_update(x, y, w, h);

    if (x == 0 && y == 0 && w == surface_width(ddl->ds) && h == surface_height(ddl->ds)) {
        v_data = g_variant_new_from_data(
            G_VARIANT_TYPE("ay"),
            surface_data(ddl->ds),
            surface_stride(ddl->ds) * surface_height(ddl->ds),
            TRUE,
            (GDestroyNotify)pixman_image_unref,
            pixman_image_ref(ddl->ds->image));
        qemu_dbus_display1_listener_call_scanout(
            ddl->proxy,
            surface_width(ddl->ds),
            surface_height(ddl->ds),
            surface_stride(ddl->ds),
            surface_format(ddl->ds),
            v_data,
            G_DBUS_CALL_FLAGS_NONE,
            DBUS_DEFAULT_TIMEOUT, NULL, NULL, NULL);
        return;
    }

    /* make a copy, since gvariant only handles linear data */
    img = pixman_image_create_bits(surface_format(ddl->ds),
                                   w, h, NULL, stride);
    pixman_image_composite(PIXMAN_OP_SRC, ddl->ds->image, NULL, img,
                           x, y, 0, 0, 0, 0, w, h);

    v_data = g_variant_new_from_data(
        G_VARIANT_TYPE("ay"),
        pixman_image_get_data(img),
        pixman_image_get_stride(img) * h,
        TRUE,
        (GDestroyNotify)pixman_image_unref,
        img);
    qemu_dbus_display1_listener_call_update(ddl->proxy,
        x, y, w, h, pixman_image_get_stride(img), pixman_image_get_format(img),
        v_data,
        G_DBUS_CALL_FLAGS_NONE,
        DBUS_DEFAULT_TIMEOUT, NULL, NULL, NULL);
}

static void dbus_gl_gfx_switch(DisplayChangeListener *dcl,
                               struct DisplaySurface *new_surface)
{
    DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);

    ddl->ds = new_surface;
    if (ddl->ds) {
        int width = surface_width(ddl->ds);
        int height = surface_height(ddl->ds);

        /* TODO: lazy send dmabuf (there are unnecessary sent otherwise) */
        dbus_scanout_texture(&ddl->dcl, ddl->ds->texture, false,
                             width, height, 0, 0, width, height);
    }
}

static void dbus_gfx_switch(DisplayChangeListener *dcl,
                            struct DisplaySurface *new_surface)
{
    DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);

    ddl->ds = new_surface;
    if (!ddl->ds) {
        /* why not call disable instead? */
        return;
    }
}

static void dbus_mouse_set(DisplayChangeListener *dcl,
                           int x, int y, int on)
{
    DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);

    qemu_dbus_display1_listener_call_mouse_set(
        ddl->proxy, x, y, on, G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
}

static void dbus_cursor_define(DisplayChangeListener *dcl,
                               QEMUCursor *c)
{
    DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
    GVariant *v_data = NULL;

    cursor_get(c);
    v_data = g_variant_new_from_data(
        G_VARIANT_TYPE("ay"),
        c->data,
        c->width * c->height * 4,
        TRUE,
        (GDestroyNotify)cursor_put,
        c);

    qemu_dbus_display1_listener_call_cursor_define(
        ddl->proxy,
        c->width,
        c->height,
        c->hot_x,
        c->hot_y,
        v_data,
        G_DBUS_CALL_FLAGS_NONE,
        -1,
        NULL,
        NULL,
        NULL);
}

const DisplayChangeListenerOps dbus_gl_dcl_ops = {
    .dpy_name                = "dbus-gl",
    .dpy_gfx_update          = dbus_gl_gfx_update,
    .dpy_gfx_switch          = dbus_gl_gfx_switch,
    .dpy_gfx_check_format    = console_gl_check_format,
    .dpy_refresh             = dbus_gl_refresh,
    .dpy_mouse_set           = dbus_mouse_set,
    .dpy_cursor_define       = dbus_cursor_define,

    .dpy_gl_scanout_disable  = dbus_scanout_disable,
    .dpy_gl_scanout_texture  = dbus_scanout_texture,
    .dpy_gl_scanout_dmabuf   = dbus_scanout_dmabuf,
    .dpy_gl_cursor_dmabuf    = dbus_cursor_dmabuf,
    .dpy_gl_cursor_position  = dbus_cursor_position,
    .dpy_gl_release_dmabuf   = dbus_release_dmabuf,
    .dpy_gl_update           = dbus_scanout_update,
};

const DisplayChangeListenerOps dbus_dcl_ops = {
    .dpy_name                = "dbus",
    .dpy_gfx_update          = dbus_gfx_update,
    .dpy_gfx_switch          = dbus_gfx_switch,
    .dpy_refresh             = dbus_refresh,
    .dpy_mouse_set           = dbus_mouse_set,
    .dpy_cursor_define       = dbus_cursor_define,
};

static void
dbus_display_listener_dispose(GObject *object)
{
    DBusDisplayListener *ddl = DBUS_DISPLAY_LISTENER(object);

    unregister_displaychangelistener(&ddl->dcl);
    g_clear_object(&ddl->conn);
    g_clear_pointer(&ddl->bus_name, g_free);
    g_clear_object(&ddl->proxy);

    G_OBJECT_CLASS(dbus_display_listener_parent_class)->dispose(object);
}

static void
dbus_display_listener_constructed(GObject *object)
{
    DBusDisplayListener *ddl = DBUS_DISPLAY_LISTENER(object);

    if (display_opengl) {
        ddl->dcl.ops = &dbus_gl_dcl_ops;
    } else {
        ddl->dcl.ops = &dbus_dcl_ops;
    }

    G_OBJECT_CLASS(dbus_display_listener_parent_class)->constructed(object);
}

static void
dbus_display_listener_class_init(DBusDisplayListenerClass *klass)
{
    GObjectClass *object_class = G_OBJECT_CLASS(klass);

    object_class->dispose = dbus_display_listener_dispose;
    object_class->constructed = dbus_display_listener_constructed;
}

static void
dbus_display_listener_init(DBusDisplayListener *ddl)
{
}

const char *
dbus_display_listener_get_bus_name(DBusDisplayListener *ddl)
{
    return ddl->bus_name ?: "p2p";
}

DBusDisplayConsole *
dbus_display_listener_get_console(DBusDisplayListener *ddl)
{
    return ddl->console;
}

DBusDisplayListener *
dbus_display_listener_new(const char *bus_name,
                          GDBusConnection *conn,
                          DBusDisplayConsole *console)
{
    DBusDisplayListener *ddl;
    QemuConsole *con;
    g_autoptr(GError) err = NULL;

    ddl = g_object_new(DBUS_DISPLAY_TYPE_LISTENER, NULL);
    ddl->proxy =
        qemu_dbus_display1_listener_proxy_new_sync(conn,
            G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
            NULL,
            "/org/qemu/Display1/Listener",
            NULL,
            &err);
    if (!ddl->proxy) {
        error_report("Failed to setup proxy: %s", err->message);
        g_object_unref(conn);
        g_object_unref(ddl);
        return NULL;
    }

    ddl->bus_name = g_strdup(bus_name);
    ddl->conn = conn;
    ddl->console = console;

    con = qemu_console_lookup_by_index(dbus_display_console_get_index(console));
    assert(con);
    ddl->dcl.con = con;
    register_displaychangelistener(&ddl->dcl);

    return ddl;
}
Commit	Line	Data
142ca628 MAL	1	/*
	2	* QEMU DBus display console
	3	*
	4	* Copyright (c) 2021 Marc-André Lureau <marcandre.lureau@redhat.com>
	5	*
	6	* Permission is hereby granted, free of charge, to any person obtaining a copy
	7	* of this software and associated documentation files (the "Software"), to deal
	8	* in the Software without restriction, including without limitation the rights
	9	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	10	* copies of the Software, and to permit persons to whom the Software is
	11	* furnished to do so, subject to the following conditions:
	12	*
	13	* The above copyright notice and this permission notice shall be included in
	14	* all copies or substantial portions of the Software.
	15	*
	16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	17	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	18	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	19	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	20	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	21	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	22	* THE SOFTWARE.
	23	*/
	24	#include "qemu/osdep.h"
	25	#include "sysemu/sysemu.h"
	26	#include "dbus.h"
	27	#include <gio/gunixfdlist.h>
	28
	29	#include "ui/shader.h"
	30	#include "ui/egl-helpers.h"
	31	#include "ui/egl-context.h"
	32	#include "trace.h"
	33
	34	struct _DBusDisplayListener {
	35	GObject parent;
	36
	37	char *bus_name;
	38	DBusDisplayConsole *console;
	39	GDBusConnection *conn;
	40
	41	QemuDBusDisplay1Listener *proxy;
	42
	43	DisplayChangeListener dcl;
	44	DisplaySurface *ds;
142ca628 MAL	45	int gl_updates;
	46	};
	47
	48	G_DEFINE_TYPE(DBusDisplayListener, dbus_display_listener, G_TYPE_OBJECT)
	49
	50	static void dbus_update_gl_cb(GObject *source_object,
	51	GAsyncResult *res,
	52	gpointer user_data)
	53	{
	54	g_autoptr(GError) err = NULL;
	55	DBusDisplayListener *ddl = user_data;
	56
	57	if (!qemu_dbus_display1_listener_call_update_dmabuf_finish(ddl->proxy,
	58	res, &err)) {
	59	error_report("Failed to call update: %s", err->message);
	60	}
	61
	62	graphic_hw_gl_block(ddl->dcl.con, false);
	63	g_object_unref(ddl);
	64	}
	65
	66	static void dbus_call_update_gl(DBusDisplayListener *ddl,
	67	int x, int y, int w, int h)
	68	{
	69	graphic_hw_gl_block(ddl->dcl.con, true);
	70	glFlush();
	71	qemu_dbus_display1_listener_call_update_dmabuf(ddl->proxy,
	72	x, y, w, h,
	73	G_DBUS_CALL_FLAGS_NONE,
	74	DBUS_DEFAULT_TIMEOUT, NULL,
	75	dbus_update_gl_cb,
	76	g_object_ref(ddl));
	77	}
	78
	79	static void dbus_scanout_disable(DisplayChangeListener *dcl)
	80	{
	81	DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
	82
	83	ddl->ds = NULL;
	84	qemu_dbus_display1_listener_call_disable(
	85	ddl->proxy, G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
	86	}
	87
	88	static void dbus_scanout_dmabuf(DisplayChangeListener *dcl,
	89	QemuDmaBuf *dmabuf)
	90	{
	91	DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
	92	g_autoptr(GError) err = NULL;
	93	g_autoptr(GUnixFDList) fd_list = NULL;
	94
	95	fd_list = g_unix_fd_list_new();
	96	if (g_unix_fd_list_append(fd_list, dmabuf->fd, &err) != 0) {
	97	error_report("Failed to setup dmabuf fdlist: %s", err->message);
	98	return;
	99	}
	100
	101	qemu_dbus_display1_listener_call_scanout_dmabuf(
	102	ddl->proxy,
	103	g_variant_new_handle(0),
	104	dmabuf->width,
	105	dmabuf->height,
	106	dmabuf->stride,
	107	dmabuf->fourcc,
	108	dmabuf->modifier,
109	dmabuf->y0_top,
110	G_DBUS_CALL_FLAGS_NONE,
111	-1,
112	fd_list,
113	NULL, NULL, NULL);
114	}
115
116	static void dbus_scanout_texture(DisplayChangeListener *dcl,
117	uint32_t tex_id,
118	bool backing_y_0_top,
119	uint32_t backing_width,
120	uint32_t backing_height,
121	uint32_t x, uint32_t y,
122	uint32_t w, uint32_t h)
123	{
124	QemuDmaBuf dmabuf = {
125	.width = backing_width,
126	.height = backing_height,
127	.y0_top = backing_y_0_top,
128	};
129
130	assert(tex_id);
131	dmabuf.fd = egl_get_fd_for_texture(
132	tex_id, (EGLint *)&dmabuf.stride,
133	(EGLint *)&dmabuf.fourcc,
134	&dmabuf.modifier);
135	if (dmabuf.fd < 0) {
136	error_report("%s: failed to get fd for texture", __func__);
137	return;
138	}
139
140	dbus_scanout_dmabuf(dcl, &dmabuf);
141	close(dmabuf.fd);
142	}
143
144	static void dbus_cursor_dmabuf(DisplayChangeListener *dcl,
145	QemuDmaBuf *dmabuf, bool have_hot,
146	uint32_t hot_x, uint32_t hot_y)
147	{
148	DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
149	DisplaySurface *ds;
150	GVariant *v_data = NULL;
151	egl_fb cursor_fb;
152
153	if (!dmabuf) {
154	qemu_dbus_display1_listener_call_mouse_set(
155	ddl->proxy, 0, 0, false,
156	G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
157	return;
158	}
159
160	egl_dmabuf_import_texture(dmabuf);
161	if (!dmabuf->texture) {
162	return;
163	}
164	egl_fb_setup_for_tex(&cursor_fb, dmabuf->width, dmabuf->height,
165	dmabuf->texture, false);
166	ds = qemu_create_displaysurface(dmabuf->width, dmabuf->height);
167	egl_fb_read(ds, &cursor_fb);
168
169	v_data = g_variant_new_from_data(
170	G_VARIANT_TYPE("ay"),
171	surface_data(ds),
172	surface_width(ds) * surface_height(ds) * 4,
173	TRUE,
174	(GDestroyNotify)qemu_free_displaysurface,
175	ds);
176	qemu_dbus_display1_listener_call_cursor_define(
177	ddl->proxy,
178	surface_width(ds),
179	surface_height(ds),
180	hot_x,
181	hot_y,
182	v_data,
183	G_DBUS_CALL_FLAGS_NONE,
184	-1,
185	NULL,
186	NULL,
187	NULL);
188	}
189
190	static void dbus_cursor_position(DisplayChangeListener *dcl,
191	uint32_t pos_x, uint32_t pos_y)
192	{
193	DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
194
195	qemu_dbus_display1_listener_call_mouse_set(
196	ddl->proxy, pos_x, pos_y, true,
197	G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
198	}
199
200	static void dbus_release_dmabuf(DisplayChangeListener *dcl,
201	QemuDmaBuf *dmabuf)
202	{
203	dbus_scanout_disable(dcl);
204	}
205
206	static void dbus_scanout_update(DisplayChangeListener *dcl,
207	uint32_t x, uint32_t y,
208	uint32_t w, uint32_t h)
209	{
210	DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
211
212	dbus_call_update_gl(ddl, x, y, w, h);
213	}
214
215	static void dbus_gl_refresh(DisplayChangeListener *dcl)
216	{
217	DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
218
219	graphic_hw_update(dcl->con);
220
221	if (!ddl->ds \|\| qemu_console_is_gl_blocked(ddl->dcl.con)) {
222	return;
223	}
224
225	if (ddl->gl_updates) {
226	dbus_call_update_gl(ddl, 0, 0,
227	surface_width(ddl->ds), surface_height(ddl->ds));
228	ddl->gl_updates = 0;
229	}
230	}
231
232	static void dbus_refresh(DisplayChangeListener *dcl)
233	{
234	graphic_hw_update(dcl->con);
235	}
236
237	static void dbus_gl_gfx_update(DisplayChangeListener *dcl,
238	int x, int y, int w, int h)
239	{
240	DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
241
142ca628 MAL	242	ddl->gl_updates++;
	243	}
	244
	245	static void dbus_gfx_update(DisplayChangeListener *dcl,
	246	int x, int y, int w, int h)
	247	{
	248	DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
	249	pixman_image_t *img;
	250	GVariant *v_data;
	251	size_t stride;
	252
	253	assert(ddl->ds);
	254	stride = w * DIV_ROUND_UP(PIXMAN_FORMAT_BPP(surface_format(ddl->ds)), 8);
	255
	256	trace_dbus_update(x, y, w, h);
	257
2fa2386e MAL	258	if (x == 0 && y == 0 && w == surface_width(ddl->ds) && h == surface_height(ddl->ds)) {
	259	v_data = g_variant_new_from_data(
	260	G_VARIANT_TYPE("ay"),
	261	surface_data(ddl->ds),
	262	surface_stride(ddl->ds) * surface_height(ddl->ds),
	263	TRUE,
	264	(GDestroyNotify)pixman_image_unref,
	265	pixman_image_ref(ddl->ds->image));
	266	qemu_dbus_display1_listener_call_scanout(
	267	ddl->proxy,
	268	surface_width(ddl->ds),
	269	surface_height(ddl->ds),
	270	surface_stride(ddl->ds),
	271	surface_format(ddl->ds),
	272	v_data,
	273	G_DBUS_CALL_FLAGS_NONE,
	274	DBUS_DEFAULT_TIMEOUT, NULL, NULL, NULL);
	275	return;
	276	}
	277
142ca628 MAL	278	/* make a copy, since gvariant only handles linear data */
	279	img = pixman_image_create_bits(surface_format(ddl->ds),
	280	w, h, NULL, stride);
	281	pixman_image_composite(PIXMAN_OP_SRC, ddl->ds->image, NULL, img,
	282	x, y, 0, 0, 0, 0, w, h);
	283
	284	v_data = g_variant_new_from_data(
	285	G_VARIANT_TYPE("ay"),
	286	pixman_image_get_data(img),
	287	pixman_image_get_stride(img) * h,
	288	TRUE,
	289	(GDestroyNotify)pixman_image_unref,
	290	img);
	291	qemu_dbus_display1_listener_call_update(ddl->proxy,
	292	x, y, w, h, pixman_image_get_stride(img), pixman_image_get_format(img),
	293	v_data,
	294	G_DBUS_CALL_FLAGS_NONE,
	295	DBUS_DEFAULT_TIMEOUT, NULL, NULL, NULL);
	296	}
	297
	298	static void dbus_gl_gfx_switch(DisplayChangeListener *dcl,
	299	struct DisplaySurface *new_surface)
	300	{
	301	DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
	302
142ca628 MAL	303	ddl->ds = new_surface;
	304	if (ddl->ds) {
	305	int width = surface_width(ddl->ds);
	306	int height = surface_height(ddl->ds);
	307
142ca628 MAL	308	/* TODO: lazy send dmabuf (there are unnecessary sent otherwise) */
	309	dbus_scanout_texture(&ddl->dcl, ddl->ds->texture, false,
	310	width, height, 0, 0, width, height);
	311	}
	312	}
	313
	314	static void dbus_gfx_switch(DisplayChangeListener *dcl,
	315	struct DisplaySurface *new_surface)
	316	{
	317	DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
142ca628 MAL	318
	319	ddl->ds = new_surface;
	320	if (!ddl->ds) {
	321	/* why not call disable instead? */
	322	return;
	323	}
142ca628 MAL	324	}
	325
	326	static void dbus_mouse_set(DisplayChangeListener *dcl,
	327	int x, int y, int on)
	328	{
	329	DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
	330
	331	qemu_dbus_display1_listener_call_mouse_set(
	332	ddl->proxy, x, y, on, G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
	333	}
	334
	335	static void dbus_cursor_define(DisplayChangeListener *dcl,
	336	QEMUCursor *c)
	337	{
	338	DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
	339	GVariant *v_data = NULL;
	340
	341	cursor_get(c);
	342	v_data = g_variant_new_from_data(
	343	G_VARIANT_TYPE("ay"),
	344	c->data,
	345	c->width * c->height * 4,
	346	TRUE,
	347	(GDestroyNotify)cursor_put,
	348	c);
	349
	350	qemu_dbus_display1_listener_call_cursor_define(
	351	ddl->proxy,
	352	c->width,
	353	c->height,
	354	c->hot_x,
	355	c->hot_y,
	356	v_data,
	357	G_DBUS_CALL_FLAGS_NONE,
	358	-1,
	359	NULL,
	360	NULL,
	361	NULL);
	362	}
	363
	364	const DisplayChangeListenerOps dbus_gl_dcl_ops = {
	365	.dpy_name = "dbus-gl",
	366	.dpy_gfx_update = dbus_gl_gfx_update,
	367	.dpy_gfx_switch = dbus_gl_gfx_switch,
	368	.dpy_gfx_check_format = console_gl_check_format,
	369	.dpy_refresh = dbus_gl_refresh,
	370	.dpy_mouse_set = dbus_mouse_set,
	371	.dpy_cursor_define = dbus_cursor_define,
	372
	373	.dpy_gl_scanout_disable = dbus_scanout_disable,
	374	.dpy_gl_scanout_texture = dbus_scanout_texture,
	375	.dpy_gl_scanout_dmabuf = dbus_scanout_dmabuf,
	376	.dpy_gl_cursor_dmabuf = dbus_cursor_dmabuf,
	377	.dpy_gl_cursor_position = dbus_cursor_position,
	378	.dpy_gl_release_dmabuf = dbus_release_dmabuf,
	379	.dpy_gl_update = dbus_scanout_update,
	380	};
	381
	382	const DisplayChangeListenerOps dbus_dcl_ops = {
	383	.dpy_name = "dbus",
	384	.dpy_gfx_update = dbus_gfx_update,
	385	.dpy_gfx_switch = dbus_gfx_switch,
	386	.dpy_refresh = dbus_refresh,
	387	.dpy_mouse_set = dbus_mouse_set,
388	.dpy_cursor_define = dbus_cursor_define,
389	};
390
391	static void
392	dbus_display_listener_dispose(GObject *object)
393	{
394	DBusDisplayListener *ddl = DBUS_DISPLAY_LISTENER(object);
395
396	unregister_displaychangelistener(&ddl->dcl);
397	g_clear_object(&ddl->conn);
398	g_clear_pointer(&ddl->bus_name, g_free);
399	g_clear_object(&ddl->proxy);
142ca628 MAL	400
	401	G_OBJECT_CLASS(dbus_display_listener_parent_class)->dispose(object);
	402	}
	403
	404	static void
	405	dbus_display_listener_constructed(GObject *object)
	406	{
	407	DBusDisplayListener *ddl = DBUS_DISPLAY_LISTENER(object);
	408
	409	if (display_opengl) {
142ca628 MAL	410	ddl->dcl.ops = &dbus_gl_dcl_ops;
	411	} else {
	412	ddl->dcl.ops = &dbus_dcl_ops;
	413	}
	414
	415	G_OBJECT_CLASS(dbus_display_listener_parent_class)->constructed(object);
	416	}
	417
	418	static void
	419	dbus_display_listener_class_init(DBusDisplayListenerClass *klass)
	420	{
	421	GObjectClass *object_class = G_OBJECT_CLASS(klass);
	422
	423	object_class->dispose = dbus_display_listener_dispose;
	424	object_class->constructed = dbus_display_listener_constructed;
	425	}
	426
	427	static void
	428	dbus_display_listener_init(DBusDisplayListener *ddl)
	429	{
	430	}
	431
	432	const char *
	433	dbus_display_listener_get_bus_name(DBusDisplayListener *ddl)
	434	{
99997823	435	return ddl->bus_name ?: "p2p";
142ca628 MAL	436	}
	437
	438	DBusDisplayConsole *
	439	dbus_display_listener_get_console(DBusDisplayListener *ddl)
	440	{
	441	return ddl->console;
	442	}
	443
	444	DBusDisplayListener *
	445	dbus_display_listener_new(const char *bus_name,
	446	GDBusConnection *conn,
	447	DBusDisplayConsole *console)
	448	{
	449	DBusDisplayListener *ddl;
	450	QemuConsole *con;
	451	g_autoptr(GError) err = NULL;
	452
	453	ddl = g_object_new(DBUS_DISPLAY_TYPE_LISTENER, NULL);
	454	ddl->proxy =
	455	qemu_dbus_display1_listener_proxy_new_sync(conn,
	456	G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
	457	NULL,
	458	"/org/qemu/Display1/Listener",
	459	NULL,
	460	&err);
	461	if (!ddl->proxy) {
	462	error_report("Failed to setup proxy: %s", err->message);
	463	g_object_unref(conn);
	464	g_object_unref(ddl);
	465	return NULL;
	466	}
	467
	468	ddl->bus_name = g_strdup(bus_name);
	469	ddl->conn = conn;
	470	ddl->console = console;
	471
	472	con = qemu_console_lookup_by_index(dbus_display_console_get_index(console));
	473	assert(con);
	474	ddl->dcl.con = con;
	475	register_displaychangelistener(&ddl->dcl);
	476
	477	return ddl;
	478	}