Change license and style, reorganise file, make makefile portable, and fix bugs1.3

Signed-off-by: Mattias Andrée <maandree@kth.se>

1 files changed, 381 insertions, 0 deletions

diff --git a/servers-gamma.c b/servers-gamma.c
new file mode 100644
index 0000000..8907e8f
--- /dev/null
+++ b/servers-gamma.c
@@ -0,0 +1,381 @@
+/* See LICENSE file for copyright and license details. */
+#include "servers-gamma.h"
+#include "servers-crtc.h"
+#include "state.h"
+#include "communication.h"
+#include "util.h"
+
+#include <errno.h>
+#include <string.h>
+
+
+#if defined(__clang__)
+# pragma GCC diagnostic ignored "-Wswitch-enum"
+#endif
+
+
+/**
+ * Handle a ‘Command: set-gamma’ message
+ * 
+ * @param   conn        The index of the connection
+ * @param   message_id  The value of the ‘Message ID’ header
+ * @param   crtc        The value of the ‘CRTC’ header
+ * @return              Zero on success (even if ignored), -1 on error,
+ *                      1 if connection closed
+ */
+int
+handle_get_gamma_info(size_t conn, const char *restrict message_id, const char *restrict crtc)
+{
+	struct output *restrict output;
+	char *restrict buf;
+	char depth[3 * sizeof(output->depth) + 2];
+	const char *supported;
+	const char *colourspace;
+	char gamut[8 * (sizeof("White x: ") + 3 * sizeof(unsigned))];
+	size_t n;
+
+	if (!crtc)
+		return send_error("protocol error: 'CRTC' header omitted");
+
+	output = output_find_by_name(crtc, outputs, outputs_n);
+	if (!output)
+		return send_error("selected CRTC does not exist");
+
+	switch (output->depth) {
+	case -2: strcpy(depth, "d"); break;
+	case -1: strcpy(depth, "f"); break;
+	default:
+		sprintf(depth, "%i", output->depth);
+		break;
+	}
+
+	switch (output->supported) {
+	case LIBGAMMA_YES: supported = "yes";   break;
+	case LIBGAMMA_NO:  supported = "no";    break;
+	case LIBGAMMA_MAYBE:
+	default:           supported = "maybe"; break;
+	}
+
+	switch (output->colourspace) {
+	case COLOURSPACE_SRGB_SANS_GAMUT:
+	case COLOURSPACE_SRGB:    colourspace = "Colour space: sRGB\n";    break;
+	case COLOURSPACE_RGB_SANS_GAMUT:
+	case COLOURSPACE_RGB:     colourspace = "Colour space: RGB\n";     break;
+	case COLOURSPACE_NON_RGB: colourspace = "Colour space: non-RGB\n"; break;
+	case COLOURSPACE_GREY:    colourspace = "Colour space: grey\n";    break;
+	case COLOURSPACE_UNKNOWN:
+	default:                  colourspace = "";                        break;
+	}
+
+	switch (output->colourspace) {
+	case COLOURSPACE_SRGB:
+	case COLOURSPACE_RGB:
+		sprintf(gamut,
+		        "Red x: %u\n"      "Red y: %u\n"
+		        "Green x: %u\n"    "Green y: %u\n"
+		        "Blue x: %u\n"     "Blue y: %u\n"
+		        "White x: %u\n"    "White y: %u\n",
+		output->red_x, output->red_y, output->green_x, output->green_y,
+		output->blue_x, output->blue_y, output->white_x, output->white_y);
+		break;
+	case COLOURSPACE_SRGB_SANS_GAMUT:
+	case COLOURSPACE_RGB_SANS_GAMUT:
+	case COLOURSPACE_NON_RGB:
+	case COLOURSPACE_GREY:
+	case COLOURSPACE_UNKNOWN:
+	default:
+		*gamut = '\0';
+		break;
+	}
+
+	MAKE_MESSAGE(&buf, &n, 0,
+	             "In response to: %s\n"
+	             "Cooperative: yes\n" /* In mds: say ‘no’, mds-coopgamma changes to ‘yes’.” */
+	             "Depth: %s\n"
+	             "Red size: %zu\n"
+	             "Green size: %zu\n"
+	             "Blue size: %zu\n"
+	             "Gamma support: %s\n"
+	             "%s%s"
+	             "\n",
+	             message_id, depth, output->red_size, output->green_size,
+	             output->blue_size, supported, gamut, colourspace);
+
+	return send_message(conn, buf, n);
+}
+
+
+/**
+ * Set the gamma ramps on an output
+ * 
+ * @param  output  The output
+ * @param  ramps   The gamma ramps
+ */
+void
+set_gamma(const struct output *restrict output, const union gamma_ramps *restrict ramps)
+{
+	int r = 0;
+
+	if (!connected)
+		return;
+
+	switch (output->depth) {
+	case  8: r = libgamma_crtc_set_gamma_ramps8(output->crtc,  ramps->u8);  break;
+	case 16: r = libgamma_crtc_set_gamma_ramps16(output->crtc, ramps->u16); break;
+	case 32: r = libgamma_crtc_set_gamma_ramps32(output->crtc, ramps->u32); break;
+	case 64: r = libgamma_crtc_set_gamma_ramps64(output->crtc, ramps->u64); break;
+	case -1: r = libgamma_crtc_set_gamma_rampsf(output->crtc,  ramps->f);   break;
+	case -2: r = libgamma_crtc_set_gamma_rampsd(output->crtc,  ramps->d);   break;
+	default:
+		abort();
+	}
+
+	if (r)
+		libgamma_perror(argv0, r); /* Not fatal */
+}
+
+
+/**
+ * Parse the EDID of a monitor
+ * 
+ * @param  output  The output
+ * @param  edid    The EDID in binary format
+ * @param  n       The length of the EDID
+ */
+static void
+parse_edid(struct output *restrict output, const unsigned char *restrict edid, size_t n)
+{
+	size_t i;
+	int analogue;
+	unsigned sum;
+
+	output->red_x = output->green_x = output->blue_x = output->white_x = 0;
+	output->red_y = output->green_y = output->blue_y = output->white_y = 0;
+	output->colourspace = COLOURSPACE_UNKNOWN;
+
+	if (!edid || n < 128)
+		return;
+	for (i = 0, sum = 0; i < 128; i++)
+		sum += (unsigned)edid[i];
+	if ((sum & 0xFF) != 0)
+		return;
+	if (edid[0] || edid[7])
+		return;
+	for (i = 1; i < 7; i++)
+		if (edid[i] != 0xFF)
+			return;
+
+	analogue = !(edid[20] & 0x80);
+	if (!analogue) {
+		output->colourspace = COLOURSPACE_RGB;
+	} else {
+		switch ((edid[24] >> 3) & 3) {
+		case 0:  output->colourspace = COLOURSPACE_GREY;    break;
+		case 1:  output->colourspace = COLOURSPACE_RGB;     break;
+		case 2:  output->colourspace = COLOURSPACE_NON_RGB; break;
+		default: output->colourspace = COLOURSPACE_UNKNOWN; break;
+		}
+	}
+
+	if (output->colourspace != COLOURSPACE_RGB)
+		return;
+
+	if (edid[24] & 4)
+		output->colourspace = COLOURSPACE_SRGB;
+
+	output->red_x   = (edid[25] >> 6) & 3;
+	output->red_y   = (edid[25] >> 4) & 3;
+	output->green_x = (edid[25] >> 2) & 3;
+	output->green_y = (edid[25] >> 0) & 3;
+	output->blue_x  = (edid[26] >> 6) & 3;
+	output->blue_y  = (edid[26] >> 4) & 3;
+	output->white_x = (edid[26] >> 2) & 3;
+	output->white_y = (edid[26] >> 0) & 3;
+
+	output->red_x   |= ((unsigned)(edid[27])) << 2;
+	output->red_y   |= ((unsigned)(edid[28])) << 2;
+	output->green_x |= ((unsigned)(edid[29])) << 2;
+	output->green_y |= ((unsigned)(edid[30])) << 2;
+	output->blue_x  |= ((unsigned)(edid[31])) << 2;
+	output->blue_y  |= ((unsigned)(edid[32])) << 2;
+	output->white_x |= ((unsigned)(edid[33])) << 2;
+	output->white_y |= ((unsigned)(edid[34])) << 2;
+
+	if ((output->red_x == output->red_y)   &&
+	    (output->red_x == output->green_x) &&
+	    (output->red_x == output->green_y) &&
+	    (output->red_x == output->blue_x)  &&
+	    (output->red_x == output->blue_y)  &&
+	    (output->red_x == output->white_x) &&
+	    (output->red_x == output->white_y)) {
+		if (output->colourspace == COLOURSPACE_SRGB)
+			output->colourspace = COLOURSPACE_SRGB_SANS_GAMUT;
+		else
+			output->colourspace = COLOURSPACE_RGB_SANS_GAMUT;
+	}
+}
+
+
+/**
+ * Store all current gamma ramps
+ * 
+ * @return  Zero on success, -1 on error
+ */
+int
+initialise_gamma_info(void)
+{
+	libgamma_crtc_information_t info;
+	int saved_errno;
+	size_t i;
+
+	for (i = 0; i < outputs_n; i++) {
+		libgamma_get_crtc_information(&info, crtcs + i,
+		                              LIBGAMMA_CRTC_INFO_EDID |
+		                              LIBGAMMA_CRTC_INFO_MACRO_RAMP |
+		                              LIBGAMMA_CRTC_INFO_GAMMA_SUPPORT |
+		                              LIBGAMMA_CRTC_INFO_CONNECTOR_NAME);
+
+		outputs[i].depth        = info.gamma_depth_error   ? 0 : info.gamma_depth;
+		outputs[i].red_size     = info.gamma_size_error    ? 0 : info.red_gamma_size;
+		outputs[i].green_size   = info.gamma_size_error    ? 0 : info.green_gamma_size;
+		outputs[i].blue_size    = info.gamma_size_error    ? 0 : info.blue_gamma_size;
+		outputs[i].supported    = info.gamma_support_error ? 0 : info.gamma_support;
+
+		if (info.gamma_support_error == LIBGAMMA_CRTC_INFO_NOT_SUPPORTED)
+			outputs[i].supported = LIBGAMMA_MAYBE;
+
+		if (!outputs[i].depth      || !outputs[i].red_size ||
+		    !outputs[i].green_size || !outputs[i].blue_size)
+			outputs[i].supported  = 0;
+
+		parse_edid(&outputs[i], info.edid_error ? NULL : info.edid, info.edid_error ? 0 : info.edid_length);
+
+		outputs[i].name = get_crtc_name(&info, crtcs + i);
+
+		saved_errno = errno;
+		outputs[i].name_is_edid = (!info.edid_error && info.edid);
+		outputs[i].crtc         = &crtcs[i];
+
+		libgamma_crtc_information_destroy(&info);
+		outputs[i].ramps_size = outputs[i].red_size + outputs[i].green_size + outputs[i].blue_size;
+
+		switch (outputs[i].depth) {
+		default:
+			outputs[i].depth = 64;
+			/* Fall through */
+		case  8:
+		case 16:
+		case 32:
+		case 64: outputs[i].ramps_size *= (size_t)(outputs[i].depth / 8); break;
+		case -2: outputs[i].ramps_size *= sizeof(double);                 break;
+		case -1: outputs[i].ramps_size *= sizeof(float);                  break;
+		}
+
+		errno = saved_errno;
+		if (!outputs[i].name)
+			return -1;
+	}
+
+	return 0;
+}
+
+
+/**
+ * Store all current gamma ramps
+ */
+void
+store_gamma(void)
+{
+	int gerror;
+	size_t i;
+
+#define LOAD_RAMPS(SUFFIX, MEMBER)\
+	do {\
+		libgamma_gamma_ramps##SUFFIX##_initialise(&outputs[i].saved_ramps.MEMBER);\
+		gerror = libgamma_crtc_get_gamma_ramps##SUFFIX(outputs[i].crtc, &outputs[i].saved_ramps.MEMBER);\
+		if (gerror) {\
+			libgamma_perror(argv0, gerror);\
+			outputs[i].supported = LIBGAMMA_NO;\
+			libgamma_gamma_ramps##SUFFIX##_destroy(&outputs[i].saved_ramps.MEMBER);\
+			memset(&outputs[i].saved_ramps.MEMBER, 0, sizeof(outputs[i].saved_ramps.MEMBER));\
+		}\
+	} while (0)
+
+	for (i = 0; i < outputs_n; i++) {
+		if (outputs[i].supported == LIBGAMMA_NO)
+			continue;
+
+		outputs[i].saved_ramps.u8.red_size   = outputs[i].red_size;
+		outputs[i].saved_ramps.u8.green_size = outputs[i].green_size;
+		outputs[i].saved_ramps.u8.blue_size  = outputs[i].blue_size;
+
+		switch (outputs[i].depth) {
+		case 64: LOAD_RAMPS(64, u64); break;
+		case 32: LOAD_RAMPS(32, u32); break;
+		case 16: LOAD_RAMPS(16, u16); break;
+		case  8: LOAD_RAMPS( 8, u8);  break;
+		case -2: LOAD_RAMPS(d, d);    break;
+		case -1: LOAD_RAMPS(f, f);    break;
+		default: /* impossible */     break;
+		}
+	}
+}
+
+
+/**
+ * Restore all gamma ramps
+ */
+void
+restore_gamma(void)
+{
+	size_t i;
+	int gerror;
+
+#define RESTORE_RAMPS(SUFFIX, MEMBER)\
+	do {\
+		if (outputs[i].saved_ramps.MEMBER.red) {\
+			gerror = libgamma_crtc_set_gamma_ramps##SUFFIX(outputs[i].crtc, outputs[i].saved_ramps.MEMBER);\
+			if (gerror)\
+				libgamma_perror(argv0, gerror);\
+		}\
+	} while (0)
+
+	for (i = 0; i < outputs_n; i++) {
+		if (outputs[i].supported == LIBGAMMA_NO)
+			continue;
+		if (!outputs[i].saved_ramps.u8.red)
+			continue;
+
+		switch (outputs[i].depth){
+		case 64: RESTORE_RAMPS(64, u64); break;
+		case 32: RESTORE_RAMPS(32, u32); break;
+		case 16: RESTORE_RAMPS(16, u16); break;
+		case  8: RESTORE_RAMPS( 8, u8);  break;
+		case -2: RESTORE_RAMPS(d, d);    break;
+		case -1: RESTORE_RAMPS(f, f);    break;
+		default: /* impossible */        break;
+		}
+	}
+}
+
+
+/**
+ * Reapplu all gamma ramps
+ */
+void
+reapply_gamma(void)
+{
+	union gamma_ramps plain;
+	size_t i;
+
+	/* Reapply gamma ramps */
+	for (i = 0; i < outputs_n; i++) {
+		if (outputs[i].table_size > 0) {
+			set_gamma(&outputs[i], &outputs[i].table_sums[outputs[i].table_size - 1]);
+		} else {
+			make_plain_ramps(&plain, &outputs[i]);
+			set_gamma(&outputs[i], &plain);
+			libgamma_gamma_ramps8_destroy(&plain.u8);
+		}
+	}
+}