From 3970264ccffd30ab1bf06d7dab4f6cc176b9d797 Mon Sep 17 00:00:00 2001 From: emersion Date: Sun, 17 Dec 2017 12:56:42 +0100 Subject: [PATCH 1/5] Initialize headless backend --- backend/headless/backend.c | 156 +++++++++++++++++++++++++++++++++ backend/headless/output.c | 83 ++++++++++++++++++ backend/meson.build | 2 + include/backend/headless.h | 25 ++++++ include/wlr/backend/headless.h | 13 +++ rootston/main.c | 4 +- 6 files changed, 282 insertions(+), 1 deletion(-) create mode 100644 backend/headless/backend.c create mode 100644 backend/headless/output.c create mode 100644 include/backend/headless.h create mode 100644 include/wlr/backend/headless.h diff --git a/backend/headless/backend.c b/backend/headless/backend.c new file mode 100644 index 00000000..c60eb7e5 --- /dev/null +++ b/backend/headless/backend.c @@ -0,0 +1,156 @@ +#include +#include +#include +#include +#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, "Initializating headless backend"); + + // TODO + for (size_t i = 0; i < 1; ++i) { + wlr_headless_add_output(&backend->backend, 1280, 720); + } + + 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); + 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); +} + +static bool egl_get_config(EGLDisplay disp, EGLConfig *out) { + EGLint count = 0, matched = 0, ret; + + ret = eglGetConfigs(disp, NULL, 0, &count); + if (ret == EGL_FALSE || count == 0) { + wlr_log(L_ERROR, "eglGetConfigs returned no configs"); + return false; + } + + EGLConfig configs[count]; + + static const EGLint attribs[] = { + EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, + EGL_NONE, + }; + + ret = eglChooseConfig(disp, attribs, configs, count, &matched); + if (ret == EGL_FALSE) { + wlr_log(L_ERROR, "eglChooseConfig failed"); + return false; + } + + // TODO + *out = configs[0]; + return true; +} + +static bool egl_init(struct wlr_egl *egl) { + if (!load_glapi()) { + return false; + } + + if (eglBindAPI(EGL_OPENGL_ES_API) == EGL_FALSE) { + wlr_log(L_ERROR, "Failed to bind to the OpenGL ES API: %s", egl_error()); + goto error; + } + + egl->display = eglGetDisplay(EGL_DEFAULT_DISPLAY); + if (egl->display == EGL_NO_DISPLAY) { + wlr_log(L_ERROR, "Failed to create EGL display: %s", egl_error()); + goto error; + } + + EGLint major, minor; + if (eglInitialize(egl->display, &major, &minor) == EGL_FALSE) { + wlr_log(L_ERROR, "Failed to initialize EGL: %s", egl_error()); + goto error; + } + + if (!egl_get_config(egl->display, &egl->config)) { + wlr_log(L_ERROR, "Failed to get EGL config"); + goto error; + } + + static const EGLint attribs[] = { + EGL_CONTEXT_CLIENT_VERSION, 2, + EGL_NONE, + }; + + egl->context = eglCreateContext(egl->display, egl->config, + EGL_NO_CONTEXT, attribs); + if (egl->context == EGL_NO_CONTEXT) { + wlr_log(L_ERROR, "Failed to create EGL context: %s", egl_error()); + goto error; + } + + eglMakeCurrent(egl->display, EGL_NO_SURFACE, EGL_NO_SURFACE, egl->context); + egl->egl_exts = eglQueryString(egl->display, EGL_EXTENSIONS); + if (strstr(egl->egl_exts, "EGL_KHR_image_base") == NULL) { + wlr_log(L_ERROR, "Required egl extensions not supported"); + goto error; + } + + egl->gl_exts = (const char*) glGetString(GL_EXTENSIONS); + wlr_log(L_INFO, "Using EGL %d.%d", (int)major, (int)minor); + wlr_log(L_INFO, "Using %s", glGetString(GL_VERSION)); + wlr_log(L_INFO, "Supported EGL extensions: %s", egl->egl_exts); + wlr_log(L_INFO, "Supported OpenGL ES extensions: %s", egl->gl_exts); + return true; + +error: + eglMakeCurrent(EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); + eglTerminate(egl->display); + eglReleaseThread(); + return false; +} + +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; + + egl_init(&backend->egl); + + backend->display_destroy.notify = handle_display_destroy; + wl_display_add_destroy_listener(display, &backend->display_destroy); + + return &backend->backend; +} diff --git a/backend/headless/output.c b/backend/headless/output.c new file mode 100644 index 00000000..194f542f --- /dev/null +++ b/backend/headless/output.c @@ -0,0 +1,83 @@ +#include +#include +#include +#include +#include +#include +#include "backend/headless.h" + +static void output_destroy(struct wlr_output *wlr_output) { + struct wlr_headless_backend_output *output = + (struct wlr_headless_backend_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 = wlr_wl_output_set_custom_mode, + //.transform = wlr_wl_output_transform, + .destroy = output_destroy, + //.make_current = wlr_wl_output_make_current, + //.swap_buffers = wlr_wl_output_swap_buffers, +}; + +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; +} + +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_backend_output *output = + calloc(1, sizeof(struct wlr_headless_backend_output)); + if (output == NULL) { + wlr_log(L_ERROR, "Failed to allocate wlr_headless_backend_output"); + return NULL; + } + 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); + + wlr_output_update_size(wlr_output, width, height); + + 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); + + if (!eglSwapBuffers(output->backend->egl.display, output->egl_surface)) { + wlr_log(L_ERROR, "eglSwapBuffers failed: %s", egl_error()); + goto error; + } + + wl_list_insert(&backend->outputs, &output->link); + 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..fb16944e 100644 --- a/backend/meson.build +++ b/backend/meson.build @@ -9,6 +9,8 @@ backend_files = files( 'drm/properties.c', 'drm/renderer.c', 'drm/util.c', + 'headless/backend.c', + 'headless/output.c', 'libinput/backend.c', 'libinput/events.c', 'libinput/keyboard.c', diff --git a/include/backend/headless.h b/include/backend/headless.h new file mode 100644 index 00000000..56ae626a --- /dev/null +++ b/include/backend/headless.h @@ -0,0 +1,25 @@ +#ifndef BACKEND_HEADLESS_H +#define BACKEND_HEADLESS_H + +#include +#include +#include + +struct wlr_headless_backend { + struct wlr_backend backend; + struct wlr_egl egl; + struct wl_display *display; + struct wl_list outputs; + struct wl_listener display_destroy; +}; + +struct wlr_headless_backend_output { + struct wlr_output wlr_output; + + struct wlr_headless_backend *backend; + struct wl_list link; + + void *egl_surface; +}; + +#endif diff --git a/include/wlr/backend/headless.h b/include/wlr/backend/headless.h new file mode 100644 index 00000000..475c2f6c --- /dev/null +++ b/include/wlr/backend/headless.h @@ -0,0 +1,13 @@ +#ifndef WLR_BACKEND_HEADLESS_H +#define WLR_BACKEND_HEADLESS_H + +#include +#include + +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(struct wlr_backend *backend, + enum wlr_input_device_type type); + +#endif diff --git a/rootston/main.c b/rootston/main.c index 3b65a067..a3efa219 100644 --- a/rootston/main.c +++ b/rootston/main.c @@ -4,6 +4,7 @@ #include #include #include +#include #include #include #include @@ -29,7 +30,8 @@ int main(int argc, char **argv) { assert(server.wl_display = wl_display_create()); assert(server.wl_event_loop = wl_display_get_event_loop(server.wl_display)); - assert(server.backend = wlr_backend_autocreate(server.wl_display)); + //assert(server.backend = wlr_backend_autocreate(server.wl_display)); + assert(server.backend = wlr_headless_backend_create(server.wl_display)); assert(server.renderer = wlr_gles2_renderer_create(server.backend)); server.data_device_manager = From b852fb9a2b3842dc6d122a2483c11322beb7a489 Mon Sep 17 00:00:00 2001 From: emersion Date: Sun, 17 Dec 2017 13:35:07 +0100 Subject: [PATCH 2/5] Minimal working headless output --- backend/headless/backend.c | 10 ++++++++ backend/headless/output.c | 48 +++++++++++++++++++++++++++++++------- include/backend/headless.h | 1 + 3 files changed, 51 insertions(+), 8 deletions(-) diff --git a/backend/headless/backend.c b/backend/headless/backend.c index c60eb7e5..bc2de2f2 100644 --- a/backend/headless/backend.c +++ b/backend/headless/backend.c @@ -26,6 +26,9 @@ static void backend_destroy(struct wlr_backend *wlr_backend) { } wl_list_remove(&backend->display_destroy.link); + + // TODO: destroy outputs + wlr_egl_finish(&backend->egl); free(backend); } @@ -61,6 +64,12 @@ static bool egl_get_config(EGLDisplay disp, EGLConfig *out) { static const EGLint attribs[] = { EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, + EGL_BUFFER_SIZE, 32, + 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, }; @@ -146,6 +155,7 @@ struct wlr_backend *wlr_headless_backend_create(struct wl_display *display) { } wlr_backend_init(&backend->backend, &backend_impl); backend->display = display; + wl_list_init(&backend->outputs); egl_init(&backend->egl); diff --git a/backend/headless/output.c b/backend/headless/output.c index 194f542f..d4a46978 100644 --- a/backend/headless/output.c +++ b/backend/headless/output.c @@ -6,6 +6,27 @@ #include #include "backend/headless.h" +static void output_transform(struct wlr_output *wlr_output, + enum wl_output_transform transform) { + struct wlr_headless_backend_output *output = + (struct wlr_headless_backend_output *)wlr_output; + output->wlr_output.transform = transform; +} + +static void output_make_current(struct wlr_output *wlr_output) { + struct wlr_headless_backend_output *output = + (struct wlr_headless_backend_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_backend_output *output = (struct wlr_headless_backend_output *)wlr_output; @@ -19,13 +40,20 @@ static void output_destroy(struct wlr_output *wlr_output) { } static const struct wlr_output_impl output_impl = { - //.set_custom_mode = wlr_wl_output_set_custom_mode, - //.transform = wlr_wl_output_transform, + //.set_custom_mode = output_set_custom_mode, + .transform = output_transform, .destroy = output_destroy, - //.make_current = wlr_wl_output_make_current, - //.swap_buffers = wlr_wl_output_swap_buffers, + .make_current = output_make_current, + .swap_buffers = output_swap_buffers, }; +static int signal_frame(void *data) { + struct wlr_headless_backend_output *output = data; + wl_signal_emit(&output->wlr_output.events.frame, &output->wlr_output); + wl_event_source_timer_update(output->frame_timer, 16); + return 0; +} + 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}; @@ -49,10 +77,15 @@ struct wlr_output *wlr_headless_add_output(struct wlr_backend *wlr_backend, wlr_log(L_ERROR, "Failed to allocate wlr_headless_backend_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) { + // TODO: cleanup + return NULL; + } wlr_output_update_size(wlr_output, width, height); @@ -67,14 +100,13 @@ struct wlr_output *wlr_headless_add_output(struct wlr_backend *wlr_backend, glClearColor(1.0, 1.0, 1.0, 1.0); glClear(GL_COLOR_BUFFER_BIT); - if (!eglSwapBuffers(output->backend->egl.display, output->egl_surface)) { - wlr_log(L_ERROR, "eglSwapBuffers failed: %s", egl_error()); - goto error; - } + 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); wlr_output_create_global(wlr_output, backend->display); wl_signal_emit(&backend->backend.events.output_add, wlr_output); + wl_event_source_timer_update(output->frame_timer, 16); return wlr_output; error: diff --git a/include/backend/headless.h b/include/backend/headless.h index 56ae626a..e4cc85e4 100644 --- a/include/backend/headless.h +++ b/include/backend/headless.h @@ -20,6 +20,7 @@ struct wlr_headless_backend_output { struct wl_list link; void *egl_surface; + struct wl_event_source *frame_timer; }; #endif From 0256de00029e8f17da0514e14460fb9ff2283433 Mon Sep 17 00:00:00 2001 From: emersion Date: Sun, 17 Dec 2017 18:02:55 +0100 Subject: [PATCH 3/5] Add full refresh rate support to custom modes --- backend/drm/drm.c | 3 +- backend/headless/backend.c | 22 ++++++--- backend/headless/output.c | 71 +++++++++++++++++++++-------- backend/wayland/output.c | 6 +-- backend/x11/backend.c | 3 +- include/backend/headless.h | 2 + include/wlr/backend/headless.h | 1 + include/wlr/interfaces/wlr_output.h | 6 ++- include/wlr/types/wlr_output.h | 1 + rootston/main.c | 1 + types/wlr_output.c | 22 ++++++--- 11 files changed, 98 insertions(+), 40 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/headless/backend.c b/backend/headless/backend.c index bc2de2f2..c56753ba 100644 --- a/backend/headless/backend.c +++ b/backend/headless/backend.c @@ -2,19 +2,23 @@ #include #include #include +#include #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, "Initializating headless backend"); + wlr_log(L_INFO, "Starting headless backend"); - // TODO - for (size_t i = 0; i < 1; ++i) { - wlr_headless_add_output(&backend->backend, 1280, 720); + struct wlr_headless_backend_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); } + backend->started = true; return true; } @@ -27,7 +31,10 @@ static void backend_destroy(struct wlr_backend *wlr_backend) { wl_list_remove(&backend->display_destroy.link); - // TODO: destroy outputs + struct wlr_headless_backend_output *output, *tmp; + wl_list_for_each_safe(output, tmp, &backend->outputs, link) { + wlr_output_destroy(&output->wlr_output); + } wlr_egl_finish(&backend->egl); free(backend); @@ -64,7 +71,6 @@ static bool egl_get_config(EGLDisplay disp, EGLConfig *out) { static const EGLint attribs[] = { EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, - EGL_BUFFER_SIZE, 32, EGL_ALPHA_SIZE, 0, EGL_BLUE_SIZE, 8, EGL_GREEN_SIZE, 8, @@ -164,3 +170,7 @@ struct wlr_backend *wlr_headless_backend_create(struct wl_display *display) { return &backend->backend; } + +bool wlr_backend_is_headless(struct wlr_backend *backend) { + return backend->impl == &backend_impl; +} diff --git a/backend/headless/output.c b/backend/headless/output.c index d4a46978..a6d48400 100644 --- a/backend/headless/output.c +++ b/backend/headless/output.c @@ -6,6 +6,41 @@ #include #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_backend_output *output = + (struct wlr_headless_backend_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_backend_output *output = @@ -40,7 +75,7 @@ static void output_destroy(struct wlr_output *wlr_output) { } static const struct wlr_output_impl output_impl = { - //.set_custom_mode = output_set_custom_mode, + .set_custom_mode = output_set_custom_mode, .transform = output_transform, .destroy = output_destroy, .make_current = output_make_current, @@ -50,22 +85,10 @@ static const struct wlr_output_impl output_impl = { static int signal_frame(void *data) { struct wlr_headless_backend_output *output = data; wl_signal_emit(&output->wlr_output.events.frame, &output->wlr_output); - wl_event_source_timer_update(output->frame_timer, 16); + wl_event_source_timer_update(output->frame_timer, output->frame_delay); return 0; } -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; -} - struct wlr_output *wlr_headless_add_output(struct wlr_backend *wlr_backend, unsigned int width, unsigned int height) { struct wlr_headless_backend *backend = @@ -83,11 +106,15 @@ struct wlr_output *wlr_headless_add_output(struct wlr_backend *wlr_backend, output->egl_surface = egl_create_surface(&backend->egl, width, height); if (output->egl_surface == EGL_NO_SURFACE) { - // TODO: cleanup - return NULL; + wlr_log(L_ERROR, "Failed to create EGL surface"); + goto error; } - wlr_output_update_size(wlr_output, width, height); + 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, @@ -104,9 +131,13 @@ struct wlr_output *wlr_headless_add_output(struct wlr_backend *wlr_backend, output->frame_timer = wl_event_loop_add_timer(ev, signal_frame, output); wl_list_insert(&backend->outputs, &output->link); - wlr_output_create_global(wlr_output, backend->display); - wl_signal_emit(&backend->backend.events.output_add, wlr_output); - wl_event_source_timer_update(output->frame_timer, 16); + + 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: 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..0d45cfb5 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 = diff --git a/include/backend/headless.h b/include/backend/headless.h index e4cc85e4..6aaf5f76 100644 --- a/include/backend/headless.h +++ b/include/backend/headless.h @@ -11,6 +11,7 @@ struct wlr_headless_backend { struct wl_display *display; struct wl_list outputs; struct wl_listener display_destroy; + bool started; }; struct wlr_headless_backend_output { @@ -21,6 +22,7 @@ struct wlr_headless_backend_output { void *egl_surface; struct wl_event_source *frame_timer; + int frame_delay; // ms }; #endif diff --git a/include/wlr/backend/headless.h b/include/wlr/backend/headless.h index 475c2f6c..245a65dc 100644 --- a/include/wlr/backend/headless.h +++ b/include/wlr/backend/headless.h @@ -9,5 +9,6 @@ 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(struct wlr_backend *backend, enum wlr_input_device_type type); +bool wlr_backend_is_headless(struct wlr_backend *backend); #endif diff --git a/include/wlr/interfaces/wlr_output.h b/include/wlr/interfaces/wlr_output.h index 1cfe7568..6d71f9b6 100644 --- a/include/wlr/interfaces/wlr_output.h +++ b/include/wlr/interfaces/wlr_output.h @@ -28,8 +28,10 @@ struct wlr_output_impl { void wlr_output_init(struct wlr_output *output, struct wlr_backend *backend, const struct wlr_output_impl *impl); void wlr_output_free(struct wlr_output *output); -void wlr_output_update_size(struct wlr_output *output, int32_t width, - int32_t height); +void wlr_output_update_mode(struct wlr_output *output, + struct wlr_output_mode *mode); +void wlr_output_update_custom_mode(struct wlr_output *output, int32_t width, + int32_t height, int32_t refresh); struct wl_global *wlr_output_create_global(struct wlr_output *wlr_output, struct wl_display *display); void wlr_output_destroy_global(struct wlr_output *wlr_output); diff --git a/include/wlr/types/wlr_output.h b/include/wlr/types/wlr_output.h index 037fa515..a974a154 100644 --- a/include/wlr/types/wlr_output.h +++ b/include/wlr/types/wlr_output.h @@ -47,6 +47,7 @@ struct wlr_output { char serial[16]; float scale; int32_t width, height; + int32_t refresh; // mHz int32_t phys_width, phys_height; // mm enum wl_output_subpixel subpixel; enum wl_output_transform transform; diff --git a/rootston/main.c b/rootston/main.c index a3efa219..dc98bdc7 100644 --- a/rootston/main.c +++ b/rootston/main.c @@ -32,6 +32,7 @@ int main(int argc, char **argv) { //assert(server.backend = wlr_backend_autocreate(server.wl_display)); assert(server.backend = wlr_headless_backend_create(server.wl_display)); + wlr_headless_add_output(server.backend, 1280, 720); assert(server.renderer = wlr_gles2_renderer_create(server.backend)); server.data_device_manager = diff --git a/types/wlr_output.c b/types/wlr_output.c index de1d29df..923f8f52 100644 --- a/types/wlr_output.c +++ b/types/wlr_output.c @@ -39,7 +39,7 @@ static void wl_output_send_to_resource(struct wl_resource *resource) { if (wl_list_length(&output->modes) == 0) { // Output has no mode, send the current width/height wl_output_send_mode(resource, WL_OUTPUT_MODE_CURRENT, - output->width, output->height, 0); + output->width, output->height, output->refresh); } } if (version >= WL_OUTPUT_SCALE_SINCE_VERSION) { @@ -65,9 +65,9 @@ static void wlr_output_send_current_mode_to_resource( wl_output_send_mode(resource, flags | WL_OUTPUT_MODE_CURRENT, mode->width, mode->height, mode->refresh); } else { - // Output has no mode, send the current width/height + // Output has no mode wl_output_send_mode(resource, WL_OUTPUT_MODE_CURRENT, output->width, - output->height, 0); + output->height, output->refresh); } if (version >= WL_OUTPUT_DONE_SINCE_VERSION) { wl_output_send_done(resource); @@ -192,9 +192,17 @@ bool wlr_output_set_custom_mode(struct wlr_output *output, int32_t width, return result; } -void wlr_output_update_size(struct wlr_output *output, int32_t width, - int32_t height) { - if (output->width == width && output->height == height) { +void wlr_output_update_mode(struct wlr_output *output, + struct wlr_output_mode *mode) { + output->current_mode = mode; + wlr_output_update_custom_mode(output, mode->width, mode->height, + mode->refresh); +} + +void wlr_output_update_custom_mode(struct wlr_output *output, int32_t width, + int32_t height, int32_t refresh) { + if (output->width == width && output->height == height && + output->refresh == refresh) { return; } @@ -202,6 +210,8 @@ void wlr_output_update_size(struct wlr_output *output, int32_t width, output->height = height; wlr_output_update_matrix(output); + output->refresh = refresh; + struct wl_resource *resource; wl_resource_for_each(resource, &output->wl_resources) { wlr_output_send_current_mode_to_resource(resource); From bc5bdb7793d7737a42489ddb07b2fbb7f74a47f5 Mon Sep 17 00:00:00 2001 From: emersion Date: Sun, 17 Dec 2017 18:49:20 +0100 Subject: [PATCH 4/5] Add headless input devices --- backend/headless/backend.c | 24 +++++++-- backend/headless/input_device.c | 91 +++++++++++++++++++++++++++++++++ backend/headless/output.c | 24 ++++----- backend/meson.build | 1 + include/backend/headless.h | 9 +++- include/wlr/backend/headless.h | 4 +- rootston/main.c | 2 + 7 files changed, 136 insertions(+), 19 deletions(-) create mode 100644 backend/headless/input_device.c diff --git a/backend/headless/backend.c b/backend/headless/backend.c index c56753ba..71c87dd0 100644 --- a/backend/headless/backend.c +++ b/backend/headless/backend.c @@ -3,6 +3,7 @@ #include #include #include +#include #include "backend/headless.h" #include "glapi.h" @@ -11,11 +12,19 @@ static bool backend_start(struct wlr_backend *wlr_backend) { (struct wlr_headless_backend *)wlr_backend; wlr_log(L_INFO, "Starting headless backend"); - struct wlr_headless_backend_output *output; + 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); + 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; @@ -31,11 +40,17 @@ static void backend_destroy(struct wlr_backend *wlr_backend) { wl_list_remove(&backend->display_destroy.link); - struct wlr_headless_backend_output *output, *tmp; - wl_list_for_each_safe(output, tmp, &backend->outputs, 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); } @@ -162,6 +177,7 @@ struct wlr_backend *wlr_headless_backend_create(struct wl_display *display) { wlr_backend_init(&backend->backend, &backend_impl); backend->display = display; wl_list_init(&backend->outputs); + wl_list_init(&backend->input_devices); egl_init(&backend->egl); 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 +#include +#include +#include +#include +#include +#include +#include +#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 index a6d48400..9c4ba35e 100644 --- a/backend/headless/output.c +++ b/backend/headless/output.c @@ -20,8 +20,8 @@ static EGLSurface egl_create_surface(struct wlr_egl *egl, unsigned int width, static bool output_set_custom_mode(struct wlr_output *wlr_output, int32_t width, int32_t height, int32_t refresh) { - struct wlr_headless_backend_output *output = - (struct wlr_headless_backend_output *)wlr_output; + struct wlr_headless_output *output = + (struct wlr_headless_output *)wlr_output; struct wlr_headless_backend *backend = output->backend; if (output->egl_surface) { @@ -43,14 +43,14 @@ static bool output_set_custom_mode(struct wlr_output *wlr_output, int32_t width, static void output_transform(struct wlr_output *wlr_output, enum wl_output_transform transform) { - struct wlr_headless_backend_output *output = - (struct wlr_headless_backend_output *)wlr_output; + 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_backend_output *output = - (struct wlr_headless_backend_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)) { @@ -63,8 +63,8 @@ static void output_swap_buffers(struct wlr_output *wlr_output) { } static void output_destroy(struct wlr_output *wlr_output) { - struct wlr_headless_backend_output *output = - (struct wlr_headless_backend_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); @@ -83,7 +83,7 @@ static const struct wlr_output_impl output_impl = { }; static int signal_frame(void *data) { - struct wlr_headless_backend_output *output = 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; @@ -94,10 +94,10 @@ struct wlr_output *wlr_headless_add_output(struct wlr_backend *wlr_backend, struct wlr_headless_backend *backend = (struct wlr_headless_backend *)wlr_backend; - struct wlr_headless_backend_output *output = - calloc(1, sizeof(struct wlr_headless_backend_output)); + struct wlr_headless_output *output = + calloc(1, sizeof(struct wlr_headless_output)); if (output == NULL) { - wlr_log(L_ERROR, "Failed to allocate wlr_headless_backend_output"); + wlr_log(L_ERROR, "Failed to allocate wlr_headless_output"); return NULL; } output->backend = backend; diff --git a/backend/meson.build b/backend/meson.build index fb16944e..68d958a7 100644 --- a/backend/meson.build +++ b/backend/meson.build @@ -11,6 +11,7 @@ backend_files = files( '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/include/backend/headless.h b/include/backend/headless.h index 6aaf5f76..91ff37dd 100644 --- a/include/backend/headless.h +++ b/include/backend/headless.h @@ -10,11 +10,12 @@ struct wlr_headless_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_backend_output { +struct wlr_headless_output { struct wlr_output wlr_output; struct wlr_headless_backend *backend; @@ -25,4 +26,10 @@ struct wlr_headless_backend_output { int frame_delay; // ms }; +struct wlr_headless_input_device { + struct wlr_input_device wlr_input_device; + + struct wlr_headless_backend *backend; +}; + #endif diff --git a/include/wlr/backend/headless.h b/include/wlr/backend/headless.h index 245a65dc..68ad84da 100644 --- a/include/wlr/backend/headless.h +++ b/include/wlr/backend/headless.h @@ -7,8 +7,8 @@ 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(struct wlr_backend *backend, - enum wlr_input_device_type type); +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 diff --git a/rootston/main.c b/rootston/main.c index dc98bdc7..c081f57c 100644 --- a/rootston/main.c +++ b/rootston/main.c @@ -33,6 +33,8 @@ int main(int argc, char **argv) { //assert(server.backend = wlr_backend_autocreate(server.wl_display)); assert(server.backend = wlr_headless_backend_create(server.wl_display)); wlr_headless_add_output(server.backend, 1280, 720); + wlr_headless_add_input_device(server.backend, WLR_INPUT_DEVICE_KEYBOARD); + wlr_headless_add_input_device(server.backend, WLR_INPUT_DEVICE_POINTER); assert(server.renderer = wlr_gles2_renderer_create(server.backend)); server.data_device_manager = From b99d1f4fcca0f8d7b1d2042f51fdefcc73304e6f Mon Sep 17 00:00:00 2001 From: emersion Date: Sun, 17 Dec 2017 23:51:04 +0100 Subject: [PATCH 5/5] Refactor wlr_egl_init to accept config_attribs --- backend/drm/renderer.c | 4 +- backend/headless/backend.c | 108 ++++++------------------------------- backend/wayland/backend.c | 2 +- backend/x11/backend.c | 4 +- include/wlr/render/egl.h | 3 +- render/egl.c | 21 +++++--- 6 files changed, 36 insertions(+), 106 deletions(-) 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 index 71c87dd0..f95e3897 100644 --- a/backend/headless/backend.c +++ b/backend/headless/backend.c @@ -73,98 +73,6 @@ static void handle_display_destroy(struct wl_listener *listener, void *data) { backend_destroy(&backend->backend); } -static bool egl_get_config(EGLDisplay disp, EGLConfig *out) { - EGLint count = 0, matched = 0, ret; - - ret = eglGetConfigs(disp, NULL, 0, &count); - if (ret == EGL_FALSE || count == 0) { - wlr_log(L_ERROR, "eglGetConfigs returned no configs"); - return false; - } - - EGLConfig configs[count]; - - static const EGLint 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, - }; - - ret = eglChooseConfig(disp, attribs, configs, count, &matched); - if (ret == EGL_FALSE) { - wlr_log(L_ERROR, "eglChooseConfig failed"); - return false; - } - - // TODO - *out = configs[0]; - return true; -} - -static bool egl_init(struct wlr_egl *egl) { - if (!load_glapi()) { - return false; - } - - if (eglBindAPI(EGL_OPENGL_ES_API) == EGL_FALSE) { - wlr_log(L_ERROR, "Failed to bind to the OpenGL ES API: %s", egl_error()); - goto error; - } - - egl->display = eglGetDisplay(EGL_DEFAULT_DISPLAY); - if (egl->display == EGL_NO_DISPLAY) { - wlr_log(L_ERROR, "Failed to create EGL display: %s", egl_error()); - goto error; - } - - EGLint major, minor; - if (eglInitialize(egl->display, &major, &minor) == EGL_FALSE) { - wlr_log(L_ERROR, "Failed to initialize EGL: %s", egl_error()); - goto error; - } - - if (!egl_get_config(egl->display, &egl->config)) { - wlr_log(L_ERROR, "Failed to get EGL config"); - goto error; - } - - static const EGLint attribs[] = { - EGL_CONTEXT_CLIENT_VERSION, 2, - EGL_NONE, - }; - - egl->context = eglCreateContext(egl->display, egl->config, - EGL_NO_CONTEXT, attribs); - if (egl->context == EGL_NO_CONTEXT) { - wlr_log(L_ERROR, "Failed to create EGL context: %s", egl_error()); - goto error; - } - - eglMakeCurrent(egl->display, EGL_NO_SURFACE, EGL_NO_SURFACE, egl->context); - egl->egl_exts = eglQueryString(egl->display, EGL_EXTENSIONS); - if (strstr(egl->egl_exts, "EGL_KHR_image_base") == NULL) { - wlr_log(L_ERROR, "Required egl extensions not supported"); - goto error; - } - - egl->gl_exts = (const char*) glGetString(GL_EXTENSIONS); - wlr_log(L_INFO, "Using EGL %d.%d", (int)major, (int)minor); - wlr_log(L_INFO, "Using %s", glGetString(GL_VERSION)); - wlr_log(L_INFO, "Supported EGL extensions: %s", egl->egl_exts); - wlr_log(L_INFO, "Supported OpenGL ES extensions: %s", egl->gl_exts); - return true; - -error: - eglMakeCurrent(EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); - eglTerminate(egl->display); - eglReleaseThread(); - return false; -} - struct wlr_backend *wlr_headless_backend_create(struct wl_display *display) { wlr_log(L_INFO, "Creating headless backend"); @@ -179,7 +87,21 @@ struct wlr_backend *wlr_headless_backend_create(struct wl_display *display) { wl_list_init(&backend->outputs); wl_list_init(&backend->input_devices); - egl_init(&backend->egl); + 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); 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/x11/backend.c b/backend/x11/backend.c index 0d45cfb5..a218c589 100644 --- a/backend/x11/backend.c +++ b/backend/x11/backend.c @@ -311,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; } diff --git a/include/wlr/render/egl.h b/include/wlr/render/egl.h index 67a81f37..bdb8d286 100644 --- a/include/wlr/render/egl.h +++ b/include/wlr/render/egl.h @@ -22,7 +22,8 @@ struct wlr_egl { * Initializes an egl context for the given platform and remote display. * Will attempt to load all possibly required api functions. */ -bool wlr_egl_init(struct wlr_egl *egl, EGLenum platform, EGLint visual_id, void *display); +bool wlr_egl_init(struct wlr_egl *egl, EGLenum platform, void *remote_display, + EGLint *config_attribs, EGLint visual_id); /** * Frees all related egl resources, makes the context not-current and diff --git a/render/egl.c b/render/egl.c index e895df8d..fe20973c 100644 --- a/render/egl.c +++ b/render/egl.c @@ -1,3 +1,4 @@ +#include #include #include #include @@ -47,7 +48,8 @@ const char *egl_error(void) { } } -static bool egl_get_config(EGLDisplay disp, EGLConfig *out, EGLint visual_id) { +static bool egl_get_config(EGLDisplay disp, EGLint *attribs, EGLConfig *out, + EGLint visual_id) { EGLint count = 0, matched = 0, ret; ret = eglGetConfigs(disp, NULL, 0, &count); @@ -58,7 +60,7 @@ static bool egl_get_config(EGLDisplay disp, EGLConfig *out, EGLint visual_id) { EGLConfig configs[count]; - ret = eglChooseConfig(disp, NULL, configs, count, &matched); + ret = eglChooseConfig(disp, attribs, configs, count, &matched); if (ret == EGL_FALSE) { wlr_log(L_ERROR, "eglChooseConfig failed"); return false; @@ -71,7 +73,7 @@ static bool egl_get_config(EGLDisplay disp, EGLConfig *out, EGLint visual_id) { continue; } - if (visual == visual_id) { + if (!visual_id || visual == visual_id) { *out = configs[i]; return true; } @@ -81,8 +83,8 @@ static bool egl_get_config(EGLDisplay disp, EGLConfig *out, EGLint visual_id) { return false; } -bool wlr_egl_init(struct wlr_egl *egl, EGLenum platform, EGLint visual_id, - void *remote_display) { +bool wlr_egl_init(struct wlr_egl *egl, EGLenum platform, void *remote_display, + EGLint *config_attribs, EGLint visual_id) { if (!load_glapi()) { return false; } @@ -92,7 +94,12 @@ bool wlr_egl_init(struct wlr_egl *egl, EGLenum platform, EGLint visual_id, goto error; } - egl->display = eglGetPlatformDisplayEXT(platform, remote_display, NULL); + if (platform == EGL_PLATFORM_SURFACELESS_MESA) { + assert(remote_display == NULL); + egl->display = eglGetDisplay(EGL_DEFAULT_DISPLAY); + } else { + egl->display = eglGetPlatformDisplayEXT(platform, remote_display, NULL); + } if (egl->display == EGL_NO_DISPLAY) { wlr_log(L_ERROR, "Failed to create EGL display: %s", egl_error()); goto error; @@ -104,7 +111,7 @@ bool wlr_egl_init(struct wlr_egl *egl, EGLenum platform, EGLint visual_id, goto error; } - if (!egl_get_config(egl->display, &egl->config, visual_id)) { + if (!egl_get_config(egl->display, config_attribs, &egl->config, visual_id)) { wlr_log(L_ERROR, "Failed to get EGL config"); goto error; }