From 99235f71420bc3e0a90f3a39fc1ae0944a35ec60 Mon Sep 17 00:00:00 2001 From: Andri Yngvason Date: Mon, 18 May 2026 15:45:19 +0000 Subject: [PATCH 1/7] render: color: Add method to get matrix from encoding and range Signed-off-by: Andri Yngvason --- include/render/color.h | 3 ++ render/color.c | 88 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 91 insertions(+) diff --git a/include/render/color.h b/include/render/color.h index 60c841d12..14832565a 100644 --- a/include/render/color.h +++ b/include/render/color.h @@ -108,4 +108,7 @@ void wlr_color_primaries_to_xyz(const struct wlr_color_primaries *primaries, flo void wlr_color_transfer_function_get_default_luminance(enum wlr_color_transfer_function tf, struct wlr_color_luminances *lum); +void wlr_color_rgb_to_ycbcr_matrix(enum wlr_color_encoding encoding, + enum wlr_color_range range, float matrix[static 16]); + #endif diff --git a/render/color.c b/render/color.c index e89fab260..0f857dab0 100644 --- a/render/color.c +++ b/render/color.c @@ -5,6 +5,10 @@ #include "render/color.h" #include "util/matrix.h" +struct luma_coefficients { + float kr, kb; +}; + // See H.273 ColourPrimaries static const struct wlr_color_primaries COLOR_PRIMARIES_SRGB = { // code point 1 @@ -21,6 +25,12 @@ static const struct wlr_color_primaries COLOR_PRIMARIES_BT2020 = { // code point .white = { 0.3127, 0.3290 }, }; +static const struct luma_coefficients LUMA_COEFFICIENTS_BT709 = { 0.2126f, 0.0722f }; +static const struct luma_coefficients LUMA_COEFFICIENTS_FCC = { 0.30f, 0.11f }; +static const struct luma_coefficients LUMA_COEFFICIENTS_BT601 = { 0.299f, 0.114f }; +static const struct luma_coefficients LUMA_COEFFICIENTS_SMPTE240 = { 0.212f, 0.087f }; +static const struct luma_coefficients LUMA_COEFFICIENTS_BT2020 = { 0.2627f, 0.0593f }; + void wlr_color_transform_init(struct wlr_color_transform *tr, enum wlr_color_transform_type type) { *tr = (struct wlr_color_transform){ .type = type, @@ -431,3 +441,81 @@ void wlr_color_transfer_function_get_default_luminance(enum wlr_color_transfer_f break; } } + +static const struct luma_coefficients *luma_coefficients_from_encoding(enum wlr_color_encoding encoding) { + switch (encoding) { + case WLR_COLOR_ENCODING_NONE: + case WLR_COLOR_ENCODING_IDENTITY: + return NULL; + case WLR_COLOR_ENCODING_BT709: + return &LUMA_COEFFICIENTS_BT709; + case WLR_COLOR_ENCODING_FCC: + return &LUMA_COEFFICIENTS_FCC; + case WLR_COLOR_ENCODING_BT601: + return &LUMA_COEFFICIENTS_BT601; + case WLR_COLOR_ENCODING_SMPTE240: + return &LUMA_COEFFICIENTS_SMPTE240; + case WLR_COLOR_ENCODING_BT2020: + case WLR_COLOR_ENCODING_BT2020_CL: + return &LUMA_COEFFICIENTS_BT2020; + case WLR_COLOR_ENCODING_ICTCP: + return NULL; + } + return NULL; +} + +// https://en.wikipedia.org/w/index.php?title=YCbCr&oldid=1350695871#RGB_conversion +static void rgb_to_ypbpr(const struct luma_coefficients *coeffs, float out[static 16]) { + float kr = coeffs->kr; + float kb = coeffs->kb; + float kg = 1.0f - kr - kb; + float pb_r = -kr / (2.0f * (1.0f - kb)); + float pb_g = -kg / (2.0f * (1.0f - kb)); + float pr_g = -kg / (2.0f * (1.0f - kr)); + float pr_b = -kb / (2.0f * (1.0f - kr)); + + // This is column major, but the matrix is row major on wikipedia. + float m[16] = { + kr, pb_r, 0.5f, 0.0f, + kg, pb_g, pr_g, 0.0f, + kb, 0.5f, pr_b, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f, + }; + memcpy(out, m, sizeof(m)); +} + +static void apply_color_range(enum wlr_color_range range, float matrix[static 16]) { + float y_scale = 1.0f, y_offset = 0.0f; + float c_scale = 1.0f, c_offset = 0.5f; + if (range == WLR_COLOR_RANGE_LIMITED) { + y_scale = 219.0f / 255.0f; + y_offset = 16.0f / 255.0f; + c_scale = 224.0f / 255.0f; + c_offset = 128.0f / 255.0f; + } + for (int col = 0; col < 4; col++) { + matrix[col * 4 + 0] *= y_scale; + matrix[col * 4 + 1] *= c_scale; + matrix[col * 4 + 2] *= c_scale; + } + matrix[12] = y_offset; + matrix[13] = c_offset; + matrix[14] = c_offset; +} + +void wlr_color_rgb_to_ycbcr_matrix(enum wlr_color_encoding encoding, + enum wlr_color_range range, float matrix[static 16]) { + const struct luma_coefficients *coeffs = luma_coefficients_from_encoding(encoding); + if (coeffs == NULL) { + static const float identity[16] = { + 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f, + }; + memcpy(matrix, identity, sizeof(identity)); + return; + } + rgb_to_ypbpr(coeffs, matrix); + apply_color_range(range, matrix); +} From 20c20850574ba814f69d2bf7c8dab99ba903d343 Mon Sep 17 00:00:00 2001 From: Andri Yngvason Date: Mon, 18 May 2026 17:33:32 +0000 Subject: [PATCH 2/7] Pass output color encoding & range to renderer Signed-off-by: Andri Yngvason --- include/wlr/render/pass.h | 5 +++++ types/output/render.c | 14 +++++++++++++- 2 files changed, 18 insertions(+), 1 deletion(-) diff --git a/include/wlr/render/pass.h b/include/wlr/render/pass.h index 61ab77132..14d06e038 100644 --- a/include/wlr/render/pass.h +++ b/include/wlr/render/pass.h @@ -36,6 +36,11 @@ struct wlr_buffer_pass_options { * sRGB monitors) */ struct wlr_color_transform *color_transform; + /* Color encoding of the destination buffer for RGB to YCbCr conversion */ + enum wlr_color_encoding color_encoding; + /* Color range of the destination buffer */ + enum wlr_color_range color_range; + /* Signal a timeline synchronization point when the render pass completes. * * When a compositor provides a signal timeline, the renderer may skip diff --git a/types/output/render.c b/types/output/render.c index 155da5cf8..a2df53f0b 100644 --- a/types/output/render.c +++ b/types/output/render.c @@ -205,9 +205,21 @@ struct wlr_render_pass *wlr_output_begin_render_pass(struct wlr_output *output, return NULL; } + struct wlr_buffer_pass_options opts = {0}; + if (render_options != NULL) { + opts = *render_options; + } + if (state->committed & WLR_OUTPUT_STATE_COLOR_REPRESENTATION) { + opts.color_encoding = state->color_encoding; + opts.color_range = state->color_range; + } else { + opts.color_encoding = output->color_encoding; + opts.color_range = output->color_range; + } + struct wlr_renderer *renderer = output->renderer; assert(renderer != NULL); - struct wlr_render_pass *pass = wlr_renderer_begin_buffer_pass(renderer, buffer, render_options); + struct wlr_render_pass *pass = wlr_renderer_begin_buffer_pass(renderer, buffer, &opts); if (pass == NULL) { return NULL; } From 2283e05c30aaf9b1fc6a8da7b22ff55e069c3037 Mon Sep 17 00:00:00 2001 From: Andri Yngvason Date: Thu, 16 Apr 2026 13:30:21 +0000 Subject: [PATCH 3/7] render: gles2: Add colour conversion matrix to shaders This allows mapping to YCbCr without modifying the shader itself. Signed-off-by: Andri Yngvason --- include/render/gles2.h | 16 ++++++++++------ render/gles2/pass.c | 9 +++++++++ render/gles2/renderer.c | 4 ++++ render/gles2/shaders/quad.frag | 3 ++- render/gles2/shaders/tex_external.frag | 3 ++- render/gles2/shaders/tex_rgba.frag | 3 ++- render/gles2/shaders/tex_rgbx.frag | 3 ++- 7 files changed, 31 insertions(+), 10 deletions(-) diff --git a/include/render/gles2.h b/include/render/gles2.h index 6b852dcb7..072845aea 100644 --- a/include/render/gles2.h +++ b/include/render/gles2.h @@ -28,12 +28,21 @@ struct wlr_gles2_pixel_format { GLint gl_format, gl_type; }; +struct wlr_gles2_quad_shader { + GLuint program; + GLint proj; + GLint color; + GLint color_matrix; + GLint pos_attrib; +}; + struct wlr_gles2_tex_shader { GLuint program; GLint proj; GLint tex_proj; GLint tex; GLint alpha; + GLint color_matrix; GLint pos_attrib; }; @@ -74,12 +83,7 @@ struct wlr_gles2_renderer { } procs; struct { - struct { - GLuint program; - GLint proj; - GLint color; - GLint pos_attrib; - } quad; + struct wlr_gles2_quad_shader quad; struct wlr_gles2_tex_shader tex_rgba; struct wlr_gles2_tex_shader tex_rgbx; struct wlr_gles2_tex_shader tex_ext; diff --git a/render/gles2/pass.c b/render/gles2/pass.c index a70ea1320..26c15e437 100644 --- a/render/gles2/pass.c +++ b/render/gles2/pass.c @@ -11,6 +11,13 @@ #define MAX_QUADS 86 // 4kb +static const GLfloat color_matrix_identity[16] = { + 1, 0, 0, 0, + 0, 1, 0, 0, + 0, 0, 1, 0, + 0, 0, 0, 1, +}; + static const struct wlr_render_pass_impl render_pass_impl; static struct wlr_gles2_render_pass *get_render_pass(struct wlr_render_pass *wlr_pass) { @@ -227,6 +234,7 @@ static void render_pass_add_texture(struct wlr_render_pass *wlr_pass, WLR_RENDER_BLEND_MODE_NONE : options->blend_mode); glUseProgram(shader->program); + glUniformMatrix4fv(shader->color_matrix, 1, GL_FALSE, color_matrix_identity); glActiveTexture(GL_TEXTURE0); glBindTexture(texture->target, texture->tex); @@ -276,6 +284,7 @@ static void render_pass_add_rect(struct wlr_render_pass *wlr_pass, } else { setup_blending(blend_mode); glUseProgram(renderer->shaders.quad.program); + glUniformMatrix4fv(renderer->shaders.quad.color_matrix, 1, GL_FALSE, color_matrix_identity); set_proj_matrix(renderer->shaders.quad.proj, pass->projection_matrix, &box); glUniform4f(renderer->shaders.quad.color, color->r, color->g, color->b, color->a); render(&box, options->clip, renderer->shaders.quad.pos_attrib); diff --git a/render/gles2/renderer.c b/render/gles2/renderer.c index 7f01b8acd..bed4f8893 100644 --- a/render/gles2/renderer.c +++ b/render/gles2/renderer.c @@ -640,6 +640,7 @@ struct wlr_renderer *wlr_gles2_renderer_create(struct wlr_egl *egl) { } renderer->shaders.quad.proj = glGetUniformLocation(prog, "proj"); renderer->shaders.quad.color = glGetUniformLocation(prog, "color"); + renderer->shaders.quad.color_matrix = glGetUniformLocation(prog, "color_matrix"); renderer->shaders.quad.pos_attrib = glGetAttribLocation(prog, "pos"); renderer->shaders.tex_rgba.program = prog = @@ -651,6 +652,7 @@ struct wlr_renderer *wlr_gles2_renderer_create(struct wlr_egl *egl) { renderer->shaders.tex_rgba.tex_proj = glGetUniformLocation(prog, "tex_proj"); renderer->shaders.tex_rgba.tex = glGetUniformLocation(prog, "tex"); renderer->shaders.tex_rgba.alpha = glGetUniformLocation(prog, "alpha"); + renderer->shaders.tex_rgba.color_matrix = glGetUniformLocation(prog, "color_matrix"); renderer->shaders.tex_rgba.pos_attrib = glGetAttribLocation(prog, "pos"); renderer->shaders.tex_rgbx.program = prog = @@ -662,6 +664,7 @@ struct wlr_renderer *wlr_gles2_renderer_create(struct wlr_egl *egl) { renderer->shaders.tex_rgbx.tex_proj = glGetUniformLocation(prog, "tex_proj"); renderer->shaders.tex_rgbx.tex = glGetUniformLocation(prog, "tex"); renderer->shaders.tex_rgbx.alpha = glGetUniformLocation(prog, "alpha"); + renderer->shaders.tex_rgbx.color_matrix = glGetUniformLocation(prog, "color_matrix"); renderer->shaders.tex_rgbx.pos_attrib = glGetAttribLocation(prog, "pos"); if (renderer->exts.OES_egl_image_external) { @@ -674,6 +677,7 @@ struct wlr_renderer *wlr_gles2_renderer_create(struct wlr_egl *egl) { renderer->shaders.tex_ext.tex_proj = glGetUniformLocation(prog, "tex_proj"); renderer->shaders.tex_ext.tex = glGetUniformLocation(prog, "tex"); renderer->shaders.tex_ext.alpha = glGetUniformLocation(prog, "alpha"); + renderer->shaders.tex_ext.color_matrix = glGetUniformLocation(prog, "color_matrix"); renderer->shaders.tex_ext.pos_attrib = glGetAttribLocation(prog, "pos"); } diff --git a/render/gles2/shaders/quad.frag b/render/gles2/shaders/quad.frag index 97d3a31c1..fe859e3c8 100644 --- a/render/gles2/shaders/quad.frag +++ b/render/gles2/shaders/quad.frag @@ -7,7 +7,8 @@ precision mediump float; varying vec4 v_color; varying vec2 v_texcoord; uniform vec4 color; +uniform mat4 color_matrix; void main() { - gl_FragColor = color; + gl_FragColor = color_matrix * color; } diff --git a/render/gles2/shaders/tex_external.frag b/render/gles2/shaders/tex_external.frag index 73909fe03..60f4d4883 100644 --- a/render/gles2/shaders/tex_external.frag +++ b/render/gles2/shaders/tex_external.frag @@ -9,7 +9,8 @@ precision mediump float; varying vec2 v_texcoord; uniform samplerExternalOES texture0; uniform float alpha; +uniform mat4 color_matrix; void main() { - gl_FragColor = texture2D(texture0, v_texcoord) * alpha; + gl_FragColor = color_matrix * texture2D(texture0, v_texcoord) * alpha; } diff --git a/render/gles2/shaders/tex_rgba.frag b/render/gles2/shaders/tex_rgba.frag index c0a0dea61..bfda76426 100644 --- a/render/gles2/shaders/tex_rgba.frag +++ b/render/gles2/shaders/tex_rgba.frag @@ -7,7 +7,8 @@ precision mediump float; varying vec2 v_texcoord; uniform sampler2D tex; uniform float alpha; +uniform mat4 color_matrix; void main() { - gl_FragColor = texture2D(tex, v_texcoord) * alpha; + gl_FragColor = color_matrix * texture2D(tex, v_texcoord) * alpha; } diff --git a/render/gles2/shaders/tex_rgbx.frag b/render/gles2/shaders/tex_rgbx.frag index ae40ad53e..b388f22e9 100644 --- a/render/gles2/shaders/tex_rgbx.frag +++ b/render/gles2/shaders/tex_rgbx.frag @@ -7,7 +7,8 @@ precision mediump float; varying vec2 v_texcoord; uniform sampler2D tex; uniform float alpha; +uniform mat4 color_matrix; void main() { - gl_FragColor = vec4(texture2D(tex, v_texcoord).rgb, 1.0) * alpha; + gl_FragColor = color_matrix * vec4(texture2D(tex, v_texcoord).rgb, 1.0) * alpha; } From c074f6e83fef2a769091a67c71d047aacb89e266 Mon Sep 17 00:00:00 2001 From: Andri Yngvason Date: Thu, 16 Apr 2026 13:44:19 +0000 Subject: [PATCH 4/7] render: gles2: Add NV12 GLES2 buffers Rendering to NV12 buffers is not directly supported in GL ES2.0, but can be implemented by rendering in 2 passes to 2 different EGL images. This change makes provisions for multiple EGL images inside a wlr_gles2_buffer and adds a special case for mapping NV12 buffers to multiple EGL images. Signed-off-by: Andri Yngvason --- include/render/gles2.h | 10 +++--- render/gles2/pass.c | 2 +- render/gles2/renderer.c | 78 ++++++++++++++++++++++++++++++----------- render/gles2/texture.c | 4 +-- 4 files changed, 66 insertions(+), 28 deletions(-) diff --git a/include/render/gles2.h b/include/render/gles2.h index 072845aea..2c9fbcef0 100644 --- a/include/render/gles2.h +++ b/include/render/gles2.h @@ -108,9 +108,11 @@ struct wlr_gles2_buffer { struct wl_list link; // wlr_gles2_renderer.buffers bool external_only; - EGLImageKHR image; - GLuint rbo; - GLuint fbo; + int n_images; + EGLImageKHR image[4]; + GLuint rbo[4]; + GLuint fbo[4]; + GLuint tex; struct wlr_addon addon; @@ -153,7 +155,7 @@ const struct wlr_gles2_pixel_format *get_gles2_format_from_gl( void get_gles2_shm_formats(const struct wlr_gles2_renderer *renderer, struct wlr_drm_format_set *out); -GLuint gles2_buffer_get_fbo(struct wlr_gles2_buffer *buffer); +GLuint gles2_buffer_get_fbo(struct wlr_gles2_buffer *buffer, int index); struct wlr_gles2_renderer *gles2_get_renderer( struct wlr_renderer *wlr_renderer); diff --git a/render/gles2/pass.c b/render/gles2/pass.c index 26c15e437..532ea6120 100644 --- a/render/gles2/pass.c +++ b/render/gles2/pass.c @@ -327,7 +327,7 @@ struct wlr_gles2_render_pass *begin_gles2_buffer_pass(struct wlr_gles2_buffer *b } } - GLint fbo = gles2_buffer_get_fbo(buffer); + GLint fbo = gles2_buffer_get_fbo(buffer, 0); if (!fbo) { return NULL; } diff --git a/render/gles2/renderer.c b/render/gles2/renderer.c index bed4f8893..392d05772 100644 --- a/render/gles2/renderer.c +++ b/render/gles2/renderer.c @@ -59,13 +59,18 @@ static void destroy_buffer(struct wlr_gles2_buffer *buffer) { push_gles2_debug(buffer->renderer); - glDeleteFramebuffers(1, &buffer->fbo); - glDeleteRenderbuffers(1, &buffer->rbo); + for (int i = 0; i < buffer->n_images; ++i) { + glDeleteFramebuffers(1, &buffer->fbo[i]); + glDeleteRenderbuffers(1, &buffer->rbo[i]); + } + glDeleteTextures(1, &buffer->tex); pop_gles2_debug(buffer->renderer); - wlr_egl_destroy_image(buffer->renderer->egl, buffer->image); + for (int i = 0; i < buffer->n_images; ++i) { + wlr_egl_destroy_image(buffer->renderer->egl, buffer->image[i]); + } wlr_egl_restore_context(&prev_ctx); @@ -83,42 +88,42 @@ static const struct wlr_addon_interface buffer_addon_impl = { .destroy = handle_buffer_destroy, }; -GLuint gles2_buffer_get_fbo(struct wlr_gles2_buffer *buffer) { +GLuint gles2_buffer_get_fbo(struct wlr_gles2_buffer *buffer, int index) { if (buffer->external_only) { wlr_log(WLR_ERROR, "DMA-BUF format is external-only"); return 0; } - if (buffer->fbo) { - return buffer->fbo; + if (buffer->fbo[index]) { + return buffer->fbo[index]; } push_gles2_debug(buffer->renderer); - if (!buffer->rbo) { - glGenRenderbuffers(1, &buffer->rbo); - glBindRenderbuffer(GL_RENDERBUFFER, buffer->rbo); + if (!buffer->rbo[index]) { + glGenRenderbuffers(1, &buffer->rbo[index]); + glBindRenderbuffer(GL_RENDERBUFFER, buffer->rbo[index]); buffer->renderer->procs.glEGLImageTargetRenderbufferStorageOES(GL_RENDERBUFFER, - buffer->image); + buffer->image[index]); glBindRenderbuffer(GL_RENDERBUFFER, 0); } - glGenFramebuffers(1, &buffer->fbo); - glBindFramebuffer(GL_FRAMEBUFFER, buffer->fbo); + glGenFramebuffers(1, &buffer->fbo[index]); + glBindFramebuffer(GL_FRAMEBUFFER, buffer->fbo[index]); glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, - GL_RENDERBUFFER, buffer->rbo); + GL_RENDERBUFFER, buffer->rbo[index]); GLenum fb_status = glCheckFramebufferStatus(GL_FRAMEBUFFER); glBindFramebuffer(GL_FRAMEBUFFER, 0); if (fb_status != GL_FRAMEBUFFER_COMPLETE) { wlr_log(WLR_ERROR, "Failed to create FBO"); - glDeleteFramebuffers(1, &buffer->fbo); - buffer->fbo = 0; + glDeleteFramebuffers(1, &buffer->fbo[index]); + buffer->fbo[index] = 0; } pop_gles2_debug(buffer->renderer); - return buffer->fbo; + return buffer->fbo[index]; } struct wlr_gles2_buffer *gles2_buffer_get_or_create(struct wlr_gles2_renderer *renderer, @@ -143,10 +148,41 @@ struct wlr_gles2_buffer *gles2_buffer_get_or_create(struct wlr_gles2_renderer *r goto error_buffer; } - buffer->image = wlr_egl_create_image_from_dmabuf(renderer->egl, - &dmabuf, &buffer->external_only); - if (buffer->image == EGL_NO_IMAGE_KHR) { - goto error_buffer; + if (dmabuf.format == DRM_FORMAT_NV12) { + buffer->n_images = 2; + + struct wlr_dmabuf_attributes luma = dmabuf; + luma.n_planes = 1; + luma.format = DRM_FORMAT_R8; + buffer->image[0] = wlr_egl_create_image_from_dmabuf(renderer->egl, + &luma, &buffer->external_only); + if (buffer->image[0] == EGL_NO_IMAGE_KHR) { + goto error_buffer; + } + + struct wlr_dmabuf_attributes chroma = { + .format = DRM_FORMAT_GR88, + .n_planes = 1, + .offset = { dmabuf.offset[1] }, + .stride = { dmabuf.stride[1] }, + .fd = { dmabuf.fd[1] }, + .width = (dmabuf.width + 1) / 2, + .height = (dmabuf.height + 1) / 2, + .modifier = dmabuf.modifier, + }; + buffer->image[1] = wlr_egl_create_image_from_dmabuf(renderer->egl, + &chroma, &buffer->external_only); + if (buffer->image[1] == EGL_NO_IMAGE_KHR) { + wlr_egl_destroy_image(renderer->egl, buffer->image[0]); + goto error_buffer; + } + } else { + buffer->n_images = 1; + buffer->image[0] = wlr_egl_create_image_from_dmabuf(renderer->egl, + &dmabuf, &buffer->external_only); + if (buffer->image[0] == EGL_NO_IMAGE_KHR) { + goto error_buffer; + } } wlr_addon_init(&buffer->addon, &wlr_buffer->addons, renderer, @@ -278,7 +314,7 @@ GLuint wlr_gles2_renderer_get_buffer_fbo(struct wlr_renderer *wlr_renderer, struct wlr_gles2_buffer *buffer = gles2_buffer_get_or_create(renderer, wlr_buffer); if (buffer) { - fbo = gles2_buffer_get_fbo(buffer); + fbo = gles2_buffer_get_fbo(buffer, 0); } wlr_egl_restore_context(&prev_ctx); diff --git a/render/gles2/texture.c b/render/gles2/texture.c index 575a11fca..259bc8e11 100644 --- a/render/gles2/texture.c +++ b/render/gles2/texture.c @@ -139,7 +139,7 @@ static bool gles2_texture_bind(struct wlr_gles2_texture *texture) { return false; } - GLuint fbo = gles2_buffer_get_fbo(texture->buffer); + GLuint fbo = gles2_buffer_get_fbo(texture->buffer, 0); if (!fbo) { return false; } @@ -419,7 +419,7 @@ static struct wlr_texture *gles2_texture_from_dmabuf( glBindTexture(texture->target, buffer->tex); glTexParameteri(texture->target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(texture->target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); - renderer->procs.glEGLImageTargetTexture2DOES(texture->target, buffer->image); + renderer->procs.glEGLImageTargetTexture2DOES(texture->target, buffer->image[0]); glBindTexture(texture->target, 0); } From 97c8d24fa470be9302e9d406146b852b84fc2bcb Mon Sep 17 00:00:00 2001 From: Andri Yngvason Date: Thu, 16 Apr 2026 13:45:56 +0000 Subject: [PATCH 5/7] render: gles2: pass: Implement rendering into NV12 buffers As mentioned in the previous commit message, we can't create an RBO out of an NV12 buffer in GL ES2.0. Instead, we render in 2 passes to 2 separate RBOs. This could be made more generic by having a lookup table for the parameters that need to be set for each plane for any given format, but as of yet, I see no practical reason for implementing any other kind of YCbCr target buffer rendering as NV12 seems to be the only format that's commonly supported by hardware video encoders. Signed-off-by: Andri Yngvason --- include/render/gles2.h | 5 +- render/gles2/pass.c | 144 ++++++++++++++++++++++++++++++++++------ render/gles2/renderer.c | 3 +- 3 files changed, 131 insertions(+), 21 deletions(-) diff --git a/include/render/gles2.h b/include/render/gles2.h index 2c9fbcef0..4fc904e6a 100644 --- a/include/render/gles2.h +++ b/include/render/gles2.h @@ -145,6 +145,8 @@ struct wlr_gles2_render_pass { struct wlr_gles2_render_timer *timer; struct wlr_drm_syncobj_timeline *signal_timeline; uint64_t signal_point; + float color_matrix[16]; + float color_matrix_nv12_chroma[16]; }; bool is_gles2_pixel_format_supported(const struct wlr_gles2_renderer *renderer, @@ -177,6 +179,7 @@ void pop_gles2_debug(struct wlr_gles2_renderer *renderer); struct wlr_gles2_render_pass *begin_gles2_buffer_pass(struct wlr_gles2_buffer *buffer, struct wlr_egl_context *prev_ctx, struct wlr_gles2_render_timer *timer, - struct wlr_drm_syncobj_timeline *signal_timeline, uint64_t signal_point); + struct wlr_drm_syncobj_timeline *signal_timeline, uint64_t signal_point, + enum wlr_color_encoding color_encoding, enum wlr_color_range color_range); #endif diff --git a/render/gles2/pass.c b/render/gles2/pass.c index 532ea6120..d38b64ba9 100644 --- a/render/gles2/pass.c +++ b/render/gles2/pass.c @@ -1,10 +1,12 @@ #include #include +#include #include #include #include #include #include +#include "render/color.h" #include "render/egl.h" #include "render/gles2.h" #include "util/matrix.h" @@ -160,6 +162,19 @@ static void set_tex_matrix(GLint loc, enum wl_output_transform trans, glUniformMatrix3fv(loc, 1, GL_FALSE, tex_matrix); } +static void set_filter_mode(GLenum target, enum wlr_scale_filter_mode mode) { + switch (mode) { + case WLR_SCALE_FILTER_BILINEAR: + glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + break; + case WLR_SCALE_FILTER_NEAREST: + glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + break; + } +} + static void setup_blending(enum wlr_render_blend_mode mode) { switch (mode) { case WLR_RENDER_BLEND_MODE_PREMULTIPLIED: @@ -174,11 +189,17 @@ static void setup_blending(enum wlr_render_blend_mode mode) { static void render_pass_add_texture(struct wlr_render_pass *wlr_pass, const struct wlr_render_texture_options *options) { struct wlr_gles2_render_pass *pass = get_render_pass(wlr_pass); - struct wlr_gles2_renderer *renderer = pass->buffer->renderer; + struct wlr_gles2_buffer *buffer = pass->buffer; + struct wlr_gles2_renderer *renderer = buffer->renderer; + struct wlr_buffer *wlr_buffer = buffer->buffer; struct wlr_gles2_texture *texture = gles2_get_texture(options->texture); - struct wlr_gles2_tex_shader *shader = NULL; + struct wlr_dmabuf_attributes dmabuf = {0}; + if (!wlr_buffer_get_dmabuf(wlr_buffer, &dmabuf)) { + return; + } + struct wlr_gles2_tex_shader *shader; switch (texture->target) { case GL_TEXTURE_2D: if (texture->has_alpha) { @@ -239,24 +260,48 @@ static void render_pass_add_texture(struct wlr_render_pass *wlr_pass, glActiveTexture(GL_TEXTURE0); glBindTexture(texture->target, texture->tex); - switch (options->filter_mode) { - case WLR_SCALE_FILTER_BILINEAR: - glTexParameteri(texture->target, GL_TEXTURE_MIN_FILTER, GL_LINEAR); - glTexParameteri(texture->target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - break; - case WLR_SCALE_FILTER_NEAREST: - glTexParameteri(texture->target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); - glTexParameteri(texture->target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); - break; - } + set_filter_mode(texture->target, options->filter_mode); glUniform1i(shader->tex, 0); glUniform1f(shader->alpha, alpha); set_proj_matrix(shader->proj, pass->projection_matrix, &dst_box); set_tex_matrix(shader->tex_proj, options->transform, &src_fbox); - render(&dst_box, options->clip, shader->pos_attrib); + if (dmabuf.format == DRM_FORMAT_NV12) { + GLint luma_fbo = gles2_buffer_get_fbo(buffer, 0); + GLint chroma_fbo = gles2_buffer_get_fbo(buffer, 1); + if (!luma_fbo || !chroma_fbo) { + wlr_log(WLR_ERROR, "Failed to get fbo"); + goto out; + } + glBindFramebuffer(GL_FRAMEBUFFER, luma_fbo); + glViewport(0, 0, wlr_buffer->width, wlr_buffer->height); + /* Note: this is the full matrix, but chroma gets discarded so zeroing out the chroma part + * wouldn't make any difference. + */ + glUniformMatrix4fv(shader->color_matrix, 1, GL_FALSE, pass->color_matrix); + render(&dst_box, options->clip, shader->pos_attrib); + + set_filter_mode(texture->target, WLR_SCALE_FILTER_BILINEAR); + glBindFramebuffer(GL_FRAMEBUFFER, chroma_fbo); + glViewport(0, 0, (wlr_buffer->width + 1) / 2, (wlr_buffer->height + 1) / 2); + glUniformMatrix4fv(shader->color_matrix, 1, GL_FALSE, pass->color_matrix_nv12_chroma); + render(&dst_box, options->clip, shader->pos_attrib); + } else { + GLint fbo = gles2_buffer_get_fbo(buffer, 0); + if (!fbo) { + wlr_log(WLR_ERROR, "Failed to get fbo"); + goto out; + } + + glBindFramebuffer(GL_FRAMEBUFFER, fbo); + glViewport(0, 0, wlr_buffer->width, wlr_buffer->height); + glUniformMatrix4fv(shader->color_matrix, 1, GL_FALSE, color_matrix_identity); + render(&dst_box, options->clip, shader->pos_attrib); + } + +out: glBindTexture(texture->target, 0); pop_gles2_debug(renderer); } @@ -264,16 +309,60 @@ static void render_pass_add_texture(struct wlr_render_pass *wlr_pass, static void render_pass_add_rect(struct wlr_render_pass *wlr_pass, const struct wlr_render_rect_options *options) { struct wlr_gles2_render_pass *pass = get_render_pass(wlr_pass); - struct wlr_gles2_renderer *renderer = pass->buffer->renderer; + struct wlr_gles2_buffer *buffer = pass->buffer; + struct wlr_gles2_renderer *renderer = buffer->renderer; + struct wlr_buffer *wlr_buffer = buffer->buffer; + + struct wlr_dmabuf_attributes dmabuf = {0}; + if (!wlr_buffer_get_dmabuf(wlr_buffer, &dmabuf)) { + return; + } const struct wlr_render_color *color = &options->color; struct wlr_box box; - struct wlr_buffer *wlr_buffer = pass->buffer->buffer; wlr_render_rect_options_get_box(options, wlr_buffer, &box); push_gles2_debug(renderer); + enum wlr_render_blend_mode blend_mode = color->a == 1.0 ? WLR_RENDER_BLEND_MODE_NONE : options->blend_mode; + + // TODO: Maybe it would be better to apply the color_matrix to the color outside the shader. + // TODO: Implement the glClear fullscreen optimisiation for NV12 too. + if (dmabuf.format == DRM_FORMAT_NV12) { + GLint luma_fbo = gles2_buffer_get_fbo(buffer, 0); + GLint chroma_fbo = gles2_buffer_get_fbo(buffer, 1); + if (!luma_fbo || !chroma_fbo) { + wlr_log(WLR_ERROR, "Failed to get fbo"); + goto out; + } + + setup_blending(blend_mode); + glUseProgram(renderer->shaders.quad.program); + set_proj_matrix(renderer->shaders.quad.proj, pass->projection_matrix, &box); + glUniform4f(renderer->shaders.quad.color, color->r, color->g, color->b, color->a); + + glBindFramebuffer(GL_FRAMEBUFFER, luma_fbo); + glViewport(0, 0, wlr_buffer->width, wlr_buffer->height); + glUniformMatrix4fv(renderer->shaders.quad.color_matrix, 1, GL_FALSE, pass->color_matrix); + render(&box, options->clip, renderer->shaders.quad.pos_attrib); + + glBindFramebuffer(GL_FRAMEBUFFER, chroma_fbo); + glViewport(0, 0, (wlr_buffer->width + 1) / 2, (wlr_buffer->height + 1) / 2); + glUniformMatrix4fv(renderer->shaders.quad.color_matrix, 1, GL_FALSE, pass->color_matrix_nv12_chroma); + render(&box, options->clip, renderer->shaders.quad.pos_attrib); + goto out; + } + + GLint fbo = gles2_buffer_get_fbo(buffer, 0); + if (!fbo) { + wlr_log(WLR_ERROR, "Failed to get fbo"); + goto out; + } + + glBindFramebuffer(GL_FRAMEBUFFER, fbo); + glViewport(0, 0, wlr_buffer->width, wlr_buffer->height); + if (blend_mode == WLR_RENDER_BLEND_MODE_NONE && options->clip == NULL && box.x == 0 && box.y == 0 && @@ -290,6 +379,7 @@ static void render_pass_add_rect(struct wlr_render_pass *wlr_pass, render(&box, options->clip, renderer->shaders.quad.pos_attrib); } +out: pop_gles2_debug(renderer); } @@ -312,9 +402,20 @@ static const char *reset_status_str(GLenum status) { } } +static void derive_nv12_chroma_matrix(const float full[16], float chroma[16]) { + for (int col = 0; col < 4; col++) { + chroma[col * 4 + 0] = full[col * 4 + 1]; + chroma[col * 4 + 1] = full[col * 4 + 2]; + chroma[col * 4 + 2] = 0.0f; + chroma[col * 4 + 3] = 0.0f; + } + chroma[15] = 1.0f; +} + struct wlr_gles2_render_pass *begin_gles2_buffer_pass(struct wlr_gles2_buffer *buffer, struct wlr_egl_context *prev_ctx, struct wlr_gles2_render_timer *timer, - struct wlr_drm_syncobj_timeline *signal_timeline, uint64_t signal_point) { + struct wlr_drm_syncobj_timeline *signal_timeline, uint64_t signal_point, + enum wlr_color_encoding color_encoding, enum wlr_color_range color_range) { struct wlr_gles2_renderer *renderer = buffer->renderer; struct wlr_buffer *wlr_buffer = buffer->buffer; @@ -342,6 +443,14 @@ struct wlr_gles2_render_pass *begin_gles2_buffer_pass(struct wlr_gles2_buffer *b pass->buffer = buffer; pass->timer = timer; pass->prev_ctx = *prev_ctx; + if (color_encoding == WLR_COLOR_ENCODING_NONE) { + color_encoding = WLR_COLOR_ENCODING_BT709; + } + if (color_range == WLR_COLOR_RANGE_NONE) { + color_range = WLR_COLOR_RANGE_FULL; + } + wlr_color_rgb_to_ycbcr_matrix(color_encoding, color_range, pass->color_matrix); + derive_nv12_chroma_matrix(pass->color_matrix, pass->color_matrix_nv12_chroma); if (signal_timeline != NULL) { pass->signal_timeline = wlr_drm_syncobj_timeline_ref(signal_timeline); pass->signal_point = signal_point; @@ -351,9 +460,6 @@ struct wlr_gles2_render_pass *begin_gles2_buffer_pass(struct wlr_gles2_buffer *b WL_OUTPUT_TRANSFORM_FLIPPED_180); push_gles2_debug(renderer); - glBindFramebuffer(GL_FRAMEBUFFER, fbo); - - glViewport(0, 0, wlr_buffer->width, wlr_buffer->height); glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); glDisable(GL_SCISSOR_TEST); pop_gles2_debug(renderer); diff --git a/render/gles2/renderer.c b/render/gles2/renderer.c index 392d05772..bceb74549 100644 --- a/render/gles2/renderer.c +++ b/render/gles2/renderer.c @@ -295,7 +295,8 @@ static struct wlr_render_pass *gles2_begin_buffer_pass(struct wlr_renderer *wlr_ } struct wlr_gles2_render_pass *pass = begin_gles2_buffer_pass(buffer, - &prev_ctx, timer, options->signal_timeline, options->signal_point); + &prev_ctx, timer, options->signal_timeline, options->signal_point, + options->color_encoding, options->color_range); if (!pass) { return NULL; } From 9f5c3f23a2fe139ef1bf89055b4c08ff7953f8d4 Mon Sep 17 00:00:00 2001 From: Andri Yngvason Date: Wed, 15 Apr 2026 12:27:22 +0000 Subject: [PATCH 6/7] render: allocator: gbm: Implement allocation of NV12 buffers This needs to be handled specifically for NV12 because GBM does not know how to allocate NV12 buffers. The approach I've taken is to allocate a linear R8 buffer for storage and then to import it as NV12 with an offset for the chroma plane. Signed-off-by: Andri Yngvason --- render/allocator/gbm.c | 47 ++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 45 insertions(+), 2 deletions(-) diff --git a/render/allocator/gbm.c b/render/allocator/gbm.c index fadfac9f8..010a36440 100644 --- a/render/allocator/gbm.c +++ b/render/allocator/gbm.c @@ -59,6 +59,41 @@ error_fd: return false; } +static struct gbm_bo *create_nv12_bo(struct gbm_device *gbm, int width, int height) { + int usage = GBM_BO_USE_RENDERING | GBM_BO_USE_SCANOUT | GBM_BO_USE_LINEAR; + struct gbm_bo *base = gbm_bo_create(gbm, width, height + (height + 1) / 2, + DRM_FORMAT_R8, usage); + if (!base) { + return NULL; + } + + int fd = gbm_bo_get_fd(base); + if (fd < 0) { + gbm_bo_destroy(base); + return NULL; + } + + struct gbm_import_fd_modifier_data d = { + .format = DRM_FORMAT_NV12, + .width = width, + .height = height, + .modifier = gbm_bo_get_modifier(base), + .num_fds = 2, + .fds[0] = fd, + .offsets[0] = 0, + .strides[0] = gbm_bo_get_stride(base), + .fds[1] = fd, + .offsets[1] = height * gbm_bo_get_stride(base), + .strides[1] = gbm_bo_get_stride(base), + }; + struct gbm_bo *bo = gbm_bo_import(gbm, GBM_BO_IMPORT_FD_MODIFIER, &d, 0); + + close(fd); + gbm_bo_destroy(base); + + return bo; +} + static struct wlr_gbm_buffer *create_buffer(struct wlr_gbm_allocator *alloc, int width, int height, const struct wlr_drm_format *format) { struct gbm_device *gbm_device = alloc->gbm_device; @@ -68,8 +103,16 @@ static struct wlr_gbm_buffer *create_buffer(struct wlr_gbm_allocator *alloc, bool has_modifier = true; uint64_t fallback_modifier = DRM_FORMAT_MOD_INVALID; errno = 0; - struct gbm_bo *bo = gbm_bo_create_with_modifiers(gbm_device, width, height, - format->format, format->modifiers, format->len); + struct gbm_bo *bo; + if (format->format == DRM_FORMAT_NV12) { + bo = create_nv12_bo(gbm_device, width, height); + if (bo == NULL) { + return NULL; + } + } else { + bo = gbm_bo_create_with_modifiers(gbm_device, width, height, + format->format, format->modifiers, format->len); + } if (bo == NULL) { uint32_t usage = GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING; if (format->len == 1 && From 1aa17c928102a04bc2d33512b490e5f5a0709404 Mon Sep 17 00:00:00 2001 From: Andri Yngvason Date: Wed, 15 Apr 2026 12:46:17 +0000 Subject: [PATCH 7/7] render: gles2: renderer: Add NV12 to render format set The previous commit adds a synthetic NV12 render format to the set, but it is contingent upon the presence of the R8 and GR88 render formats. Signed-off-by: Andri Yngvason --- include/render/gles2.h | 1 + render/gles2/renderer.c | 12 +++++++++++- 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/include/render/gles2.h b/include/render/gles2.h index 4fc904e6a..ab41ff93f 100644 --- a/include/render/gles2.h +++ b/include/render/gles2.h @@ -53,6 +53,7 @@ struct wlr_gles2_renderer { int drm_fd; struct wlr_drm_format_set shm_texture_formats; + struct wlr_drm_format_set dmabuf_render_formats; const char *exts_str; struct { diff --git a/render/gles2/renderer.c b/render/gles2/renderer.c index bceb74549..6c22e3bb0 100644 --- a/render/gles2/renderer.c +++ b/render/gles2/renderer.c @@ -15,6 +15,7 @@ #include #include #include +#include "render/drm_format_set.h" #include "render/egl.h" #include "render/gles2.h" #include "render/pixel_format.h" @@ -215,7 +216,7 @@ static const struct wlr_drm_format_set *gles2_get_texture_formats( static const struct wlr_drm_format_set *gles2_get_render_formats( struct wlr_renderer *wlr_renderer) { struct wlr_gles2_renderer *renderer = gles2_get_renderer(wlr_renderer); - return wlr_egl_get_dmabuf_render_formats(renderer->egl); + return &renderer->dmabuf_render_formats; } static int gles2_get_drm_fd(struct wlr_renderer *wlr_renderer) { @@ -266,6 +267,7 @@ static void gles2_destroy(struct wlr_renderer *wlr_renderer) { wlr_egl_destroy(renderer->egl); wlr_drm_format_set_finish(&renderer->shm_texture_formats); + wlr_drm_format_set_finish(&renderer->dmabuf_render_formats); if (renderer->drm_fd >= 0) { close(renderer->drm_fd); @@ -724,6 +726,14 @@ struct wlr_renderer *wlr_gles2_renderer_create(struct wlr_egl *egl) { get_gles2_shm_formats(renderer, &renderer->shm_texture_formats); + wlr_drm_format_set_copy(&renderer->dmabuf_render_formats, + wlr_egl_get_dmabuf_render_formats(renderer->egl)); + + if (wlr_drm_format_set_has(&renderer->dmabuf_render_formats, DRM_FORMAT_R8, DRM_FORMAT_MOD_LINEAR) && + wlr_drm_format_set_has(&renderer->dmabuf_render_formats, DRM_FORMAT_GR88, DRM_FORMAT_MOD_LINEAR)) { + wlr_drm_format_set_add(&renderer->dmabuf_render_formats, DRM_FORMAT_NV12, DRM_FORMAT_MOD_LINEAR); + } + int drm_fd = wlr_renderer_get_drm_fd(&renderer->wlr_renderer); uint64_t cap_syncobj_timeline; if (drm_fd >= 0 && drmGetCap(drm_fd, DRM_CAP_SYNCOBJ_TIMELINE, &cap_syncobj_timeline) == 0) {