servers-gamma.c

/* 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);
		}
	}
}