Drew DeVault
7 years ago
committed by
GitHub
commit
f3769a4b1f
@ -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;
|
||||
}
|
||||
@ -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;
|
||||
}
|
||||
@ -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;
|
||||
}
|
||||
@ -0,0 +1,35 @@
|
||||
#ifndef BACKEND_HEADLESS_H
|
||||
#define BACKEND_HEADLESS_H
|
||||
|
||||
#include <wlr/backend/interface.h>
|
||||
#include <wlr/backend/headless.h>
|
||||
#include <wlr/types/wlr_output.h>
|
||||
|
||||
struct wlr_headless_backend {
|
||||
struct wlr_backend backend;
|
||||
struct wlr_egl egl;
|
||||
struct wl_display *display;
|
||||
struct wl_list outputs;
|
||||
struct wl_list input_devices;
|
||||
struct wl_listener display_destroy;
|
||||
bool started;
|
||||
};
|
||||
|
||||
struct wlr_headless_output {
|
||||
struct wlr_output wlr_output;
|
||||
|
||||
struct wlr_headless_backend *backend;
|
||||
struct wl_list link;
|
||||
|
||||
void *egl_surface;
|
||||
struct wl_event_source *frame_timer;
|
||||
int frame_delay; // ms
|
||||
};
|
||||
|
||||
struct wlr_headless_input_device {
|
||||
struct wlr_input_device wlr_input_device;
|
||||
|
||||
struct wlr_headless_backend *backend;
|
||||
};
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,14 @@
|
||||
#ifndef WLR_BACKEND_HEADLESS_H
|
||||
#define WLR_BACKEND_HEADLESS_H
|
||||
|
||||
#include <wlr/backend.h>
|
||||
#include <wlr/types/wlr_input_device.h>
|
||||
|
||||
struct wlr_backend *wlr_headless_backend_create(struct wl_display *display);
|
||||
struct wlr_output *wlr_headless_add_output(struct wlr_backend *backend,
|
||||
unsigned int width, unsigned int height);
|
||||
struct wlr_input_device *wlr_headless_add_input_device(
|
||||
struct wlr_backend *backend, enum wlr_input_device_type type);
|
||||
bool wlr_backend_is_headless(struct wlr_backend *backend);
|
||||
|
||||
#endif
|
||||
Loading…
Reference in new issue