Split native drm part of compositor out

parent 44be655b
*.o
*.so
*.pc
wayland-system-compositor
gears
terminal
flower
screenshot
compositor
*.jpg
*.png
*~
......
......@@ -27,9 +27,9 @@ $(libs) :
compositor : \
compositor.o \
evdev.o \
cairo-util.o \
wayland-util.o
compositor-drm.o \
screenshooter.o \
cairo-util.o
compositor : CFLAGS += $(COMPOSITOR_CFLAGS)
compositor : LDLIBS += ./libwayland-server.so $(COMPOSITOR_LIBS) -rdynamic -lrt -lEGL -lm
......
gears
flower
screenshot
terminal
image
view
This diff is collapsed.
This diff is collapsed.
......@@ -19,9 +19,131 @@
#ifndef _WAYLAND_SYSTEM_COMPOSITOR_H_
#define _WAYLAND_SYSTEM_COMPOSITOR_H_
struct wlsc_input_device;
void
wlsc_device_get_position(struct wlsc_input_device *device, int32_t *x, int32_t *y);
#include <termios.h>
#include <xf86drm.h>
#include <xf86drmMode.h>
#include <libudev.h>
#include "wayland.h"
#include "wayland-util.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 wl_visual {
struct wl_object base;
};
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;
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 wlsc_input_device {
struct wl_object base;
int32_t x, y;
struct wlsc_compositor *ec;
struct wlsc_surface *sprite;
struct wl_list link;
int grab;
struct wlsc_surface *grab_surface;
struct wlsc_surface *pointer_focus;
struct wlsc_surface *keyboard_focus;
struct wl_array keys;
struct wlsc_listener listener;
};
struct wlsc_compositor {
struct wl_compositor base;
struct wl_visual argb_visual, premultiplied_argb_visual, rgb_visual;
EGLDisplay display;
EGLContext context;
int drm_fd;
GLuint fbo, vbo;
GLuint proj_uniform, tex_uniform;
struct wl_display *wl_display;
/* 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;
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 udev *udev;
/* Repaint state. */
struct wl_event_source *timer_source;
int repaint_needed;
int repaint_on_timeout;
struct timespec previous_swap;
uint32_t current_frame;
struct wl_event_source *drm_source;
uint32_t modifier_state;
};
#define MODIFIER_CTRL (1 << 8)
#define MODIFIER_ALT (1 << 9)
struct wlsc_vector {
GLfloat f[4];
};
struct wlsc_surface {
struct wl_surface base;
struct wlsc_compositor *compositor;
struct wl_visual *visual;
GLuint texture;
EGLImageKHR image;
int width, height;
struct wl_list link;
struct wlsc_matrix matrix;
struct wlsc_matrix matrix_inv;
};
void
notify_motion(struct wlsc_input_device *device, int x, int y);
void
......@@ -29,8 +151,19 @@ notify_button(struct wlsc_input_device *device, int32_t button, int32_t state);
void
notify_key(struct wlsc_input_device *device, uint32_t key, uint32_t state);
struct evdev_input_device *
evdev_input_device_create(struct wlsc_input_device *device,
struct wl_display *display, const char *path);
void
wlsc_compositor_present_drm(struct wlsc_compositor *wlsc);
int
wlsc_compositor_init_drm(struct wlsc_compositor *ec);
void
wlsc_compositor_finish_frame(struct wlsc_compositor *compositor, int msecs);
struct wlsc_input_device *
wlsc_input_device_create(struct wlsc_compositor *ec);
void
screenshooter_create(struct wlsc_compositor *ec);
extern const char *option_background;
extern int option_connector;
#endif
/*
* 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 <stdio.h>
#include <stdlib.h>
#include <linux/input.h>
#include <fcntl.h>
#include <unistd.h>
#include <linux/input.h>
#include "wayland.h"
#include "compositor.h"
struct evdev_input_device {
struct wlsc_input_device *device;
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 evdev_input_device *device = data;
struct input_event ev[8], *e, *end;
int len, value, dx, dy, absolute_event;
int x, y;
dx = 0;
dy = 0;
absolute_event = 0;
wlsc_device_get_position(device->device, &x, &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;
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->device, e->code, value);
break;
default:
notify_key(device->device, e->code, value);
break;
}
}
}
if (dx != 0 || dy != 0)
notify_motion(device->device, x + dx, y + dy);
if (absolute_event && device->tool)
notify_motion(device->device, x, y);
}
struct evdev_input_device *
evdev_input_device_create(struct wlsc_input_device *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->device = 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;
}
/*
* 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);
};
main.aux
main.log
main.pdf
......@@ -165,14 +165,10 @@ delivered in both screen coordinates and surface local coordinates.
\texttt{keyboard\_focus(surface, keys)} \\ \hline
\end{tabular}
\item input group, keyboard, mouse
\item keyboard map, change events
\item pointer motion
\item enter, leave, focus
Talk about:
\begin{itemize}
\item keyboard map, change events
\item xkb on wayland
\item multi pointer wayland
\end{itemize}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment