From 6292ef9dabbe57c197fa30528e5a6fae0cad51b7 Mon Sep 17 00:00:00 2001 From: Maxim Solovyov Date: Tue, 27 Feb 2024 01:07:30 +0300 Subject: [PATCH 1/3] backend: xrender: drop the leading underscore from structure names as requested on the discord server. this also addresses clang-tidy issues. --- src/backend/xrender/xrender.c | 54 +++++++++++++++++------------------ 1 file changed, 27 insertions(+), 27 deletions(-) diff --git a/src/backend/xrender/xrender.c b/src/backend/xrender/xrender.c index 72d5ece6..5dd4358c 100644 --- a/src/backend/xrender/xrender.c +++ b/src/backend/xrender/xrender.c @@ -24,7 +24,7 @@ #include "win.h" #include "x.h" -typedef struct _xrender_data { +typedef struct xrender_data { backend_t base; /// If vsync is enabled and supported by the current system bool vsync; @@ -62,7 +62,7 @@ typedef struct _xrender_data { xcb_xfixes_region_t present_region; } xrender_data; -struct _xrender_blur_context { +struct xrender_blur_context { enum blur_method method; /// Blur kernels converted to X format struct x_convolution_kernel **x_blur_kernel; @@ -73,7 +73,7 @@ struct _xrender_blur_context { int x_blur_kernel_count; }; -struct _xrender_image_data_inner { +struct xrender_image_data_inner { // struct backend_image_inner_base int refcount; bool has_alpha; @@ -173,9 +173,9 @@ make_rounded_corner_cache(struct x_connection *c, xcb_render_picture_t src, int return ret; } -static xcb_render_picture_t process_mask(struct _xrender_data *xd, struct xrender_image *mask, +static xcb_render_picture_t process_mask(struct xrender_data *xd, struct xrender_image *mask, xcb_render_picture_t alpha_pict, bool *allocated) { - auto inner = (struct _xrender_image_data_inner *)mask->base.inner; + auto inner = (struct xrender_image_data_inner *)mask->base.inner; if (!mask->base.color_inverted && mask->base.corner_radius == 0) { *allocated = false; return inner->pict; @@ -216,7 +216,7 @@ static xcb_render_picture_t process_mask(struct _xrender_data *xd, struct xrende } static void -compose_impl(struct _xrender_data *xd, struct xrender_image *xrimg, coord_t dst, +compose_impl(struct xrender_data *xd, struct xrender_image *xrimg, coord_t dst, struct xrender_image *mask, coord_t mask_dst, const region_t *reg_paint, const region_t *reg_visible, xcb_render_picture_t result) { const struct backend_image *img = &xrimg->base; @@ -226,7 +226,7 @@ compose_impl(struct _xrender_data *xd, struct xrender_image *xrimg, coord_t dst, mask_pict = process_mask( xd, mask, img->opacity < 1.0 ? mask_pict : XCB_NONE, &mask_allocated); } - auto inner = (struct _xrender_image_data_inner *)img->inner; + auto inner = (struct xrender_image_data_inner *)img->inner; region_t reg; bool has_alpha = inner->has_alpha || img->opacity != 1; @@ -361,7 +361,7 @@ compose_impl(struct _xrender_data *xd, struct xrender_image *xrimg, coord_t dst, static void compose(backend_t *base, image_handle image_, coord_t dst, image_handle mask_, coord_t mask_dst, const region_t *reg_paint, const region_t *reg_visible) { - struct _xrender_data *xd = (void *)base; + struct xrender_data *xd = (void *)base; auto image = (struct xrender_image *)image_; auto mask = (struct xrender_image *)mask_; return compose_impl(xd, image, dst, mask, mask_dst, reg_paint, reg_visible, @@ -369,7 +369,7 @@ static void compose(backend_t *base, image_handle image_, coord_t dst, image_han } static void fill(backend_t *base, struct color c, const region_t *clip) { - struct _xrender_data *xd = (void *)base; + struct xrender_data *xd = (void *)base; const rect_t *extent = pixman_region32_extents((region_t *)clip); x_set_picture_clip_region(base->c, xd->back[2], 0, 0, clip); // color is in X fixed point representation @@ -388,13 +388,13 @@ static void fill(backend_t *base, struct color c, const region_t *clip) { static bool blur(backend_t *backend_data, double opacity, void *ctx_, image_handle mask_, coord_t mask_dst, const region_t *reg_blur, const region_t *reg_visible) { - auto bctx = (struct _xrender_blur_context *)ctx_; + auto bctx = (struct xrender_blur_context *)ctx_; auto mask = (struct xrender_image *)mask_; if (bctx->method == BLUR_METHOD_NONE) { return true; } - struct _xrender_data *xd = (void *)backend_data; + struct xrender_data *xd = (void *)backend_data; auto c = xd->base.c; region_t reg_op; pixman_region32_init(®_op); @@ -532,7 +532,7 @@ bind_pixmap(backend_t *base, xcb_pixmap_t pixmap, struct xvisual_info fmt, bool } auto img = ccalloc(1, struct xrender_image); - auto inner = ccalloc(1, struct _xrender_image_data_inner); + auto inner = ccalloc(1, struct xrender_image_data_inner); inner->depth = (uint8_t)fmt.visual_depth; inner->width = img->base.ewidth = r->width; inner->height = img->base.eheight = r->height; @@ -557,7 +557,7 @@ bind_pixmap(backend_t *base, xcb_pixmap_t pixmap, struct xvisual_info fmt, bool } return (image_handle)img; } -static void release_image_inner(backend_t *base, struct _xrender_image_data_inner *inner) { +static void release_image_inner(backend_t *base, struct xrender_image_data_inner *inner) { x_free_picture(base->c, inner->pict); if (inner->owned) { xcb_free_pixmap(base->c->c, inner->pixmap); @@ -585,13 +585,13 @@ static void release_image(backend_t *base, image_handle image) { img->rounded_rectangle = NULL; img->base.inner->refcount -= 1; if (img->base.inner->refcount == 0) { - release_image_inner(base, (struct _xrender_image_data_inner *)img->base.inner); + release_image_inner(base, (struct xrender_image_data_inner *)img->base.inner); } free(img); } static void deinit(backend_t *backend_data) { - struct _xrender_data *xd = (void *)backend_data; + struct xrender_data *xd = (void *)backend_data; for (int i = 0; i < 256; i++) { x_free_picture(xd->base.c, xd->alpha_pict[i]); } @@ -614,7 +614,7 @@ static void deinit(backend_t *backend_data) { } static void present(backend_t *base, const region_t *region) { - struct _xrender_data *xd = (void *)base; + struct xrender_data *xd = (void *)base; const rect_t *extent = pixman_region32_extents((region_t *)region); int16_t orig_x = to_i16_checked(extent->x1), orig_y = to_i16_checked(extent->y1); uint16_t region_width = to_u16_checked(extent->x2 - extent->x1), @@ -679,7 +679,7 @@ static void present(backend_t *base, const region_t *region) { } static int buffer_age(backend_t *backend_data) { - struct _xrender_data *xd = (void *)backend_data; + struct xrender_data *xd = (void *)backend_data; if (!xd->vsync) { // Only the target picture really holds the screen content, and its // content is always up to date. So buffer age is always 1. @@ -688,9 +688,9 @@ static int buffer_age(backend_t *backend_data) { return xd->buffer_age[xd->curr_back]; } -static struct _xrender_image_data_inner * +static struct xrender_image_data_inner * new_inner(backend_t *base, int w, int h, xcb_visualid_t visual, uint8_t depth) { - auto new_inner = ccalloc(1, struct _xrender_image_data_inner); + auto new_inner = ccalloc(1, struct xrender_image_data_inner); new_inner->pixmap = x_create_pixmap(base->c, depth, w, h); if (new_inner->pixmap == XCB_NONE) { log_error("Failed to create pixmap for copy"); @@ -715,7 +715,7 @@ new_inner(backend_t *base, int w, int h, xcb_visualid_t visual, uint8_t depth) { } static image_handle make_mask(backend_t *base, geometry_t size, const region_t *reg) { - struct _xrender_data *xd = (void *)base; + struct xrender_data *xd = (void *)base; // Give the mask a 1 pixel wide border to emulate the clamp to border behavior of // OpenGL textures. auto w16 = to_u16_checked(size.width + 2); @@ -764,7 +764,7 @@ static bool decouple_image(backend_t *base, struct backend_image *img, const reg if (img->inner->refcount == 1) { return true; } - auto inner = (struct _xrender_image_data_inner *)img->inner; + auto inner = (struct xrender_image_data_inner *)img->inner; // Force new pixmap to a 32-bit ARGB visual to allow for transparent frames around // non-transparent windows auto visual = (inner->depth == 32) @@ -787,7 +787,7 @@ static bool decouple_image(backend_t *base, struct backend_image *img, const reg static bool image_op(backend_t *base, enum image_operations op, image_handle image, const region_t *reg_op, const region_t *reg_visible, void *arg) { - struct _xrender_data *xd = (void *)base; + struct xrender_data *xd = (void *)base; auto img = (struct backend_image *)image; region_t reg; double *dargs = arg; @@ -812,7 +812,7 @@ static bool image_op(backend_t *base, enum image_operations op, image_handle ima return false; } - auto inner = (struct _xrender_image_data_inner *)img->inner; + auto inner = (struct xrender_image_data_inner *)img->inner; auto alpha_pict = xd->alpha_pict[(int)((1 - dargs[0]) * MAX_ALPHA)]; x_set_picture_clip_region(base->c, inner->pict, 0, 0, ®); xcb_render_composite(base->c->c, XCB_RENDER_PICT_OP_OUT_REVERSE, @@ -828,7 +828,7 @@ static bool image_op(backend_t *base, enum image_operations op, image_handle ima static void * create_blur_context(backend_t *base attr_unused, enum blur_method method, void *args) { - auto ret = ccalloc(1, struct _xrender_blur_context); + auto ret = ccalloc(1, struct xrender_blur_context); if (!method || method >= BLUR_METHOD_INVALID) { ret->method = BLUR_METHOD_NONE; return ret; @@ -871,7 +871,7 @@ create_blur_context(backend_t *base attr_unused, enum blur_method method, void * } static void destroy_blur_context(backend_t *base attr_unused, void *ctx_) { - struct _xrender_blur_context *ctx = ctx_; + struct xrender_blur_context *ctx = ctx_; for (int i = 0; i < ctx->x_blur_kernel_count; i++) { free(ctx->x_blur_kernel[i]); } @@ -880,7 +880,7 @@ static void destroy_blur_context(backend_t *base attr_unused, void *ctx_) { } static void get_blur_size(void *blur_context, int *width, int *height) { - struct _xrender_blur_context *ctx = blur_context; + struct xrender_blur_context *ctx = blur_context; *width = ctx->resize_width; *height = ctx->resize_height; } @@ -890,7 +890,7 @@ static backend_t *backend_xrender_init(session_t *ps, xcb_window_t target) { log_warn("\"dithered-present\" is not supported by the xrender backend."); } - auto xd = ccalloc(1, struct _xrender_data); + auto xd = ccalloc(1, struct xrender_data); init_backend_base(&xd->base, ps); for (int i = 0; i <= MAX_ALPHA; ++i) { From 1f703a1a9819465f85cee64a4f92b2f87b05a4d4 Mon Sep 17 00:00:00 2001 From: Maxim Solovyov Date: Tue, 27 Feb 2024 01:28:05 +0300 Subject: [PATCH 2/3] backend: xrender: prefer explicit casts explicit casts are preferred at least according to the discussion in the #343. this also makes the xrender backend's code consistent with the other backends' code. --- src/backend/xrender/xrender.c | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/src/backend/xrender/xrender.c b/src/backend/xrender/xrender.c index 5dd4358c..b57ebf2c 100644 --- a/src/backend/xrender/xrender.c +++ b/src/backend/xrender/xrender.c @@ -361,7 +361,7 @@ compose_impl(struct xrender_data *xd, struct xrender_image *xrimg, coord_t dst, static void compose(backend_t *base, image_handle image_, coord_t dst, image_handle mask_, coord_t mask_dst, const region_t *reg_paint, const region_t *reg_visible) { - struct xrender_data *xd = (void *)base; + auto xd = (struct xrender_data *)base; auto image = (struct xrender_image *)image_; auto mask = (struct xrender_image *)mask_; return compose_impl(xd, image, dst, mask, mask_dst, reg_paint, reg_visible, @@ -369,7 +369,7 @@ static void compose(backend_t *base, image_handle image_, coord_t dst, image_han } static void fill(backend_t *base, struct color c, const region_t *clip) { - struct xrender_data *xd = (void *)base; + auto xd = (struct xrender_data *)base; const rect_t *extent = pixman_region32_extents((region_t *)clip); x_set_picture_clip_region(base->c, xd->back[2], 0, 0, clip); // color is in X fixed point representation @@ -394,7 +394,7 @@ static bool blur(backend_t *backend_data, double opacity, void *ctx_, image_hand return true; } - struct xrender_data *xd = (void *)backend_data; + auto xd = (struct xrender_data *)backend_data; auto c = xd->base.c; region_t reg_op; pixman_region32_init(®_op); @@ -591,7 +591,7 @@ static void release_image(backend_t *base, image_handle image) { } static void deinit(backend_t *backend_data) { - struct xrender_data *xd = (void *)backend_data; + auto xd = (struct xrender_data *)backend_data; for (int i = 0; i < 256; i++) { x_free_picture(xd->base.c, xd->alpha_pict[i]); } @@ -614,7 +614,7 @@ static void deinit(backend_t *backend_data) { } static void present(backend_t *base, const region_t *region) { - struct xrender_data *xd = (void *)base; + auto xd = (struct xrender_data *)base; const rect_t *extent = pixman_region32_extents((region_t *)region); int16_t orig_x = to_i16_checked(extent->x1), orig_y = to_i16_checked(extent->y1); uint16_t region_width = to_u16_checked(extent->x2 - extent->x1), @@ -647,8 +647,8 @@ static void present(backend_t *base, const region_t *region) { return; } // TODO(yshui) don't block wait for present completion - xcb_present_generic_event_t *pev = - (void *)xcb_wait_for_special_event(base->c->c, xd->present_event); + auto pev = (xcb_present_generic_event_t *)xcb_wait_for_special_event( + base->c->c, xd->present_event); if (!pev) { // We don't know what happened, maybe X died // But reset buffer age, so in case we do recover, we will @@ -657,7 +657,7 @@ static void present(backend_t *base, const region_t *region) { return; } assert(pev->evtype == XCB_PRESENT_COMPLETE_NOTIFY); - xcb_present_complete_notify_event_t *pcev = (void *)pev; + auto pcev = (xcb_present_complete_notify_event_t *)pev; // log_trace("Present complete: %d %ld", pcev->mode, pcev->msc); xd->buffer_age[xd->curr_back] = 1; @@ -679,7 +679,7 @@ static void present(backend_t *base, const region_t *region) { } static int buffer_age(backend_t *backend_data) { - struct xrender_data *xd = (void *)backend_data; + auto xd = (struct xrender_data *)backend_data; if (!xd->vsync) { // Only the target picture really holds the screen content, and its // content is always up to date. So buffer age is always 1. @@ -715,7 +715,7 @@ new_inner(backend_t *base, int w, int h, xcb_visualid_t visual, uint8_t depth) { } static image_handle make_mask(backend_t *base, geometry_t size, const region_t *reg) { - struct xrender_data *xd = (void *)base; + auto xd = (struct xrender_data *)base; // Give the mask a 1 pixel wide border to emulate the clamp to border behavior of // OpenGL textures. auto w16 = to_u16_checked(size.width + 2); @@ -787,7 +787,7 @@ static bool decouple_image(backend_t *base, struct backend_image *img, const reg static bool image_op(backend_t *base, enum image_operations op, image_handle image, const region_t *reg_op, const region_t *reg_visible, void *arg) { - struct xrender_data *xd = (void *)base; + auto xd = (struct xrender_data *)base; auto img = (struct backend_image *)image; region_t reg; double *dargs = arg; From 925fef083e0629f0d41af7ffdd22e849a5080fa1 Mon Sep 17 00:00:00 2001 From: Maxim Solovyov Date: Tue, 27 Feb 2024 01:52:52 +0300 Subject: [PATCH 3/3] backend: xrender: prefix backend-specific function names with xrender_ and sort the xrender_ops structure in the order backend operations are declared in the backend_operations structure. this makes the xrender backend's code consistent with the other backends' code and reduces the risk of collisions because some backend operation names are quite simple (e.g. init, deinit, fill, etc.). --- src/backend/xrender/xrender.c | 147 ++++++++++++++++++---------------- 1 file changed, 76 insertions(+), 71 deletions(-) diff --git a/src/backend/xrender/xrender.c b/src/backend/xrender/xrender.c index b57ebf2c..9e053ab2 100644 --- a/src/backend/xrender/xrender.c +++ b/src/backend/xrender/xrender.c @@ -107,8 +107,8 @@ struct xrender_image { /// Make a picture of size width x height, which has a rounded rectangle of corner_radius /// rendered in it. struct xrender_rounded_rectangle_cache * -make_rounded_corner_cache(struct x_connection *c, xcb_render_picture_t src, int width, - int height, int corner_radius) { +xrender_make_rounded_corner_cache(struct x_connection *c, xcb_render_picture_t src, + int width, int height, int corner_radius) { auto picture = x_create_picture_with_standard(c, width, height, XCB_PICT_STANDARD_ARGB_32, 0, NULL); if (picture == XCB_NONE) { @@ -173,8 +173,9 @@ make_rounded_corner_cache(struct x_connection *c, xcb_render_picture_t src, int return ret; } -static xcb_render_picture_t process_mask(struct xrender_data *xd, struct xrender_image *mask, - xcb_render_picture_t alpha_pict, bool *allocated) { +static xcb_render_picture_t +xrender_process_mask(struct xrender_data *xd, struct xrender_image *mask, + xcb_render_picture_t alpha_pict, bool *allocated) { auto inner = (struct xrender_image_data_inner *)mask->base.inner; if (!mask->base.color_inverted && mask->base.corner_radius == 0) { *allocated = false; @@ -192,7 +193,7 @@ static xcb_render_picture_t process_mask(struct xrender_data *xd, struct xrender // Remember: the mask has a 1-pixel border if (mask->base.corner_radius != 0) { if (mask->rounded_rectangle == NULL) { - mask->rounded_rectangle = make_rounded_corner_cache( + mask->rounded_rectangle = xrender_make_rounded_corner_cache( xd->base.c, xd->white_pixel, inner->width - 2, inner->height - 2, (int)mask->base.corner_radius); } @@ -215,15 +216,15 @@ static xcb_render_picture_t process_mask(struct xrender_data *xd, struct xrender return ret; } -static void -compose_impl(struct xrender_data *xd, struct xrender_image *xrimg, coord_t dst, - struct xrender_image *mask, coord_t mask_dst, const region_t *reg_paint, - const region_t *reg_visible, xcb_render_picture_t result) { +static void xrender_compose_impl(struct xrender_data *xd, struct xrender_image *xrimg, + coord_t dst, struct xrender_image *mask, coord_t mask_dst, + const region_t *reg_paint, const region_t *reg_visible, + xcb_render_picture_t result) { const struct backend_image *img = &xrimg->base; bool mask_allocated = false; auto mask_pict = xd->alpha_pict[(int)(img->opacity * MAX_ALPHA)]; if (mask != NULL) { - mask_pict = process_mask( + mask_pict = xrender_process_mask( xd, mask, img->opacity < 1.0 ? mask_pict : XCB_NONE, &mask_allocated); } auto inner = (struct xrender_image_data_inner *)img->inner; @@ -248,9 +249,9 @@ compose_impl(struct xrender_data *xd, struct xrender_image *xrimg, coord_t dst, pixman_region32_intersect(®, (region_t *)reg_paint, (region_t *)reg_visible); x_set_picture_clip_region(xd->base.c, result, 0, 0, ®); if (img->corner_radius != 0 && xrimg->rounded_rectangle == NULL) { - xrimg->rounded_rectangle = - make_rounded_corner_cache(xd->base.c, xd->white_pixel, inner->width, - inner->height, (int)img->corner_radius); + xrimg->rounded_rectangle = xrender_make_rounded_corner_cache( + xd->base.c, xd->white_pixel, inner->width, inner->height, + (int)img->corner_radius); } if (((img->color_inverted || img->dim != 0) && has_alpha) || img->corner_radius != 0) { // Apply image properties using a temporary image, because the source @@ -359,16 +360,17 @@ compose_impl(struct xrender_data *xd, struct xrender_image *xrimg, coord_t dst, pixman_region32_fini(®); } -static void compose(backend_t *base, image_handle image_, coord_t dst, image_handle mask_, - coord_t mask_dst, const region_t *reg_paint, const region_t *reg_visible) { +static void +xrender_compose(backend_t *base, image_handle image_, coord_t dst, image_handle mask_, + coord_t mask_dst, const region_t *reg_paint, const region_t *reg_visible) { auto xd = (struct xrender_data *)base; auto image = (struct xrender_image *)image_; auto mask = (struct xrender_image *)mask_; - return compose_impl(xd, image, dst, mask, mask_dst, reg_paint, reg_visible, - xd->back[2]); + return xrender_compose_impl(xd, image, dst, mask, mask_dst, reg_paint, + reg_visible, xd->back[2]); } -static void fill(backend_t *base, struct color c, const region_t *clip) { +static void xrender_fill(backend_t *base, struct color c, const region_t *clip) { auto xd = (struct xrender_data *)base; const rect_t *extent = pixman_region32_extents((region_t *)clip); x_set_picture_clip_region(base->c, xd->back[2], 0, 0, clip); @@ -386,8 +388,9 @@ static void fill(backend_t *base, struct color c, const region_t *clip) { .height = to_u16_checked(extent->y2 - extent->y1)}}); } -static bool blur(backend_t *backend_data, double opacity, void *ctx_, image_handle mask_, - coord_t mask_dst, const region_t *reg_blur, const region_t *reg_visible) { +static bool +xrender_blur(backend_t *backend_data, double opacity, void *ctx_, image_handle mask_, + coord_t mask_dst, const region_t *reg_blur, const region_t *reg_visible) { auto bctx = (struct xrender_blur_context *)ctx_; auto mask = (struct xrender_image *)mask_; if (bctx->method == BLUR_METHOD_NONE) { @@ -444,8 +447,8 @@ static bool blur(backend_t *backend_data, double opacity, void *ctx_, image_hand auto mask_pict = xd->alpha_pict[(int)(opacity * MAX_ALPHA)]; bool mask_allocated = false; if (mask != NULL) { - mask_pict = process_mask(xd, mask, opacity != 1.0 ? mask_pict : XCB_NONE, - &mask_allocated); + mask_pict = xrender_process_mask( + xd, mask, opacity != 1.0 ? mask_pict : XCB_NONE, &mask_allocated); } int current = 0; x_set_picture_clip_region(c, src_pict, 0, 0, ®_op_resized); @@ -520,8 +523,8 @@ static bool blur(backend_t *backend_data, double opacity, void *ctx_, image_hand return true; } -static image_handle -bind_pixmap(backend_t *base, xcb_pixmap_t pixmap, struct xvisual_info fmt, bool owned) { +static image_handle xrender_bind_pixmap(backend_t *base, xcb_pixmap_t pixmap, + struct xvisual_info fmt, bool owned) { xcb_generic_error_t *e; auto r = xcb_get_geometry_reply(base->c->c, xcb_get_geometry(base->c->c, pixmap), &e); if (!r) { @@ -557,7 +560,8 @@ bind_pixmap(backend_t *base, xcb_pixmap_t pixmap, struct xvisual_info fmt, bool } return (image_handle)img; } -static void release_image_inner(backend_t *base, struct xrender_image_data_inner *inner) { +static void +xrender_release_image_inner(backend_t *base, struct xrender_image_data_inner *inner) { x_free_picture(base->c, inner->pict); if (inner->owned) { xcb_free_pixmap(base->c->c, inner->pixmap); @@ -566,7 +570,8 @@ static void release_image_inner(backend_t *base, struct xrender_image_data_inner } static void -release_rounded_corner_cache(backend_t *base, struct xrender_rounded_rectangle_cache *cache) { +xrender_release_rounded_corner_cache(backend_t *base, + struct xrender_rounded_rectangle_cache *cache) { if (!cache) { return; } @@ -579,18 +584,19 @@ release_rounded_corner_cache(backend_t *base, struct xrender_rounded_rectangle_c } } -static void release_image(backend_t *base, image_handle image) { +static void xrender_release_image(backend_t *base, image_handle image) { auto img = (struct xrender_image *)image; - release_rounded_corner_cache(base, img->rounded_rectangle); + xrender_release_rounded_corner_cache(base, img->rounded_rectangle); img->rounded_rectangle = NULL; img->base.inner->refcount -= 1; if (img->base.inner->refcount == 0) { - release_image_inner(base, (struct xrender_image_data_inner *)img->base.inner); + xrender_release_image_inner( + base, (struct xrender_image_data_inner *)img->base.inner); } free(img); } -static void deinit(backend_t *backend_data) { +static void xrender_deinit(backend_t *backend_data) { auto xd = (struct xrender_data *)backend_data; for (int i = 0; i < 256; i++) { x_free_picture(xd->base.c, xd->alpha_pict[i]); @@ -613,7 +619,7 @@ static void deinit(backend_t *backend_data) { free(xd); } -static void present(backend_t *base, const region_t *region) { +static void xrender_present(backend_t *base, const region_t *region) { auto xd = (struct xrender_data *)base; const rect_t *extent = pixman_region32_extents((region_t *)region); int16_t orig_x = to_i16_checked(extent->x1), orig_y = to_i16_checked(extent->y1); @@ -678,7 +684,7 @@ static void present(backend_t *base, const region_t *region) { } } -static int buffer_age(backend_t *backend_data) { +static int xrender_buffer_age(backend_t *backend_data) { auto xd = (struct xrender_data *)backend_data; if (!xd->vsync) { // Only the target picture really holds the screen content, and its @@ -689,7 +695,7 @@ static int buffer_age(backend_t *backend_data) { } static struct xrender_image_data_inner * -new_inner(backend_t *base, int w, int h, xcb_visualid_t visual, uint8_t depth) { +xrender_new_inner(backend_t *base, int w, int h, xcb_visualid_t visual, uint8_t depth) { auto new_inner = ccalloc(1, struct xrender_image_data_inner); new_inner->pixmap = x_create_pixmap(base->c, depth, w, h); if (new_inner->pixmap == XCB_NONE) { @@ -714,15 +720,15 @@ new_inner(backend_t *base, int w, int h, xcb_visualid_t visual, uint8_t depth) { return new_inner; } -static image_handle make_mask(backend_t *base, geometry_t size, const region_t *reg) { +static image_handle xrender_make_mask(backend_t *base, geometry_t size, const region_t *reg) { auto xd = (struct xrender_data *)base; // Give the mask a 1 pixel wide border to emulate the clamp to border behavior of // OpenGL textures. auto w16 = to_u16_checked(size.width + 2); auto h16 = to_u16_checked(size.height + 2); - auto inner = - new_inner(base, size.width + 2, size.height + 2, - x_get_visual_for_standard(base->c, XCB_PICT_STANDARD_ARGB_32), 32); + auto inner = xrender_new_inner( + base, size.width + 2, size.height + 2, + x_get_visual_for_standard(base->c, XCB_PICT_STANDARD_ARGB_32), 32); xcb_render_change_picture(base->c->c, inner->pict, XCB_RENDER_CP_REPEAT, (uint32_t[]){XCB_RENDER_REPEAT_PAD}); const rect_t *extent = pixman_region32_extents((region_t *)reg); @@ -760,7 +766,8 @@ static image_handle make_mask(backend_t *base, geometry_t size, const region_t * return (image_handle)img; } -static bool decouple_image(backend_t *base, struct backend_image *img, const region_t *reg) { +static bool +xrender_decouple_image(backend_t *base, struct backend_image *img, const region_t *reg) { if (img->inner->refcount == 1) { return true; } @@ -770,7 +777,7 @@ static bool decouple_image(backend_t *base, struct backend_image *img, const reg auto visual = (inner->depth == 32) ? inner->visual : x_get_visual_for_standard(base->c, XCB_PICT_STANDARD_ARGB_32); - auto inner2 = new_inner(base, inner->width, inner->height, visual, 32); + auto inner2 = xrender_new_inner(base, inner->width, inner->height, visual, 32); if (!inner2) { return false; } @@ -785,8 +792,8 @@ static bool decouple_image(backend_t *base, struct backend_image *img, const reg return true; } -static bool image_op(backend_t *base, enum image_operations op, image_handle image, - const region_t *reg_op, const region_t *reg_visible, void *arg) { +static bool xrender_image_op(backend_t *base, enum image_operations op, image_handle image, + const region_t *reg_op, const region_t *reg_visible, void *arg) { auto xd = (struct xrender_data *)base; auto img = (struct backend_image *)image; region_t reg; @@ -807,7 +814,7 @@ static bool image_op(backend_t *base, enum image_operations op, image_handle ima break; } - if (!decouple_image(base, img, reg_visible)) { + if (!xrender_decouple_image(base, img, reg_visible)) { pixman_region32_fini(®); return false; } @@ -826,8 +833,8 @@ static bool image_op(backend_t *base, enum image_operations op, image_handle ima return true; } -static void * -create_blur_context(backend_t *base attr_unused, enum blur_method method, void *args) { +static void *xrender_create_blur_context(backend_t *base attr_unused, + enum blur_method method, void *args) { auto ret = ccalloc(1, struct xrender_blur_context); if (!method || method >= BLUR_METHOD_INVALID) { ret->method = BLUR_METHOD_NONE; @@ -870,7 +877,7 @@ create_blur_context(backend_t *base attr_unused, enum blur_method method, void * return ret; } -static void destroy_blur_context(backend_t *base attr_unused, void *ctx_) { +static void xrender_destroy_blur_context(backend_t *base attr_unused, void *ctx_) { struct xrender_blur_context *ctx = ctx_; for (int i = 0; i < ctx->x_blur_kernel_count; i++) { free(ctx->x_blur_kernel[i]); @@ -879,13 +886,13 @@ static void destroy_blur_context(backend_t *base attr_unused, void *ctx_) { free(ctx); } -static void get_blur_size(void *blur_context, int *width, int *height) { +static void xrender_get_blur_size(void *blur_context, int *width, int *height) { struct xrender_blur_context *ctx = blur_context; *width = ctx->resize_width; *height = ctx->resize_height; } -static backend_t *backend_xrender_init(session_t *ps, xcb_window_t target) { +static backend_t *xrender_init(session_t *ps, xcb_window_t target) { if (ps->o.dithered_present) { log_warn("\"dithered-present\" is not supported by the xrender backend."); } @@ -963,12 +970,12 @@ static backend_t *backend_xrender_init(session_t *ps, xcb_window_t target) { return &xd->base; err: - deinit(&xd->base); + xrender_deinit(&xd->base); return NULL; } -image_handle clone_image(backend_t *base attr_unused, image_handle image, - const region_t *reg_visible attr_unused) { +image_handle xrender_clone_image(backend_t *base attr_unused, image_handle image, + const region_t *reg_visible attr_unused) { auto new_img = ccalloc(1, struct xrender_image); *new_img = *(struct xrender_image *)image; new_img->base.inner->refcount++; @@ -978,41 +985,39 @@ image_handle clone_image(backend_t *base attr_unused, image_handle image, return (image_handle)new_img; } -static bool set_image_property(backend_t *base, enum image_properties op, - image_handle image, void *args) { +static bool xrender_set_image_property(backend_t *base, enum image_properties op, + image_handle image, void *args) { auto xrimg = (struct xrender_image *)image; if (op == IMAGE_PROPERTY_CORNER_RADIUS && ((double *)args)[0] != xrimg->base.corner_radius) { // Free cached rounded rectangle if corner radius changed - release_rounded_corner_cache(base, xrimg->rounded_rectangle); + xrender_release_rounded_corner_cache(base, xrimg->rounded_rectangle); xrimg->rounded_rectangle = NULL; } return default_set_image_property(base, op, image, args); } struct backend_operations xrender_ops = { - .init = backend_xrender_init, - .deinit = deinit, - .blur = blur, - .present = present, - .compose = compose, - .fill = fill, - .bind_pixmap = bind_pixmap, - .release_image = release_image, + .init = xrender_init, + .deinit = xrender_deinit, + .compose = xrender_compose, + .fill = xrender_fill, + .blur = xrender_blur, + .present = xrender_present, + .bind_pixmap = xrender_bind_pixmap, .create_shadow_context = default_create_shadow_context, .destroy_shadow_context = default_destroy_shadow_context, .render_shadow = default_render_shadow, - .make_mask = make_mask, + .make_mask = xrender_make_mask, + .release_image = xrender_release_image, .is_image_transparent = default_is_image_transparent, - .buffer_age = buffer_age, + .buffer_age = xrender_buffer_age, .max_buffer_age = 2, - - .image_op = image_op, - .clone_image = clone_image, - .set_image_property = set_image_property, - .create_blur_context = create_blur_context, - .destroy_blur_context = destroy_blur_context, - .get_blur_size = get_blur_size, -}; + .set_image_property = xrender_set_image_property, + .image_op = xrender_image_op, + .clone_image = xrender_clone_image, + .create_blur_context = xrender_create_blur_context, + .destroy_blur_context = xrender_destroy_blur_context, + .get_blur_size = xrender_get_blur_size}; // vim: set noet sw=8 ts=8: