aboutsummaryrefslogtreecommitdiff
path: root/render
diff options
context:
space:
mode:
Diffstat (limited to 'render')
-rw-r--r--render/egl.c243
-rw-r--r--render/gles2/renderer.c47
-rw-r--r--render/gles2/shaders.c10
-rw-r--r--render/gles2/texture.c88
-rw-r--r--render/meson.build5
-rw-r--r--render/wlr_renderer.c5
-rw-r--r--render/wlr_texture.c5
7 files changed, 394 insertions, 9 deletions
diff --git a/render/egl.c b/render/egl.c
new file mode 100644
index 00000000..73680d1d
--- /dev/null
+++ b/render/egl.c
@@ -0,0 +1,243 @@
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <GLES2/gl2.h>
+#include <gbm.h> // GBM_FORMAT_XRGB8888
+#include <stdlib.h>
+#include <wlr/util/log.h>
+#include <wlr/egl.h>
+
+// Extension documentation
+// https://www.khronos.org/registry/EGL/extensions/KHR/EGL_KHR_image_base.txt.
+// https://cgit.freedesktop.org/mesa/mesa/tree/docs/specs/WL_bind_wayland_display.spec
+
+const char *egl_error(void) {
+ switch (eglGetError()) {
+ case EGL_SUCCESS:
+ return "Success";
+ case EGL_NOT_INITIALIZED:
+ return "Not initialized";
+ case EGL_BAD_ACCESS:
+ return "Bad access";
+ case EGL_BAD_ALLOC:
+ return "Bad alloc";
+ case EGL_BAD_ATTRIBUTE:
+ return "Bad attribute";
+ case EGL_BAD_CONTEXT:
+ return "Bad Context";
+ case EGL_BAD_CONFIG:
+ return "Bad Config";
+ case EGL_BAD_CURRENT_SURFACE:
+ return "Bad current surface";
+ case EGL_BAD_DISPLAY:
+ return "Bad display";
+ case EGL_BAD_SURFACE:
+ return "Bad surface";
+ case EGL_BAD_MATCH:
+ return "Bad match";
+ case EGL_BAD_PARAMETER:
+ return "Bad parameter";
+ case EGL_BAD_NATIVE_PIXMAP:
+ return "Bad native pixmap";
+ case EGL_BAD_NATIVE_WINDOW:
+ return "Bad native window";
+ case EGL_CONTEXT_LOST:
+ return "Context lost";
+ default:
+ return "Unknown";
+ }
+}
+
+static bool egl_exts(struct wlr_egl *egl) {
+ egl->get_platform_display = (PFNEGLGETPLATFORMDISPLAYEXTPROC)
+ eglGetProcAddress("eglGetPlatformDisplayEXT");
+
+ if (!egl->get_platform_display) {
+ wlr_log(L_ERROR, "Failed to load EGL extension 'eglGetPlatformDisplayEXT'");
+ return false;
+ }
+
+ egl->create_platform_window_surface = (PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC)
+ eglGetProcAddress("eglCreatePlatformWindowSurfaceEXT");
+
+ if (!egl->get_platform_display) {
+ wlr_log(L_ERROR,
+ "Failed to load EGL extension 'eglCreatePlatformWindowSurfaceEXT'");
+ return false;
+ }
+
+ return true;
+}
+
+static bool egl_get_config(EGLDisplay disp, EGLConfig *out, EGLenum platform) {
+ 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];
+
+ ret = eglChooseConfig(disp, NULL, configs, count, &matched);
+ if (ret == EGL_FALSE) {
+ wlr_log(L_ERROR, "eglChooseConfig failed");
+ return false;
+ }
+
+ for (int i = 0; i < matched; ++i) {
+ EGLint gbm_format;
+
+ if (platform == EGL_PLATFORM_WAYLAND_EXT) {
+ *out = configs[i];
+ return true;
+ }
+
+ if (!eglGetConfigAttrib(disp,
+ configs[i],
+ EGL_NATIVE_VISUAL_ID,
+ &gbm_format)) {
+ continue;
+ }
+
+ if (gbm_format == GBM_FORMAT_ARGB8888) {
+ *out = configs[i];
+ return true;
+ }
+ }
+
+ wlr_log(L_ERROR, "no valid egl config found");
+ return false;
+}
+
+bool wlr_egl_init(struct wlr_egl *egl, EGLenum platform,
+ void *remote_display) {
+ if (!egl_exts(egl)) {
+ 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 = egl->get_platform_display(platform, remote_display, NULL);
+ 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, platform)) {
+ 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_WL_bind_wayland_display") == NULL ||
+ strstr(egl->egl_exts, "EGL_KHR_image_base") == NULL) {
+ wlr_log(L_ERROR, "Required egl extensions not supported");
+ goto error;
+ }
+
+ egl->eglCreateImageKHR = (PFNEGLCREATEIMAGEKHRPROC)
+ eglGetProcAddress("eglCreateImageKHR");
+ egl->eglDestroyImageKHR = (PFNEGLDESTROYIMAGEKHRPROC)
+ eglGetProcAddress("eglDestroyImageKHR");
+ egl->eglQueryWaylandBufferWL = (PFNEGLQUERYWAYLANDBUFFERWL)
+ (void*) eglGetProcAddress("eglQueryWaylandBufferWL");
+ egl->eglBindWaylandDisplayWL = (PFNEGLBINDWAYLANDDISPLAYWL)
+ (void*) eglGetProcAddress("eglBindWaylandDisplayWL");
+ egl->eglUnbindWaylandDisplayWL = (PFNEGLUNBINDWAYLANDDISPLAYWL)
+ (void*) eglGetProcAddress("eglUnbindWaylandDisplayWL");
+
+ egl->gl_exts = (const char*) glGetString(GL_EXTENSIONS);
+ wlr_log(L_INFO, "Using EGL %d.%d", (int)major, (int)minor);
+ wlr_log(L_INFO, "Supported EGL extensions: %s", egl->egl_exts);
+ wlr_log(L_INFO, "Using %s", glGetString(GL_VERSION));
+ wlr_log(L_INFO, "Supported OpenGL ES extensions: %s", egl->gl_exts);
+ return true;
+
+error:
+ eglTerminate(egl->display);
+ eglReleaseThread();
+ eglMakeCurrent(EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+ return false;
+}
+
+void wlr_egl_free(struct wlr_egl *egl) {
+ if (egl->wl_display && egl->eglUnbindWaylandDisplayWL) {
+ egl->eglUnbindWaylandDisplayWL(egl->display, egl->wl_display);
+ }
+
+ eglDestroyContext(egl->display, egl->context);
+ eglTerminate(egl->display);
+ eglReleaseThread();
+ eglMakeCurrent(EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+}
+
+bool wlr_egl_bind_display(struct wlr_egl *egl, struct wl_display *local_display) {
+ if (!egl->eglBindWaylandDisplayWL) {
+ return false;
+ }
+
+ if (egl->eglBindWaylandDisplayWL(egl->display, local_display)) {
+ egl->wl_display = local_display;
+ return true;
+ }
+
+ return false;
+}
+
+bool wlr_egl_query_buffer(struct wlr_egl *egl, struct wl_resource *buf,
+ int attrib, int *value) {
+ if (!egl->eglQueryWaylandBufferWL) {
+ return false;
+ }
+ return egl->eglQueryWaylandBufferWL(egl->display, buf, attrib, value);
+}
+
+EGLImage wlr_egl_create_image(struct wlr_egl *egl, EGLenum target,
+ EGLClientBuffer buffer, const EGLint *attribs) {
+ if (!egl->eglCreateImageKHR) {
+ return false;
+ }
+
+ return egl->eglCreateImageKHR(egl->display, egl->context, target,
+ buffer, attribs);
+}
+
+bool wlr_egl_destroy_image(struct wlr_egl *egl, EGLImage image) {
+ if (!egl->eglDestroyImageKHR) {
+ return false;
+ }
+
+ egl->eglDestroyImageKHR(egl->display, image);
+ return true;
+}
+
+EGLSurface wlr_egl_create_surface(struct wlr_egl *egl, void *window) {
+ EGLSurface surf = egl->create_platform_window_surface(egl->display, egl->config,
+ window, NULL);
+ if (surf == EGL_NO_SURFACE) {
+ wlr_log(L_ERROR, "Failed to create EGL surface: %s", egl_error());
+ return EGL_NO_SURFACE;
+ }
+ return surf;
+}
diff --git a/render/gles2/renderer.c b/render/gles2/renderer.c
index 703edd46..237dc67b 100644
--- a/render/gles2/renderer.c
+++ b/render/gles2/renderer.c
@@ -2,14 +2,18 @@
#include <stdlib.h>
#include <assert.h>
#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
#include <wayland-util.h>
#include <wayland-server-protocol.h>
+#include <wlr/egl.h>
+#include <wlr/backend.h>
#include <wlr/render.h>
#include <wlr/render/interface.h>
#include <wlr/render/matrix.h>
#include <wlr/util/log.h>
#include "render/gles2.h"
+PFNGLEGLIMAGETARGETTEXTURE2DOESPROC glEGLImageTargetTexture2DOES = NULL;
struct shaders shaders;
static bool compile_shader(GLuint type, const GLchar *src, GLuint *shader) {
@@ -65,13 +69,36 @@ static void init_default_shaders() {
if (!compile_program(quad_vertex_src, ellipse_fragment_src, &shaders.ellipse)) {
goto error;
}
+ if (glEGLImageTargetTexture2DOES) {
+ if (!compile_program(quad_vertex_src, fragment_src_external, &shaders.external)) {
+ goto error;
+ }
+ }
+
wlr_log(L_DEBUG, "Compiled default shaders");
return;
error:
wlr_log(L_ERROR, "Failed to set up default shaders!");
}
+static void init_image_ext() {
+ if (glEGLImageTargetTexture2DOES)
+ return;
+
+ const char *exts = (const char*) glGetString(GL_EXTENSIONS);
+ if (strstr(exts, "GL_OES_EGL_image_external")) {
+ glEGLImageTargetTexture2DOES = (PFNGLEGLIMAGETARGETTEXTURE2DOESPROC)
+ eglGetProcAddress("glEGLImageTargetTexture2DOES");
+ }
+
+ if (!glEGLImageTargetTexture2DOES) {
+ wlr_log(L_INFO, "Failed to load glEGLImageTargetTexture2DOES "
+ "Will not be able to attach drm buffers");
+ }
+}
+
static void init_globals() {
+ init_image_ext();
init_default_shaders();
}
@@ -97,7 +124,7 @@ static void wlr_gles2_end(struct wlr_renderer_state *state) {
}
static struct wlr_texture *wlr_gles2_texture_init(struct wlr_renderer_state *state) {
- return gles2_texture_init();
+ return gles2_texture_init(state->egl);
}
static void draw_quad() {
@@ -169,8 +196,14 @@ static const enum wl_shm_format *wlr_gles2_formats(
return formats;
}
+static bool wlr_gles2_buffer_is_drm(struct wlr_renderer_state *state,
+ struct wl_resource *buffer) {
+ EGLint format;
+ return wlr_egl_query_buffer(state->egl, buffer, EGL_TEXTURE_FORMAT, &format);
+}
+
static void wlr_gles2_destroy(struct wlr_renderer_state *state) {
- // no-op
+ free(state);
}
static struct wlr_renderer_impl wlr_renderer_impl = {
@@ -181,10 +214,16 @@ static struct wlr_renderer_impl wlr_renderer_impl = {
.render_quad = wlr_gles2_render_quad,
.render_ellipse = wlr_gles2_render_ellipse,
.formats = wlr_gles2_formats,
+ .buffer_is_drm = wlr_gles2_buffer_is_drm,
.destroy = wlr_gles2_destroy
};
-struct wlr_renderer *wlr_gles2_renderer_init() {
+struct wlr_renderer *wlr_gles2_renderer_init(struct wlr_backend *backend) {
init_globals();
- return wlr_renderer_init(NULL, &wlr_renderer_impl);
+ struct wlr_egl *egl = wlr_backend_get_egl(backend);
+ struct wlr_renderer_state *state = calloc(1, sizeof(struct wlr_renderer_state));
+ struct wlr_renderer *renderer = wlr_renderer_init(state, &wlr_renderer_impl);
+ state->renderer = renderer;
+ state->egl = egl;
+ return renderer;
}
diff --git a/render/gles2/shaders.c b/render/gles2/shaders.c
index f5e61dd6..c1db6e20 100644
--- a/render/gles2/shaders.c
+++ b/render/gles2/shaders.c
@@ -90,3 +90,13 @@ const GLchar fragment_src_rgbx[] =
" gl_FragColor.rgb = alpha * texture2D(tex, v_texcoord).rgb;"
" gl_FragColor.a = alpha;"
"}";
+
+const GLchar fragment_src_external[] =
+"#extension GL_OES_EGL_image_external : require\n"
+"precision mediump float;"
+"uniform samplerExternalOES texture0;"
+"varying vec2 v_uv;"
+"void main() {"
+" vec4 col = texture2D(texture0, v_uv);"
+" gl_FragColor = vec4(col.rgb, col.a);"
+"}";
diff --git a/render/gles2/texture.c b/render/gles2/texture.c
index 7a030f25..f2c88af5 100644
--- a/render/gles2/texture.c
+++ b/render/gles2/texture.c
@@ -5,12 +5,33 @@
#include <GLES2/gl2ext.h>
#include <wayland-util.h>
#include <wayland-server-protocol.h>
+#include <wlr/egl.h>
#include <wlr/render.h>
#include <wlr/render/interface.h>
#include <wlr/render/matrix.h>
#include <wlr/util/log.h>
#include "render/gles2.h"
+static struct pixel_format external_pixel_format = {
+ .wl_format = 0,
+ .depth = 0,
+ .bpp = 0,
+ .gl_format = 0,
+ .gl_type = 0,
+ .shader = &shaders.external
+};
+
+static void gles2_texture_gen_texture(struct wlr_texture_state *surface) {
+ if (surface->tex_id) {
+ return;
+ }
+
+ GL_CALL(glGenTextures(1, &surface->tex_id));
+ GL_CALL(glBindTexture(GL_TEXTURE_2D, surface->tex_id));
+ GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
+ GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
+}
+
static bool gles2_texture_upload_pixels(struct wlr_texture_state *texture,
enum wl_shm_format format, int stride, int width, int height,
const unsigned char *pixels) {
@@ -24,7 +45,8 @@ static bool gles2_texture_upload_pixels(struct wlr_texture_state *texture,
texture->wlr_texture->height = height;
texture->wlr_texture->format = format;
texture->pixel_format = fmt;
- GL_CALL(glGenTextures(1, &texture->tex_id));
+
+ gles2_texture_gen_texture(texture);
GL_CALL(glBindTexture(GL_TEXTURE_2D, texture->tex_id));
GL_CALL(glPixelStorei(GL_UNPACK_ROW_LENGTH_EXT, stride));
GL_CALL(glTexImage2D(GL_TEXTURE_2D, 0, fmt->gl_format, width, height, 0,
@@ -74,7 +96,7 @@ static bool gles2_texture_upload_shm(struct wlr_texture_state *texture,
texture->wlr_texture->format = format;
texture->pixel_format = fmt;
- GL_CALL(glGenTextures(1, &texture->tex_id));
+ gles2_texture_gen_texture(texture);
GL_CALL(glBindTexture(GL_TEXTURE_2D, texture->tex_id));
GL_CALL(glPixelStorei(GL_UNPACK_ROW_LENGTH_EXT, pitch));
GL_CALL(glPixelStorei(GL_UNPACK_SKIP_PIXELS_EXT, 0));
@@ -113,6 +135,64 @@ static bool gles2_texture_update_shm(struct wlr_texture_state *texture,
GL_CALL(glPixelStorei(GL_UNPACK_SKIP_ROWS_EXT, 0));
wl_shm_buffer_end_access(buffer);
+
+ return true;
+}
+
+static bool gles2_texture_upload_drm(struct wlr_texture_state *tex,
+ struct wl_resource *buf) {
+ if (!glEGLImageTargetTexture2DOES) {
+ return false;
+ }
+
+ EGLint format;
+ if (!wlr_egl_query_buffer(tex->egl, buf, EGL_TEXTURE_FORMAT, &format)) {
+ wlr_log(L_INFO, "upload_drm called with no drm buffer");
+ return false;
+ }
+
+ wlr_egl_query_buffer(tex->egl, buf, EGL_WIDTH,
+ (EGLint*)&tex->wlr_texture->width);
+ wlr_egl_query_buffer(tex->egl, buf, EGL_HEIGHT,
+ (EGLint*)&tex->wlr_texture->height);
+
+ EGLint inverted_y;
+ wlr_egl_query_buffer(tex->egl, buf, EGL_WAYLAND_Y_INVERTED_WL, &inverted_y);
+
+ GLenum target;
+ const struct pixel_format *pf;
+ switch (format) {
+ case EGL_TEXTURE_RGB:
+ case EGL_TEXTURE_RGBA:
+ target = GL_TEXTURE_2D;
+ pf = gl_format_for_wl_format(WL_SHM_FORMAT_ARGB8888);
+ break;
+ case EGL_TEXTURE_EXTERNAL_WL:
+ target = GL_TEXTURE_EXTERNAL_OES;
+ pf = &external_pixel_format;
+ break;
+ default:
+ wlr_log(L_ERROR, "invalid/unsupported egl buffer format");
+ return false;
+ }
+
+ gles2_texture_gen_texture(tex);
+ GL_CALL(glBindTexture(GL_TEXTURE_2D, tex->tex_id));
+
+ EGLint attribs[] = { EGL_WAYLAND_PLANE_WL, 0, EGL_NONE };
+ tex->image = wlr_egl_create_image(tex->egl, EGL_WAYLAND_BUFFER_WL,
+ (EGLClientBuffer*) buf, attribs);
+ if (!tex->image) {
+ wlr_log(L_ERROR, "failed to create egl image: %s", egl_error());
+ return false;
+ }
+
+ GL_CALL(glActiveTexture(GL_TEXTURE0));
+ GL_CALL(glBindTexture(target, tex->tex_id));
+ GL_CALL(glEGLImageTargetTexture2DOES(target, tex->image));
+ tex->wlr_texture->valid = true;
+ tex->pixel_format = pf;
+
return true;
}
@@ -146,15 +226,17 @@ static struct wlr_texture_impl wlr_texture_impl = {
.update_pixels = gles2_texture_update_pixels,
.upload_shm = gles2_texture_upload_shm,
.update_shm = gles2_texture_update_shm,
+ .upload_drm = gles2_texture_upload_drm,
.get_matrix = gles2_texture_get_matrix,
.bind = gles2_texture_bind,
.destroy = gles2_texture_destroy,
};
-struct wlr_texture *gles2_texture_init() {
+struct wlr_texture *gles2_texture_init(struct wlr_egl *egl) {
struct wlr_texture_state *state = calloc(sizeof(struct wlr_texture_state), 1);
struct wlr_texture *texture = wlr_texture_init(state, &wlr_texture_impl);
state->wlr_texture = texture;
+ state->egl = egl;
wl_signal_init(&texture->destroy_signal);
return texture;
}
diff --git a/render/meson.build b/render/meson.build
index 93bf8b4b..a0a44ea2 100644
--- a/render/meson.build
+++ b/render/meson.build
@@ -1,10 +1,11 @@
wlr_files += files(
+ 'egl.c',
'matrix.c',
- 'wlr_renderer.c',
- 'wlr_texture.c',
'gles2/pixel_format.c',
'gles2/renderer.c',
'gles2/shaders.c',
'gles2/texture.c',
'gles2/util.c',
+ 'wlr_renderer.c',
+ 'wlr_texture.c',
)
diff --git a/render/wlr_renderer.c b/render/wlr_renderer.c
index 8418fd5b..640d737e 100644
--- a/render/wlr_renderer.c
+++ b/render/wlr_renderer.c
@@ -46,3 +46,8 @@ const enum wl_shm_format *wlr_renderer_get_formats(
struct wlr_renderer *r, size_t *len) {
return r->impl->formats(r->state, len);
}
+
+bool wlr_renderer_buffer_is_drm(struct wlr_renderer *r,
+ struct wl_resource *buffer) {
+ return r->impl->buffer_is_drm(r->state, buffer);
+}
diff --git a/render/wlr_texture.c b/render/wlr_texture.c
index 64f90990..0d4362dc 100644
--- a/render/wlr_texture.c
+++ b/render/wlr_texture.c
@@ -43,6 +43,11 @@ bool wlr_texture_update_shm(struct wlr_texture *texture, uint32_t format,
x, y, width, height, shm);
}
+bool wlr_texture_upload_drm(struct wlr_texture *texture,
+ struct wl_resource *drm_buffer) {
+ return texture->impl->upload_drm(texture->state, drm_buffer);
+}
+
void wlr_texture_get_matrix(struct wlr_texture *texture,
float (*matrix)[16], const float (*projection)[16], int x, int y) {
texture->impl->get_matrix(texture->state, matrix, projection, x, y);
generated by cgit v1.2.3 (git 2.39.1) at 2024-10-02 22:35:49 +0000