mirrors
/
weston
mirror of https://gitlab.freedesktop.org/wayland/weston.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

compositor: Use eglBindWaylandDisplayWL

This commit is contained in:
Benjamin Franzke 2011-02-21 16:24:53 +01:00
parent 3b288afd1a
commit faa0a9dfa9
4 changed files with 29 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
compositor/compositor-drm.c
View File

@ -116,8 +116,7 @@ init_egl(struct drm_compositor *ec, struct udev_device *device)
return -1;
}
wlsc_drm_init(&ec->base, fd, filename);
ec->base.drm.fd = fd;
ec->base.display = eglGetDRMDisplayMESA(ec->base.drm.fd);
if (ec->base.display == NULL) {
fprintf(stderr, "failed to create display\n");
@ -294,14 +293,6 @@ create_outputs(struct drm_compositor *ec, int option_connector)
return 0;
}
static int
drm_authenticate(struct wlsc_compositor *c, uint32_t id)
{
struct drm_compositor *ec = (struct drm_compositor *) c;
return drmAuthMagic(ec->base.drm.fd, id);
}
static void
drm_destroy(struct wlsc_compositor *ec)
{
@ -357,7 +348,6 @@ drm_compositor_create(struct wl_display *display, int connector)
}
ec->base.destroy = drm_destroy;
ec->base.authenticate = drm_authenticate;
ec->base.present = drm_compositor_present;
ec->base.create_buffer = wlsc_drm_buffer_create;
ec->base.focus = 1;

40
compositor/compositor-x11.c
View File

@ -106,7 +106,6 @@ x11_input_create(struct x11_compositor *c)
return 0;
}
static int
dri2_connect(struct x11_compositor *c)
{
@ -118,7 +117,6 @@ dri2_connect(struct x11_compositor *c)
xcb_dri2_connect_cookie_t connect_cookie;
xcb_generic_error_t *error;
char path[256];
int fd;
xcb_prefetch_extension_data (c->conn, &xcb_xfixes_id);
xcb_prefetch_extension_data (c->conn, &xcb_dri2_id);
@ -185,37 +183,6 @@ dri2_connect(struct x11_compositor *c)
xcb_dri2_connect_device_name (connect));
#endif
free(connect);
fd = open(path, O_RDWR);
if (fd < 0) {
fprintf(stderr,
"DRI2: could not open %s (%s)\n", path, strerror(errno));
return -1;
}
return wlsc_drm_init(&c->base, fd, path);
}
static int
dri2_authenticate(struct x11_compositor *c, uint32_t magic)
{
xcb_dri2_authenticate_reply_t *authenticate;
xcb_dri2_authenticate_cookie_t authenticate_cookie;
authenticate_cookie =
xcb_dri2_authenticate_unchecked(c->conn,
c->screen->root, magic);
authenticate =
xcb_dri2_authenticate_reply(c->conn,
authenticate_cookie, NULL);
if (authenticate == NULL || !authenticate->authenticated) {
fprintf(stderr, "DRI2: failed to authenticate\n");
free(authenticate);
return -1;
}
free(authenticate);
return 0;
}
@ -725,12 +692,6 @@ x11_compositor_get_resources(struct x11_compositor *c)
xcb_free_pixmap(c->conn, pixmap);
}
static int
x11_authenticate(struct wlsc_compositor *c, uint32_t id)
{
return dri2_authenticate((struct x11_compositor *) c, id);
}
static void
x11_destroy(struct wlsc_compositor *ec)
{
@ -767,7 +728,6 @@ x11_compositor_create(struct wl_display *display, int width, int height)
return NULL;
c->base.destroy = x11_destroy;
c->base.authenticate = x11_authenticate;
c->base.present = x11_compositor_present;
c->base.create_buffer = wlsc_drm_buffer_create;

31
compositor/compositor.c
View File

@ -282,6 +282,27 @@ wlsc_load_image(const char *filename, int width, int height)
return (uint32_t *) argb_pixels;
}
static void
wlsc_buffer_attach(struct wl_buffer *buffer, struct wl_surface *surface)
{
struct wlsc_surface *es = (struct wlsc_surface *) surface;
struct wlsc_compositor *ec = es->compositor;
EGLImageKHR *image;
if (buffer->attach) {
buffer->attach(buffer, surface);
} else {
image = eglCreateImageKHR(ec->display, ec->context,
EGL_WAYLAND_BUFFER_WL,
buffer, NULL);
glBindTexture(GL_TEXTURE_2D, es->texture);
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image);
es->visual = buffer->visual;
eglDestroyImageKHR(ec->display, image);
}
}
static struct wl_buffer *
create_buffer_from_png(struct wlsc_compositor *ec,
const char *filename, int width, int height)
@ -354,7 +375,8 @@ background_create(struct wlsc_output *output, const char *filename)
free(background);
return NULL;
}
buffer->attach(buffer, &background->surface);
wlsc_buffer_attach(buffer, &background->surface);
return background;
}
@ -569,7 +591,8 @@ surface_attach(struct wl_client *client,
* damaged by the client. */
wlsc_surface_damage(es);
buffer->attach(buffer, surface);
wlsc_buffer_attach(buffer, surface);
es->buffer = buffer;
es->x += x;
es->y += y;
@ -694,7 +717,7 @@ wlsc_input_device_attach(struct wlsc_input_device *device,
{
wlsc_surface_damage(device->sprite);
buffer->attach(buffer, &device->sprite->surface);
wlsc_buffer_attach(buffer, &device->sprite->surface);
device->hotspot_x = x;
device->hotspot_y = y;
@ -1306,6 +1329,7 @@ wlsc_compositor_init(struct wlsc_compositor *ec, struct wl_display *display)
wl_compositor_init(&ec->compositor, &compositor_interface, display);
wlsc_shm_init(ec);
eglBindWaylandDisplayWL(ec->display, ec->wl_display);
wlsc_shell_init(ec);
@ -1403,6 +1427,7 @@ int main(int argc, char *argv[])
wl_display_run(display);
eglUnbindWaylandDisplayWL(ec->display, display);
wl_display_destroy(display);
ec->destroy(ec);

133
compositor/drm.c
View File

@ -27,45 +27,6 @@ struct wlsc_drm_buffer {
EGLImageKHR image;
};
static void
drm_authenticate(struct wl_client *client,
struct wl_drm *drm_base, uint32_t id)
{
struct wlsc_drm *drm = (struct wlsc_drm *) drm_base;
struct wlsc_compositor *compositor =
container_of(drm, struct wlsc_compositor, drm);
if (compositor->authenticate(compositor, id) < 0)
wl_client_post_event(client,
(struct wl_object *) compositor->wl_display,
WL_DISPLAY_INVALID_OBJECT, 0);
else
wl_client_post_event(client, &drm->object,
WL_DRM_AUTHENTICATED);
}
static void
destroy_buffer(struct wl_resource *resource, struct wl_client *client)
{
struct wlsc_drm_buffer *buffer =
container_of(resource, struct wlsc_drm_buffer, buffer.resource);
struct wlsc_compositor *compositor =
(struct wlsc_compositor *) buffer->buffer.compositor;
eglDestroyImageKHR(compositor->display, buffer->image);
free(buffer);
}
static void
buffer_destroy(struct wl_client *client, struct wl_buffer *buffer)
{
wl_resource_destroy(&buffer->resource, client);
}
const static struct wl_buffer_interface buffer_interface = {
buffer_destroy
};
static void
drm_buffer_attach(struct wl_buffer *buffer_base, struct wl_surface *surface)
{
@ -108,100 +69,6 @@ wlsc_drm_buffer_create_for_image(struct wlsc_compositor *compositor,
return buffer;
}
static void
drm_create_buffer(struct wl_client *client, struct wl_drm *drm_base,
uint32_t id, uint32_t name, int32_t width, int32_t height,
uint32_t stride, struct wl_visual *visual)
{
struct wlsc_drm *drm = (struct wlsc_drm *) drm_base;
struct wlsc_compositor *compositor =
container_of(drm, struct wlsc_compositor, drm);
struct wlsc_drm_buffer *buffer;
EGLImageKHR image;
EGLint attribs[] = {
EGL_WIDTH, 0,
EGL_HEIGHT, 0,
EGL_DRM_BUFFER_STRIDE_MESA, 0,
EGL_DRM_BUFFER_FORMAT_MESA, EGL_DRM_BUFFER_FORMAT_ARGB32_MESA,
EGL_NONE
};
if (visual->object.interface != &wl_visual_interface) {
/* FIXME: Define a real exception event instead of
* abusing this one */
wl_client_post_event(client,
(struct wl_object *) compositor->wl_display,
WL_DISPLAY_INVALID_OBJECT, 0);
fprintf(stderr, "invalid visual in create_buffer\n");
return;
}
attribs[1] = width;
attribs[3] = height;
attribs[5] = stride / 4;
image = eglCreateImageKHR(compositor->display,
EGL_NO_CONTEXT,
EGL_DRM_BUFFER_MESA,
(EGLClientBuffer) name, attribs);
if (image == NULL) {
/* FIXME: Define a real exception event instead of
* abusing this one */
wl_client_post_event(client,
(struct wl_object *) compositor->wl_display,
WL_DISPLAY_INVALID_OBJECT, 0);
fprintf(stderr, "failed to create image for name %d\n", name);
return;
}
buffer = wlsc_drm_buffer_create_for_image(compositor, image,
width, height, visual);
if (buffer == NULL) {
eglDestroyImageKHR(compositor->display, image);
wl_client_post_no_memory(client);
return;
}
buffer->buffer.resource.object.id = id;
buffer->buffer.resource.object.interface = &wl_buffer_interface;
buffer->buffer.resource.object.implementation = (void (**)(void))
&buffer_interface;
buffer->buffer.resource.destroy = destroy_buffer;
wl_client_add_resource(client, &buffer->buffer.resource);
}
const static struct wl_drm_interface drm_interface = {
drm_authenticate,
drm_create_buffer
};
static void
post_drm_device(struct wl_client *client, struct wl_object *global)
{
struct wlsc_drm *drm = container_of(global, struct wlsc_drm, object);
wl_client_post_event(client, global, WL_DRM_DEVICE, drm->filename);
}
int
wlsc_drm_init(struct wlsc_compositor *ec, int fd, const char *filename)
{
struct wlsc_drm *drm = &ec->drm;
drm->fd = fd;
drm->filename = strdup(filename);
if (drm->filename == NULL)
return -1;
drm->object.interface = &wl_drm_interface;
drm->object.implementation = (void (**)(void)) &drm_interface;
wl_display_add_object(ec->wl_display, &drm->object);
wl_display_add_global(ec->wl_display, &drm->object, post_drm_device);
return 0;
}
struct wl_buffer *
wlsc_drm_buffer_create(struct wlsc_compositor *ec, int width, int height,
struct wl_visual *visual, const void *data)