perf: skip capture when only blurred-window content changes

Author: dy-tea

include/effects.h

@@ -78,6 +78,10 @@ typedef struct effects_output_t {
 
 	uint64_t cached_bg_tex;
 	bool bg_cache_valid;
+
+	// true when pong holds the shared backdrop (i.e. the last capture was a
+	// full/shared capture); allows region-based re-capture instead of whole
+	bool shared_bg_valid;
 } effects_output_t;
 
 typedef struct effects_state_t {

include/effects_backend.h

@@ -152,7 +152,8 @@ typedef struct effects_backend_t {
 		struct be_screen_shader_params *p);
 
 	bool (*capture_readback)(struct wlr_buffer *capture_buffer, be_output_state_t *state,
-		uint64_t dst_fbo, int dst_w, int dst_h, int src_w, int src_h, uint64_t *out_tex);
+		uint64_t dst_fbo, int dst_x, int dst_y, int dst_w, int dst_h, int src_x, int src_y, int src_w,
+		int src_h, uint64_t *out_tex);
 
 	const char *(*get_screen_shader_source)(const char *name);
 	bool (*compile_screen_shader)(const char *frag_src);

src/effects.c

@@ -25,6 +25,7 @@
 #include <wlr/types/wlr_output.h>
 #include <wlr/types/wlr_scene.h>
 #include <wlr/util/log.h>
+#include <wlr/util/region.h>
 
 // private wlroots functions
 extern bool wlr_renderer_is_pixman(const struct wlr_renderer *wlr_renderer);
@@ -346,6 +347,7 @@ void effects_output_resize(effects_output_t *ctx, int width, int height, output_
 	ctx->height = height;
 	ctx->blur_w = new_bw;
 	ctx->blur_h = new_bh;
+	ctx->shared_bg_valid = false;
 	wlr_output_state_set_custom_mode(&ctx->capture_state, width, height, 0);
 
 	effects_destroy_buffer(&ctx->mica_buf, ctx->mica_native);
@@ -453,6 +455,45 @@ static uint64_t capture_bg_to_tex1_ex(output_t *output, effects_output_t *ctx, b
 	if (w <= 0 || h <= 0)
 		return 0;
 
+	// Re-capture only the damaged area at blur resolution instead of the whole
+	// frame: the backdrop texture (pong) keeps its previous content everywhere
+	// else. Damage that only touches the inside of blurred windows (which are
+	// hidden during the capture) still re-renders their rects, but at blur
+	// resolution that is far cheaper than a full-frame capture.
+	struct wlr_box region = {
+		0,
+		0,
+		ctx->blur_w,
+		ctx->blur_h
+	};
+	bool region_capture = false;
+	// only the shared backdrop capture (all blur toplevels/layer surfaces hidden)
+	// produces content compatible with the existing pong content
+	if (!exclude_slide_out && !mica_only && hide_blur_toplevels && ctx->shared_bg_valid) {
+		struct wlr_scene_output *real_so = wlr_scene_get_scene_output(server.scene, output->wlr_output);
+		if (real_so && !pixman_region32_empty(&real_so->damage_ring.current)) {
+			pixman_region32_copy(&ctx->scratch_region_a, &real_so->damage_ring.current);
+			wlr_region_scale_xy(&ctx->scratch_region_a, &ctx->scratch_region_a, (float)ctx->blur_w / (float)w,
+				(float)ctx->blur_h / (float)h);
+			pixman_region32_intersect_rect(&ctx->scratch_region_a, &ctx->scratch_region_a, 0, 0, ctx->blur_w,
+				ctx->blur_h);
+			if (!pixman_region32_empty(&ctx->scratch_region_a)) {
+				pixman_box32_t *ext = pixman_region32_extents(&ctx->scratch_region_a);
+				region = (struct wlr_box){
+					ext->x1,
+					ext->y1,
+					ext->x2 - ext->x1,
+					ext->y2 - ext->y1
+				};
+				region_capture = true;
+			}
+		}
+		if (!region_capture) {
+			wlr_scene_output_set_position(ctx->capture_scene_output, -0x7fff, -0x7fff);
+			return ctx->be_state.pong.native_handle[1];
+		}
+	}
+
 	struct wl_array hidden_slide_out;
 	wl_array_init(&hidden_slide_out);
 	if (exclude_slide_out) {
@@ -522,7 +563,10 @@ static uint64_t capture_bg_to_tex1_ex(output_t *output, effects_output_t *ctx, b
 	wlr_output_state_set_custom_mode(&cap_state, ctx->blur_w, ctx->blur_h, 0);
 	wlr_output_state_set_scale(&cap_state, (float)ctx->blur_w / (float)w);
 
-	wlr_damage_ring_add_whole(&ctx->capture_scene_output->damage_ring);
+	if (region_capture)
+		wlr_damage_ring_add_box(&ctx->capture_scene_output->damage_ring, &region);
+	else
+		wlr_damage_ring_add_whole(&ctx->capture_scene_output->damage_ring);
 
 	bool ok = wlr_scene_output_build_state(ctx->capture_scene_output, &cap_state, NULL);
 
@@ -571,11 +615,15 @@ static uint64_t capture_bg_to_tex1_ex(output_t *output, effects_output_t *ctx, b
 		return 0;
 	}
 
-	uint64_t result;
+	uint64_t result = 0;
 	effects_backend->capture_readback(cap_state.buffer, &ctx->be_state,
-		ctx->be_state.pong.native_handle[0], ctx->blur_w, ctx->blur_h, ctx->blur_w, ctx->blur_h, &result);
+		ctx->be_state.pong.native_handle[0], region.x, region.y, region.width, region.height, region.x,
+		region.y, region.width, region.height, &result);
 	wlr_output_state_finish(&cap_state);
 
+	if (result)
+		ctx->shared_bg_valid = !mica_only && hide_blur_toplevels;
+
 	return result;
 }
 
@@ -1462,12 +1510,15 @@ static bool rebuild_corner_masks(output_t *output, uint64_t bg_tex) {
 			}
 
 			effects_backend->capture_readback(cap_state.buffer, &ctx->be_state,
-				ctx->be_state.pong.native_handle[0], ctx->blur_w, ctx->blur_h, cw, ch, &src);
+				ctx->be_state.pong.native_handle[0], 0, 0, ctx->blur_w, ctx->blur_h, 0, 0, cw, ch, &src);
 			wlr_output_state_finish(&cap_state);
 			if (!src) {
 				tl->rounded->corner_mask_dirty = false;
 				continue;
 			}
+			// this capture overwrites pong with the corner-mask backdrop
+			// (blur output nodes hidden), so the shared backdrop is stale
+			ctx->shared_bg_valid = false;
 		}
 
 		if (!ensure_output_buf(&tl->rounded->corner_mask_buf, tl->rounded->corner_mask_native, w, h)) {
@@ -1587,8 +1638,8 @@ static uint64_t capture_full_scene_to_tex(output_t *output, effects_output_t *ct
 	}
 
 	uint64_t result;
-	effects_backend->capture_readback(ctx->capture_state.buffer, &ctx->be_state, screen_fbo, w, h, w, h,
-		&result);
+	effects_backend->capture_readback(ctx->capture_state.buffer, &ctx->be_state, screen_fbo, 0, 0, w, h,
+		0, 0, w, h, &result);
 
 	wlr_buffer_unlock(ctx->capture_state.buffer);
 	ctx->capture_state.buffer = NULL;

src/effects_gles2.c

@@ -963,7 +963,8 @@ static bool gles2_apply_screen_shader(uint64_t src_tex, uint64_t dst_fbo, int w,
 }
 
 static bool gles2_capture_readback(struct wlr_buffer *capture_buffer, be_output_state_t *state,
-		uint64_t dst_fbo, int dst_w, int dst_h, int src_w, int src_h, uint64_t *out_tex) {
+		uint64_t dst_fbo, int dst_x, int dst_y, int dst_w, int dst_h, int src_x, int src_y, int src_w,
+		int src_h, uint64_t *out_tex) {
 	GLuint capture_fbo = wlr_gles2_renderer_get_buffer_fbo(g->renderer, capture_buffer);
 	if (!capture_fbo) {
 		wlr_log(WLR_INFO, "gles2: capture_readback: no FBO");
@@ -984,7 +985,7 @@ static bool gles2_capture_readback(struct wlr_buffer *capture_buffer, be_output_
 
 	if (attach_type == GL_TEXTURE && attach_name > 0 && g->prog_ext_blit) {
 		glBindFramebuffer(GL_FRAMEBUFFER, (GLuint)dst_fbo);
-		glViewport(0, 0, dst_w, dst_h);
+		glViewport(dst_x, dst_y, dst_w, dst_h);
 		glActiveTexture(GL_TEXTURE0);
 		glBindTexture(GL_TEXTURE_EXTERNAL_OES, (GLuint)attach_name);
 		glUseProgram(g->prog_ext_blit);
@@ -996,7 +997,7 @@ static bool gles2_capture_readback(struct wlr_buffer *capture_buffer, be_output_
 			result_tex = (GLuint)state->screen_shader.native_handle[1];
 	} else if (attach_type == GL_TEXTURE && attach_name > 0) {
 		glBindFramebuffer(GL_FRAMEBUFFER, (GLuint)dst_fbo);
-		glViewport(0, 0, dst_w, dst_h);
+		glViewport(dst_x, dst_y, dst_w, dst_h);
 		glActiveTexture(GL_TEXTURE0);
 		glBindTexture(GL_TEXTURE_2D, (GLuint)attach_name);
 		glUseProgram(g->prog_blit);
@@ -1025,11 +1026,11 @@ static bool gles2_capture_readback(struct wlr_buffer *capture_buffer, be_output_
 
 		glBindFramebuffer(GL_FRAMEBUFFER, capture_fbo);
 		glBindTexture(GL_TEXTURE_2D, staging_tex);
-		glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, src_w, src_h);
+		glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, src_x, src_y, src_w, src_h);
 		glBindFramebuffer(GL_FRAMEBUFFER, 0);
 
 		glBindFramebuffer(GL_FRAMEBUFFER, (GLuint)dst_fbo);
-		glViewport(0, 0, dst_w, dst_h);
+		glViewport(dst_x, dst_y, dst_w, dst_h);
 		glActiveTexture(GL_TEXTURE0);
 		glBindTexture(GL_TEXTURE_2D, staging_tex);
 		glUseProgram(g->prog_blit);

src/effects_vk.c

@@ -2071,7 +2071,8 @@ static bool vk_apply_screen_shader(uint64_t src_tex, uint64_t dst_fbo, int w, in
 }
 
 static bool vk_capture_readback(struct wlr_buffer *capture_buffer, be_output_state_t *state,
-		uint64_t dst_fbo, int dst_w, int dst_h, int src_w, int src_h, uint64_t *out_tex) {
+		uint64_t dst_fbo, int dst_x, int dst_y, int dst_w, int dst_h, int src_x, int src_y, int src_w,
+		int src_h, uint64_t *out_tex) {
 	vk->frame_dirty = true;
 	vk_ensure_cb_begun();
 	(void)src_w;
@@ -2130,13 +2131,13 @@ static bool vk_capture_readback(struct wlr_buffer *capture_buffer, be_output_sta
 	VkImageBlit region = {
 		.srcSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1},
 		.srcOffsets = {
-			{0, 0, 0},
-			{capture_w, capture_h, 1}
+			{src_x, src_y, 0},
+			{src_x + capture_w, src_y + capture_h, 1}
 		},
 		.dstSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1},
 		.dstOffsets = {
-			{0, 0, 0},
-			{dst_w, dst_h, 1}
+			{dst_x, dst_y, 0},
+			{dst_x + dst_w, dst_y + dst_h, 1}
 		},
 	};
 	vkCmdBlitImage(vk->frame_cb, vk_attribs.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dst->img.image,