aboutsummaryrefslogtreecommitdiffstats
path: root/servers-gamma.c
diff options
context:
space:
mode:
Diffstat (limited to 'servers-gamma.c')
-rw-r--r--servers-gamma.c381
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);
+ }
+ }
+}
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2024-09-19 15:55:16 +0000