Merge pull request #1518 from anthonyde/blur-noise

Add noise to blur shaders

Author: yshui

include/picom/backend.h

@@ -54,21 +54,30 @@ enum shader_attributes {
 	SHADER_ATTRIBUTE_ANIMATED = 1,
 };
 
+struct blur_args {
+	int noise_radius;
+	double noise_scale;
+};
+
 struct gaussian_blur_args {
+	struct blur_args base;
 	int size;
 	double deviation;
 };
 
 struct box_blur_args {
+	struct blur_args base;
 	int size;
 };
 
 struct kernel_blur_args {
+	struct blur_args base;
 	struct conv **kernels;
 	int kernel_count;
 };
 
 struct dual_kawase_blur_args {
+	struct blur_args base;
 	int size;
 	int strength;
 };
@@ -433,7 +442,7 @@ struct backend_operations {
 	/// Create a blur context that can be used to call `blur` for images with a
 	/// specific format.
 	void *(*create_blur_context)(backend_t *base, enum blur_method,
-	                             enum backend_image_format format, void *args);
+	                             enum backend_image_format format, struct blur_args *args);
 	/// Destroy a blur context
 	void (*destroy_blur_context)(backend_t *base, void *ctx);
 	/// Get how many pixels outside of the blur area is needed for blur

man/picom.1.adoc

@@ -178,6 +178,9 @@ OPTIONS
 *--blur-method*, *--blur-size*, *--blur-deviation*, *--blur-strength*::
 	Parameters for background blurring, see the xref:_blur[*BLUR*] section for more information.
 
+*--blur-noise-radius*, *--blur-noise-scale*::
+	Parameters for blur noise. See the xref:_blur[*BLUR*] section for more information.
+
 *--blur-background*::
 	Blur background of semi-transparent / ARGB windows. Bad in performance, with driver-dependent behavior. The name of the switch may change without prior notifications.
 
@@ -917,6 +920,14 @@ Available options of the _blur_ section are: ::
   *kernel*:::
     A string. The kernel to use for the _kernel_ blur method, specified in the same format as the *--blur-kern* option. Corresponds to the *--blur-kern* command line option.
 
+If blur is enabled, noise can be configured with the following options: ::
+
+  *noise-radius*:::
+  An integer. The maximum displacement of background pixels when applying noise. Corresponds to the *--blur-noise-radius* command line option. If set to zero, noise is disabled (default: 0).
+
+  *noise-scale*:::
+  A floating point number. The size of noise features. Corresponds to the *--blur-noise-scale* command line option. If negative or zero, noise is disabled (default: 0.005).
+
 SIGNALS
 -------
 

src/backend/backend_common.c

@@ -252,20 +252,23 @@ generate_gaussian_blur_kernel(struct gaussian_blur_args *args, int *kernel_count
 
 /// Generate blur kernels for gaussian and box blur methods. Generated kernel is not
 /// normalized, and the center element will always be 1.
-struct conv **generate_blur_kernel(enum blur_method method, void *args, int *kernel_count) {
+struct conv **
+generate_blur_kernel(enum blur_method method, struct blur_args *args, int *kernel_count) {
 	switch (method) {
-	case BLUR_METHOD_BOX: return generate_box_blur_kernel(args, kernel_count);
+	case BLUR_METHOD_BOX:
+		return generate_box_blur_kernel((struct box_blur_args *)args, kernel_count);
 	case BLUR_METHOD_GAUSSIAN:
-		return generate_gaussian_blur_kernel(args, kernel_count);
+		return generate_gaussian_blur_kernel((struct gaussian_blur_args *)args,
+		                                     kernel_count);
 	default: break;
 	}
 	return NULL;
 }
 
 /// Generate kernel parameters for dual-kawase blur method. Falls back on approximating
 /// standard gauss radius if strength is zero or below.
-struct dual_kawase_params *generate_dual_kawase_params(void *args) {
-	struct dual_kawase_blur_args *blur_args = args;
+struct dual_kawase_params *generate_dual_kawase_params(struct blur_args *args) {
+	auto blur_args = (struct dual_kawase_blur_args *)args;
 	static const struct {
 		int iterations;        /// Number of down- and upsample iterations
 		float offset;          /// Sample offset in half-pixels

src/backend/backend_common.h

@@ -15,6 +15,7 @@ struct conv;
 struct backend_base;
 struct backend_operations;
 struct x_connection;
+struct blur_args;
 
 struct dual_kawase_params {
 	/// Number of downsample passes
@@ -33,7 +34,8 @@ solid_picture(struct x_connection *, bool argb, double a, double r, double g, do
 
 void init_backend_base(struct backend_base *base, session_t *ps);
 
-struct conv **generate_blur_kernel(enum blur_method method, void *args, int *kernel_count);
-struct dual_kawase_params *generate_dual_kawase_params(void *args);
+struct conv **
+generate_blur_kernel(enum blur_method method, struct blur_args *args, int *kernel_count);
+struct dual_kawase_params *generate_dual_kawase_params(struct blur_args *args);
 
 uint32_t backend_no_quirks(struct backend_base *base attr_unused);

src/backend/dummy/dummy.c

@@ -179,7 +179,7 @@ image_handle dummy_back_buffer(struct backend_base *base) {
 void *dummy_create_blur_context(struct backend_base *base attr_unused,
                                 enum blur_method method attr_unused,
                                 enum backend_image_format format attr_unused,
-                                void *args attr_unused) {
+                                struct blur_args *args attr_unused) {
 	static int dummy_context;
 	return &dummy_context;
 }

src/backend/gl/blur.c

@@ -37,6 +37,9 @@ struct gl_blur_context {
 	/// How much do we need to resize the damaged region for blurring.
 	int resize_width, resize_height;
 
+	int noise_radius;
+	float noise_scale;
+
 	int npasses;
 
 	enum backend_image_format format;
@@ -82,12 +85,8 @@ gl_kernel_blur(double opacity, struct gl_blur_context *bctx,
 		glBindTexture(GL_TEXTURE_2D, src_texture);
 		glBindSampler(0, blur_sampler);
 		glUseProgram(p->prog);
-		if (p->uniform_bitmask & (1 << UNIFORM_PIXEL_NORM_LOC)) {
-			// If the last pass is a trivial blend pass, it will not have
-			// pixel_norm.
-			glUniform2f(UNIFORM_PIXEL_NORM_LOC, 1.0F / (GLfloat)tex_width,
-			            1.0F / (GLfloat)tex_height);
-		}
+		glUniform2f(UNIFORM_PIXEL_NORM_LOC, 1.0F / (GLfloat)tex_width,
+		            1.0F / (GLfloat)tex_height);
 
 		glActiveTexture(GL_TEXTURE1);
 		glBindTexture(GL_TEXTURE_2D, default_mask);
@@ -118,6 +117,8 @@ gl_kernel_blur(double opacity, struct gl_blur_context *bctx,
 			}
 
 			glUniform1f(UNIFORM_OPACITY_LOC, 1.0F);
+			glUniform1i(UNIFORM_BLUR_NOISE_RADIUS_LOC, 0);
+			glUniform1f(UNIFORM_BLUR_NOISE_SCALE_LOC, 0.0F);
 		} else {
 			// last pass, draw directly into the back buffer, with origin
 			// regions. And apply mask if requested
@@ -139,6 +140,8 @@ gl_kernel_blur(double opacity, struct gl_blur_context *bctx,
 			glBindFramebuffer(GL_FRAMEBUFFER, target_fbo);
 
 			glUniform1f(UNIFORM_OPACITY_LOC, (float)opacity);
+			glUniform1i(UNIFORM_BLUR_NOISE_RADIUS_LOC, bctx->noise_radius);
+			glUniform1f(UNIFORM_BLUR_NOISE_SCALE_LOC, bctx->noise_scale);
 			glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 		}
 
@@ -224,6 +227,8 @@ bool gl_dual_kawase_blur(double opacity, struct gl_blur_context *bctx,
 	glUniform1f(UNIFORM_MASK_CORNER_RADIUS_LOC, 0.0F);
 	glUniform2f(UNIFORM_MASK_SCALE_LOC, 1.0F, 1.0F);
 	glUniform1f(UNIFORM_OPACITY_LOC, 1.0F);
+	glUniform1i(UNIFORM_BLUR_NOISE_RADIUS_LOC, 0);
+	glUniform1f(UNIFORM_BLUR_NOISE_SCALE_LOC, 0.0F);
 
 	for (int i = iterations - 1; i >= 0; --i) {
 		// Scale output width / height back by two in each iteration
@@ -267,6 +272,8 @@ bool gl_dual_kawase_blur(double opacity, struct gl_blur_context *bctx,
 			glBindFramebuffer(GL_DRAW_FRAMEBUFFER, target_fbo);
 
 			glUniform1f(UNIFORM_OPACITY_LOC, (GLfloat)opacity);
+			glUniform1i(UNIFORM_BLUR_NOISE_RADIUS_LOC, bctx->noise_radius);
+			glUniform1f(UNIFORM_BLUR_NOISE_SCALE_LOC, bctx->noise_scale);
 			glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 		}
 
@@ -534,18 +541,22 @@ bool gl_create_kernel_blur_context(void *blur_context, GLfloat *projection,
 
 	// clang-format off
 	static const char *FRAG_SHADER_BLUR = GLSL(330,
-		%s\n // other extension pragmas
 		layout(location = UNIFORM_TEX_SRC_LOC)
 		uniform sampler2D tex_src;
 		layout(location = UNIFORM_PIXEL_NORM_LOC)
 		uniform vec2 pixel_norm;
 		layout(location = UNIFORM_OPACITY_LOC)
 		uniform float opacity;
+		layout(location = UNIFORM_BLUR_NOISE_RADIUS_LOC)
+		uniform int noise_radius;
+		layout(location = UNIFORM_BLUR_NOISE_SCALE_LOC)
+		uniform float noise_scale;
 		in vec2 texcoord;
 		out vec4 out_color;
 		float mask_factor();
+		vec2 perturb(vec2, float, float);
 		void main() {
-			vec2 uv = texcoord * pixel_norm;
+			vec2 uv = perturb(texcoord, noise_radius, noise_scale) * pixel_norm;
 			vec4 sum = vec4(0.0, 0.0, 0.0, 0.0);
 			%s //body of the convolution
 			out_color = sum / float(%.7g) * opacity * mask_factor();
@@ -557,7 +568,6 @@ bool gl_create_kernel_blur_context(void *blur_context, GLfloat *projection,
 	// clang-format on
 
 	const char *shader_add = FRAG_SHADER_BLUR_ADD;
-	char *extension = strdup("");
 
 	for (int i = 0; i < nkernels; i++) {
 		auto kern = kernels[i];
@@ -628,27 +638,25 @@ bool gl_create_kernel_blur_context(void *blur_context, GLfloat *projection,
 		}
 
 		auto pass = ctx->blur_shader + i;
-		size_t shader_len = strlen(FRAG_SHADER_BLUR) + strlen(extension) +
-		                    strlen(shader_body) + 10 /* sum */ +
-		                    1 /* null terminator */;
+		size_t shader_len = strlen(FRAG_SHADER_BLUR) + strlen(shader_body) +
+		                    10 /* sum */ + 1 /* null terminator */;
 		char *shader_str = ccalloc(shader_len, char);
-		auto real_shader_len = snprintf(shader_str, shader_len, FRAG_SHADER_BLUR,
-		                                extension, shader_body, sum);
+		auto real_shader_len =
+		    snprintf(shader_str, shader_len, FRAG_SHADER_BLUR, shader_body, sum);
 		CHECK(real_shader_len >= 0);
 		CHECK((size_t)real_shader_len < shader_len);
 		free(shader_body);
 
 		// Build program
 		pass->prog = gl_create_program_from_strv(
 		    (const char *[]){vertex_shader, NULL},
-		    (const char *[]){shader_str, scaled_masking_glsl, NULL});
+		    (const char *[]){shader_str, scaled_masking_glsl, perturb_glsl, NULL});
 		free(shader_str);
 		if (!pass->prog) {
 			log_error("Failed to create GLSL program.");
 			success = false;
 			goto out;
 		}
-		pass->uniform_bitmask = 1 << UNIFORM_PIXEL_NORM_LOC;
 		glBindFragDataLocation(pass->prog, 0, "out_color");
 
 		// Setup projection matrix
@@ -666,7 +674,8 @@ bool gl_create_kernel_blur_context(void *blur_context, GLfloat *projection,
 		auto pass = &ctx->blur_shader[1];
 		pass->prog = gl_create_program_from_strv(
 		    (const char *[]){vertex_shader, NULL},
-		    (const char *[]){blend_with_mask_frag, scaled_masking_glsl, NULL});
+		    (const char *[]){blend_with_mask_frag, scaled_masking_glsl,
+		                     perturb_glsl, NULL});
 
 		// Setup projection matrix
 		glUseProgram(pass->prog);
@@ -688,7 +697,6 @@ bool gl_create_kernel_blur_context(void *blur_context, GLfloat *projection,
 		free(kernels);
 	}
 
-	free(extension);
 	// Restore LC_NUMERIC
 	setlocale(LC_NUMERIC, lc_numeric_old);
 	free(lc_numeric_old);
@@ -784,12 +792,17 @@ bool gl_create_dual_kawase_blur_context(void *blur_context, GLfloat *projection,
 			uniform vec2 pixel_norm;
 			layout(location = UNIFORM_OPACITY_LOC)
 			uniform float opacity;
+			layout(location = UNIFORM_BLUR_NOISE_RADIUS_LOC)
+			uniform int noise_radius;
+			layout(location = UNIFORM_BLUR_NOISE_SCALE_LOC)
+			uniform float noise_scale;
 			in vec2 texcoord;
 			out vec4 out_color;
 			float mask_factor();
+			vec2 perturb(vec2, float, float);
 			void main() {
 				vec2 offset = %.7g * pixel_norm;
-				vec2 uv = texcoord * pixel_norm / (2 * scale);
+				vec2 uv = perturb(texcoord, noise_radius, noise_scale) * pixel_norm / (2 * scale);
 				vec4 sum = texture2D(tex_src, uv + vec2(-1.0, 0.0) * offset);
 				sum += texture2D(tex_src, uv + vec2(-0.5, 0.5) * offset) * 2.0;
 				sum += texture2D(tex_src, uv + vec2(0.0, 1.0) * offset);
@@ -815,7 +828,7 @@ bool gl_create_dual_kawase_blur_context(void *blur_context, GLfloat *projection,
 		// Build program
 		up_pass->prog = gl_create_program_from_strv(
 		    (const char *[]){vertex_shader, NULL},
-		    (const char *[]){shader_str, scaled_masking_glsl, NULL});
+		    (const char *[]){shader_str, scaled_masking_glsl, perturb_glsl, NULL});
 		free(shader_str);
 		if (!up_pass->prog) {
 			log_error("Failed to create GLSL program.");
@@ -834,10 +847,6 @@ bool gl_create_dual_kawase_blur_context(void *blur_context, GLfloat *projection,
 out:
 	free(blur_params);
 
-	if (!success) {
-		ctx = NULL;
-	}
-
 	// Restore LC_NUMERIC
 	setlocale(LC_NUMERIC, lc_numeric_old);
 	free(lc_numeric_old);
@@ -846,7 +855,7 @@ bool gl_create_dual_kawase_blur_context(void *blur_context, GLfloat *projection,
 }
 
 void *gl_create_blur_context(backend_t *base, enum blur_method method,
-                             enum backend_image_format format, void *args) {
+                             enum backend_image_format format, struct blur_args *args) {
 	bool success;
 	auto gd = (struct gl_data *)base;
 
@@ -878,6 +887,12 @@ void *gl_create_blur_context(backend_t *base, enum blur_method method,
 		goto out;
 	}
 
+	ctx->noise_radius = args->noise_radius;
+	ctx->noise_scale = (float)args->noise_scale;
+	// Expand the blur region to account for noise samples
+	ctx->resize_width = max2(ctx->resize_width, ctx->noise_radius);
+	ctx->resize_height = max2(ctx->resize_height, ctx->noise_radius);
+
 	// Texture size will be defined by gl_blur
 	ctx->blur_textures = ccalloc(ctx->blur_texture_count, GLuint);
 	ctx->texture_sizes = ccalloc(ctx->blur_texture_count, struct texture_size);

src/backend/gl/gl_common.h

@@ -40,7 +40,9 @@ struct gl_blur_context;
 // Added in backend API 2.0
 #define UNIFORM_TINT_LOC 22
 #define UNIFORM_MASK_SCALE_LOC 23
-#define NUMBER_OF_UNIFORMS (UNIFORM_TINT_LOC + 1)
+#define UNIFORM_BLUR_NOISE_RADIUS_LOC 24
+#define UNIFORM_BLUR_NOISE_SCALE_LOC 25
+#define NUMBER_OF_UNIFORMS (UNIFORM_BLUR_NOISE_SCALE_LOC + 1)
 
 struct gl_shader {
 	GLuint prog;
@@ -173,7 +175,7 @@ image_handle gl_back_buffer(struct backend_base *base);
 uint32_t gl_image_capabilities(backend_t *base, image_handle img);
 bool gl_is_format_supported(backend_t *base, enum backend_image_format format);
 void *gl_create_blur_context(backend_t *base, enum blur_method,
-                             enum backend_image_format format, void *args);
+                             enum backend_image_format format, struct blur_args *args);
 void gl_destroy_blur_context(backend_t *base, void *ctx);
 void gl_get_blur_size(void *blur_context, int *width, int *height);
 
@@ -311,4 +313,4 @@ static const GLuint vert_in_texcoord_loc = 1;
 extern const char vertex_shader[], blend_with_mask_frag[], masking_glsl[],
     scaled_masking_glsl[], copy_area_frag[], copy_area_with_dither_frag[], fill_frag[],
     fill_vert[], interpolating_frag[], interpolating_vert[], blit_shader_glsl[],
-    blit_shader_default[], present_vertex_shader[], dither_glsl[];
+    blit_shader_default[], present_vertex_shader[], dither_glsl[], perturb_glsl[];