aboutsummaryrefslogtreecommitdiff
path: root/backend
diff options
context:
space:
mode:
Diffstat (limited to 'backend')
-rw-r--r--backend/drm/drm.c3
-rw-r--r--backend/drm/renderer.c4
-rw-r--r--backend/headless/backend.c114
-rw-r--r--backend/headless/input_device.c91
-rw-r--r--backend/headless/output.c146
-rw-r--r--backend/meson.build3
-rw-r--r--backend/wayland/backend.c2
-rw-r--r--backend/wayland/output.c6
-rw-r--r--backend/x11/backend.c7
9 files changed, 365 insertions, 11 deletions
diff --git a/backend/drm/drm.c b/backend/drm/drm.c
index 96b7d93d..1fceff95 100644
--- a/backend/drm/drm.c
+++ b/backend/drm/drm.c
@@ -452,8 +452,7 @@ static bool wlr_drm_connector_set_mode(struct wlr_output *output,
crtc->cursor ? crtc->cursor - drm->cursor_planes : -1);
conn->state = WLR_DRM_CONN_CONNECTED;
- conn->output.current_mode = mode;
- wlr_output_update_size(&conn->output, mode->width, mode->height);
+ wlr_output_update_mode(&conn->output, mode);
// Since realloc_crtcs can deallocate planes on OTHER outputs,
// we actually need to reinitalise any than has changed
diff --git a/backend/drm/renderer.c b/backend/drm/renderer.c
index 8a8d7d1f..00182c59 100644
--- a/backend/drm/renderer.c
+++ b/backend/drm/renderer.c
@@ -24,8 +24,8 @@ bool wlr_drm_renderer_init(struct wlr_drm_backend *drm,
return false;
}
- if (!wlr_egl_init(&renderer->egl, EGL_PLATFORM_GBM_MESA,
- GBM_FORMAT_ARGB8888, renderer->gbm)) {
+ if (!wlr_egl_init(&renderer->egl, EGL_PLATFORM_GBM_MESA, renderer->gbm,
+ NULL, GBM_FORMAT_ARGB8888)) {
goto error_gbm;
}
diff --git a/backend/headless/backend.c b/backend/headless/backend.c
new file mode 100644
index 00000000..f95e3897
--- /dev/null
+++ b/backend/headless/backend.c
@@ -0,0 +1,114 @@
+#include <stdlib.h>
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <wlr/util/log.h>
+#include <wlr/interfaces/wlr_output.h>
+#include <wlr/interfaces/wlr_input_device.h>
+#include "backend/headless.h"
+#include "glapi.h"
+
+static bool backend_start(struct wlr_backend *wlr_backend) {
+ struct wlr_headless_backend *backend =
+ (struct wlr_headless_backend *)wlr_backend;
+ wlr_log(L_INFO, "Starting headless backend");
+
+ struct wlr_headless_output *output;
+ wl_list_for_each(output, &backend->outputs, link) {
+ wl_event_source_timer_update(output->frame_timer, output->frame_delay);
+ wlr_output_create_global(&output->wlr_output, backend->display);
+ wl_signal_emit(&backend->backend.events.output_add,
+ &output->wlr_output);
+ }
+
+ struct wlr_headless_input_device *input_device;
+ wl_list_for_each(input_device, &backend->input_devices,
+ wlr_input_device.link) {
+ wl_signal_emit(&backend->backend.events.input_add,
+ &input_device->wlr_input_device);
+ }
+
+ backend->started = true;
+ return true;
+}
+
+static void backend_destroy(struct wlr_backend *wlr_backend) {
+ struct wlr_headless_backend *backend =
+ (struct wlr_headless_backend *)wlr_backend;
+ if (!wlr_backend) {
+ return;
+ }
+
+ wl_list_remove(&backend->display_destroy.link);
+
+ struct wlr_headless_output *output, *output_tmp;
+ wl_list_for_each_safe(output, output_tmp, &backend->outputs, link) {
+ wlr_output_destroy(&output->wlr_output);
+ }
+
+ struct wlr_headless_input_device *input_device, *input_device_tmp;
+ wl_list_for_each_safe(input_device, input_device_tmp,
+ &backend->input_devices, wlr_input_device.link) {
+ wlr_input_device_destroy(&input_device->wlr_input_device);
+ }
+
+ wlr_egl_finish(&backend->egl);
+ free(backend);
+}
+
+static struct wlr_egl *backend_get_egl(struct wlr_backend *wlr_backend) {
+ struct wlr_headless_backend *backend =
+ (struct wlr_headless_backend *)wlr_backend;
+ return &backend->egl;
+}
+
+static const struct wlr_backend_impl backend_impl = {
+ .start = backend_start,
+ .destroy = backend_destroy,
+ .get_egl = backend_get_egl,
+};
+
+static void handle_display_destroy(struct wl_listener *listener, void *data) {
+ struct wlr_headless_backend *backend =
+ wl_container_of(listener, backend, display_destroy);
+ backend_destroy(&backend->backend);
+}
+
+struct wlr_backend *wlr_headless_backend_create(struct wl_display *display) {
+ wlr_log(L_INFO, "Creating headless backend");
+
+ struct wlr_headless_backend *backend =
+ calloc(1, sizeof(struct wlr_headless_backend));
+ if (!backend) {
+ wlr_log(L_ERROR, "Failed to allocate wlr_headless_backend");
+ return NULL;
+ }
+ wlr_backend_init(&backend->backend, &backend_impl);
+ backend->display = display;
+ wl_list_init(&backend->outputs);
+ wl_list_init(&backend->input_devices);
+
+ static const EGLint config_attribs[] = {
+ EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
+ EGL_ALPHA_SIZE, 0,
+ EGL_BLUE_SIZE, 8,
+ EGL_GREEN_SIZE, 8,
+ EGL_RED_SIZE, 8,
+ EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+ EGL_NONE,
+ };
+ bool ok = wlr_egl_init(&backend->egl, EGL_PLATFORM_SURFACELESS_MESA, NULL,
+ (EGLint *)config_attribs, 0);
+ if (!ok) {
+ free(backend);
+ return NULL;
+ }
+
+ backend->display_destroy.notify = handle_display_destroy;
+ wl_display_add_destroy_listener(display, &backend->display_destroy);
+
+ return &backend->backend;
+}
+
+bool wlr_backend_is_headless(struct wlr_backend *backend) {
+ return backend->impl == &backend_impl;
+}
diff --git a/backend/headless/input_device.c b/backend/headless/input_device.c
new file mode 100644
index 00000000..05def775
--- /dev/null
+++ b/backend/headless/input_device.c
@@ -0,0 +1,91 @@
+#include <stdlib.h>
+#include <wlr/interfaces/wlr_input_device.h>
+#include <wlr/interfaces/wlr_pointer.h>
+#include <wlr/interfaces/wlr_keyboard.h>
+#include <wlr/interfaces/wlr_touch.h>
+#include <wlr/interfaces/wlr_tablet_tool.h>
+#include <wlr/interfaces/wlr_tablet_pad.h>
+#include <wlr/util/log.h>
+#include "backend/headless.h"
+
+static void input_device_destroy(struct wlr_input_device *wlr_dev) {
+ struct wlr_headless_input_device *device =
+ (struct wlr_headless_input_device *)wlr_dev;
+ wl_signal_emit(&device->backend->backend.events.input_remove, wlr_dev);
+ free(device);
+}
+
+static struct wlr_input_device_impl input_device_impl = {
+ .destroy = input_device_destroy,
+};
+
+struct wlr_input_device *wlr_headless_add_input_device(
+ struct wlr_backend *wlr_backend, enum wlr_input_device_type type) {
+ struct wlr_headless_backend *backend =
+ (struct wlr_headless_backend *)wlr_backend;
+
+ struct wlr_headless_input_device *device =
+ calloc(1, sizeof(struct wlr_headless_input_device));
+ if (device == NULL) {
+ return NULL;
+ }
+ device->backend = backend;
+
+ int vendor = 0;
+ int product = 0;
+ const char *name = "headless";
+ struct wlr_input_device *wlr_device = &device->wlr_input_device;
+ wlr_input_device_init(wlr_device, type, &input_device_impl, name, vendor,
+ product);
+
+ switch (type) {
+ case WLR_INPUT_DEVICE_KEYBOARD:
+ wlr_device->keyboard = calloc(1, sizeof(struct wlr_keyboard));
+ if (wlr_device->keyboard == NULL) {
+ wlr_log(L_ERROR, "Unable to allocate wlr_keyboard");
+ return NULL;
+ }
+ wlr_keyboard_init(wlr_device->keyboard, NULL);
+ break;
+ case WLR_INPUT_DEVICE_POINTER:
+ wlr_device->pointer = calloc(1, sizeof(struct wlr_pointer));
+ if (wlr_device->pointer == NULL) {
+ wlr_log(L_ERROR, "Unable to allocate wlr_pointer");
+ return NULL;
+ }
+ wlr_pointer_init(wlr_device->pointer, NULL);
+ break;
+ case WLR_INPUT_DEVICE_TOUCH:
+ wlr_device->touch = calloc(1, sizeof(struct wlr_touch));
+ if (wlr_device->touch == NULL) {
+ wlr_log(L_ERROR, "Unable to allocate wlr_touch");
+ return NULL;
+ }
+ wlr_touch_init(wlr_device->touch, NULL);
+ break;
+ case WLR_INPUT_DEVICE_TABLET_TOOL:
+ wlr_device->tablet_tool = calloc(1, sizeof(struct wlr_tablet_tool));
+ if (wlr_device->tablet_tool == NULL) {
+ wlr_log(L_ERROR, "Unable to allocate wlr_tablet_tool");
+ return NULL;
+ }
+ wlr_tablet_tool_init(wlr_device->tablet_tool, NULL);
+ break;
+ case WLR_INPUT_DEVICE_TABLET_PAD:
+ wlr_device->tablet_pad = calloc(1, sizeof(struct wlr_tablet_pad));
+ if (wlr_device->tablet_pad == NULL) {
+ wlr_log(L_ERROR, "Unable to allocate wlr_tablet_pad");
+ return NULL;
+ }
+ wlr_tablet_pad_init(wlr_device->tablet_pad, NULL);
+ break;
+ }
+
+ wl_list_insert(&backend->input_devices, &wlr_device->link);
+
+ if (backend->started) {
+ wl_signal_emit(&backend->backend.events.input_add, wlr_device);
+ }
+
+ return wlr_device;
+}
diff --git a/backend/headless/output.c b/backend/headless/output.c
new file mode 100644
index 00000000..9c4ba35e
--- /dev/null
+++ b/backend/headless/output.c
@@ -0,0 +1,146 @@
+#include <stdlib.h>
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <GLES2/gl2.h>
+#include <wlr/interfaces/wlr_output.h>
+#include <wlr/util/log.h>
+#include "backend/headless.h"
+
+static EGLSurface egl_create_surface(struct wlr_egl *egl, unsigned int width,
+ unsigned int height) {
+ EGLint attribs[] = {EGL_WIDTH, width, EGL_HEIGHT, height, EGL_NONE};
+
+ EGLSurface surf = eglCreatePbufferSurface(egl->display, egl->config, attribs);
+ if (surf == EGL_NO_SURFACE) {
+ wlr_log(L_ERROR, "Failed to create EGL surface: %s", egl_error());
+ return EGL_NO_SURFACE;
+ }
+ return surf;
+}
+
+static bool output_set_custom_mode(struct wlr_output *wlr_output, int32_t width,
+ int32_t height, int32_t refresh) {
+ struct wlr_headless_output *output =
+ (struct wlr_headless_output *)wlr_output;
+ struct wlr_headless_backend *backend = output->backend;
+
+ if (output->egl_surface) {
+ eglDestroySurface(backend->egl.display, output->egl_surface);
+ }
+
+ output->egl_surface = egl_create_surface(&backend->egl, width, height);
+ if (output->egl_surface == EGL_NO_SURFACE) {
+ wlr_log(L_ERROR, "Failed to recreate EGL surface");
+ wlr_output_destroy(wlr_output);
+ return false;
+ }
+
+ output->frame_delay = 1000000 / refresh;
+
+ wlr_output_update_custom_mode(&output->wlr_output, width, height, refresh);
+ return true;
+}
+
+static void output_transform(struct wlr_output *wlr_output,
+ enum wl_output_transform transform) {
+ struct wlr_headless_output *output =
+ (struct wlr_headless_output *)wlr_output;
+ output->wlr_output.transform = transform;
+}
+
+static void output_make_current(struct wlr_output *wlr_output) {
+ struct wlr_headless_output *output =
+ (struct wlr_headless_output *)wlr_output;
+ if (!eglMakeCurrent(output->backend->egl.display,
+ output->egl_surface, output->egl_surface,
+ output->backend->egl.context)) {
+ wlr_log(L_ERROR, "eglMakeCurrent failed: %s", egl_error());
+ }
+}
+
+static void output_swap_buffers(struct wlr_output *wlr_output) {
+ // No-op
+}
+
+static void output_destroy(struct wlr_output *wlr_output) {
+ struct wlr_headless_output *output =
+ (struct wlr_headless_output *)wlr_output;
+ wl_signal_emit(&output->backend->backend.events.output_remove,
+ &output->wlr_output);
+
+ wl_list_remove(&output->link);
+
+ eglDestroySurface(output->backend->egl.display, output->egl_surface);
+ free(output);
+}
+
+static const struct wlr_output_impl output_impl = {
+ .set_custom_mode = output_set_custom_mode,
+ .transform = output_transform,
+ .destroy = output_destroy,
+ .make_current = output_make_current,
+ .swap_buffers = output_swap_buffers,
+};
+
+static int signal_frame(void *data) {
+ struct wlr_headless_output *output = data;
+ wl_signal_emit(&output->wlr_output.events.frame, &output->wlr_output);
+ wl_event_source_timer_update(output->frame_timer, output->frame_delay);
+ return 0;
+}
+
+struct wlr_output *wlr_headless_add_output(struct wlr_backend *wlr_backend,
+ unsigned int width, unsigned int height) {
+ struct wlr_headless_backend *backend =
+ (struct wlr_headless_backend *)wlr_backend;
+
+ struct wlr_headless_output *output =
+ calloc(1, sizeof(struct wlr_headless_output));
+ if (output == NULL) {
+ wlr_log(L_ERROR, "Failed to allocate wlr_headless_output");
+ return NULL;
+ }
+ output->backend = backend;
+ wlr_output_init(&output->wlr_output, &backend->backend, &output_impl);
+ struct wlr_output *wlr_output = &output->wlr_output;
+
+ output->egl_surface = egl_create_surface(&backend->egl, width, height);
+ if (output->egl_surface == EGL_NO_SURFACE) {
+ wlr_log(L_ERROR, "Failed to create EGL surface");
+ goto error;
+ }
+
+ output_set_custom_mode(wlr_output, width, height, 60*1000);
+ strncpy(wlr_output->make, "headless", sizeof(wlr_output->make));
+ strncpy(wlr_output->model, "headless", sizeof(wlr_output->model));
+ snprintf(wlr_output->name, sizeof(wlr_output->name), "HEADLESS-%d",
+ wl_list_length(&backend->outputs) + 1);
+
+ if (!eglMakeCurrent(output->backend->egl.display,
+ output->egl_surface, output->egl_surface,
+ output->backend->egl.context)) {
+ wlr_log(L_ERROR, "eglMakeCurrent failed: %s", egl_error());
+ goto error;
+ }
+
+ glViewport(0, 0, wlr_output->width, wlr_output->height);
+ glClearColor(1.0, 1.0, 1.0, 1.0);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ struct wl_event_loop *ev = wl_display_get_event_loop(backend->display);
+ output->frame_timer = wl_event_loop_add_timer(ev, signal_frame, output);
+
+ wl_list_insert(&backend->outputs, &output->link);
+
+ if (backend->started) {
+ wl_event_source_timer_update(output->frame_timer, output->frame_delay);
+ wlr_output_create_global(wlr_output, backend->display);
+ wl_signal_emit(&backend->backend.events.output_add, wlr_output);
+ }
+
+ return wlr_output;
+
+error:
+ wlr_output_destroy(&output->wlr_output);
+ return NULL;
+}
diff --git a/backend/meson.build b/backend/meson.build
index c9d47317..68d958a7 100644
--- a/backend/meson.build
+++ b/backend/meson.build
@@ -9,6 +9,9 @@ backend_files = files(
'drm/properties.c',
'drm/renderer.c',
'drm/util.c',
+ 'headless/backend.c',
+ 'headless/output.c',
+ 'headless/input_device.c',
'libinput/backend.c',
'libinput/events.c',
'libinput/keyboard.c',
diff --git a/backend/wayland/backend.c b/backend/wayland/backend.c
index 6ebc6615..36fbd8e0 100644
--- a/backend/wayland/backend.c
+++ b/backend/wayland/backend.c
@@ -185,7 +185,7 @@ struct wlr_backend *wlr_wl_backend_create(struct wl_display *display) {
}
wlr_egl_init(&backend->egl, EGL_PLATFORM_WAYLAND_EXT,
- WL_SHM_FORMAT_ARGB8888, backend->remote_display);
+ backend->remote_display, NULL, WL_SHM_FORMAT_ARGB8888);
wlr_egl_bind_display(&backend->egl, backend->local_display);
backend->local_display_destroy.notify = handle_display_destroy;
diff --git a/backend/wayland/output.c b/backend/wayland/output.c
index fc09903e..d841ec49 100644
--- a/backend/wayland/output.c
+++ b/backend/wayland/output.c
@@ -32,7 +32,7 @@ static bool wlr_wl_output_set_custom_mode(struct wlr_output *_output,
int32_t width, int32_t height, int32_t refresh) {
struct wlr_wl_backend_output *output = (struct wlr_wl_backend_output *)_output;
wl_egl_window_resize(output->egl_window, width, height, 0, 0);
- wlr_output_update_size(&output->wlr_output, width, height);
+ wlr_output_update_custom_mode(&output->wlr_output, width, height, 0);
return true;
}
@@ -229,7 +229,7 @@ static void xdg_toplevel_handle_configure(void *data, struct zxdg_toplevel_v6 *x
}
// loop over states for maximized etc?
wl_egl_window_resize(output->egl_window, width, height, 0, 0);
- wlr_output_update_size(&output->wlr_output, width, height);
+ wlr_output_update_custom_mode(&output->wlr_output, width, height, 0);
}
static void xdg_toplevel_handle_close(void *data, struct zxdg_toplevel_v6 *xdg_toplevel) {
@@ -260,7 +260,7 @@ struct wlr_output *wlr_wl_output_create(struct wlr_backend *_backend) {
wlr_output_init(&output->wlr_output, &backend->backend, &output_impl);
struct wlr_output *wlr_output = &output->wlr_output;
- wlr_output_update_size(wlr_output, 1280, 720);
+ wlr_output_update_custom_mode(wlr_output, 1280, 720, 0);
strncpy(wlr_output->make, "wayland", sizeof(wlr_output->make));
strncpy(wlr_output->model, "wayland", sizeof(wlr_output->model));
snprintf(wlr_output->name, sizeof(wlr_output->name), "WL-%d",
diff --git a/backend/x11/backend.c b/backend/x11/backend.c
index c116e78e..a218c589 100644
--- a/backend/x11/backend.c
+++ b/backend/x11/backend.c
@@ -117,7 +117,8 @@ static bool handle_x11_event(struct wlr_x11_backend *x11, xcb_generic_event_t *e
case XCB_CONFIGURE_NOTIFY: {
xcb_configure_notify_event_t *ev = (xcb_configure_notify_event_t *)event;
- wlr_output_update_size(&output->wlr_output, ev->width, ev->height);
+ wlr_output_update_custom_mode(&output->wlr_output, ev->width,
+ ev->height, 0);
// Move the pointer to its new location
xcb_query_pointer_cookie_t cookie =
@@ -310,8 +311,8 @@ struct wlr_backend *wlr_x11_backend_create(struct wl_display *display,
x11->screen = xcb_setup_roots_iterator(xcb_get_setup(x11->xcb_conn)).data;
- if (!wlr_egl_init(&x11->egl, EGL_PLATFORM_X11_KHR,
- x11->screen->root_visual, x11->xlib_conn)) {
+ if (!wlr_egl_init(&x11->egl, EGL_PLATFORM_X11_KHR, x11->xlib_conn, NULL,
+ x11->screen->root_visual)) {
goto error_event;
}