mirrors/wayland
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/wayland/wayland.git synced 2025-11-03 09:01:42 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Port window.c to use wayland-egl

Browse source
This commit is contained in:
Kristian Høgsberg 2011-02-04 14:11:33 -05:00
parent 66cea0ad25
commit 297c6313eb
5 changed files with 62 additions and 98 deletions
Download patch file Download diff file Expand all files Collapse all files

2
clients/Makefile.am
View file

@ -31,7 +31,7 @@ libtoytoolkit_la_SOURCES = \
toolkit_libs = \ toolkit_libs = \
libtoytoolkit.la \ libtoytoolkit.la \
$(top_builddir)/wayland/libwayland-client.la \ $(top_builddir)/wayland/libwayland-client.la \
$(CLIENT_LIBS) -lrt -lm $(CLIENT_LIBS) -lrt -lm -lwayland-egl
gears_SOURCES = gears.c gears_SOURCES = gears.c
gears_LDADD = $(toolkit_libs) gears_LDADD = $(toolkit_libs)

2
clients/flower.c
View file

@ -148,7 +148,7 @@ int main(int argc, char *argv[])
window_draw(flower.window); window_draw(flower.window);
s = window_get_surface(flower.window); s = window_get_surface(flower.window);
if (s == NULL || cairo_surface_status (s) != CAIRO_STATUS_SUCCESS) { if (s == NULL || cairo_surface_status (s) != CAIRO_STATUS_SUCCESS) {
fprintf(stderr, "failed to create cairo drm surface\n"); fprintf(stderr, "failed to create cairo egl surface\n");
return -1; return -1;
} }

4
clients/gears.c
View file

@ -213,8 +213,8 @@ allocate_buffer(struct gears *gears)
gears->surface[gears->current] = window_get_surface(gears->window); gears->surface[gears->current] = window_get_surface(gears->window);
#ifdef HAVE_CAIRO_EGL #ifdef HAVE_CAIRO_EGL
image = display_get_image_for_drm_surface(gears->display, image = display_get_image_for_egl_image_surface(gears->display,
gears->surface[gears->current]); gears->surface[gears->current]);
#else /* XXX: hack to make Wayland compile, even if this example doesn't run */ #else /* XXX: hack to make Wayland compile, even if this example doesn't run */
die("gears cannot allocate buffer: it was compiled without cairo-gl\n"); die("gears cannot allocate buffer: it was compiled without cairo-gl\n");
return; return;

146
clients/window.c
View file

@ -34,7 +34,6 @@
#include <glib.h> #include <glib.h>
#include <glib-object.h> #include <glib-object.h>
#include <gdk-pixbuf/gdk-pixbuf.h> #include <gdk-pixbuf/gdk-pixbuf.h>
#include <xf86drm.h>
#include <sys/mman.h> #include <sys/mman.h>
#define EGL_EGLEXT_PROTOTYPES 1 #define EGL_EGLEXT_PROTOTYPES 1
@ -49,6 +48,8 @@
#include <X11/extensions/XKBcommon.h> #include <X11/extensions/XKBcommon.h>
#include <wayland-egl.h>
#include <linux/input.h> #include <linux/input.h>
#include "wayland-util.h" #include "wayland-util.h"
#include "wayland-client.h" #include "wayland-client.h"
@ -59,9 +60,9 @@
struct display { struct display {
struct wl_display *display; struct wl_display *display;
struct wl_egl_display *native_dpy;
struct wl_compositor *compositor; struct wl_compositor *compositor;
struct wl_shell *shell; struct wl_shell *shell;
struct wl_drm *drm;
struct wl_shm *shm; struct wl_shm *shm;
struct wl_output *output; struct wl_output *output;
struct rectangle screen_allocation; struct rectangle screen_allocation;
@ -185,17 +186,18 @@ struct surface_data {
#ifdef HAVE_CAIRO_EGL #ifdef HAVE_CAIRO_EGL
struct drm_surface_data { struct egl_image_surface_data {
struct surface_data data; struct surface_data data;
EGLImageKHR image; EGLImageKHR image;
GLuint texture; GLuint texture;
struct display *display; struct display *display;
struct wl_egl_pixmap *pixmap;
}; };
static void static void
drm_surface_data_destroy(void *p) egl_image_surface_data_destroy(void *p)
{ {
struct drm_surface_data *data = p; struct egl_image_surface_data *data = p;
struct display *d = data->display; struct display *d = data->display;
cairo_device_acquire(d->device); cairo_device_acquire(d->device);
@ -204,13 +206,15 @@ drm_surface_data_destroy(void *p)
eglDestroyImageKHR(d->dpy, data->image); eglDestroyImageKHR(d->dpy, data->image);
wl_buffer_destroy(data->data.buffer); wl_buffer_destroy(data->data.buffer);
wl_egl_native_pixmap_destroy(data->pixmap);
free(p);
} }
EGLImageKHR EGLImageKHR
display_get_image_for_drm_surface(struct display *display, display_get_image_for_egl_image_surface(struct display *display,
cairo_surface_t *surface) cairo_surface_t *surface)
{ {
struct drm_surface_data *data; struct egl_image_surface_data *data;
data = cairo_surface_get_user_data (surface, &surface_data_key); data = cairo_surface_get_user_data (surface, &surface_data_key);
@ -218,22 +222,13 @@ display_get_image_for_drm_surface(struct display *display,
} }
static cairo_surface_t * static cairo_surface_t *
display_create_drm_surface(struct display *display, display_create_egl_image_surface(struct display *display,
struct rectangle *rectangle) struct rectangle *rectangle)
{ {
struct drm_surface_data *data; struct egl_image_surface_data *data;
EGLDisplay dpy = display->dpy; EGLDisplay dpy = display->dpy;
cairo_surface_t *surface; cairo_surface_t *surface;
struct wl_visual *visual; struct wl_visual *visual;
EGLint name, stride;
EGLint image_attribs[] = {
EGL_WIDTH, 0,
EGL_HEIGHT, 0,
EGL_DRM_BUFFER_FORMAT_MESA, EGL_DRM_BUFFER_FORMAT_ARGB32_MESA,
EGL_DRM_BUFFER_USE_MESA, EGL_DRM_BUFFER_USE_SCANOUT_MESA,
EGL_NONE
};
data = malloc(sizeof *data); data = malloc(sizeof *data);
if (data == NULL) if (data == NULL)
@ -241,28 +236,35 @@ display_create_drm_surface(struct display *display,
data->display = display; data->display = display;
image_attribs[1] = rectangle->width; visual = wl_display_get_premultiplied_argb_visual(display->display);
image_attribs[3] = rectangle->height; data->pixmap =wl_egl_native_pixmap_create(display->native_dpy,
data->image = eglCreateDRMImageMESA(dpy, image_attribs); rectangle->width,
rectangle->height,
if (data->image == EGL_NO_IMAGE_KHR) { visual, 0);
if (data->pixmap == NULL) {
free(data); free(data);
return NULL; return NULL;
} }
data->image = eglCreateImageKHR(dpy, NULL,
EGL_NATIVE_PIXMAP_KHR,
(EGLClientBuffer) data->pixmap, NULL);
if (data->image == EGL_NO_IMAGE_KHR) {
wl_egl_native_pixmap_destroy(data->pixmap);
free(data);
return NULL;
}
data->data.buffer =
wl_egl_native_pixmap_create_buffer(display->native_dpy,
data->pixmap);
cairo_device_acquire(display->device); cairo_device_acquire(display->device);
glGenTextures(1, &data->texture); glGenTextures(1, &data->texture);
glBindTexture(GL_TEXTURE_2D, data->texture); glBindTexture(GL_TEXTURE_2D, data->texture);
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, data->image); glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, data->image);
cairo_device_release(display->device); cairo_device_release(display->device);
eglExportDRMImageMESA(display->dpy, data->image, &name, NULL, &stride);
visual = wl_display_get_premultiplied_argb_visual(display->display);
data->data.buffer =
wl_drm_create_buffer(display->drm, name, rectangle->width,
rectangle->height, stride, visual);
surface = cairo_gl_surface_create_for_texture(display->device, surface = cairo_gl_surface_create_for_texture(display->device,
CAIRO_CONTENT_COLOR_ALPHA, CAIRO_CONTENT_COLOR_ALPHA,
data->texture, data->texture,
@ -270,22 +272,22 @@ display_create_drm_surface(struct display *display,
rectangle->height); rectangle->height);
cairo_surface_set_user_data (surface, &surface_data_key, cairo_surface_set_user_data (surface, &surface_data_key,
data, drm_surface_data_destroy); data, egl_image_surface_data_destroy);
return surface; return surface;
} }
static cairo_surface_t * static cairo_surface_t *
display_create_drm_surface_from_file(struct display *display, display_create_egl_image_surface_from_file(struct display *display,
const char *filename, const char *filename,
struct rectangle *rect) struct rectangle *rect)
{ {
cairo_surface_t *surface; cairo_surface_t *surface;
GdkPixbuf *pixbuf; GdkPixbuf *pixbuf;
GError *error = NULL; GError *error = NULL;
int stride, i; int stride, i;
unsigned char *pixels, *p, *end; unsigned char *pixels, *p, *end;
struct drm_surface_data *data; struct egl_image_surface_data *data;
pixbuf = gdk_pixbuf_new_from_file_at_scale(filename, pixbuf = gdk_pixbuf_new_from_file_at_scale(filename,
rect->width, rect->height, rect->width, rect->height,
@ -317,7 +319,7 @@ display_create_drm_surface_from_file(struct display *display,
} }
} }
surface = display_create_drm_surface(display, rect); surface = display_create_egl_image_surface(display, rect);
if (surface == NULL) { if (surface == NULL) {
g_object_unref(pixbuf); g_object_unref(pixbuf);
return NULL; return NULL;
@ -500,8 +502,8 @@ display_create_surface(struct display *display,
if (check_size(rectangle) < 0) if (check_size(rectangle) < 0)
return NULL; return NULL;
#ifdef HAVE_CAIRO_EGL #ifdef HAVE_CAIRO_EGL
if (display->drm) { if (display->dpy) {
return display_create_drm_surface(display, rectangle); return display_create_egl_image_surface(display, rectangle);
} }
#endif #endif
return display_create_shm_surface(display, rectangle); return display_create_shm_surface(display, rectangle);
@ -515,8 +517,10 @@ display_create_surface_from_file(struct display *display,
if (check_size(rectangle) < 0) if (check_size(rectangle) < 0)
return NULL; return NULL;
#ifdef HAVE_CAIRO_EGL #ifdef HAVE_CAIRO_EGL
if (display->drm) { if (display->dpy) {
return display_create_drm_surface_from_file(display, filename, rectangle); return display_create_egl_image_surface_from_file(display,
filename,
rectangle);
} }
#endif #endif
return display_create_shm_surface_from_file(display, filename, rectangle); return display_create_shm_surface_from_file(display, filename, rectangle);
@ -667,7 +671,7 @@ window_create_surface(struct window *window)
switch (window->buffer_type) { switch (window->buffer_type) {
#ifdef HAVE_CAIRO_EGL #ifdef HAVE_CAIRO_EGL
case WINDOW_BUFFER_TYPE_DRM: case WINDOW_BUFFER_TYPE_EGL_IMAGE:
surface = display_create_surface(window->display, surface = display_create_surface(window->display,
&window->allocation); &window->allocation);
break; break;
@ -1318,8 +1322,8 @@ window_create_internal(struct display *display, struct window *parent,
window->margin = 16; window->margin = 16;
window->decoration = 1; window->decoration = 1;
if (display->drm) if (display->dpy)
window->buffer_type = WINDOW_BUFFER_TYPE_DRM; window->buffer_type = WINDOW_BUFFER_TYPE_EGL_IMAGE;
else else
window->buffer_type = WINDOW_BUFFER_TYPE_SHM; window->buffer_type = WINDOW_BUFFER_TYPE_SHM;
@ -1364,26 +1368,6 @@ window_set_buffer_type(struct window *window, enum window_buffer_type type)
window->buffer_type = type; window->buffer_type = type;
} }
static void
drm_handle_device(void *data, struct wl_drm *drm, const char *device)
{
struct display *d = data;
d->device_name = strdup(device);
}
static void drm_handle_authenticated(void *data, struct wl_drm *drm)
{
struct display *d = data;
d->authenticated = 1;
}
static const struct wl_drm_listener drm_listener = {
drm_handle_device,
drm_handle_authenticated
};
static void static void
display_handle_geometry(void *data, display_handle_geometry(void *data,
struct wl_output *output, struct wl_output *output,
@ -1544,9 +1528,6 @@ display_handle_global(struct wl_display *display, uint32_t id,
} else if (strcmp(interface, "shell") == 0) { } else if (strcmp(interface, "shell") == 0) {
d->shell = wl_shell_create(display, id); d->shell = wl_shell_create(display, id);
wl_shell_add_listener(d->shell, &shell_listener, d); wl_shell_add_listener(d->shell, &shell_listener, d);
} else if (strcmp(interface, "drm") == 0) {
d->drm = wl_drm_create(display, id);
wl_drm_add_listener(d->drm, &drm_listener, d);
} else if (strcmp(interface, "shm") == 0) { } else if (strcmp(interface, "shm") == 0) {
d->shm = wl_shm_create(display, id); d->shm = wl_shm_create(display, id);
} else if (strcmp(interface, "selection_offer") == 0) { } else if (strcmp(interface, "selection_offer") == 0) {
@ -1609,30 +1590,11 @@ init_xkb(struct display *d)
} }
static int static int
init_drm(struct display *d) init_egl(struct display *d)
{ {
EGLint major, minor; EGLint major, minor;
int fd;
drm_magic_t magic;
fd = open(d->device_name, O_RDWR); d->dpy = eglGetDisplay((EGLNativeDisplayType) d->native_dpy);
if (fd < 0) {
fprintf(stderr, "drm open failed: %m\n");
return -1;
}
if (drmGetMagic(fd, &magic)) {
fprintf(stderr, "DRI2: failed to get drm magic\n");
return -1;
}
/* Wait for authenticated event */
wl_drm_authenticate(d->drm, magic);
wl_display_iterate(d->display, WL_DISPLAY_WRITABLE);
while (!d->authenticated)
wl_display_iterate(d->display, WL_DISPLAY_READABLE);
d->dpy = eglGetDRMDisplayMESA(fd);
if (!eglInitialize(d->dpy, &major, &minor)) { if (!eglInitialize(d->dpy, &major, &minor)) {
fprintf(stderr, "failed to initialize display\n"); fprintf(stderr, "failed to initialize display\n");
return -1; return -1;
@ -1657,7 +1619,7 @@ init_drm(struct display *d)
#ifdef HAVE_CAIRO_EGL #ifdef HAVE_CAIRO_EGL
d->device = cairo_egl_device_create(d->dpy, d->ctx); d->device = cairo_egl_device_create(d->dpy, d->ctx);
if (d->device == NULL) { if (d->device == NULL) {
fprintf(stderr, "failed to get cairo drm device\n"); fprintf(stderr, "failed to get cairo egl device\n");
return -1; return -1;
} }
#endif #endif
@ -1711,10 +1673,12 @@ display_create(int *argc, char **argv[], const GOptionEntry *option_entries)
wl_display_add_global_listener(d->display, wl_display_add_global_listener(d->display,
display_handle_global, d); display_handle_global, d);
d->native_dpy = wl_egl_native_display_create(d->display);
/* Process connection events. */ /* Process connection events. */
wl_display_iterate(d->display, WL_DISPLAY_READABLE); wl_display_iterate(d->display, WL_DISPLAY_READABLE);
if (d->device_name && init_drm(d) < 0) if (init_egl(d) < 0)
return NULL; return NULL;
create_pointer_surfaces(d); create_pointer_surfaces(d);

6
clients/window.h
View file

@ -57,8 +57,8 @@ display_get_egl_display(struct display *d);
#ifdef HAVE_CAIRO_EGL #ifdef HAVE_CAIRO_EGL
EGLImageKHR EGLImageKHR
display_get_image_for_drm_surface(struct display *display, display_get_image_for_egl_image_surface(struct display *display,
cairo_surface_t *surface); cairo_surface_t *surface);
#endif #endif
#endif #endif
@ -167,7 +167,7 @@ void
window_create_surface(struct window *window); window_create_surface(struct window *window);
enum window_buffer_type { enum window_buffer_type {
WINDOW_BUFFER_TYPE_DRM, WINDOW_BUFFER_TYPE_EGL_IMAGE,
WINDOW_BUFFER_TYPE_SHM, WINDOW_BUFFER_TYPE_SHM,
}; };