compositor/main.c

@@ -3493,6 +3493,7 @@ out_display:
 	free(socket_name);
 	free(option_modules);
 	free(log);
+	free(log_scopes);
 	free(modules);
 
 	return ret;

ivi-shell/ivi-shell.c

@@ -346,6 +346,8 @@ shell_destroy(struct wl_listener *listener, void *data)
 	wl_list_remove(&shell->destroy_listener.link);
 	wl_list_remove(&shell->wake_listener.link);
 
+	weston_desktop_destroy(shell->desktop);
+
 	wl_list_for_each_safe(ivisurf, next, &shell->ivi_surface_list, link) {
 		if (ivisurf->layout_surface != NULL)
 			layout_surface_cleanup(ivisurf);

libweston/backend-drm/drm.c

@@ -2515,9 +2515,9 @@ drm_destroy(struct weston_compositor *ec)
 	udev_monitor_unref(b->udev_monitor);
 	udev_unref(b->udev);
 
+	weston_launcher_close(ec->launcher, b->drm.fd);
 	weston_launcher_destroy(ec->launcher);
 
-	close(b->drm.fd);
 	free(b->drm.filename);
 	free(b);
 }

libweston/color-lcms/color-lcms.c

 /*
  * Copyright 2021 Collabora, Ltd.
+ * Copyright 2021 Advanced Micro Devices, Inc.
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files (the
@@ -25,8 +26,7 @@
 
 #include "config.h"
 
-#include <lcms2.h>
-
+#include <assert.h>
 #include <libweston/libweston.h>
 
 #include "color.h"
@@ -36,6 +36,9 @@
 static void
 cmlcms_destroy_color_transform(struct weston_color_transform *xform_base)
 {
+	struct cmlcms_color_transform *xform = get_xform(xform_base);
+
+	cmlcms_color_transform_destroy(xform);
 }
 
 static bool
@@ -44,8 +47,21 @@ cmlcms_get_surface_color_transform(struct weston_color_manager *cm_base,
 				   struct weston_output *output,
 				   struct weston_surface_color_transform *surf_xform)
 {
-	/* Identity transform */
-	surf_xform->transform = NULL;
+	struct weston_color_manager_lcms *cm = get_cmlcms(cm_base);
+	struct cmlcms_color_transform_search_param param = {
+		/*
+		 * Assumes both content and output color spaces are sRGB SDR.
+		 * This defines the blending space as optical sRGB SDR.
+		 */
+		.type = CMLCMS_TYPE_EOTF_sRGB,
+	};
+	struct cmlcms_color_transform *xform;
+
+	xform = cmlcms_color_transform_get(cm, &param);
+	if (!xform)
+		return false;
+
+	surf_xform->transform = &xform->base;
 	surf_xform->identity_pipeline = true;
 
 	return true;
@@ -56,9 +72,21 @@ cmlcms_get_output_color_transform(struct weston_color_manager *cm_base,
 				  struct weston_output *output,
 				  struct weston_color_transform **xform_out)
 {
-	/* Identity transform */
-	*xform_out = NULL;
+	struct weston_color_manager_lcms *cm = get_cmlcms(cm_base);
+	struct cmlcms_color_transform_search_param param = {
+		/*
+		 * Assumes blending space is optical sRGB SDR and
+		 * output color space is sRGB SDR.
+		 */
+		.type = CMLCMS_TYPE_EOTF_sRGB_INV,
+	};
+	struct cmlcms_color_transform *xform;
+
+	xform = cmlcms_color_transform_get(cm, &param);
+	if (!xform)
+		return false;
 
+	*xform_out = &xform->base;
 	return true;
 }
 
@@ -67,6 +95,7 @@ cmlcms_get_sRGB_to_output_color_transform(struct weston_color_manager *cm_base,
 					  struct weston_output *output,
 					  struct weston_color_transform **xform_out)
 {
+	/* Assumes output color space is sRGB SDR */
 	/* Identity transform */
 	*xform_out = NULL;
 
@@ -78,29 +107,61 @@ cmlcms_get_sRGB_to_blend_color_transform(struct weston_color_manager *cm_base,
 					 struct weston_output *output,
 					 struct weston_color_transform **xform_out)
 {
-	/* Identity transform */
-	*xform_out = NULL;
+	struct weston_color_manager_lcms *cm = get_cmlcms(cm_base);
+	struct cmlcms_color_transform_search_param param = {
+		/* Assumes blending space is optical sRGB SDR */
+		.type = CMLCMS_TYPE_EOTF_sRGB,
+	};
+	struct cmlcms_color_transform *xform;
+
+	xform = cmlcms_color_transform_get(cm, &param);
+	if (!xform)
+		return false;
 
+	*xform_out = &xform->base;
 	return true;
 }
 
+static void
+lcms_error_logger(cmsContext context_id,
+		  cmsUInt32Number error_code,
+		  const char *text)
+{
+	weston_log("LittleCMS error: %s\n", text);
+}
+
 static bool
 cmlcms_init(struct weston_color_manager *cm_base)
 {
-	if (!(cm_base->compositor->capabilities & WESTON_CAP_COLOR_OPS)) {
+	struct weston_color_manager_lcms *cm = get_cmlcms(cm_base);
+
+	if (!(cm->base.compositor->capabilities & WESTON_CAP_COLOR_OPS)) {
 		weston_log("color-lcms: error: color operations capability missing. Is GL-renderer not in use?\n");
 		return false;
 	}
 
+	cm->lcms_ctx = cmsCreateContext(NULL, cm);
+	if (!cm->lcms_ctx) {
+		weston_log("color-lcms error: creating LittCMS context failed.\n");
+		return false;
+	}
+
+	cmsSetLogErrorHandlerTHR(cm->lcms_ctx, lcms_error_logger);
+
+	weston_log("LittleCMS %d initialized.\n", cmsGetEncodedCMMversion());
+
 	return true;
 }
 
 static void
 cmlcms_destroy(struct weston_color_manager *cm_base)
 {
-	struct weston_color_manager_lcms *cmlcms = get_cmlcms(cm_base);
+	struct weston_color_manager_lcms *cm = get_cmlcms(cm_base);
 
-	free(cmlcms);
+	assert(wl_list_empty(&cm->color_transform_list));
+
+	cmsDeleteContext(cm->lcms_ctx);
+	free(cm);
 }
 
 WL_EXPORT struct weston_color_manager *
@@ -126,5 +187,7 @@ weston_color_manager_create(struct weston_compositor *compositor)
 	cm->base.get_sRGB_to_blend_color_transform =
 	      cmlcms_get_sRGB_to_blend_color_transform;
 
+	wl_list_init(&cm->color_transform_list);
+
 	return &cm->base;
 }

libweston/color-lcms/color-lcms.h

 /*
  * Copyright 2021 Collabora, Ltd.
+ * Copyright 2021 Advanced Micro Devices, Inc.
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files (the
@@ -26,6 +27,7 @@
 #ifndef WESTON_COLOR_LCMS_H
 #define WESTON_COLOR_LCMS_H
 
+#include <lcms2.h>
 #include <libweston/libweston.h>
 
 #include "color.h"
@@ -33,6 +35,9 @@
 
 struct weston_color_manager_lcms {
 	struct weston_color_manager base;
+	cmsContext lcms_ctx;
+
+	struct wl_list color_transform_list; /* cmlcms_color_transform::link */
 };
 
 static inline struct weston_color_manager_lcms *
@@ -41,4 +46,43 @@ get_cmlcms(struct weston_color_manager *cm_base)
 	return container_of(cm_base, struct weston_color_manager_lcms, base);
 }
 
+/*
+ * Perhaps a placeholder, until we get actual color spaces involved and
+ * see how this would work better.
+ */
+enum cmlcms_color_transform_type {
+	CMLCMS_TYPE_EOTF_sRGB = 0,
+	CMLCMS_TYPE_EOTF_sRGB_INV,
+	CMLCMS_TYPE__END,
+};
+
+struct cmlcms_color_transform_search_param {
+	enum cmlcms_color_transform_type type;
+};
+
+struct cmlcms_color_transform {
+	struct weston_color_transform base;
+
+	/* weston_color_manager_lcms::color_transform_list */
+	struct wl_list link;
+
+	struct cmlcms_color_transform_search_param search_key;
+
+	/* for EOTF types */
+	cmsToneCurve *curve;
+};
+
+static inline struct cmlcms_color_transform *
+get_xform(struct weston_color_transform *xform_base)
+{
+	return container_of(xform_base, struct cmlcms_color_transform, base);
+}
+
+struct cmlcms_color_transform *
+cmlcms_color_transform_get(struct weston_color_manager_lcms *cm,
+			   const struct cmlcms_color_transform_search_param *param);
+
+void
+cmlcms_color_transform_destroy(struct cmlcms_color_transform *xform);
+
 #endif /* WESTON_COLOR_LCMS_H */

libweston/color-lcms/color-transform.c

+/*
+ * Copyright 2021 Collabora, Ltd.
+ * Copyright 2021 Advanced Micro Devices, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "config.h"
+
+#include <assert.h>
+#include <libweston/libweston.h>
+
+#include "color.h"
+#include "color-lcms.h"
+#include "shared/helpers.h"
+
+/* Arguments to cmsBuildParametricToneCurve() */
+struct tone_curve_def {
+	cmsInt32Number cmstype;
+	cmsFloat64Number params[5];
+};
+
+/*
+ * LCMS uses the required number of 'params' based on 'cmstype', the parametric
+ * tone curve number. LCMS honors negative 'cmstype' as inverse function.
+ * These are LCMS built-in parametric tone curves.
+ */
+static const struct tone_curve_def predefined_eotf_curves[] = {
+	[CMLCMS_TYPE_EOTF_sRGB] = {
+		.cmstype = 4,
+		.params = { 2.4, 1. / 1.055, 0.055 / 1.055, 1. / 12.92, 0.04045 },
+	},
+	[CMLCMS_TYPE_EOTF_sRGB_INV] = {
+		.cmstype = -4,
+		.params = { 2.4, 1. / 1.055, 0.055 / 1.055, 1. / 12.92, 0.04045 },
+	},
+};
+
+static void
+cmlcms_fill_in_tone_curve(struct weston_color_transform *xform_base,
+			  float *values, unsigned len)
+{
+	struct cmlcms_color_transform *xform = get_xform(xform_base);
+	float *R_lut = values;
+	float *G_lut = R_lut + len;
+	float *B_lut = G_lut + len;
+	unsigned i;
+	cmsFloat32Number x, y;
+
+	assert(xform->curve != NULL);
+	assert(len > 1);
+
+	for (i = 0; i < len; i++) {
+		x = (double)i / (len - 1);
+		y = cmsEvalToneCurveFloat(xform->curve, x);
+		R_lut[i] = y;
+		G_lut[i] = y;
+		B_lut[i] = y;
+	}
+}
+
+void
+cmlcms_color_transform_destroy(struct cmlcms_color_transform *xform)
+{
+	wl_list_remove(&xform->link);
+	if (xform->curve)
+		cmsFreeToneCurve(xform->curve);
+	free(xform);
+}
+
+static struct cmlcms_color_transform *
+cmlcms_color_transform_create(struct weston_color_manager_lcms *cm,
+			const struct cmlcms_color_transform_search_param *param)
+{
+	struct cmlcms_color_transform *xform;
+	const struct tone_curve_def *tonedef;
+
+	if (param->type < 0 || param->type >= CMLCMS_TYPE__END) {
+		weston_log("color-lcms error: bad color transform type in %s.\n",
+			   __func__);
+		return NULL;
+	}
+	tonedef = &predefined_eotf_curves[param->type];
+
+	xform = zalloc(sizeof *xform);
+	if (!xform)
+		return NULL;
+
+	xform->curve = cmsBuildParametricToneCurve(cm->lcms_ctx,
+						   tonedef->cmstype,
+						   tonedef->params);
+	if (xform->curve == NULL) {
+		weston_log("color-lcms error: failed to build parametric tone curve.\n");
+		free(xform);
+		return NULL;
+	}
+
+	weston_color_transform_init(&xform->base, &cm->base);
+	xform->search_key = *param;
+
+	xform->base.pre_curve.type = WESTON_COLOR_CURVE_TYPE_LUT_3x1D;
+	xform->base.pre_curve.u.lut_3x1d.fill_in = cmlcms_fill_in_tone_curve;
+	xform->base.pre_curve.u.lut_3x1d.optimal_len = 256;
+
+	wl_list_insert(&cm->color_transform_list, &xform->link);
+
+	return xform;
+}
+
+static bool
+transform_matches_params(const struct cmlcms_color_transform *xform,
+			 const struct cmlcms_color_transform_search_param *param)
+{
+	if (xform->search_key.type != param->type)
+		return false;
+
+	return true;
+}
+
+struct cmlcms_color_transform *
+cmlcms_color_transform_get(struct weston_color_manager_lcms *cm,
+			   const struct cmlcms_color_transform_search_param *param)
+{
+	struct cmlcms_color_transform *xform;
+
+	wl_list_for_each(xform, &cm->color_transform_list, link) {
+		if (transform_matches_params(xform, param)) {
+			weston_color_transform_ref(&xform->base);
+			return xform;
+		}
+	}
+
+	xform = cmlcms_color_transform_create(cm, param);
+	if (!xform)
+		weston_log("color-lcms error: failed to create a color transformation.\n");
+
+	return xform;
+}

libweston/color-lcms/meson.build

@@ -9,6 +9,7 @@ endif
 
 srcs_color_lcms = [
 	'color-lcms.c',
+	'color-transform.c',
 ]
 
 deps_color_lcms = [

libweston/color.h

@@ -40,7 +40,28 @@ enum weston_color_curve_type {
 
 /** LUT_3x1D parameters */
 struct weston_color_curve_lut_3x1d {
-	/* To be defined */
+	/**
+	 * Approximate a color curve with three 1D LUTs
+	 *
+	 * A 1D LUT is a mapping from [0.0, 1.0] to arbitrary values. The first
+	 * element in the LUT corresponds to input value 0.0, and the last
+	 * element corresponds to input value 1.0. The step from one element
+	 * to the next in input space is 1.0 / (len - 1). When input value is
+	 * between two elements, linear interpolation should be used.
+	 *
+	 * This function fills in the given array with the LUT values.
+	 *
+	 * \param xform This color transformation object.
+	 * \param len The number of elements in each 1D LUT.
+	 * \param values Array of 3 x len elements. First R channel
+	 * LUT, immediately followed by G channel LUT, and then B channel LUT.
+	 */
+	void
+	(*fill_in)(struct weston_color_transform *xform,
+		   float *values, unsigned len);
+
+	/** Optimal 1D LUT length for storage vs. precision */
+	unsigned optimal_len;
 };
 
 /**

libweston/drm-formats.c

@@ -440,6 +440,7 @@ weston_drm_format_array_subtract(struct weston_drm_format_array *formats_A,
 	if (ret < 0)
 		goto err;
 
+	weston_drm_format_array_destroy(formats_result);
 	return 0;
 
 err:

libweston/renderer-gl/fragment.glsl

@@ -42,18 +42,30 @@
 #define SHADER_VARIANT_SOLID    7
 #define SHADER_VARIANT_EXTERNAL 8
 
+/* enum gl_shader_color_curve */
+#define SHADER_COLOR_CURVE_IDENTITY 0
+#define SHADER_COLOR_CURVE_LUT_3x1D 1
+
 #if DEF_VARIANT == SHADER_VARIANT_EXTERNAL
 #extension GL_OES_EGL_image_external : require
 #endif
 
-precision mediump float;
+#ifdef GL_FRAGMENT_PRECISION_HIGH
+#define HIGHPRECISION highp
+#else
+#define HIGHPRECISION mediump
+#endif
+
+precision HIGHPRECISION float;
 
 /*
  * These undeclared identifiers will be #defined by a runtime generated code
  * snippet.
  */
 compile_const int c_variant = DEF_VARIANT;
+compile_const bool c_input_is_premult = DEF_INPUT_IS_PREMULT;
 compile_const bool c_green_tint = DEF_GREEN_TINT;
+compile_const int c_color_pre_curve = DEF_COLOR_PRE_CURVE;
 
 vec4
 yuva2rgba(vec4 yuva)
@@ -79,7 +91,6 @@ yuva2rgba(vec4 yuva)
 	color_out.g = Y - 0.39176229 * su - 0.81296764 * sv;
 	color_out.b = Y + 2.01723214 * su;
 
-	color_out.rgb *= yuva.w;
 	color_out.a = yuva.w;
 
 	return color_out;
@@ -96,6 +107,8 @@ uniform sampler2D tex1;
 uniform sampler2D tex2;
 uniform float alpha;
 uniform vec4 unicolor;
+uniform HIGHPRECISION sampler2D color_pre_curve_lut_2d;
+uniform HIGHPRECISION vec2 color_pre_curve_lut_scale_offset;
 
 vec4
 sample_input_texture()
@@ -141,16 +154,82 @@ sample_input_texture()
 	return yuva2rgba(yuva);
 }
 
+/*
+ * Texture coordinates go from 0.0 to 1.0 corresponding to texture edges.
+ * When we do LUT look-ups with linear filtering, the correct range to sample
+ * from is not from edge to edge, but center of first texel to center of last
+ * texel. This follows because with LUTs, you have the exact end points given,
+ * you never extrapolate but only interpolate.
+ * The scale and offset are precomputed to achieve this mapping.
+ */
+float
+lut_texcoord(float x, vec2 scale_offset)
+{
+	return x * scale_offset.s + scale_offset.t;
+}
+
+/*
+ * Sample a 1D LUT which is a single row of a 2D texture. The 2D texture has
+ * four rows so that the centers of texels have precise y-coordinates.
+ */
+float
+sample_color_pre_curve_lut_2d(float x, compile_const int row)
+{
+	float tx = lut_texcoord(x, color_pre_curve_lut_scale_offset);
+
+	return texture2D(color_pre_curve_lut_2d,
+			 vec2(tx, (float(row) + 0.5) / 4.0)).x;
+}
+
+vec3
+color_pre_curve(vec3 color)
+{
+	vec3 ret;
+
+	if (c_color_pre_curve == SHADER_COLOR_CURVE_IDENTITY) {
+		return color;
+	} else if (c_color_pre_curve == SHADER_COLOR_CURVE_LUT_3x1D) {
+		ret.r = sample_color_pre_curve_lut_2d(color.r, 0);
+		ret.g = sample_color_pre_curve_lut_2d(color.g, 1);
+		ret.b = sample_color_pre_curve_lut_2d(color.b, 2);
+		return ret;
+	} else {
+		/* Never reached, bad c_color_pre_curve. */
+		return vec3(1.0, 0.3, 1.0);
+	}
+}
+
+vec4
+color_pipeline(vec4 color)
+{
+	/* View alpha (opacity) */
+	color.a *= alpha;
+
+	color.rgb = color_pre_curve(color.rgb);
+
+	return color;
+}
+
 void
 main()
 {
 	vec4 color;
 
-	/* Electrical (non-linear) RGBA values, pre-multiplied */
+	/* Electrical (non-linear) RGBA values, may be premult or not */
 	color = sample_input_texture();
 
-	/* View alpha (opacity) */
-	color *= alpha;
+	/* Ensure straight alpha */
+	if (c_input_is_premult) {
+		if (color.a == 0.0)
+			color.rgb = vec3(0, 0, 0);
+		else
+			color.rgb *= 1.0 / color.a;
+	}
+
+	color = color_pipeline(color);
+
+	/* pre-multiply for blending */
+	color.rgb *= color.a;
 
 	if (c_green_tint)
 		color = vec4(0.0, 0.3, 0.0, 0.2) + color * 0.8;

libweston/renderer-gl/gl-renderer-internal.h

@@ -50,6 +50,12 @@ enum gl_shader_texture_variant {
 	SHADER_VARIANT_EXTERNAL,
 };
 
+/* Keep the following in sync with fragment.glsl. */
+enum gl_shader_color_curve {
+	SHADER_COLOR_CURVE_IDENTITY = 0,
+	SHADER_COLOR_CURVE_LUT_3x1D,
+};
+
 /** GL shader requirements key
  *
  * This structure is used as a binary blob key for building and searching
@@ -62,19 +68,22 @@ enum gl_shader_texture_variant {
 struct gl_shader_requirements
 {
 	unsigned variant:4; /* enum gl_shader_texture_variant */
+	bool input_is_premult:1;
 	bool green_tint:1;
+	unsigned color_pre_curve:1; /* enum gl_shader_color_curve */
 
 	/*
 	 * The total size of all bitfields plus pad_bits_ must fill up exactly
 	 * how many bytes the compiler allocates for them together.
 	 */
-	unsigned pad_bits_:27;
+	unsigned pad_bits_:25;
 };
 static_assert(sizeof(struct gl_shader_requirements) ==
 	      4 /* total bitfield size in bytes */,
 	      "struct gl_shader_requirements must not contain implicit padding");
 
 struct gl_shader;
+struct weston_color_transform;
 
 #define GL_SHADER_INPUT_TEX_MAX 3
 struct gl_shader_config {
@@ -85,6 +94,8 @@ struct gl_shader_config {
 	GLfloat unicolor[4];
 	GLint input_tex_filter; /* GL_NEAREST or GL_LINEAR */
 	GLuint input_tex[GL_SHADER_INPUT_TEX_MAX];
+	GLuint color_pre_curve_lut_tex;
+	GLfloat color_pre_curve_lut_scale_offset[2];
 };
 
 struct gl_renderer {
@@ -202,6 +213,9 @@ gl_renderer_setup_egl_extensions(struct weston_compositor *ec);
 GLenum
 gl_shader_texture_variant_get_target(enum gl_shader_texture_variant v);
 
+bool
+gl_shader_texture_variant_can_be_premult(enum gl_shader_texture_variant v);
+
 void
 gl_shader_destroy(struct gl_renderer *gr, struct gl_shader *shader);
 
@@ -221,4 +235,8 @@ gl_renderer_use_program(struct gl_renderer *gr,
 struct weston_log_scope *
 gl_shader_scope_create(struct gl_renderer *gr);
 
+bool
+gl_shader_config_set_color_transform(struct gl_shader_config *sconf,
+				     struct weston_color_transform *xform);
+
 #endif /* GL_RENDERER_INTERNAL_H */

libweston/renderer-gl/gl-renderer.c

@@ -718,6 +718,7 @@ gl_renderer_send_shader_error(struct weston_view *view)
 static void
 triangle_fan_debug(struct gl_renderer *gr,
 		   const struct gl_shader_config *sconf,
+		   struct weston_output *output,
 		   int first, int count)
 {
 	int i;
@@ -738,12 +739,20 @@ triangle_fan_debug(struct gl_renderer *gr,
 	alt = (struct gl_shader_config) {
 		.req = {
 			.variant = SHADER_VARIANT_SOLID,
+			.input_is_premult = true,
 		},
 		.projection = sconf->projection,
 		.view_alpha = 1.0f,
 		.unicolor = { col[0], col[1], col[2], col[3] },
 	};
 
+	if (!gl_shader_config_set_color_transform(&alt,
+						  output->from_sRGB_to_blend)) {
+		weston_log("GL-renderer: %s failed to generate a color transformation.\n",
+			   __func__);
+		return;
+	}
+
 	gl_renderer_use_program(gr, &alt);
 
 	nelems = (count - 1 + count - 2) * 2;
@@ -771,6 +780,7 @@ triangle_fan_debug(struct gl_renderer *gr,
 static void
 repaint_region(struct gl_renderer *gr,
 	       struct weston_view *ev,
+	       struct weston_output *output,
 	       pixman_region32_t *region,
 	       pixman_region32_t *surf_region,
 	       const struct gl_shader_config *sconf)
@@ -808,7 +818,7 @@ repaint_region(struct gl_renderer *gr,
 	for (i = 0, first = 0; i < nfans; i++) {
 		glDrawArrays(GL_TRIANGLE_FAN, first, vtxcnt[i]);
 		if (gr->fan_debug)
-			triangle_fan_debug(gr, sconf, first, vtxcnt[i]);
+			triangle_fan_debug(gr, sconf, output, first, vtxcnt[i]);
 		first += vtxcnt[i];
 	}
 
@@ -908,6 +918,28 @@ ensure_surface_buffer_is_ready(struct gl_renderer *gr,
 	return (wait_ret == EGL_TRUE && destroy_ret == EGL_TRUE) ? 0 : -1;
 }
 
+static void
+censor_override(struct gl_shader_config *sconf,
+		struct weston_output *output)
+{
+	struct gl_shader_config alt = {
+		.req = {
+			.variant = SHADER_VARIANT_SOLID,
+			.input_is_premult = true,
+		},
+		.projection = sconf->projection,
+		.view_alpha = sconf->view_alpha,
+		.unicolor = { 0.40, 0.0, 0.0, 1.0 },
+	};
+
+	if (!gl_shader_config_set_color_transform(&alt,
+						  output->from_sRGB_to_blend)) {
+		weston_log("GL-renderer: %s failed to generate a color transformation.\n",
+			   __func__);
+	}
+
+	*sconf = alt;
+}
 
  /* Checks if a view needs to be censored on an output
   * Checks for 2 types of censor requirements
@@ -922,14 +954,6 @@ maybe_censor_override(struct gl_shader_config *sconf,
 		      struct weston_output *output,
 		      struct weston_view *ev)
 {
-	const struct gl_shader_config alt = {
-		.req = {
-			.variant = SHADER_VARIANT_SOLID,
-		},
-		.projection = sconf->projection,
-		.view_alpha = sconf->view_alpha,
-		.unicolor = { 0.40, 0.0, 0.0, 1.0 },
-	};
 	struct gl_surface_state *gs = get_surface_state(ev->surface);
 	bool recording_censor =
 		(output->disable_planes > 0) &&
@@ -939,7 +963,7 @@ maybe_censor_override(struct gl_shader_config *sconf,
 		(ev->surface->desired_protection > output->current_protection);
 
 	if (gs->direct_display) {
-		*sconf = alt;
+		censor_override(sconf, output);
 		return;
 	}
 
@@ -950,7 +974,7 @@ maybe_censor_override(struct gl_shader_config *sconf,
 		return;
 
 	if (recording_censor || unprotected_censor)
-		*sconf = alt;
+		censor_override(sconf, output);
 }
 
 static void
@@ -960,6 +984,8 @@ gl_shader_config_set_input_textures(struct gl_shader_config *sconf,
 	int i;
 
 	sconf->req.variant = gs->shader_variant;
+	sconf->req.input_is_premult =
+		gl_shader_texture_variant_can_be_premult(gs->shader_variant);
 
 	for (i = 0; i < 4; i++)
 		sconf->unicolor[i] = gs->color[i];
@@ -981,7 +1007,6 @@ gl_shader_config_init_for_paint_node(struct gl_shader_config *sconf,
 
 	if (!pnode->surf_xform_valid)
 		return false;
-	assert(pnode->surf_xform.transform == NULL);
 
 	*sconf = (struct gl_shader_config) {
 		.projection = go->output_matrix,
@@ -991,6 +1016,11 @@ gl_shader_config_init_for_paint_node(struct gl_shader_config *sconf,
 
 	gl_shader_config_set_input_textures(sconf, gs);
 
+	if (!gl_shader_config_set_color_transform(sconf, pnode->surf_xform.transform)) {
+		weston_log("GL-renderer: failed to generate a color transformation.\n");
+		return false;
+	}
+
 	return true;
 }
 
@@ -1034,9 +1064,6 @@ draw_paint_node(struct weston_paint_node *pnode,
 	else
 		filter = GL_NEAREST;
 
-	/* for triangle_fan_debug(), maybe_censor_override() */
-	assert(pnode->output->from_sRGB_to_blend == NULL);
-
 	if (!gl_shader_config_init_for_paint_node(&sconf, pnode, filter))
 		goto out;
 
@@ -1077,13 +1104,15 @@ draw_paint_node(struct weston_paint_node *pnode,
 		else
 			glDisable(GL_BLEND);
 
-		repaint_region(gr, pnode->view, &repaint, &surface_opaque, &alt);
+		repaint_region(gr, pnode->view, pnode->output,
+			       &repaint, &surface_opaque, &alt);
 		gs->used_in_output_repaint = true;
 	}
 
 	if (pixman_region32_not_empty(&surface_blend)) {
 		glEnable(GL_BLEND);
-		repaint_region(gr, pnode->view, &repaint, &surface_blend, &sconf);
+		repaint_region(gr, pnode->view, pnode->output,
+			       &repaint, &surface_blend, &sconf);
 		gs->used_in_output_repaint = true;
 	}
 
@@ -1264,6 +1293,7 @@ draw_output_borders(struct weston_output *output,
 	struct gl_shader_config sconf = {
 		.req = {
 			.variant = SHADER_VARIANT_RGBA,
+			.input_is_premult = true,
 		},
 		.view_alpha = 1.0f,
 	};
@@ -1275,7 +1305,10 @@ draw_output_borders(struct weston_output *output,
 	if (border_status == BORDER_STATUS_CLEAN)
 		return; /* Clean. Nothing to do. */
 
-	assert(output->from_sRGB_to_output == NULL);
+	if (!gl_shader_config_set_color_transform(&sconf, output->from_sRGB_to_output)) {
+		weston_log("GL-renderer: %s failed to generate a color transformation.\n", __func__);
+		return;
+	}
 
 	top = &go->borders[GL_RENDERER_BORDER_TOP];
 	bottom = &go->borders[GL_RENDERER_BORDER_BOTTOM];
@@ -1485,9 +1518,10 @@ blit_shadow_to_output(struct weston_output *output,
 		      pixman_region32_t *output_damage)
 {
 	struct gl_output_state *go = get_output_state(output);
-	const struct gl_shader_config sconf = {
+	struct gl_shader_config sconf = {
 		.req = {
 			.variant = SHADER_VARIANT_RGBA,
+			.input_is_premult = true,
 		},
 		.projection = {
 			.d = { /* transpose */
@@ -1512,7 +1546,10 @@ blit_shadow_to_output(struct weston_output *output,
 	pixman_region32_t translated_damage;
 	GLfloat verts[4 * 2];
 
-	assert(output->from_blend_to_output == NULL);
+	if (!gl_shader_config_set_color_transform(&sconf, output->from_blend_to_output)) {
+		weston_log("GL-renderer: %s failed to generate a color transformation.\n", __func__);
+		return;
+	}
 
 	pixman_region32_init(&translated_damage);
 
@@ -1577,7 +1614,7 @@ gl_renderer_repaint_output(struct weston_output *output,
 	struct weston_paint_node *pnode;
 
 	assert(output->from_blend_to_output_by_backend ||
-	       output->from_blend_to_output == NULL);
+	       output->from_blend_to_output == NULL || shadow_exists(go));
 
 	if (use_output(output) < 0)
 		return;
@@ -3821,6 +3858,7 @@ gl_renderer_setup(struct weston_compositor *ec, EGLSurface egl_surface)
 		gr->has_egl_image_external = true;
 
 	if (gr->gl_version >= gr_gl_version(3, 0) &&
+	    weston_check_egl_extension(extensions, "GL_OES_texture_float_linear") &&
 	    weston_check_egl_extension(extensions, "GL_EXT_color_buffer_half_float")) {
 		gr->gl_supports_color_transforms = true;
 	}

libweston/renderer-gl/gl-shader-config-color-transformation.c

+/*
+ * Copyright 2021 Collabora, Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "config.h"
+
+#include <GLES3/gl3.h>
+#include <GLES2/gl2ext.h>
+
+#include <assert.h>
+
+#include <libweston/libweston.h>
+#include "color.h"
+#include "gl-renderer.h"
+#include "gl-renderer-internal.h"
+
+#include "shared/weston-egl-ext.h"
+
+struct gl_renderer_color_curve {
+	enum gl_shader_color_curve type;
+	GLuint tex;
+	float scale;
+	float offset;
+};
+
+struct gl_renderer_color_transform {
+	struct weston_color_transform *owner;
+	struct wl_listener destroy_listener;
+
+	struct gl_renderer_color_curve pre_curve;
+};
+
+static void
+gl_renderer_color_curve_fini(struct gl_renderer_color_curve *gl_curve)
+{
+	if (gl_curve->tex)
+		glDeleteTextures(1, &gl_curve->tex);
+}
+
+static void
+gl_renderer_color_transform_destroy(struct gl_renderer_color_transform *gl_xform)
+{
+	gl_renderer_color_curve_fini(&gl_xform->pre_curve);
+	wl_list_remove(&gl_xform->destroy_listener.link);
+	free(gl_xform);
+}
+
+static void
+color_transform_destroy_handler(struct wl_listener *l, void *data)
+{
+	struct gl_renderer_color_transform *gl_xform;
+
+	gl_xform = wl_container_of(l, gl_xform, destroy_listener);
+	assert(gl_xform->owner == data);
+
+	gl_renderer_color_transform_destroy(gl_xform);
+}
+
+static struct gl_renderer_color_transform *
+gl_renderer_color_transform_create(struct weston_color_transform *xform)
+{
+	struct gl_renderer_color_transform *gl_xform;
+
+	gl_xform = zalloc(sizeof *gl_xform);
+	if (!gl_xform)
+		return NULL;
+
+	gl_xform->owner = xform;
+	gl_xform->destroy_listener.notify = color_transform_destroy_handler;
+	wl_signal_add(&xform->destroy_signal, &gl_xform->destroy_listener);
+
+	return gl_xform;
+}
+
+static struct gl_renderer_color_transform *
+gl_renderer_color_transform_get(struct weston_color_transform *xform)
+{
+	struct wl_listener *l;
+
+	l = wl_signal_get(&xform->destroy_signal,
+			  color_transform_destroy_handler);
+	if (!l)
+		return NULL;
+
+	return container_of(l, struct gl_renderer_color_transform,
+			    destroy_listener);
+}
+
+static bool
+gl_color_curve_lut_3x1d(struct gl_renderer_color_curve *gl_curve,
+			const struct weston_color_curve *curve,
+			struct weston_color_transform *xform)
+{
+	const unsigned lut_len = curve->u.lut_3x1d.optimal_len;
+	const unsigned nr_rows = 4;
+	GLuint tex;
+	float *lut;
+
+	/*
+	 * Four rows, see fragment.glsl sample_color_pre_curve_lut_2d().
+	 * The fourth row is unused in fragment.glsl color_pre_curve().
+	 */
+	lut = calloc(lut_len * nr_rows, sizeof *lut);
+	if (!lut)
+		return false;
+
+	curve->u.lut_3x1d.fill_in(xform, lut, lut_len);
+
+	glActiveTexture(GL_TEXTURE0);
+	glGenTextures(1, &tex);
+	glBindTexture(GL_TEXTURE_2D, tex);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+	glPixelStorei(GL_UNPACK_ALIGNMENT, sizeof (float));
+	glPixelStorei(GL_UNPACK_ROW_LENGTH_EXT, 0);
+	glPixelStorei(GL_UNPACK_SKIP_PIXELS_EXT, 0);
+	glPixelStorei(GL_UNPACK_SKIP_ROWS_EXT, 0);
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, lut_len, nr_rows, 0,
+		     GL_RED_EXT, GL_FLOAT, lut);
+
+	glBindTexture(GL_TEXTURE_2D, 0);
+	free(lut);
+
+	gl_curve->type = SHADER_COLOR_CURVE_LUT_3x1D;
+	gl_curve->tex = tex;
+	gl_curve->scale = (float)(lut_len - 1) / lut_len;
+	gl_curve->offset = 0.5f / lut_len;
+
+	return true;
+}
+
+static const struct gl_renderer_color_transform *
+gl_renderer_color_transform_from(struct weston_color_transform *xform)
+{
+	static const struct gl_renderer_color_transform no_op_gl_xform = {
+		.pre_curve.type = SHADER_COLOR_CURVE_IDENTITY,
+		.pre_curve.tex = 0,
+		.pre_curve.scale = 0.0f,
+		.pre_curve.offset = 0.0f,
+	};
+	struct gl_renderer_color_transform *gl_xform;
+	bool ok = false;
+
+	/* Identity transformation */
+	if (!xform)
+		return &no_op_gl_xform;
+
+	/* Cached transformation */
+	gl_xform = gl_renderer_color_transform_get(xform);
+	if (gl_xform)
+		return gl_xform;
+
+	/* New transformation */
+
+	gl_xform = gl_renderer_color_transform_create(xform);
+	if (!gl_xform)
+		return NULL;
+
+	switch (xform->pre_curve.type) {
+	case WESTON_COLOR_CURVE_TYPE_IDENTITY:
+		gl_xform->pre_curve = no_op_gl_xform.pre_curve;
+		ok = true;
+		break;
+	case WESTON_COLOR_CURVE_TYPE_LUT_3x1D:
+		ok = gl_color_curve_lut_3x1d(&gl_xform->pre_curve,
+					     &xform->pre_curve, xform);
+		break;
+	}
+
+	if (!ok) {
+		gl_renderer_color_transform_destroy(gl_xform);
+		return NULL;
+	}
+
+	return gl_xform;
+}
+
+bool
+gl_shader_config_set_color_transform(struct gl_shader_config *sconf,
+				     struct weston_color_transform *xform)
+{
+	const struct gl_renderer_color_transform *gl_xform;
+
+	gl_xform = gl_renderer_color_transform_from(xform);
+	if (!gl_xform)
+		return false;
+
+	sconf->req.color_pre_curve = gl_xform->pre_curve.type;
+	sconf->color_pre_curve_lut_tex = gl_xform->pre_curve.tex;
+	sconf->color_pre_curve_lut_scale_offset[0] = gl_xform->pre_curve.scale;
+	sconf->color_pre_curve_lut_scale_offset[1] = gl_xform->pre_curve.offset;
+
+	return true;
+}

libweston/renderer-gl/gl-shaders.c

@@ -58,6 +58,8 @@ struct gl_shader {
 	GLint tex_uniforms[3];
 	GLint alpha_uniform;
 	GLint color_uniform;
+	GLint color_pre_curve_lut_2d_uniform;
+	GLint color_pre_curve_lut_scale_offset_uniform;
 	struct wl_list link; /* gl_renderer::shader_list */
 	struct timespec last_used;
 };
@@ -82,6 +84,19 @@ gl_shader_texture_variant_to_string(enum gl_shader_texture_variant v)
 	return "!?!?"; /* never reached */
 }
 
+static const char *
+gl_shader_color_curve_to_string(enum gl_shader_color_curve kind)
+{
+	switch (kind) {
+#define CASERET(x) case x: return #x;
+	CASERET(SHADER_COLOR_CURVE_IDENTITY)
+	CASERET(SHADER_COLOR_CURVE_LUT_3x1D)
+#undef CASERET
+	}
+
+	return "!?!?"; /* never reached */
+}
+
 static void
 dump_program_with_line_numbers(int count, const char **sources)
 {
@@ -147,8 +162,10 @@ create_shader_description_string(const struct gl_shader_requirements *req)
 	int size;
 	char *str;
 
-	size = asprintf(&str, "%s %cgreen",
+	size = asprintf(&str, "%s %s %cinput_is_premult %cgreen",
 			gl_shader_texture_variant_to_string(req->variant),
+			gl_shader_color_curve_to_string(req->color_pre_curve),
+			req->input_is_premult ? '+' : '-',
 			req->green_tint ? '+' : '-');
 	if (size < 0)
 		return NULL;
@@ -163,8 +180,12 @@ create_shader_config_string(const struct gl_shader_requirements *req)
 
 	size = asprintf(&str,
 			"#define DEF_GREEN_TINT %s\n"
+			"#define DEF_INPUT_IS_PREMULT %s\n"
+			"#define DEF_COLOR_PRE_CURVE %s\n"
 			"#define DEF_VARIANT %s\n",
 			req->green_tint ? "true" : "false",
+			req->input_is_premult ? "true" : "false",
+			gl_shader_color_curve_to_string(req->color_pre_curve),
 			gl_shader_texture_variant_to_string(req->variant));
 	if (size < 0)
 		return NULL;
@@ -242,6 +263,10 @@ gl_shader_create(struct gl_renderer *gr,
 	shader->alpha_uniform = glGetUniformLocation(shader->program, "alpha");
 	shader->color_uniform = glGetUniformLocation(shader->program,
 						     "unicolor");
+	shader->color_pre_curve_lut_2d_uniform =
+		glGetUniformLocation(shader->program, "color_pre_curve_lut_2d");
+	shader->color_pre_curve_lut_scale_offset_uniform =
+		glGetUniformLocation(shader->program, "color_pre_curve_lut_scale_offset");
 
 	free(conf);
 
@@ -349,6 +374,8 @@ gl_renderer_create_fallback_shader(struct gl_renderer *gr)
 {
 	static const struct gl_shader_requirements fallback_requirements = {
 		.variant = SHADER_VARIANT_SOLID,
+		.input_is_premult = true,
+		.color_pre_curve = SHADER_COLOR_CURVE_IDENTITY,
 	};
 	struct gl_shader *shader;
 
@@ -415,6 +442,25 @@ gl_renderer_garbage_collect_programs(struct gl_renderer *gr)
 	}
 }
 
+bool
+gl_shader_texture_variant_can_be_premult(enum gl_shader_texture_variant v)
+{
+	switch (v) {
+	case SHADER_VARIANT_SOLID:
+	case SHADER_VARIANT_RGBA:
+	case SHADER_VARIANT_EXTERNAL:
+		return true;
+	case SHADER_VARIANT_NONE:
+	case SHADER_VARIANT_RGBX:
+	case SHADER_VARIANT_Y_U_V:
+	case SHADER_VARIANT_Y_UV:
+	case SHADER_VARIANT_Y_XUXV:
+	case SHADER_VARIANT_XYUV:
+		return false;
+	}
+	return true;
+}
+
 GLenum
 gl_shader_texture_variant_get_target(enum gl_shader_texture_variant v)
 {
@@ -450,6 +496,25 @@ gl_shader_load_config(struct gl_shader *shader,
 		glTexParameteri(in_tgt, GL_TEXTURE_MIN_FILTER, in_filter);
 		glTexParameteri(in_tgt, GL_TEXTURE_MAG_FILTER, in_filter);
 	}
+
+	/* Fixed texture unit for color_pre_curve LUT */
+	i = GL_SHADER_INPUT_TEX_MAX;
+	glActiveTexture(GL_TEXTURE0 + i);
+	switch (sconf->req.color_pre_curve) {
+	case SHADER_COLOR_CURVE_IDENTITY:
+		assert(sconf->color_pre_curve_lut_tex == 0);
+		break;
+	case SHADER_COLOR_CURVE_LUT_3x1D:
+		assert(sconf->color_pre_curve_lut_tex != 0);
+		assert(shader->color_pre_curve_lut_2d_uniform != -1);
+		assert(shader->color_pre_curve_lut_scale_offset_uniform != -1);
+
+		glBindTexture(GL_TEXTURE_2D, sconf->color_pre_curve_lut_tex);
+		glUniform1i(shader->color_pre_curve_lut_2d_uniform, i);
+		glUniform2fv(shader->color_pre_curve_lut_scale_offset_uniform,
+			     1, sconf->color_pre_curve_lut_scale_offset);
+		break;
+	}
 }
 
 bool

libweston/renderer-gl/meson.build

@@ -23,6 +23,7 @@ srcs_renderer_gl = [
 	fragment_glsl,
 	'gl-renderer.c',
 	'gl-shaders.c',
+	'gl-shader-config-color-transformation.c',
 	linux_dmabuf_unstable_v1_protocol_c,
 	linux_dmabuf_unstable_v1_server_protocol_h,
 	vertex_glsl,

tests/alpha-blending-test.c

@@ -25,9 +25,7 @@
 
 #include "config.h"
 
-#include <stdio.h>
-#include <string.h>
-#include <sys/mman.h>
+#include <math.h>
 
 #include "weston-test-client-helper.h"
 #include "weston-test-fixture-compositor.h"
@@ -35,6 +33,7 @@
 struct setup_args {
 	struct fixture_metadata meta;
 	enum renderer_type renderer;
+	bool color_management;
 };
 
 static const int ALPHA_STEPS = 256;
@@ -43,12 +42,19 @@ static const int BLOCK_WIDTH = 3;
 static const struct setup_args my_setup_args[] = {
 	{
 		.renderer = RENDERER_PIXMAN,
+		.color_management = false,
 		.meta.name = "pixman"
 	},
 	{
 		.renderer = RENDERER_GL,
+		.color_management = false,
 		.meta.name = "GL"
 	},
+	{
+		.renderer = RENDERER_GL,
+		.color_management = true,
+		.meta.name = "GL sRGB EOTF"
+	},
 };
 
 static enum test_result_code
@@ -62,6 +68,12 @@ fixture_setup(struct weston_test_harness *harness, const struct setup_args *arg)
 	setup.height = 16;
 	setup.shell = SHELL_TEST_DESKTOP;
 
+	if (arg->color_management) {
+		weston_ini_setup(&setup,
+				 cfgln("[core]"),
+				 cfgln("color-management=true"));
+	}
+
 	return weston_test_harness_execute_as_client(harness, &setup);
 }
 DECLARE_FIXTURE_SETUP_WITH_ARG(fixture_setup, my_setup_args, meta);
@@ -125,6 +137,170 @@ fill_alpha_pattern(struct buffer *buf)
 	}
 }
 
+struct color_float {
+	float r, g, b, a;
+};
+
+static struct color_float
+a8r8g8b8_to_float(uint32_t v)
+{
+	struct color_float cf;
+
+	cf.a = ((v >> 24) & 0xff) / 255.f;
+	cf.r = ((v >> 16) & 0xff) / 255.f;
+	cf.g = ((v >>  8) & 0xff) / 255.f;
+	cf.b = ((v >>  0) & 0xff) / 255.f;
+
+	return cf;
+}
+
+static void
+unpremult_float(struct color_float *cf)
+{
+	if (cf->a == 0.0f) {
+		cf->r = 0.0f;
+		cf->g = 0.0f;
+		cf->b = 0.0f;
+	} else {
+		cf->r /= cf->a;
+		cf->g /= cf->a;
+		cf->b /= cf->a;
+	}
+}
+
+static float
+sRGB_EOTF(float e)
+{
+	assert(e >= 0.0f);
+	assert(e <= 1.0f);
+
+	if (e <= 0.04045)
+		return e / 12.92;
+	else
+		return pow((e + 0.055) / 1.055, 2.4);
+}
+
+static void
+sRGB_linearize(struct color_float *cf)
+{
+	cf->r = sRGB_EOTF(cf->r);
+	cf->g = sRGB_EOTF(cf->g);
+	cf->b = sRGB_EOTF(cf->b);
+}
+
+static float
+sRGB_EOTF_inv(float o)
+{
+	assert(o >= 0.0f);
+	assert(o <= 1.0f);
+
+	if (o <= 0.04045 / 12.92)
+		return o * 12.92;
+	else
+		return pow(o, 1.0 / 2.4) * 1.055 - 0.055;
+}
+
+static void
+sRGB_delinearize(struct color_float *cf)
+{
+	cf->r = sRGB_EOTF_inv(cf->r);
+	cf->g = sRGB_EOTF_inv(cf->g);
+	cf->b = sRGB_EOTF_inv(cf->b);
+}
+
+static bool
+compare_float(float ref, float dst, int x, const char *chan, float *max_diff)
+{
+#if 0
+	/*
+	 * This file can be loaded in Octave for visualization.
+	 *
+	 * S = load('compare_float_dump.txt');
+	 *
+	 * rvec = S(S(:,1)==114, 2:3);
+	 * gvec = S(S(:,1)==103, 2:3);
+	 * bvec = S(S(:,1)==98, 2:3);
+	 *
+	 * figure
+	 * subplot(3, 1, 1);
+	 * plot(rvec(:,1), rvec(:,2) .* 255, 'r');
+	 * subplot(3, 1, 2);
+	 * plot(gvec(:,1), gvec(:,2) .* 255, 'g');
+	 * subplot(3, 1, 3);
+	 * plot(bvec(:,1), bvec(:,2) .* 255, 'b');
+	 */
+	static FILE *fp = NULL;
+
+	if (!fp)
+		fp = fopen("compare_float_dump.txt", "w");
+	fprintf(fp, "%d %d %f\n", chan[0], x, dst - ref);
+	fflush(fp);
+#endif
+
+	float diff = fabsf(ref - dst);
+
+	if (diff > *max_diff)
+		*max_diff = diff;
+
+	/*
+	 * Allow for +/- 1.5 code points of error in non-linear 8-bit channel
+	 * value. This is necessary for the BLEND_LINEAR case.
+	 *
+	 * With llvmpipe, we could go as low as +/- 0.65 code points of error
+	 * and still pass.
+	 *
+	 * AMD Polaris 11 would be ok with +/- 1.0 code points error threshold
+	 * if not for one particular case of blending (a=254, r=0) into r=255,
+	 * which results in error of 1.29 code points.
+	 */
+	if (diff < 1.5f / 255.f)
+		return true;
+
+	testlog("x=%d %s: ref %f != dst %f, delta %f\n",
+		x, chan, ref, dst, dst - ref);
+
+	return false;
+}
+
+enum blend_space {
+	BLEND_NONLINEAR,
+	BLEND_LINEAR,
+};
+
+static bool
+verify_sRGB_blend_a8r8g8b8(uint32_t bg32, uint32_t fg32, uint32_t dst32,
+			   int x, struct color_float *max_diff,
+			   enum blend_space space)
+{
+	struct color_float bg = a8r8g8b8_to_float(bg32);
+	struct color_float fg = a8r8g8b8_to_float(fg32);
+	struct color_float dst = a8r8g8b8_to_float(dst32);
+	struct color_float ref;
+	bool ok = true;
+
+	unpremult_float(&bg);
+	unpremult_float(&fg);
+	unpremult_float(&dst);
+
+	if (space == BLEND_LINEAR) {
+		sRGB_linearize(&bg);
+		sRGB_linearize(&fg);
+	}
+
+	ref.r = (1.0f - fg.a) * bg.r + fg.a * fg.r;
+	ref.g = (1.0f - fg.a) * bg.g + fg.a * fg.g;
+	ref.b = (1.0f - fg.a) * bg.b + fg.a * fg.b;
+
+	if (space == BLEND_LINEAR)
+		sRGB_delinearize(&ref);
+
+	ok = compare_float(ref.r, dst.r, x, "r", &max_diff->r) && ok;
+	ok = compare_float(ref.g, dst.g, x, "g", &max_diff->g) && ok;
+	ok = compare_float(ref.b, dst.b, x, "b", &max_diff->b) && ok;
+
+	return ok;
+}
+
 static uint8_t
 red(uint32_t v)
 {
@@ -155,27 +331,45 @@ pixels_monotonic(const uint32_t *row, int x)
 	return ret;
 }
 
-static bool
-check_blend_pattern(struct buffer *shot)
+static void *
+get_middle_row(struct buffer *buf)
 {
-	bool ret = true;
 	const int y = (BLOCK_WIDTH - 1) / 2; /* middle row */
-	int x;
 	void *pixels;
 	int stride_bytes;
-	uint32_t *row;
 
-	assert(pixman_image_get_width(shot->image) >= BLOCK_WIDTH * ALPHA_STEPS);
-	assert(pixman_image_get_height(shot->image) >= BLOCK_WIDTH);
+	assert(pixman_image_get_width(buf->image) >= BLOCK_WIDTH * ALPHA_STEPS);
+	assert(pixman_image_get_height(buf->image) >= BLOCK_WIDTH);
 
-	pixels = pixman_image_get_data(shot->image);
-	stride_bytes = pixman_image_get_stride(shot->image);
-	row = pixels + y * stride_bytes;
+	pixels = pixman_image_get_data(buf->image);
+	stride_bytes = pixman_image_get_stride(buf->image);
+	return pixels + y * stride_bytes;
+}
+
+static bool
+check_blend_pattern(struct buffer *bg, struct buffer *fg, struct buffer *shot,
+		    enum blend_space space)
+{
+	uint32_t *bg_row = get_middle_row(bg);
+	uint32_t *fg_row = get_middle_row(fg);
+	uint32_t *shot_row = get_middle_row(shot);
+	struct color_float max_diff = { 0.0f, 0.0f, 0.0f, 0.0f };
+	bool ret = true;
+	int x;
 
-	for (x = 0; x < BLOCK_WIDTH * ALPHA_STEPS - 1; x++)
-		if (!pixels_monotonic(row, x))
+	for (x = 0; x < BLOCK_WIDTH * ALPHA_STEPS - 1; x++) {
+		if (!pixels_monotonic(shot_row, x))
 			ret = false;
 
+		if (!verify_sRGB_blend_a8r8g8b8(bg_row[x], fg_row[x],
+						shot_row[x], x, &max_diff,
+						space))
+			ret = false;
+	}
+
+	testlog("%s max diff: r=%f, g=%f, b=%f\n",
+		__func__, max_diff.r, max_diff.g, max_diff.b);
+
 	return ret;
 }
 
@@ -196,8 +390,26 @@ check_blend_pattern(struct buffer *shot)
  * - red goes from 1.0 to 0.0, monotonic
  * - green is not monotonic
  * - blue goes from 0.0 to 1.0, monotonic
+ *
+ * This test has two modes: BLEND_NONLINEAR and BLEND_LINEAR.
+ *
+ * BLEND_NONLINEAR does blending with pixel values as is, which are non-linear,
+ * and therefore result in "physically incorrect" blending result. Yet, people
+ * have accustomed to seeing this effect. This mode hits pipeline_premult()
+ * in fragment.glsl.
+ *
+ * BLEND_LINEAR has sRGB encoded pixels (non-linear). These are converted to
+ * linear light (optical) values, blended, and converted back to non-linear
+ * (electrical) values. This results in "physically more correct" blending
+ * result for some value of "physical". This mode hits pipeline_straight()
+ * in fragment.glsl, and tests even more things:
+ * - gl-renderer implementation of 1D LUT is correct
+ * - color-lcms instantiates the correct sRGB EOTF and inverse LUTs
+ * - color space conversions do not happen when both content and output are
+ *   using their default color spaces
+ * - blending through gl-renderer shadow framebuffer
  */
-TEST(alpha_blend_monotonic)
+TEST(alpha_blend)
 {
 	const int width = BLOCK_WIDTH * ALPHA_STEPS;
 	const int height = BLOCK_WIDTH;
@@ -207,38 +419,51 @@ TEST(alpha_blend_monotonic)
 		.blue  = 0x0000,
 		.alpha = 0xffff
 	};
+	const struct setup_args *args;
 	struct client *client;
-	struct buffer *buf;
+	struct buffer *bg;
+	struct buffer *fg;
 	struct wl_subcompositor *subco;
 	struct wl_surface *surf;
 	struct wl_subsurface *sub;
 	struct buffer *shot;
 	bool match;
+	int seq_no;
+	enum blend_space space;
+
+	args = &my_setup_args[get_test_fixture_index()];
+	if (args->color_management) {
+		seq_no = 1;
+		space = BLEND_LINEAR;
+	} else {
+		seq_no = 0;
+		space = BLEND_NONLINEAR;
+	}
 
 	client = create_client();
 	subco = bind_to_singleton_global(client, &wl_subcompositor_interface, 1);
 
 	/* background window content */
-	buf = create_shm_buffer_a8r8g8b8(client, width, height);
-	fill_image_with_color(buf->image, &background_color);
+	bg = create_shm_buffer_a8r8g8b8(client, width, height);
+	fill_image_with_color(bg->image, &background_color);
 
 	/* background window, main surface */
 	client->surface = create_test_surface(client);
 	client->surface->width = width;
 	client->surface->height = height;
-	client->surface->buffer = buf; /* pass ownership */
+	client->surface->buffer = bg; /* pass ownership */
 	set_opaque_rect(client, client->surface,
 			&(struct rectangle){ 0, 0, width, height });
 
 	/* foreground blended content */
-	buf = create_shm_buffer_a8r8g8b8(client, width, height);
-	fill_alpha_pattern(buf);
+	fg = create_shm_buffer_a8r8g8b8(client, width, height);
+	fill_alpha_pattern(fg);
 
 	/* foreground window, sub-surface */
 	surf = wl_compositor_create_surface(client->wl_compositor);
 	sub = wl_subcompositor_get_subsurface(subco, surf, client->surface->wl_surface);
 	/* sub-surface defaults to position 0, 0, top-most, synchronized */
-	wl_surface_attach(surf, buf->proxy, 0, 0);
+	wl_surface_attach(surf, fg->proxy, 0, 0);
 	wl_surface_damage(surf, 0, 0, width, height);
 	wl_surface_commit(surf);
 
@@ -247,15 +472,15 @@ TEST(alpha_blend_monotonic)
 
 	shot = capture_screenshot_of_output(client);
 	assert(shot);
-	match = verify_image(shot, "alpha_blend_monotonic", 0, NULL, 0);
+	match = verify_image(shot, "alpha_blend", seq_no, NULL, seq_no);
+	assert(check_blend_pattern(bg, fg, shot, space));
 	assert(match);
 
-	assert(check_blend_pattern(shot));
 	buffer_destroy(shot);
 
 	wl_subsurface_destroy(sub);
 	wl_surface_destroy(surf);
-	buffer_destroy(buf);
+	buffer_destroy(fg);
 	wl_subcompositor_destroy(subco);
-	client_destroy(client);
+	client_destroy(client); /* destroys bg */
 }

tests/devices-test.c

@@ -106,6 +106,8 @@ TEST(seat_capabilities_test)
 	assert(cl->input->pointer);
 	assert(cl->input->keyboard);
 	assert(cl->input->touch);
+
+	client_destroy(cl);
 }
 
 #define COUNT 15
@@ -144,6 +146,8 @@ TEST(multiple_device_add_and_remove)
 	assert(cl->input->pointer);
 	assert(cl->input->keyboard);
 	assert(cl->input->touch);
+
+	client_destroy(cl);
 }
 
 TEST(device_release_before_destroy)
@@ -181,6 +185,8 @@ TEST(device_release_before_destroy)
 	client_roundtrip(cl);
 
 	assert(cl->input->caps == WL_SEAT_CAPABILITY_ALL);
+
+	client_destroy(cl);
 }
 
 TEST(device_release_before_destroy_multiple)
@@ -190,12 +196,6 @@ TEST(device_release_before_destroy_multiple)
 	/* if weston crashed during this test, then there is
 	 * some inconsistency */
 	for (i = 0; i < 30; ++i) {
-		/* Fifty times run the previous test. This will create
-		 * fifty clients, because we don't have any
-		 * way how to destroy them (worth of adding!). Only one
-		 * client will run at a time though and so should have no
-		 * effect on the result of the test (after the client
-		 * finishes its body, it just 'is' and does nothing). */
 		device_release_before_destroy();
 	}
 }
@@ -237,6 +237,8 @@ TEST(device_release_after_destroy)
 	client_roundtrip(cl);
 
 	assert(cl->input->caps == WL_SEAT_CAPABILITY_ALL);
+
+	client_destroy(cl);
 }
 
 TEST(device_release_after_destroy_multiple)
@@ -310,6 +312,8 @@ TEST(get_device_after_destroy)
 	client_roundtrip(cl);
 
 	assert(cl->input->caps == WL_SEAT_CAPABILITY_ALL);
+
+	client_destroy(cl);
 }
 
 TEST(get_device_after_destroy_multiple)
@@ -331,6 +335,8 @@ TEST(seats_have_names)
 	wl_list_for_each(input, &cl->inputs, link) {
 		assert(input->seat_name);
 	}
+
+	client_destroy(cl);
 }
 
 TEST(seat_destroy_and_recreate)
@@ -353,4 +359,6 @@ TEST(seat_destroy_and_recreate)
 	assert(cl->input->pointer);
 	assert(cl->input->keyboard);
 	assert(cl->input->touch);
+
+	client_destroy(cl);
 }

tests/drm-formats-test.c

@@ -349,11 +349,9 @@ TEST(intersect_arrays)
         format_array_A = weston_drm_format_array_create();
         format_array_B = weston_drm_format_array_create();
         format_array_C = weston_drm_format_array_create();
-        format_array_result = weston_drm_format_array_create();
         assert(format_array_A);
         assert(format_array_B);
         assert(format_array_C);
-        assert(format_array_result);
 
         ADD_FORMATS_AND_MODS(format_array_A, formats_A, modifiers_A);
         ADD_FORMATS_AND_MODS(format_array_B, formats_B, modifiers_B);
@@ -393,7 +391,7 @@ TEST(intersect_arrays_same_content)
         assert(format_array_result);
         assert(format_array_result->arr.size == 0);
 
-        weston_drm_format_array_fini(format_array_result);
+        weston_drm_format_array_destroy(format_array_result);
 
         /* DRM-format arrays A and B have the same content, so the intersection
          * should be equal to them. */

tests/event-test.c

@@ -108,6 +108,8 @@ TEST(test_surface_output)
 	/* visible */
 	check_client_move(client, x, --y);
 	assert(output_contains_client(client));
+
+	client_destroy(client);
 }
 
 static void
@@ -176,4 +178,9 @@ TEST(buffer_release)
 	assert(buf1_released == 0);
 	assert(buf2_released == 1);
 	assert(buf3_released == 1);
+
+	buffer_destroy(buf1);
+	buffer_destroy(buf2);
+	buffer_destroy(buf3);
+	client_destroy(client);
 }

tests/internal-screenshot-test.c

@@ -91,7 +91,7 @@ TEST(internal_screenshot)
 	pixman_image_t *reference_bad = NULL;
 	pixman_image_t *diffimg;
 	struct rectangle clip;
-	const char *fname;
+	char *fname;
 	bool match = false;
 	bool dump_all_images = true;
 
@@ -135,12 +135,14 @@ TEST(internal_screenshot)
 	testlog("Loading good reference image %s\n", fname);
 	reference_good = load_image_from_png(fname);
 	assert(reference_good);
+	free(fname);
 
 	/* Load bad reference image */
 	fname = screenshot_reference_filename("internal-screenshot-bad", 0);
 	testlog("Loading bad reference image %s\n", fname);
 	reference_bad = load_image_from_png(fname);
 	assert(reference_bad);
+	free(fname);
 
 	/* Test check_images_match() without a clip.
 	 * We expect this to fail since we use a bad reference image
@@ -166,6 +168,7 @@ TEST(internal_screenshot)
 		fname = screenshot_output_filename("internal-screenshot-error", 0);
 		write_image_as_png(diffimg, fname);
 		pixman_image_unref(diffimg);
+		free(fname);
 	}
 	pixman_image_unref(reference_good);
 
@@ -173,10 +176,14 @@ TEST(internal_screenshot)
 	if (!match || dump_all_images) {
 		fname = screenshot_output_filename("internal-screenshot", 0);
 		write_image_as_png(screenshot->image, fname);
+		free(fname);
 	}
 
 	buffer_destroy(screenshot);
 
 	testlog("Test complete\n");
 	assert(match);
+
+	buffer_destroy(buf);
+	client_destroy(client);
 }