mirrors/wlroots
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/wlroots/wlroots.git synced 2026-06-13 14:32:57 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'gles2-nv12-render-target' into 'master'

Browse source 
render: gles2: NV12 render buffers

See merge request wlroots/wlroots!5344
This commit is contained in:
Andri Yngvason 2026-06-03 09:15:17 +00:00
commit d3d2d0f668
13 changed files with 394 additions and 63 deletions
Download patch file Download diff file Expand all files Collapse all files

3
include/render/color.h
View file

@ -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

32
include/render/gles2.h
View file

@ -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;
};
@ -44,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 {
@ -74,12 +84,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;
@ -104,9 +109,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;
@ -139,6 +146,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,
@ -149,7 +158,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);
@ -171,6 +180,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

5
include/wlr/render/pass.h
View file

@ -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

45
render/allocator/gbm.c
View file

@ -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,
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 &&

88
render/color.c
View file

@ -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);
}

153
render/gles2/pass.c
View file

@ -1,16 +1,25 @@
#include <stdlib.h>
#include <assert.h>
#include <drm_fourcc.h>
#include <pixman.h>
#include <time.h>
#include <unistd.h>
#include <wlr/render/drm_syncobj.h>
#include <wlr/util/transform.h>
#include "render/color.h"
#include "render/egl.h"
#include "render/gles2.h"
#include "util/matrix.h"
#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) {
@ -153,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:
@ -167,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) {
@ -227,28 +255,53 @@ 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);
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);
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);
}
@ -256,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 &&
@ -276,11 +373,13 @@ 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);
}
out:
pop_gles2_debug(renderer);
}
@ -303,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;
@ -318,7 +428,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;
}
@ -333,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;
@ -342,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);

95
render/gles2/renderer.c
View file

@ -15,6 +15,7 @@
#include <wlr/util/box.h>
#include <wlr/util/log.h>
#include <xf86drm.h>
#include "render/drm_format_set.h"
#include "render/egl.h"
#include "render/gles2.h"
#include "render/pixel_format.h"
@ -59,13 +60,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 +89,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,12 +149,43 @@ 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) {
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,
&buffer_addon_impl);
@ -179,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) {
@ -230,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);
@ -259,7 +297,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;
}
@ -278,7 +317,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);
@ -640,6 +679,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 +691,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 +703,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 +716,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");
}
@ -683,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) {

3
render/gles2/shaders/quad.frag
View file

@ -6,7 +6,8 @@ precision mediump float;
varying vec2 v_texcoord;
uniform vec4 color;
uniform mat4 color_matrix;
void main() {
gl_FragColor = color;
gl_FragColor = color_matrix * color;
}

3
render/gles2/shaders/tex_external.frag
View file

@ -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;
}

3
render/gles2/shaders/tex_rgba.frag
View file

@ -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;
}

3
render/gles2/shaders/tex_rgbx.frag
View file

@ -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;
}

4
render/gles2/texture.c
View file

@ -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);
}

14
types/output/render.c
View file

@ -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;
}