Gamma correct blending with sRGB

This MR depends on !582 (merged) and !592 (merged).

This MR introduces the color transformation type 3x1D, per-channel one-dimensional look-up tables. It is implemented in GL-renderer. As a prerequisite, undoing pre-multiplied alpha is also added, adding the "straight alpha" path in the fragment shader. Straight alpha is the path that will be used by all color managed pipelines.

As GL-renderer starts supporting color transformations, the places in GL-renderer that used to assert that no color transformation is present are changed to load the respective color transformations. This takes the weston_output members from_sRGB_to_blend, from_sRGB_to_output and from_blend_to_output into use.

Color-lcms module is changed to install the sRGB EOTF curves in such way that it will lead to "gamma correct" blending. That is, blending will happen in optical (light linear) domain, not in electrical (non-linear) domain. This is the user visible effect of this MR if color-lcms module is active.

Finally, the alpha-blending test is augmented. A manual reference blending implementation is added, which ensures that Weston's blending result does not just match the reference image but also matches the reference mathematics. It can be hard to see from an image if the pixel values are actually correct or just "looking fairly reasonable". A new fixture case is added which enables color-lcms module and checks that the blending happens correctly in optical domain. This new test case is an integration test of the whole color managed pipeline up to this point, and pretty powerful in detecting problems.

This MR contains code from @vitalyp for the LittleCMS parts, and very likely contains inspiration from @swick's Weston work on color management.

tests/alpha-blending-test.c

@@ -155,26 +155,32 @@ 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(buf->image);
+	stride_bytes = pixman_image_get_stride(buf->image);
+	return pixels + y * stride_bytes;
+}
 
-	pixels = pixman_image_get_data(shot->image);
-	stride_bytes = pixman_image_get_stride(shot->image);
-	row = pixels + y * stride_bytes;
+static bool
+check_blend_pattern(struct buffer *shot)
+{
+	uint32_t *shot_row = get_middle_row(shot);
+	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;
+	}
 
 	return ret;
 }
@@ -208,7 +214,8 @@ TEST(alpha_blend_monotonic)
 		.alpha = 0xffff
 	};
 	struct client *client;
-	struct buffer *buf;
+	struct buffer *bg;
+	struct buffer *fg;
 	struct wl_subcompositor *subco;
 	struct wl_surface *surf;
 	struct wl_subsurface *sub;
@@ -219,26 +226,26 @@ TEST(alpha_blend_monotonic)
 	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);
 
@@ -255,6 +262,6 @@ TEST(alpha_blend_monotonic)
 
 	wl_subsurface_destroy(sub);
 	wl_surface_destroy(surf);
-	buffer_destroy(buf);
-	client_destroy(client);
+	buffer_destroy(fg);
+	client_destroy(client); /* destroys bg */
 }