mirrors/wayland
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/wayland/wayland.git synced 2025-11-01 22:58:40 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Move example compositor to subdirectory

Browse source
This commit is contained in:
Kristian Høgsberg 2010-09-14 10:45:00 -04:00
parent ef2f485056
commit 76b43326a5
10 changed files with 33 additions and 14 deletions
Download patch file Download diff file Expand all files Collapse all files

18
compositor/Makefile Normal file
View file

@ -0,0 +1,18 @@
include ../config.mk
CFLAGS += $(COMPOSITOR_CFLAGS)
LDLIBS += -L.. -lwayland-server $(COMPOSITOR_LIBS) -rdynamic -lrt -lEGL -lm
all : compositor
compositor : \
compositor.o \
compositor-drm.o \
compositor-x11.o \
screenshooter.o \
drm.o
clean :
rm -f compositor *.o .*.deps
install :

683
compositor/compositor-drm.c Normal file
View file

@ -0,0 +1,683 @@
/*
* Copyright © 2008-2010 Kristian Høgsberg
*
* 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 of the License, or
* (at your option) any later version.
*
* 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, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <signal.h>
#include <linux/vt.h>
#include <linux/input.h>
#define GL_GLEXT_PROTOTYPES
#define EGL_EGLEXT_PROTOTYPES
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include "compositor.h"
struct drm_compositor {
struct wlsc_compositor base;
struct udev *udev;
struct wl_event_source *drm_source;
struct wl_event_source *term_signal_source;
/* tty handling state */
int tty_fd;
uint32_t vt_active : 1;
struct termios terminal_attributes;
struct wl_event_source *tty_input_source;
struct wl_event_source *enter_vt_source;
struct wl_event_source *leave_vt_source;
};
struct drm_output {
struct wlsc_output base;
drmModeModeInfo mode;
uint32_t crtc_id;
uint32_t connector_id;
GLuint rbo[2];
uint32_t fb_id[2];
EGLImageKHR image[2];
uint32_t current;
};
struct drm_input {
struct wlsc_input_device base;
};
struct evdev_input_device {
struct drm_input *master;
struct wl_event_source *source;
int tool, new_x, new_y;
int base_x, base_y;
int fd;
};
static void evdev_input_device_data(int fd, uint32_t mask, void *data)
{
struct drm_compositor *c;
struct evdev_input_device *device = data;
struct input_event ev[8], *e, *end;
int len, value, dx, dy, absolute_event;
int x, y;
uint32_t time;
c = (struct drm_compositor *) device->master->base.ec;
if (!c->vt_active)
return;
dx = 0;
dy = 0;
absolute_event = 0;
x = device->master->base.x;
y = device->master->base.y;
len = read(fd, &ev, sizeof ev);
if (len < 0 || len % sizeof e[0] != 0) {
/* FIXME: handle error... reopen device? */;
return;
}
e = ev;
end = (void *) ev + len;
for (e = ev; e < end; e++) {
/* Get the signed value, earlier kernels had this as unsigned */
value = e->value;
time = e->time.tv_sec * 1000 + e->time.tv_usec / 1000;
switch (e->type) {
case EV_REL:
switch (e->code) {
case REL_X:
dx += value;
break;
case REL_Y:
dy += value;
break;
}
break;
case EV_ABS:
absolute_event = 1;
switch (e->code) {
case ABS_X:
if (device->new_x) {
device->base_x = x - value;
device->new_x = 0;
}
x = device->base_x + value;
break;
case ABS_Y:
if (device->new_y) {
device->base_y = y - value;
device->new_y = 0;
}
y = device->base_y + value;
break;
}
break;
case EV_KEY:
if (value == 2)
break;
switch (e->code) {
case BTN_TOUCH:
case BTN_TOOL_PEN:
case BTN_TOOL_RUBBER:
case BTN_TOOL_BRUSH:
case BTN_TOOL_PENCIL:
case BTN_TOOL_AIRBRUSH:
case BTN_TOOL_FINGER:
case BTN_TOOL_MOUSE:
case BTN_TOOL_LENS:
if (device->tool == 0 && value) {
device->new_x = 1;
device->new_y = 1;
}
device->tool = value ? e->code : 0;
break;
case BTN_LEFT:
case BTN_RIGHT:
case BTN_MIDDLE:
case BTN_SIDE:
case BTN_EXTRA:
case BTN_FORWARD:
case BTN_BACK:
case BTN_TASK:
notify_button(&device->master->base,
time, e->code, value);
break;
default:
notify_key(&device->master->base,
time, e->code, value);
break;
}
}
}
if (dx != 0 || dy != 0)
notify_motion(&device->master->base, time, x + dx, y + dy);
if (absolute_event && device->tool)
notify_motion(&device->master->base, time, x, y);
}
static struct evdev_input_device *
evdev_input_device_create(struct drm_input *master,
struct wl_display *display, const char *path)
{
struct evdev_input_device *device;
struct wl_event_loop *loop;
device = malloc(sizeof *device);
if (device == NULL)
return NULL;
device->tool = 1;
device->new_x = 1;
device->new_y = 1;
device->master = master;
device->fd = open(path, O_RDONLY);
if (device->fd < 0) {
free(device);
fprintf(stderr, "couldn't create pointer for %s: %m\n", path);
return NULL;
}
loop = wl_display_get_event_loop(display);
device->source = wl_event_loop_add_fd(loop, device->fd,
WL_EVENT_READABLE,
evdev_input_device_data, device);
if (device->source == NULL) {
close(device->fd);
free(device);
return NULL;
}
return device;
}
static void
drm_input_create(struct drm_compositor *c)
{
struct drm_input *input;
struct udev_enumerate *e;
struct udev_list_entry *entry;
struct udev_device *device;
const char *path;
input = malloc(sizeof *input);
if (input == NULL)
return;
memset(input, 0, sizeof *input);
wlsc_input_device_init(&input->base, &c->base);
e = udev_enumerate_new(c->udev);
udev_enumerate_add_match_subsystem(e, "input");
udev_enumerate_add_match_property(e, "WAYLAND_SEAT", "1");
udev_enumerate_scan_devices(e);
udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(e)) {
path = udev_list_entry_get_name(entry);
device = udev_device_new_from_syspath(c->udev, path);
evdev_input_device_create(input, c->base.wl_display,
udev_device_get_devnode(device));
}
udev_enumerate_unref(e);
c->base.input_device = &input->base;
}
static void
drm_compositor_present(struct wlsc_compositor *ec)
{
struct drm_compositor *c = (struct drm_compositor *) ec;
struct drm_output *output;
wl_list_for_each(output, &ec->output_list, base.link) {
output->current ^= 1;
glFramebufferRenderbuffer(GL_FRAMEBUFFER,
GL_COLOR_ATTACHMENT0,
GL_RENDERBUFFER,
output->rbo[output->current]);
drmModePageFlip(c->base.drm.fd, output->crtc_id,
output->fb_id[output->current ^ 1],
DRM_MODE_PAGE_FLIP_EVENT, output);
}
}
static void
page_flip_handler(int fd, unsigned int frame,
unsigned int sec, unsigned int usec, void *data)
{
struct wlsc_output *output = data;
struct wlsc_compositor *compositor = output->compositor;
uint32_t msecs;
msecs = sec * 1000 + usec / 1000;
wlsc_compositor_finish_frame(compositor, msecs);
}
static void
on_drm_input(int fd, uint32_t mask, void *data)
{
drmEventContext evctx;
memset(&evctx, 0, sizeof evctx);
evctx.version = DRM_EVENT_CONTEXT_VERSION;
evctx.page_flip_handler = page_flip_handler;
drmHandleEvent(fd, &evctx);
}
static int
init_egl(struct drm_compositor *ec, struct udev_device *device)
{
EGLint major, minor;
const char *extensions, *filename;
int fd;
static const EGLint context_attribs[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
filename = udev_device_get_devnode(device);
fd = open(filename, O_RDWR);
if (fd < 0) {
/* Probably permissions error */
fprintf(stderr, "couldn't open %s, skipping\n",
udev_device_get_devnode(device));
return -1;
}
wlsc_drm_init(&ec->base, fd, filename);
ec->base.display = eglGetDRMDisplayMESA(ec->base.drm.fd);
if (ec->base.display == NULL) {
fprintf(stderr, "failed to create display\n");
return -1;
}
if (!eglInitialize(ec->base.display, &major, &minor)) {
fprintf(stderr, "failed to initialize display\n");
return -1;
}
extensions = eglQueryString(ec->base.display, EGL_EXTENSIONS);
if (!strstr(extensions, "EGL_KHR_surfaceless_opengl")) {
fprintf(stderr, "EGL_KHR_surfaceless_opengl not available\n");
return -1;
}
eglBindAPI(EGL_OPENGL_ES_API);
ec->base.context = eglCreateContext(ec->base.display, NULL,
EGL_NO_CONTEXT, context_attribs);
if (ec->base.context == NULL) {
fprintf(stderr, "failed to create context\n");
return -1;
}
if (!eglMakeCurrent(ec->base.display, EGL_NO_SURFACE,
EGL_NO_SURFACE, ec->base.context)) {
fprintf(stderr, "failed to make context current\n");
return -1;
}
return 0;
}
static drmModeModeInfo builtin_1024x768 = {
63500, /* clock */
1024, 1072, 1176, 1328, 0,
768, 771, 775, 798, 0,
59920,
DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC,
0,
"1024x768"
};
static int
create_output_for_connector(struct drm_compositor *ec,
drmModeRes *resources,
drmModeConnector *connector)
{
struct drm_output *output;
drmModeEncoder *encoder;
drmModeModeInfo *mode;
int i, ret;
EGLint handle, stride, 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
};
output = malloc(sizeof *output);
if (output == NULL)
return -1;
if (connector->count_modes > 0)
mode = &connector->modes[0];
else
mode = &builtin_1024x768;
encoder = drmModeGetEncoder(ec->base.drm.fd, connector->encoders[0]);
if (encoder == NULL) {
fprintf(stderr, "No encoder for connector.\n");
return -1;
}
for (i = 0; i < resources->count_crtcs; i++) {
if (encoder->possible_crtcs & (1 << i))
break;
}
if (i == resources->count_crtcs) {
fprintf(stderr, "No usable crtc for encoder.\n");
return -1;
}
memset(output, 0, sizeof *output);
wlsc_output_init(&output->base, &ec->base, 0, 0,
mode->hdisplay, mode->vdisplay);
output->crtc_id = resources->crtcs[i];
output->connector_id = connector->connector_id;
output->mode = *mode;
drmModeFreeEncoder(encoder);
glGenRenderbuffers(2, output->rbo);
for (i = 0; i < 2; i++) {
glBindRenderbuffer(GL_RENDERBUFFER, output->rbo[i]);
attribs[1] = output->base.width;
attribs[3] = output->base.height;
output->image[i] =
eglCreateDRMImageMESA(ec->base.display, attribs);
glEGLImageTargetRenderbufferStorageOES(GL_RENDERBUFFER,
output->image[i]);
eglExportDRMImageMESA(ec->base.display, output->image[i],
NULL, &handle, &stride);
ret = drmModeAddFB(ec->base.drm.fd,
output->base.width, output->base.height,
32, 32, stride, handle, &output->fb_id[i]);
if (ret) {
fprintf(stderr, "failed to add fb %d: %m\n", i);
return -1;
}
}
output->current = 0;
glFramebufferRenderbuffer(GL_FRAMEBUFFER,
GL_COLOR_ATTACHMENT0,
GL_RENDERBUFFER,
output->rbo[output->current]);
ret = drmModeSetCrtc(ec->base.drm.fd, output->crtc_id,
output->fb_id[output->current ^ 1], 0, 0,
&output->connector_id, 1, &output->mode);
if (ret) {
fprintf(stderr, "failed to set mode: %m\n");
return -1;
}
wl_list_insert(ec->base.output_list.prev, &output->base.link);
return 0;
}
static int
create_outputs(struct drm_compositor *ec)
{
drmModeConnector *connector;
drmModeRes *resources;
int i;
resources = drmModeGetResources(ec->base.drm.fd);
if (!resources) {
fprintf(stderr, "drmModeGetResources failed\n");
return -1;
}
for (i = 0; i < resources->count_connectors; i++) {
connector = drmModeGetConnector(ec->base.drm.fd, resources->connectors[i]);
if (connector == NULL)
continue;
if (connector->connection == DRM_MODE_CONNECTED &&
(option_connector == 0 ||
connector->connector_id == option_connector))
if (create_output_for_connector(ec, resources, connector) < 0)
return -1;
drmModeFreeConnector(connector);
}
if (wl_list_empty(&ec->base.output_list)) {
fprintf(stderr, "No currently active connector found.\n");
return -1;
}
drmModeFreeResources(resources);
return 0;
}
static void on_enter_vt(int signal_number, void *data)
{
struct drm_compositor *ec = data;
struct drm_output *output;
int ret;
ret = drmSetMaster(ec->base.drm.fd);
if (ret) {
fprintf(stderr, "failed to set drm master\n");
kill(0, SIGTERM);
return;
}
fprintf(stderr, "enter vt\n");
ioctl(ec->tty_fd, VT_RELDISP, VT_ACKACQ);
ec->vt_active = 1;
wl_list_for_each(output, &ec->base.output_list, base.link) {
ret = drmModeSetCrtc(ec->base.drm.fd, output->crtc_id,
output->fb_id[output->current ^ 1], 0, 0,
&output->connector_id, 1, &output->mode);
if (ret)
fprintf(stderr,
"failed to set mode for connector %d: %m\n",
output->connector_id);
}
}
static void on_leave_vt(int signal_number, void *data)
{
struct drm_compositor *ec = data;
int ret;
ret = drmDropMaster(ec->base.drm.fd);
if (ret) {
fprintf(stderr, "failed to drop drm master\n");
kill(0, SIGTERM);
return;
}
ioctl (ec->tty_fd, VT_RELDISP, 1);
ec->vt_active = 0;
}
static void
on_tty_input(int fd, uint32_t mask, void *data)
{
struct drm_compositor *ec = data;
/* Ignore input to tty. We get keyboard events from evdev
*/
tcflush(ec->tty_fd, TCIFLUSH);
}
static void on_term_signal(int signal_number, void *data)
{
struct drm_compositor *ec = data;
if (tcsetattr(ec->tty_fd, TCSANOW, &ec->terminal_attributes) < 0)
fprintf(stderr, "could not restore terminal to canonical mode\n");
exit(0);
}
static int setup_tty(struct drm_compositor *ec, struct wl_event_loop *loop)
{
struct termios raw_attributes;
struct vt_mode mode = { 0 };
ec->tty_fd = open("/dev/tty0", O_RDWR | O_NOCTTY);
if (ec->tty_fd <= 0) {
fprintf(stderr, "failed to open active tty: %m\n");
return -1;
}
if (tcgetattr(ec->tty_fd, &ec->terminal_attributes) < 0) {
fprintf(stderr, "could not get terminal attributes: %m\n");
return -1;
}
/* Ignore control characters and disable echo */
raw_attributes = ec->terminal_attributes;
cfmakeraw(&raw_attributes);
/* Fix up line endings to be normal (cfmakeraw hoses them) */
raw_attributes.c_oflag |= OPOST | OCRNL;
if (tcsetattr(ec->tty_fd, TCSANOW, &raw_attributes) < 0)
fprintf(stderr, "could not put terminal into raw mode: %m\n");
ec->term_signal_source =
wl_event_loop_add_signal(loop, SIGTERM, on_term_signal, ec);
ec->tty_input_source =
wl_event_loop_add_fd(loop, ec->tty_fd,
WL_EVENT_READABLE, on_tty_input, ec);
ec->vt_active = 1;
mode.mode = VT_PROCESS;
mode.relsig = SIGUSR1;
mode.acqsig = SIGUSR2;
if (!ioctl(ec->tty_fd, VT_SETMODE, &mode) < 0) {
fprintf(stderr, "failed to take control of vt handling\n");
}
ec->leave_vt_source =
wl_event_loop_add_signal(loop, SIGUSR1, on_leave_vt, ec);
ec->enter_vt_source =
wl_event_loop_add_signal(loop, SIGUSR2, on_enter_vt, ec);
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);
}
struct wlsc_compositor *
drm_compositor_create(struct wl_display *display)
{
struct drm_compositor *ec;
struct udev_enumerate *e;
struct udev_list_entry *entry;
struct udev_device *device;
const char *path;
struct wl_event_loop *loop;
ec = malloc(sizeof *ec);
if (ec == NULL)
return NULL;
memset(ec, 0, sizeof *ec);
ec->udev = udev_new();
if (ec->udev == NULL) {
fprintf(stderr, "failed to initialize udev context\n");
return NULL;
}
e = udev_enumerate_new(ec->udev);
udev_enumerate_add_match_subsystem(e, "drm");
udev_enumerate_add_match_property(e, "WAYLAND_SEAT", "1");
udev_enumerate_scan_devices(e);
device = NULL;
udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(e)) {
path = udev_list_entry_get_name(entry);
device = udev_device_new_from_syspath(ec->udev, path);
break;
}
udev_enumerate_unref(e);
if (device == NULL) {
fprintf(stderr, "no drm device found\n");
return NULL;
}
ec->base.wl_display = display;
if (init_egl(ec, device) < 0) {
fprintf(stderr, "failed to initialize egl\n");
return NULL;
}
/* Can't init base class until we have a current egl context */
if (wlsc_compositor_init(&ec->base, display) < 0)
return NULL;
if (create_outputs(ec) < 0) {
fprintf(stderr, "failed to create output for %s\n", path);
return NULL;
}
drm_input_create(ec);
loop = wl_display_get_event_loop(ec->base.wl_display);
ec->drm_source =
wl_event_loop_add_fd(loop, ec->base.drm.fd,
WL_EVENT_READABLE, on_drm_input, ec);
setup_tty(ec, loop);
ec->base.authenticate = drm_authenticate;
ec->base.present = drm_compositor_present;
ec->base.focus = 1;
return &ec->base;
}

666
compositor/compositor-x11.c Normal file
View file

@ -0,0 +1,666 @@
/*
* Copyright © 2008-2010 Kristian Høgsberg
*
* 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 of the License, or
* (at your option) any later version.
*
* 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, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <sys/time.h>
#include <linux/input.h>
#include <xcb/xcb.h>
#include <xcb/dri2.h>
#include <xcb/xfixes.h>
#define GL_GLEXT_PROTOTYPES
#define EGL_EGLEXT_PROTOTYPES
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include "compositor.h"
#define ARRAY_SIZE(array) (sizeof(array) / sizeof(array[0]))
struct x11_compositor {
struct wlsc_compositor base;
xcb_connection_t *conn;
xcb_screen_t *screen;
xcb_cursor_t null_cursor;
int dri2_major;
int dri2_minor;
struct wl_event_source *xcb_source;
struct {
xcb_atom_t wm_protocols;
xcb_atom_t wm_normal_hints;
xcb_atom_t wm_size_hints;
xcb_atom_t wm_delete_window;
xcb_atom_t net_wm_name;
xcb_atom_t utf8_string;
} atom;
};
struct x11_output {
struct wlsc_output base;
xcb_xfixes_region_t region;
xcb_window_t window;
GLuint rbo;
EGLImageKHR image;
xcb_rectangle_t damage[16];
int damage_count;
};
struct x11_input {
struct wlsc_input_device base;
};
static void
x11_input_create(struct x11_compositor *c)
{
struct x11_input *input;
input = malloc(sizeof *input);
if (input == NULL)
return;
memset(input, 0, sizeof *input);
wlsc_input_device_init(&input->base, &c->base);
c->base.input_device = &input->base;
}
static int
dri2_connect(struct x11_compositor *c)
{
xcb_xfixes_query_version_reply_t *xfixes_query;
xcb_xfixes_query_version_cookie_t xfixes_query_cookie;
xcb_dri2_query_version_reply_t *dri2_query;
xcb_dri2_query_version_cookie_t dri2_query_cookie;
xcb_dri2_connect_reply_t *connect;
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);
xfixes_query_cookie =
xcb_xfixes_query_version(c->conn,
XCB_XFIXES_MAJOR_VERSION,
XCB_XFIXES_MINOR_VERSION);
dri2_query_cookie =
xcb_dri2_query_version (c->conn,
XCB_DRI2_MAJOR_VERSION,
XCB_DRI2_MINOR_VERSION);
connect_cookie = xcb_dri2_connect_unchecked (c->conn,
c->screen->root,
XCB_DRI2_DRIVER_TYPE_DRI);
xfixes_query =
xcb_xfixes_query_version_reply (c->conn,
xfixes_query_cookie, &error);
if (xfixes_query == NULL ||
error != NULL || xfixes_query->major_version < 2) {
free(error);
return -1;
}
free(xfixes_query);
dri2_query =
xcb_dri2_query_version_reply (c->conn,
dri2_query_cookie, &error);
if (dri2_query == NULL || error != NULL) {
fprintf(stderr, "DRI2: failed to query version");
free(error);
return EGL_FALSE;
}
c->dri2_major = dri2_query->major_version;
c->dri2_minor = dri2_query->minor_version;
free(dri2_query);
connect = xcb_dri2_connect_reply (c->conn,
connect_cookie, NULL);
if (connect == NULL ||
connect->driver_name_length + connect->device_name_length == 0) {
fprintf(stderr, "DRI2: failed to authenticate");
return -1;
}
snprintf(path, sizeof path, "%.*s",
xcb_dri2_connect_device_name_length (connect),
xcb_dri2_connect_device_name (connect));
free(connect);
fd = open(path, O_RDWR);
if (fd < 0) {
fprintf(stderr,
"DRI2: could not open %s (%s)", 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");
free(authenticate);
return -1;
}
free(authenticate);
return 0;
}
static int
x11_compositor_init_egl(struct x11_compositor *c)
{
EGLint major, minor;
const char *extensions;
drm_magic_t magic;
static const EGLint context_attribs[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
if (dri2_connect(c) < 0)
return -1;
if (drmGetMagic(c->base.drm.fd, &magic)) {
fprintf(stderr, "DRI2: failed to get drm magic");
return -1;
}
if (dri2_authenticate(c, magic) < 0)
return -1;
c->base.display = eglGetDRMDisplayMESA(c->base.drm.fd);
if (c->base.display == NULL) {
fprintf(stderr, "failed to create display\n");
return -1;
}
if (!eglInitialize(c->base.display, &major, &minor)) {
fprintf(stderr, "failed to initialize display\n");
return -1;
}
extensions = eglQueryString(c->base.display, EGL_EXTENSIONS);
if (!strstr(extensions, "EGL_KHR_surfaceless_opengl")) {
fprintf(stderr, "EGL_KHR_surfaceless_opengl not available\n");
return -1;
}
eglBindAPI(EGL_OPENGL_ES_API);
c->base.context = eglCreateContext(c->base.display, NULL,
EGL_NO_CONTEXT, context_attribs);
if (c->base.context == NULL) {
fprintf(stderr, "failed to create context\n");
return -1;
}
if (!eglMakeCurrent(c->base.display, EGL_NO_SURFACE,
EGL_NO_SURFACE, c->base.context)) {
fprintf(stderr, "failed to make context current\n");
return -1;
}
return 0;
}
static void
x11_compositor_present(struct wlsc_compositor *base)
{
struct x11_compositor *c = (struct x11_compositor *) base;
struct x11_output *output;
xcb_dri2_copy_region_cookie_t cookie;
struct timeval tv;
uint32_t msec;
glFlush();
wl_list_for_each(output, &c->base.output_list, base.link) {
cookie = xcb_dri2_copy_region_unchecked(c->conn,
output->window,
output->region,
XCB_DRI2_ATTACHMENT_BUFFER_FRONT_LEFT,
XCB_DRI2_ATTACHMENT_BUFFER_BACK_LEFT);
free(xcb_dri2_copy_region_reply(c->conn, cookie, NULL));
}
gettimeofday(&tv, NULL);
msec = tv.tv_sec * 1000 + tv.tv_usec / 1000;
wlsc_compositor_finish_frame(&c->base, msec);
}
static void
x11_output_set_wm_protocols(struct x11_output *output)
{
xcb_atom_t list[1];
struct x11_compositor *c =
(struct x11_compositor *) output->base.compositor;
list[0] = c->atom.wm_delete_window;
xcb_change_property (c->conn,
XCB_PROP_MODE_REPLACE,
output->window,
c->atom.wm_protocols,
XCB_ATOM_ATOM,
32,
ARRAY_SIZE(list),
list);
}
struct wm_normal_hints {
uint32_t flags;
uint32_t pad[4];
int32_t min_width, min_height;
int32_t max_width, max_height;
int32_t width_inc, height_inc;
int32_t min_aspect_x, min_aspect_y;
int32_t max_aspect_x, max_aspect_y;
int32_t base_width, base_height;
int32_t win_gravity;
};
#define WM_NORMAL_HINTS_MIN_SIZE 16
#define WM_NORMAL_HINTS_MAX_SIZE 32
static int
x11_compositor_create_output(struct x11_compositor *c, int width, int height)
{
static const char name[] = "Wayland Compositor";
struct x11_output *output;
xcb_dri2_dri2_buffer_t *buffers;
xcb_dri2_get_buffers_reply_t *reply;
xcb_dri2_get_buffers_cookie_t cookie;
xcb_screen_iterator_t iter;
xcb_rectangle_t rectangle;
struct wm_normal_hints normal_hints;
unsigned int attachments[] =
{ XCB_DRI2_ATTACHMENT_BUFFER_BACK_LEFT};
uint32_t mask = XCB_CW_EVENT_MASK | XCB_CW_CURSOR;
uint32_t values[2] = {
XCB_EVENT_MASK_KEY_PRESS |
XCB_EVENT_MASK_KEY_RELEASE |
XCB_EVENT_MASK_BUTTON_PRESS |
XCB_EVENT_MASK_BUTTON_RELEASE |
XCB_EVENT_MASK_POINTER_MOTION |
XCB_EVENT_MASK_EXPOSURE |
XCB_EVENT_MASK_STRUCTURE_NOTIFY |
XCB_EVENT_MASK_ENTER_WINDOW |
XCB_EVENT_MASK_LEAVE_WINDOW,
0
};
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
};
output = malloc(sizeof *output);
if (output == NULL)
return -1;
memset(output, 0, sizeof *output);
wlsc_output_init(&output->base, &c->base, 0, 0, width, height);
values[1] = c->null_cursor;
output->window = xcb_generate_id(c->conn);
iter = xcb_setup_roots_iterator(xcb_get_setup(c->conn));
xcb_create_window(c->conn,
XCB_COPY_FROM_PARENT,
output->window,
iter.data->root,
0, 0,
width, height,
0,
XCB_WINDOW_CLASS_INPUT_OUTPUT,
iter.data->root_visual,
mask, values);
/* Don't resize me. */
memset(&normal_hints, 0, sizeof normal_hints);
normal_hints.flags =
WM_NORMAL_HINTS_MAX_SIZE | WM_NORMAL_HINTS_MIN_SIZE;
normal_hints.min_width = width;
normal_hints.min_height = height;
normal_hints.max_width = width;
normal_hints.max_height = height;
xcb_change_property (c->conn, XCB_PROP_MODE_REPLACE, output->window,
c->atom.wm_normal_hints,
c->atom.wm_size_hints, 32,
sizeof normal_hints / 4,
(uint8_t *) &normal_hints);
xcb_map_window(c->conn, output->window);
/* Set window name. Don't bother with non-EWMH WMs. */
xcb_change_property(c->conn, XCB_PROP_MODE_REPLACE, output->window,
c->atom.net_wm_name, c->atom.utf8_string, 8,
strlen(name), name);
rectangle.x = 0;
rectangle.y = 0;
rectangle.width = width;
rectangle.height = height;
output->region = xcb_generate_id(c->conn);
xcb_xfixes_create_region(c->conn, output->region, 1, &rectangle);
xcb_dri2_create_drawable (c->conn, output->window);
x11_output_set_wm_protocols(output);
cookie = xcb_dri2_get_buffers_unchecked (c->conn,
output->window,
1, 1, attachments);
reply = xcb_dri2_get_buffers_reply (c->conn, cookie, NULL);
if (reply == NULL)
return -1;
buffers = xcb_dri2_get_buffers_buffers (reply);
if (buffers == NULL)
return -1;
if (reply->count != 1) {
fprintf(stderr,
"got wrong number of buffers (%d)\n", reply->count);
return -1;
}
attribs[1] = reply->width;
attribs[3] = reply->height;
attribs[5] = buffers[0].pitch / 4;
output->image =
eglCreateImageKHR(c->base.display, c->base.context,
EGL_DRM_BUFFER_MESA,
(EGLClientBuffer) buffers[0].name,
attribs);
free(reply);
glGenRenderbuffers(1, &output->rbo);
glBindRenderbuffer(GL_RENDERBUFFER, output->rbo);
glEGLImageTargetRenderbufferStorageOES(GL_RENDERBUFFER,
output->image);
glFramebufferRenderbuffer(GL_FRAMEBUFFER,
GL_COLOR_ATTACHMENT0,
GL_RENDERBUFFER,
output->rbo);
wl_list_insert(c->base.output_list.prev, &output->base.link);
return 0;
}
static void
idle_repaint(void *data)
{
struct x11_output *output = data;
struct x11_compositor *c =
(struct x11_compositor *) output->base.compositor;
xcb_xfixes_region_t region;
xcb_dri2_copy_region_cookie_t cookie;
if (output->damage_count <= ARRAY_SIZE(output->damage)) {
region = xcb_generate_id(c->conn);
xcb_xfixes_create_region(c->conn, region,
output->damage_count, output->damage);
} else {
region = output->region;
}
cookie = xcb_dri2_copy_region_unchecked(c->conn,
output->window,
region,
XCB_DRI2_ATTACHMENT_BUFFER_FRONT_LEFT,
XCB_DRI2_ATTACHMENT_BUFFER_BACK_LEFT);
if (region != output->region)
xcb_xfixes_destroy_region(c->conn, region);
free(xcb_dri2_copy_region_reply(c->conn, cookie, NULL));
output->damage_count = 0;
}
static struct x11_output *
x11_compositor_find_output(struct x11_compositor *c, xcb_window_t window)
{
struct x11_output *output;
wl_list_for_each(output, &c->base.output_list, base.link) {
if (output->window == window)
return output;
}
return NULL;
}
static void
x11_compositor_handle_event(int fd, uint32_t mask, void *data)
{
struct x11_compositor *c = data;
struct x11_output *output;
xcb_generic_event_t *event;
struct wl_event_loop *loop;
xcb_client_message_event_t *client_message;
xcb_motion_notify_event_t *motion_notify;
xcb_key_press_event_t *key_press;
xcb_button_press_event_t *button_press;
xcb_expose_event_t *expose;
xcb_rectangle_t *r;
xcb_atom_t atom;
loop = wl_display_get_event_loop(c->base.wl_display);
while (event = xcb_poll_for_event (c->conn), event != NULL) {
switch (event->response_type & ~0x80) {
case XCB_KEY_PRESS:
key_press = (xcb_key_press_event_t *) event;
notify_key(c->base.input_device,
key_press->time, key_press->detail - 8, 1);
break;
case XCB_KEY_RELEASE:
key_press = (xcb_key_press_event_t *) event;
notify_key(c->base.input_device,
key_press->time, key_press->detail - 8, 0);
break;
case XCB_BUTTON_PRESS:
button_press = (xcb_button_press_event_t *) event;
notify_button(c->base.input_device,
button_press->time,
button_press->detail + BTN_LEFT - 1, 1);
break;
case XCB_BUTTON_RELEASE:
button_press = (xcb_button_press_event_t *) event;
notify_button(c->base.input_device,
button_press->time,
button_press->detail + BTN_LEFT - 1, 0);
break;
case XCB_MOTION_NOTIFY:
motion_notify = (xcb_motion_notify_event_t *) event;
notify_motion(c->base.input_device,
motion_notify->time,
motion_notify->event_x,
motion_notify->event_y);
break;
case XCB_EXPOSE:
expose = (xcb_expose_event_t *) event;
output = x11_compositor_find_output(c, expose->window);
if (output->damage_count == 0)
wl_event_loop_add_idle(loop,
idle_repaint, output);
r = &output->damage[output->damage_count++];
if (output->damage_count > 16)
break;
r->x = expose->x;
r->y = expose->y;
r->width = expose->width;
r->height = expose->height;
break;
case XCB_ENTER_NOTIFY:
c->base.focus = 1;
wlsc_compositor_schedule_repaint(&c->base);
break;
case XCB_LEAVE_NOTIFY:
c->base.focus = 0;
wlsc_compositor_schedule_repaint(&c->base);
break;
case XCB_CLIENT_MESSAGE:
client_message = (xcb_client_message_event_t *) event;
atom = client_message->data.data32[0];
if (atom == c->atom.wm_delete_window)
exit(1);
break;
default:
break;
}
free (event);
}
}
#define F(field) offsetof(struct x11_compositor, field)
static void
x11_compositor_get_resources(struct x11_compositor *c)
{
static const struct { const char *name; int offset; } atoms[] = {
{ "WM_PROTOCOLS", F(atom.wm_protocols) },
{ "WM_NORMAL_HINTS", F(atom.wm_normal_hints) },
{ "WM_SIZE_HINTS", F(atom.wm_size_hints) },
{ "WM_DELETE_WINDOW", F(atom.wm_delete_window) },
{ "_NET_WM_NAME", F(atom.net_wm_name) },
{ "UTF8_STRING", F(atom.utf8_string) },
};
xcb_intern_atom_cookie_t cookies[ARRAY_SIZE(atoms)];
xcb_intern_atom_reply_t *reply;
xcb_pixmap_t pixmap;
xcb_gc_t gc;
int i;
uint8_t data[] = { 0, 0, 0, 0 };
for (i = 0; i < ARRAY_SIZE(atoms); i++)
cookies[i] = xcb_intern_atom (c->conn, 0,
strlen(atoms[i].name),
atoms[i].name);
for (i = 0; i < ARRAY_SIZE(atoms); i++) {
reply = xcb_intern_atom_reply (c->conn, cookies[i], NULL);
*(xcb_atom_t *) ((char *) c + atoms[i].offset) = reply->atom;
free(reply);
}
pixmap = xcb_generate_id(c->conn);
gc = xcb_generate_id(c->conn);
xcb_create_pixmap(c->conn, 1, pixmap, c->screen->root, 1, 1);
xcb_create_gc(c->conn, gc, pixmap, 0, NULL);
xcb_put_image(c->conn, XCB_IMAGE_FORMAT_XY_PIXMAP,
pixmap, gc, 1, 1, 0, 0, 0, 32, sizeof data, data);
c->null_cursor = xcb_generate_id(c->conn);
xcb_create_cursor (c->conn, c->null_cursor,
pixmap, pixmap, 0, 0, 0, 0, 0, 0, 1, 1);
xcb_free_gc(c->conn, gc);
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);
}
struct wlsc_compositor *
x11_compositor_create(struct wl_display *display)
{
struct x11_compositor *c;
struct wl_event_loop *loop;
xcb_screen_iterator_t s;
c = malloc(sizeof *c);
if (c == NULL)
return NULL;
memset(c, 0, sizeof *c);
c->conn = xcb_connect(0, 0);
if (xcb_connection_has_error(c->conn))
return NULL;
s = xcb_setup_roots_iterator(xcb_get_setup(c->conn));
c->screen = s.data;
x11_compositor_get_resources(c);
c->base.wl_display = display;
x11_compositor_init_egl(c);
/* Can't init base class until we have a current egl context */
if (wlsc_compositor_init(&c->base, display) < 0)
return NULL;
x11_compositor_create_output(c, 1024, 640);
x11_input_create(c);
loop = wl_display_get_event_loop(c->base.wl_display);
c->xcb_source =
wl_event_loop_add_fd(loop, xcb_get_file_descriptor(c->conn),
WL_EVENT_READABLE,
x11_compositor_handle_event, c);
c->base.authenticate = x11_authenticate;
c->base.present = x11_compositor_present;
return &c->base;
}

1461
compositor/compositor.c Normal file
View file

File diff suppressed because it is too large Load diff

221
compositor/compositor.h Normal file
View file

@ -0,0 +1,221 @@
/*
* Copyright © 2008 Kristian Høgsberg
*
* 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 of the License, or
* (at your option) any later version.
*
* 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, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef _WAYLAND_SYSTEM_COMPOSITOR_H_
#define _WAYLAND_SYSTEM_COMPOSITOR_H_
#include <termios.h>
#include <xf86drm.h>
#include <xf86drmMode.h>
#include <libudev.h>
#include "wayland-server.h"
#include "wayland-util.h"
#define GL_GLEXT_PROTOTYPES
#define EGL_EGLEXT_PROTOTYPES
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
#include <EGL/egl.h>
#include <EGL/eglext.h>
#define ARRAY_LENGTH(a) (sizeof (a) / sizeof (a)[0])
struct wlsc_matrix {
GLfloat d[16];
};
struct wlsc_surface;
struct wlsc_listener {
struct wl_list link;
void (*func)(struct wlsc_listener *listener,
struct wlsc_surface *surface);
};
struct wlsc_output {
struct wl_object base;
struct wl_list link;
struct wlsc_compositor *compositor;
struct wlsc_surface *background;
struct wlsc_matrix matrix;
int32_t x, y, width, height;
};
/* These should be part of the protocol */
enum wlsc_grab_type {
WLSC_DEVICE_GRAB_NONE = 0,
WLSC_DEVICE_GRAB_RESIZE_TOP = 1,
WLSC_DEVICE_GRAB_RESIZE_BOTTOM = 2,
WLSC_DEVICE_GRAB_RESIZE_LEFT = 4,
WLSC_DEVICE_GRAB_RESIZE_TOP_LEFT = 5,
WLSC_DEVICE_GRAB_RESIZE_BOTTOM_LEFT = 6,
WLSC_DEVICE_GRAB_RESIZE_RIGHT = 8,
WLSC_DEVICE_GRAB_RESIZE_TOP_RIGHT = 9,
WLSC_DEVICE_GRAB_RESIZE_BOTTOM_RIGHT = 10,
WLSC_DEVICE_GRAB_RESIZE_MASK = 15,
WLSC_DEVICE_GRAB_MOVE = 16,
WLSC_DEVICE_GRAB_MOTION = 17,
WLSC_DEVICE_GRAB_DRAG = 18
};
enum wlsc_pointer_type {
WLSC_POINTER_BOTTOM_LEFT,
WLSC_POINTER_BOTTOM_RIGHT,
WLSC_POINTER_BOTTOM,
WLSC_POINTER_DRAGGING,
WLSC_POINTER_LEFT_PTR,
WLSC_POINTER_LEFT,
WLSC_POINTER_RIGHT,
WLSC_POINTER_TOP_LEFT,
WLSC_POINTER_TOP_RIGHT,
WLSC_POINTER_TOP,
WLSC_POINTER_IBEAM,
};
struct wlsc_input_device {
struct wl_input_device base;
int32_t x, y;
struct wlsc_compositor *ec;
struct wlsc_surface *sprite;
int32_t hotspot_x, hotspot_y;
struct wl_list link;
struct wlsc_surface *pointer_focus;
struct wlsc_surface *keyboard_focus;
struct wl_array keys;
uint32_t modifier_state;
enum wlsc_grab_type grab;
struct wlsc_surface *grab_surface;
uint32_t grab_time;
int32_t grab_x, grab_y;
int32_t grab_width, grab_height;
int32_t grab_dx, grab_dy;
uint32_t grab_button;
struct wl_drag *drag;
struct wlsc_listener listener;
};
struct wlsc_drm {
struct wl_object base;
int fd;
char *filename;
};
struct wlsc_buffer {
struct wl_buffer base;
int32_t width, height;
EGLImageKHR image;
struct wl_visual *visual;
};
struct wlsc_compositor {
struct wl_compositor base;
struct wl_visual argb_visual, premultiplied_argb_visual, rgb_visual;
struct wlsc_drm drm;
EGLDisplay display;
EGLContext context;
GLuint fbo, vbo;
GLuint proj_uniform, tex_uniform;
struct wlsc_buffer *pointer_buffers;
struct wl_display *wl_display;
/* We implement the shell interface. */
struct wl_shell shell;
/* There can be more than one, but not right now... */
struct wlsc_input_device *input_device;
struct wl_list output_list;
struct wl_list input_device_list;
struct wl_list surface_list;
struct wl_list surface_destroy_listener_list;
/* Repaint state. */
struct wl_event_source *timer_source;
int repaint_needed;
int repaint_on_timeout;
struct timespec previous_swap;
uint32_t focus;
int (*authenticate)(struct wlsc_compositor *c, uint32_t id);
void (*present)(struct wlsc_compositor *c);
};
#define MODIFIER_CTRL (1 << 8)
#define MODIFIER_ALT (1 << 9)
#define MODIFIER_SUPER (1 << 10)
struct wlsc_vector {
GLfloat f[4];
};
struct wlsc_surface {
struct wl_surface base;
struct wlsc_compositor *compositor;
GLuint texture;
int32_t x, y, width, height;
struct wl_list link;
struct wlsc_matrix matrix;
struct wlsc_matrix matrix_inv;
struct wl_visual *visual;
};
void
notify_motion(struct wlsc_input_device *device,
uint32_t time, int x, int y);
void
notify_button(struct wlsc_input_device *device,
uint32_t time, int32_t button, int32_t state);
void
notify_key(struct wlsc_input_device *device,
uint32_t time, uint32_t key, uint32_t state);
void
wlsc_compositor_finish_frame(struct wlsc_compositor *compositor, int msecs);
void
wlsc_compositor_schedule_repaint(struct wlsc_compositor *compositor);
int
wlsc_compositor_init(struct wlsc_compositor *ec, struct wl_display *display);
void
wlsc_output_init(struct wlsc_output *output, struct wlsc_compositor *c,
int x, int y, int width, int height);
void
wlsc_input_device_init(struct wlsc_input_device *device,
struct wlsc_compositor *ec);
int
wlsc_drm_init(struct wlsc_compositor *ec, int fd, const char *filename);
struct wlsc_compositor *
x11_compositor_create(struct wl_display *display);
struct wlsc_compositor *
drm_compositor_create(struct wl_display *display);
void
screenshooter_create(struct wlsc_compositor *ec);
extern const char *option_background;
extern int option_connector;
#endif

161
compositor/drm.c Normal file
View file

@ -0,0 +1,161 @@
/*
* Copyright © 2010 Kristian Høgsberg
*
* 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 of the License, or
* (at your option) any later version.
*
* 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, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "compositor.h"
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->base, WL_DRM_AUTHENTICATED);
}
static void
destroy_buffer(struct wl_resource *resource, struct wl_client *client)
{
struct wlsc_buffer *buffer =
container_of(resource, struct wlsc_buffer, base.base);
#if 0
/* FIXME: Need backlink to EGL display here */
eglDestroyImageKHR(ec->display, buffer->image);
#endif
free(buffer);
}
static void
buffer_destroy(struct wl_client *client, struct wl_buffer *buffer)
{
wl_resource_destroy(&buffer->base, client);
}
const static struct wl_buffer_interface buffer_interface = {
buffer_destroy
};
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_buffer *buffer;
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 != &compositor->argb_visual &&
visual != &compositor->premultiplied_argb_visual &&
visual != &compositor->rgb_visual) {
/* 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;
}
buffer = malloc(sizeof *buffer);
if (buffer == NULL) {
wl_client_post_no_memory(client);
return;
}
attribs[1] = width;
attribs[3] = height;
attribs[5] = stride / 4;
buffer->width = width;
buffer->height = height;
buffer->visual = visual;
buffer->image = eglCreateImageKHR(compositor->display,
compositor->context,
EGL_DRM_BUFFER_MESA,
(EGLClientBuffer) name, attribs);
if (buffer->image == NULL) {
/* FIXME: Define a real exception event instead of
* abusing this one */
free(buffer);
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->base.base.base.id = id;
buffer->base.base.base.interface = &wl_buffer_interface;
buffer->base.base.base.implementation = (void (**)(void))
&buffer_interface;
buffer->base.base.destroy = destroy_buffer;
wl_client_add_resource(client, &buffer->base.base);
}
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, base);
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->base.interface = &wl_drm_interface;
drm->base.implementation = (void (**)(void)) &drm_interface;
wl_display_add_object(ec->wl_display, &drm->base);
wl_display_add_global(ec->wl_display, &drm->base, post_drm_device);
return 0;
}

103
compositor/screenshooter.c Normal file
View file

@ -0,0 +1,103 @@
/*
* Copyright © 2008 Kristian Høgsberg
*
* 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 of the License, or
* (at your option) any later version.
*
* 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, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <stdlib.h>
#include <GLES2/gl2.h>
#include <gdk-pixbuf/gdk-pixbuf.h>
#include "compositor.h"
struct screenshooter {
struct wl_object base;
struct wlsc_compositor *ec;
};
struct screenshooter_interface {
void (*shoot)(struct wl_client *client, struct screenshooter *shooter);
};
static void
screenshooter_shoot(struct wl_client *client, struct screenshooter *shooter)
{
struct wlsc_compositor *ec = shooter->ec;
struct wlsc_output *output;
char buffer[256];
GdkPixbuf *pixbuf, *normal;
GError *error = NULL;
unsigned char *data;
int i, j;
i = 0;
wl_list_for_each(output, &ec->output_list, link) {
snprintf(buffer, sizeof buffer, "wayland-screenshot-%d.png", i++);
data = malloc(output->width * output->height * 4);
if (data == NULL) {
fprintf(stderr, "couldn't allocate image buffer\n");
continue;
}
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glReadPixels(0, 0, output->width, output->height,
GL_RGBA, GL_UNSIGNED_BYTE, data);
/* FIXME: We should just use a RGB visual for the frontbuffer. */
for (j = 3; j < output->width * output->height * 4; j += 4)
data[j] = 0xff;
pixbuf = gdk_pixbuf_new_from_data(data, GDK_COLORSPACE_RGB, TRUE,
8, output->width, output->height, output->width * 4,
NULL, NULL);
normal = gdk_pixbuf_flip(pixbuf, FALSE);
gdk_pixbuf_save(normal, buffer, "png", &error, NULL);
gdk_pixbuf_unref(normal);
gdk_pixbuf_unref(pixbuf);
free(data);
}
}
static const struct wl_message screenshooter_methods[] = {
{ "shoot", "", NULL }
};
static const struct wl_interface screenshooter_interface = {
"screenshooter", 1,
ARRAY_LENGTH(screenshooter_methods),
screenshooter_methods,
};
struct screenshooter_interface screenshooter_implementation = {
screenshooter_shoot
};
void
screenshooter_create(struct wlsc_compositor *ec)
{
struct screenshooter *shooter;
shooter = malloc(sizeof *shooter);
if (shooter == NULL)
return;
shooter->base.interface = &screenshooter_interface;
shooter->base.implementation =
(void(**)(void)) &screenshooter_implementation;
shooter->ec = ec;
wl_display_add_object(ec->wl_display, &shooter->base);
wl_display_add_global(ec->wl_display, &shooter->base, NULL);
};