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

Merge branch 'drm-dumb-buffer-prefer-shadow' into 'master'

Browse source 
pixman: render on shadow buffer when prefered

Closes #2914

See merge request wlroots/wlroots!4418
This commit is contained in:
Simon Zeni 2023-11-21 19:30:35 +00:00
commit dd96057771
6 changed files with 87 additions and 50 deletions
Download patch file Download diff file Expand all files Collapse all files

1
include/render/allocator/drm_dumb.h
View file

@ -25,6 +25,7 @@ struct wlr_drm_dumb_allocator {
struct wlr_allocator base; struct wlr_allocator base;
struct wl_list buffers; // wlr_drm_dumb_buffer.link struct wl_list buffers; // wlr_drm_dumb_buffer.link
int drm_fd; int drm_fd;
bool prefer_shadow;
}; };
/** /**

5
include/render/pixman.h
View file

@ -29,11 +29,12 @@ struct wlr_pixman_renderer {
struct wlr_pixman_buffer { struct wlr_pixman_buffer {
struct wlr_buffer *buffer; struct wlr_buffer *buffer;
struct wlr_pixman_renderer *renderer; struct wlr_pixman_renderer *renderer;
struct wl_list link; // wlr_pixman_renderer.buffers
pixman_image_t *image; pixman_image_t *image;
pixman_image_t *shadow;
struct wl_listener buffer_destroy; struct wlr_addon addon;
struct wl_list link; // wlr_pixman_renderer.buffers
}; };
struct wlr_pixman_texture { struct wlr_pixman_texture {

1
include/wlr/render/dmabuf.h
View file

@ -35,6 +35,7 @@ struct wlr_dmabuf_attributes {
int32_t width, height; int32_t width, height;
uint32_t format; // FourCC code, see DRM_FORMAT_* in <drm_fourcc.h> uint32_t format; // FourCC code, see DRM_FORMAT_* in <drm_fourcc.h>
uint64_t modifier; // see DRM_FORMAT_MOD_* in <drm_fourcc.h> uint64_t modifier; // see DRM_FORMAT_MOD_* in <drm_fourcc.h>
bool prefer_shadow;
int n_planes; int n_planes;
uint32_t offset[WLR_DMABUF_MAX_PLANES]; uint32_t offset[WLR_DMABUF_MAX_PLANES];

8
render/allocator/drm_dumb.c
View file

@ -97,6 +97,7 @@ static struct wlr_drm_dumb_buffer *create_buffer(
.height = buffer->height, .height = buffer->height,
.format = format->format, .format = format->format,
.modifier = DRM_FORMAT_MOD_LINEAR, .modifier = DRM_FORMAT_MOD_LINEAR,
.prefer_shadow = alloc->prefer_shadow,
.n_planes = 1, .n_planes = 1,
.offset[0] = 0, .offset[0] = 0,
.stride[0] = buffer->stride, .stride[0] = buffer->stride,
@ -216,6 +217,12 @@ struct wlr_allocator *wlr_drm_dumb_allocator_create(int drm_fd) {
return NULL; return NULL;
} }
uint64_t prefer_shadow;
if (drmGetCap(drm_fd, DRM_CAP_DUMB_PREFER_SHADOW, &prefer_shadow) < 0) {
wlr_log(WLR_ERROR, "Failed to get DRM capabilities");
return NULL;
}
struct wlr_drm_dumb_allocator *alloc = calloc(1, sizeof(*alloc)); struct wlr_drm_dumb_allocator *alloc = calloc(1, sizeof(*alloc));
if (alloc == NULL) { if (alloc == NULL) {
return NULL; return NULL;
@ -224,6 +231,7 @@ struct wlr_allocator *wlr_drm_dumb_allocator_create(int drm_fd) {
WLR_BUFFER_CAP_DATA_PTR | WLR_BUFFER_CAP_DMABUF); WLR_BUFFER_CAP_DATA_PTR | WLR_BUFFER_CAP_DMABUF);
alloc->drm_fd = drm_fd; alloc->drm_fd = drm_fd;
alloc->prefer_shadow = prefer_shadow;
wl_list_init(&alloc->buffers); wl_list_init(&alloc->buffers);
wlr_log(WLR_DEBUG, "Created DRM dumb allocator"); wlr_log(WLR_DEBUG, "Created DRM dumb allocator");

25
render/pixman/pass.c
View file

@ -18,9 +18,15 @@ static struct wlr_pixman_texture *get_texture(struct wlr_texture *wlr_texture) {
static bool render_pass_submit(struct wlr_render_pass *wlr_pass) { static bool render_pass_submit(struct wlr_render_pass *wlr_pass) {
struct wlr_pixman_render_pass *pass = get_render_pass(wlr_pass); struct wlr_pixman_render_pass *pass = get_render_pass(wlr_pass);
struct wlr_pixman_buffer *buffer = pass->buffer;
wlr_buffer_end_data_ptr_access(pass->buffer->buffer); if (buffer->shadow) {
wlr_buffer_unlock(pass->buffer->buffer); pixman_image_composite32(PIXMAN_OP_SRC, buffer->shadow, NULL, buffer->image, 0, 0, 0,
0, 0, 0, buffer->buffer->width, buffer->buffer->height);
}
wlr_buffer_end_data_ptr_access(buffer->buffer);
wlr_buffer_unlock(buffer->buffer);
free(pass); free(pass);
return true; return true;
@ -141,11 +147,13 @@ static void render_pass_add_texture(struct wlr_render_pass *wlr_pass,
pixman_op_t op = get_pixman_blending(options->blend_mode); pixman_op_t op = get_pixman_blending(options->blend_mode);
pixman_image_set_clip_region32(buffer->image, (pixman_region32_t *)options->clip); pixman_image_t *target = buffer->shadow ? buffer->shadow : buffer->image;
pixman_image_set_clip_region32(target, (pixman_region32_t *)options->clip);
pixman_image_composite32(op, texture->image, mask, pixman_image_composite32(op, texture->image, mask,
buffer->image, src_box.x, src_box.y, 0, 0, dest_x, dest_y, target, src_box.x, src_box.y, 0, 0, dest_x, dest_y,
width, height); width, height);
pixman_image_set_clip_region32(buffer->image, NULL); pixman_image_set_clip_region32(target, NULL);
pixman_image_set_transform(texture->image, NULL); pixman_image_set_transform(texture->image, NULL);
@ -176,11 +184,12 @@ static void render_pass_add_rect(struct wlr_render_pass *wlr_pass,
}; };
pixman_image_t *fill = pixman_image_create_solid_fill(&color); pixman_image_t *fill = pixman_image_create_solid_fill(&color);
pixman_image_t *target = buffer->shadow ? buffer->shadow : buffer->image;
pixman_image_set_clip_region32(buffer->image, (pixman_region32_t *)options->clip); pixman_image_set_clip_region32(target, (pixman_region32_t *)options->clip);
pixman_image_composite32(op, fill, NULL, buffer->image, pixman_image_composite32(op, fill, NULL, target,
0, 0, 0, 0, box.x, box.y, box.width, box.height); 0, 0, 0, 0, box.x, box.y, box.width, box.height);
pixman_image_set_clip_region32(buffer->image, NULL); pixman_image_set_clip_region32(target, NULL);
pixman_image_unref(fill); pixman_image_unref(fill);
} }

97
render/pixman/renderer.c
View file

@ -57,17 +57,6 @@ bool begin_pixman_data_ptr_access(struct wlr_buffer *wlr_buffer, pixman_image_t
return true; return true;
} }
static struct wlr_pixman_buffer *get_buffer(
struct wlr_pixman_renderer *renderer, struct wlr_buffer *wlr_buffer) {
struct wlr_pixman_buffer *buffer;
wl_list_for_each(buffer, &renderer->buffers, link) {
if (buffer->buffer == wlr_buffer) {
return buffer;
}
}
return NULL;
}
static const struct wlr_texture_impl texture_impl; static const struct wlr_texture_impl texture_impl;
bool wlr_texture_is_pixman(struct wlr_texture *texture) { bool wlr_texture_is_pixman(struct wlr_texture *texture) {
@ -94,23 +83,39 @@ static const struct wlr_texture_impl texture_impl = {
.destroy = texture_destroy, .destroy = texture_destroy,
}; };
static void destroy_buffer(struct wlr_pixman_buffer *buffer) { static void destroy_buffer(struct wlr_pixman_buffer *buffer) {
wl_list_remove(&buffer->link); wl_list_remove(&buffer->link);
wl_list_remove(&buffer->buffer_destroy.link); wlr_addon_finish(&buffer->addon);
if (buffer->shadow) {
pixman_image_unref(buffer->shadow);
}
pixman_image_unref(buffer->image); pixman_image_unref(buffer->image);
free(buffer); free(buffer);
} }
static void handle_destroy_buffer(struct wl_listener *listener, void *data) { static void handle_buffer_destroy(struct wlr_addon *addon) {
struct wlr_pixman_buffer *buffer = struct wlr_pixman_buffer *buffer = wl_container_of(addon, buffer, addon);
wl_container_of(listener, buffer, buffer_destroy);
destroy_buffer(buffer); destroy_buffer(buffer);
} }
static struct wlr_pixman_buffer *create_buffer( static const struct wlr_addon_interface buffer_addon_impl = {
struct wlr_pixman_renderer *renderer, struct wlr_buffer *wlr_buffer) { .name = "wlr_pixman_buffer",
.destroy = handle_buffer_destroy,
};
static struct wlr_pixman_buffer *get_or_create_buffer(struct wlr_pixman_renderer *renderer,
struct wlr_buffer *wlr_buffer) {
struct wlr_addon *addon =
wlr_addon_find(&wlr_buffer->addons, renderer, &buffer_addon_impl);
if (addon) {
struct wlr_pixman_buffer *buffer = wl_container_of(addon, buffer, addon);
return buffer;
}
struct wlr_pixman_buffer *buffer = calloc(1, sizeof(*buffer)); struct wlr_pixman_buffer *buffer = calloc(1, sizeof(*buffer));
if (buffer == NULL) { if (buffer == NULL) {
wlr_log_errno(WLR_ERROR, "Allocation failed"); wlr_log_errno(WLR_ERROR, "Allocation failed");
@ -137,6 +142,15 @@ static struct wlr_pixman_buffer *create_buffer(
goto error_buffer; goto error_buffer;
} }
struct wlr_dmabuf_attributes dmabuf = {0};
if (wlr_buffer_get_dmabuf(wlr_buffer, &dmabuf) && dmabuf.prefer_shadow) {
buffer->shadow = pixman_image_create_bits(format, wlr_buffer->width, wlr_buffer->height,
NULL, stride);
if (!buffer->shadow) {
wlr_log(WLR_ERROR, "Failed to allocate pixman shadow image");
}
}
buffer->image = pixman_image_create_bits(format, wlr_buffer->width, buffer->image = pixman_image_create_bits(format, wlr_buffer->width,
wlr_buffer->height, data, stride); wlr_buffer->height, data, stride);
if (!buffer->image) { if (!buffer->image) {
@ -144,8 +158,7 @@ static struct wlr_pixman_buffer *create_buffer(
goto error_buffer; goto error_buffer;
} }
buffer->buffer_destroy.notify = handle_destroy_buffer; wlr_addon_init(&buffer->addon, &wlr_buffer->addons, renderer, &buffer_addon_impl);
wl_signal_add(&wlr_buffer->events.destroy, &buffer->buffer_destroy);
wl_list_insert(&renderer->buffers, &buffer->link); wl_list_insert(&renderer->buffers, &buffer->link);
@ -174,8 +187,13 @@ static bool pixman_begin(struct wlr_renderer *wlr_renderer, uint32_t width,
static void pixman_end(struct wlr_renderer *wlr_renderer) { static void pixman_end(struct wlr_renderer *wlr_renderer) {
struct wlr_pixman_renderer *renderer = get_renderer(wlr_renderer); struct wlr_pixman_renderer *renderer = get_renderer(wlr_renderer);
struct wlr_pixman_buffer *buffer = renderer->current_buffer;
assert(buffer != NULL);
assert(renderer->current_buffer != NULL); if (buffer->shadow) {
pixman_image_composite32(PIXMAN_OP_SRC, buffer->shadow, NULL, buffer->image, 0, 0, 0,
0, 0, 0, renderer->width, renderer->height);
}
wlr_buffer_end_data_ptr_access(renderer->current_buffer->buffer); wlr_buffer_end_data_ptr_access(renderer->current_buffer->buffer);
} }
@ -193,8 +211,9 @@ static void pixman_clear(struct wlr_renderer *wlr_renderer,
}; };
pixman_image_t *fill = pixman_image_create_solid_fill(&colour); pixman_image_t *fill = pixman_image_create_solid_fill(&colour);
pixman_image_t *target = buffer->shadow ? buffer->shadow : buffer->image;
pixman_image_composite32(PIXMAN_OP_SRC, fill, NULL, buffer->image, 0, 0, 0, pixman_image_composite32(PIXMAN_OP_SRC, fill, NULL, target, 0, 0, 0,
0, 0, 0, renderer->width, renderer->height); 0, 0, 0, renderer->width, renderer->height);
pixman_image_unref(fill); pixman_image_unref(fill);
@ -205,14 +224,16 @@ static void pixman_scissor(struct wlr_renderer *wlr_renderer,
struct wlr_pixman_renderer *renderer = get_renderer(wlr_renderer); struct wlr_pixman_renderer *renderer = get_renderer(wlr_renderer);
struct wlr_pixman_buffer *buffer = renderer->current_buffer; struct wlr_pixman_buffer *buffer = renderer->current_buffer;
pixman_image_t *target = buffer->shadow ? buffer->shadow : buffer->image;
if (box != NULL) { if (box != NULL) {
struct pixman_region32 region = {0}; struct pixman_region32 region = {0};
pixman_region32_init_rect(&region, box->x, box->y, box->width, pixman_region32_init_rect(&region, box->x, box->y, box->width,
box->height); box->height);
pixman_image_set_clip_region32(buffer->image, &region); pixman_image_set_clip_region32(target, &region);
pixman_region32_fini(&region); pixman_region32_fini(&region);
} else { } else {
pixman_image_set_clip_region32(buffer->image, NULL); pixman_image_set_clip_region32(target, NULL);
} }
} }
@ -263,9 +284,9 @@ static bool pixman_render_subtexture_with_matrix(
pixman_image_set_transform(texture->image, &transform); pixman_image_set_transform(texture->image, &transform);
// TODO clip properly with src_x and src_y // TODO clip properly with src_x and src_y
pixman_image_composite32(PIXMAN_OP_OVER, texture->image, mask, pixman_image_t *target = buffer->shadow ? buffer->shadow : buffer->image;
buffer->image, 0, 0, 0, 0, 0, 0, renderer->width, pixman_image_composite32(PIXMAN_OP_OVER, texture->image, mask, target,
renderer->height); 0, 0, 0, 0, 0, 0, buffer->buffer->width, buffer->buffer->height);
if (texture->buffer != NULL) { if (texture->buffer != NULL) {
wlr_buffer_end_data_ptr_access(texture->buffer); wlr_buffer_end_data_ptr_access(texture->buffer);
@ -321,7 +342,8 @@ static void pixman_render_quad_with_matrix(struct wlr_renderer *wlr_renderer,
pixman_image_set_transform(image, &transform); pixman_image_set_transform(image, &transform);
pixman_image_composite32(PIXMAN_OP_OVER, image, NULL, buffer->image, pixman_image_t *target = buffer->shadow ? buffer->shadow : buffer->image;
pixman_image_composite32(PIXMAN_OP_OVER, image, NULL, target,
0, 0, 0, 0, 0, 0, renderer->width, renderer->height); 0, 0, 0, 0, 0, 0, renderer->width, renderer->height);
pixman_image_unref(image); pixman_image_unref(image);
@ -416,10 +438,7 @@ static bool pixman_bind_buffer(struct wlr_renderer *wlr_renderer,
return true; return true;
} }
struct wlr_pixman_buffer *buffer = get_buffer(renderer, wlr_buffer); struct wlr_pixman_buffer *buffer = get_or_create_buffer(renderer, wlr_buffer);
if (buffer == NULL) {
buffer = create_buffer(renderer, wlr_buffer);
}
if (buffer == NULL) { if (buffer == NULL) {
return false; return false;
} }
@ -453,8 +472,7 @@ static uint32_t pixman_preferred_read_format(
struct wlr_pixman_renderer *renderer = get_renderer(wlr_renderer); struct wlr_pixman_renderer *renderer = get_renderer(wlr_renderer);
struct wlr_pixman_buffer *buffer = renderer->current_buffer; struct wlr_pixman_buffer *buffer = renderer->current_buffer;
pixman_format_code_t pixman_format = pixman_image_get_format( pixman_format_code_t pixman_format = pixman_image_get_format(buffer->image);
buffer->image);
return get_drm_format_from_pixman(pixman_format); return get_drm_format_from_pixman(pixman_format);
} }
@ -479,7 +497,8 @@ static bool pixman_read_pixels(struct wlr_renderer *wlr_renderer,
pixman_image_t *dst = pixman_image_create_bits_no_clear(fmt, width, height, pixman_image_t *dst = pixman_image_create_bits_no_clear(fmt, width, height,
data, stride); data, stride);
pixman_image_composite32(PIXMAN_OP_SRC, buffer->image, NULL, dst, pixman_image_t *src = buffer->shadow ? buffer->shadow : buffer->image;
pixman_image_composite32(PIXMAN_OP_SRC, src, NULL, dst,
src_x, src_y, 0, 0, dst_x, dst_y, width, height); src_x, src_y, 0, 0, dst_x, dst_y, width, height);
pixman_image_unref(dst); pixman_image_unref(dst);
@ -495,10 +514,7 @@ static struct wlr_render_pass *pixman_begin_buffer_pass(struct wlr_renderer *wlr
struct wlr_buffer *wlr_buffer, const struct wlr_buffer_pass_options *options) { struct wlr_buffer *wlr_buffer, const struct wlr_buffer_pass_options *options) {
struct wlr_pixman_renderer *renderer = get_renderer(wlr_renderer); struct wlr_pixman_renderer *renderer = get_renderer(wlr_renderer);
struct wlr_pixman_buffer *buffer = get_buffer(renderer, wlr_buffer); struct wlr_pixman_buffer *buffer = get_or_create_buffer(renderer, wlr_buffer);
if (buffer == NULL) {
buffer = create_buffer(renderer, wlr_buffer);
}
if (buffer == NULL) { if (buffer == NULL) {
return NULL; return NULL;
} }
@ -560,6 +576,7 @@ pixman_image_t *wlr_pixman_texture_get_image(struct wlr_texture *wlr_texture) {
pixman_image_t *wlr_pixman_renderer_get_current_image( pixman_image_t *wlr_pixman_renderer_get_current_image(
struct wlr_renderer *wlr_renderer) { struct wlr_renderer *wlr_renderer) {
struct wlr_pixman_renderer *renderer = get_renderer(wlr_renderer); struct wlr_pixman_renderer *renderer = get_renderer(wlr_renderer);
assert(renderer->current_buffer); struct wlr_pixman_buffer *buffer = renderer->current_buffer;
return renderer->current_buffer->image; assert(buffer);
return buffer->shadow ? buffer->shadow : buffer->image;
} }