Add coopgamma backend

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

19 files changed, 697 insertions, 81 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index 318fc2c..73d986b 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -25,6 +25,7 @@ EXTRA_redshift_SOURCES = \
 	gamma-vidmode.c gamma-vidmode.h \
 	gamma-quartz.c gamma-quartz.h \
 	gamma-w32gdi.c gamma-w32gdi.h \
+	gamma-coopgamma.c gamma-coopgamma.h \
 	location-geoclue.c location-geoclue.h
 
 AM_CFLAGS =
@@ -66,6 +67,11 @@ redshift_SOURCES += gamma-w32gdi.c gamma-w32gdi.h
 redshift_LDADD += -lgdi32
 endif
 
+if ENABLE_COOPGAMMA
+redshift_SOURCES += gamma-coopgamma.c gamma-coopgamma.h
+redshift_LDADD += -lcoopgamma
+endif
+
 
 if ENABLE_GEOCLUE
 redshift_SOURCES += location-geoclue.c location-geoclue.h
diff --git a/src/colorramp.c b/src/colorramp.c
index fda75f2..2c67969 100644
--- a/src/colorramp.c
+++ b/src/colorramp.c
@@ -21,6 +21,7 @@
 #include <stdint.h>
 #include <math.h>
 
+#include "colorramp.h"
 #include "redshift.h"
 
 /* Whitepoint values for temperatures at 100K intervals.
@@ -285,43 +286,29 @@ interpolate_color(float a, const float *c1, const float *c2, float *c)
 #define F(Y, C)  pow((Y) * setting->brightness * \
 		     white_point[C], 1.0/setting->gamma[C])
 
-void
-colorramp_fill(uint16_t *gamma_r, uint16_t *gamma_g, uint16_t *gamma_b,
-	       int size, const color_setting_t *setting)
-{
-	/* Approximate white point */
-	float white_point[3];
-	float alpha = (setting->temperature % 100) / 100.0;
-	int temp_index = ((setting->temperature - 1000) / 100)*3;
-	interpolate_color(alpha, &blackbody_color[temp_index],
-			  &blackbody_color[temp_index+3], white_point);
 
-	for (int i = 0; i < size; i++) {
-		gamma_r[i] = F((double)gamma_r[i]/(UINT16_MAX+1), 0) *
-			(UINT16_MAX+1);
-		gamma_g[i] = F((double)gamma_g[i]/(UINT16_MAX+1), 1) *
-			(UINT16_MAX+1);
-		gamma_b[i] = F((double)gamma_b[i]/(UINT16_MAX+1), 2) *
-			(UINT16_MAX+1);
+#define X(SUFFIX, TYPE, MAX, TRUE_MAX, DEPTH)\
+	void\
+	colorramp_fill_##SUFFIX(TYPE *gamma_r, TYPE *gamma_g, TYPE *gamma_b,\
+				size_t size_r, size_t size_g, size_t size_b,\
+				const color_setting_t *setting)\
+	{\
+		/* Approximate white point */\
+		float white_point[3];\
+		float alpha = (setting->temperature % 100) / 100.0;\
+		int temp_index = ((setting->temperature - 1000) / 100) * 3;\
+		interpolate_color(alpha, &blackbody_color[temp_index],\
+				  &blackbody_color[temp_index+3], white_point);\
+		\
+		for (size_t i = 0; i < size_r; i++)\
+			gamma_r[i] = F((double)gamma_r[i] / (MAX), 0) * (MAX);\
+		for (size_t i = 0; i < size_g; i++)\
+			gamma_g[i] = F((double)gamma_g[i] / (MAX), 1) * (MAX);\
+		for (size_t i = 0; i < size_b; i++)\
+			gamma_b[i] = F((double)gamma_b[i] / (MAX), 2) * (MAX);\
 	}
-}
-
-void
-colorramp_fill_float(float *gamma_r, float *gamma_g, float *gamma_b,
-		     int size, const color_setting_t *setting)
-{
-	/* Approximate white point */
-	float white_point[3];
-	float alpha = (setting->temperature % 100) / 100.0;
-	int temp_index = ((setting->temperature - 1000) / 100)*3;
-	interpolate_color(alpha, &blackbody_color[temp_index],
-			  &blackbody_color[temp_index+3], white_point);
 
-	for (int i = 0; i < size; i++) {
-		gamma_r[i] = F((double)gamma_r[i], 0);
-		gamma_g[i] = F((double)gamma_g[i], 1);
-		gamma_b[i] = F((double)gamma_b[i], 2);
-	}
-}
+LIST_RAMPS_STOP_VALUE_TYPES
+#undef X
 
 #undef F
diff --git a/src/colorramp.h b/src/colorramp.h
index 438c563..8802844 100644
--- a/src/colorramp.h
+++ b/src/colorramp.h
@@ -24,9 +24,19 @@
 
 #include "redshift.h"
 
-void colorramp_fill(uint16_t *gamma_r, uint16_t *gamma_g, uint16_t *gamma_b,
-		    int size, const color_setting_t *setting);
-void colorramp_fill_float(float *gamma_r, float *gamma_g, float *gamma_b,
-			  int size, const color_setting_t *setting);
+#define LIST_RAMPS_STOP_VALUE_TYPES\
+	X(u8, uint8_t, UINT8_MAX + 1ULL, UINT8_MAX, 8)\
+	X(u16, uint16_t, UINT16_MAX + 1ULL, UINT16_MAX, 16)\
+	X(u32, uint32_t, UINT32_MAX + 1ULL, UINT32_MAX, 32)\
+	X(u64, uint64_t, UINT64_MAX, UINT64_MAX, 64)\
+	X(float, float, 1, 1, -1)\
+	X(double, double, 1, 1, -2)
+
+#define X(SUFFIX, TYPE, MAX, TRUE_MAX, DEPTH)\
+	void colorramp_fill_##SUFFIX(TYPE *gamma_r, TYPE *gamma_g, TYPE *gamma_b,\
+				     size_t size_r, size_t size_g, size_t size_b,\
+				     const color_setting_t *setting);
+LIST_RAMPS_STOP_VALUE_TYPES
+#undef X
 
 #endif /* ! REDSHIFT_COLORRAMP_H */
diff --git a/src/gamma-coopgamma.c b/src/gamma-coopgamma.c
new file mode 100644
index 0000000..e3fb8e3
--- /dev/null
+++ b/src/gamma-coopgamma.c
@@ -0,0 +1,527 @@
+/* gamma-coopgamma.h -- coopgamma gamma adjustment source
+   This file is part of Redshift.
+
+   Redshift is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   Redshift is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with Redshift.  If not, see <http://www.gnu.org/licenses/>.
+
+   Copyright (c) 2016  Mattias Andrée <maandree@member.fsf.org>
+*/
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#else
+# define PACKAGE "redshift"
+#endif
+
+#include <errno.h>
+#include <inttypes.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef ENABLE_NLS
+# include <libintl.h>
+# define _(s) gettext(s)
+#else
+# define _(s) s
+#endif
+
+#include "gamma-coopgamma.h"
+#include "colorramp.h"
+
+
+struct signal_blockage {
+};
+
+static int
+unblocked_signal(int signo, struct signal_blockage *prev)
+{
+	/* TODO */
+	return 0;
+}
+
+
+static int
+restore_signal_blockage(int signo, const struct signal_blockage *blockage)
+{
+	/* TODO */
+	return 0;
+}
+
+
+static int
+update(coopgamma_state_t *state)
+{
+	for (size_t i = 0; i < state->n_crtcs; i++)
+		libcoopgamma_set_gamma_sync(&state->crtcs[i].filter, &state->ctx);
+}
+
+
+static void
+print_error(coopgamma_state_t *state)
+{
+	const char* side = state->ctx.error.server_side ? _("server-side") : _("client-side");
+	if (state->ctx.error.custom) {
+		if (state->ctx.error.number != 0 && state->ctx.error.description != NULL)
+			fprintf(stderr, "%s error number %llu: %s\n",
+				side, (unsigned long long int)state->ctx.error.number,
+				state->ctx.error.description);
+		else if (state->ctx.error.number != 0)
+			fprintf(stderr, _("%s error number %llu\n"),
+				side, (unsigned long long int)state->ctx.error.number);
+		else if (state->ctx.error.description != NULL)
+			fprintf(stderr, _("%s error: %s\n"), side, state->ctx.error.description);
+	} else if (state->ctx.error.description != NULL) {
+		fprintf(stderr, _("%s error: %s\n"), side, state->ctx.error.description);
+	} else {
+		fprintf(stderr, _("%s error: %s\n"), side, strerror(state->ctx.error.number));
+	}
+}
+
+
+int
+coopgamma_init(coopgamma_state_t *state)
+{
+	struct signal_blockage signal_blockage;
+	memset(state, 0, sizeof(*state));
+	if (libcoopgamma_context_initialise(&state->ctx)) {
+		perror("libcoopgamma_context_initialise");
+		return -1;
+	}
+
+	/* This is done this early to check if coopgamma is available */
+	if (unblocked_signal(SIGCHLD, &signal_blockage) < 0)
+		return -1;
+	state->methods = libcoopgamma_get_methods();
+	if (state->methods == NULL) {
+		perror("libcoopgamma_get_methods");
+		if (restore_signal_blockage(SIGCHLD, &signal_blockage) < 0)
+			exit(EXIT_FAILURE);
+		return -1;
+	}
+	if (restore_signal_blockage(SIGCHLD, &signal_blockage) < 0)
+		return -1;
+
+	state->priority = 0x0800000000000000LL;
+
+	return 0;
+}
+
+int
+coopgamma_start(coopgamma_state_t *state, program_mode_t mode)
+{
+	struct signal_blockage signal_blockage;
+	libcoopgamma_lifespan_t lifespan;
+	char** outputs;
+	size_t i, j, n_outputs;
+	int r;
+	double d;
+
+	switch (mode) {
+	case PROGRAM_MODE_RESET:
+		lifespan = LIBCOOPGAMMA_REMOVE;
+		break;
+	case PROGRAM_MODE_ONE_SHOT:
+	case PROGRAM_MODE_MANUAL:
+		lifespan = LIBCOOPGAMMA_UNTIL_REMOVAL;
+		break;
+	default:
+		lifespan = LIBCOOPGAMMA_UNTIL_DEATH;
+		break;
+	}
+
+	free(state->methods);
+	state->methods = NULL;
+
+	/* Connect to server */
+	if (unblocked_signal(SIGCHLD, &signal_blockage) < 0)
+		return -1;
+	if (libcoopgamma_connect(state->method, state->site, &state->ctx) < 0) {
+		if (errno)
+			perror("libcoopgamma_connect");
+		else
+			fprintf(stderr, _("libcoopgamma_connect: could not "
+					  "start coopgamma server\n"));
+		if (restore_signal_blockage(SIGCHLD, &signal_blockage) < 0)
+			exit(EXIT_FAILURE);
+		return -1;
+	}
+	if (restore_signal_blockage(SIGCHLD, &signal_blockage) < 0)
+		return -1;
+	free(state->method);
+	state->method = NULL;
+	free(state->site);
+	state->site = NULL;
+
+	/* Get available outputs */
+	outputs = libcoopgamma_get_crtcs_sync(&state->ctx);
+	for (n_outputs = 0; outputs[n_outputs]; n_outputs++);
+
+	/* List available output if edid=list was used */
+	if (state->list_outputs) {
+		if (outputs == NULL) {
+			print_error(state);
+			return -1;
+		}
+		printf(_("Available outputs:\n"));
+		for (i = 0; outputs[i]; i++)
+			printf("  %s\n", outputs[i]);
+		if (ferror(stdout)) {
+			perror("printf");
+			exit(EXIT_FAILURE);
+		}
+		exit(EXIT_SUCCESS);
+	}
+
+	/* Translate crtc=N to edid=EDID */
+	for (i = 0; i < state->n_outputs; i++) {
+		if (state->outputs[i].edid != NULL)
+			continue;
+		if (state->outputs[i].index >= n_outputs) {
+			fprintf(stderr, _("monitor number %zu does not exist,"
+					  "available monitors are [0, %zu]\n"),
+				state->outputs[i].index, n_outputs - 1);
+			return -1;
+		}
+		state->outputs[i].edid = strdup(outputs[state->outputs[i].index]);
+		if (state->outputs[i].edid == NULL) {
+			perror("strdup");
+			return -1;
+		}
+	}
+
+	/* Use all outputs if none were specified */
+	if (state->n_outputs == 0) {
+		state->n_outputs = state->a_outputs = n_outputs;
+		state->outputs = malloc(n_outputs * sizeof(*state->outputs));
+		if (state->outputs == NULL) {
+			perror("malloc");
+			return -1;
+		}
+		for (i = 0; i < n_outputs; i++) {
+			state->outputs[i].edid = strdup(outputs[i]);
+			if (state->outputs[i].edid == NULL) {
+				perror("strdup");
+				return -1;
+			}
+		}
+	}
+
+	free(outputs);
+
+	/* Initialise information for each output */
+	state->crtcs = calloc(state->n_outputs, sizeof(*state->crtcs));
+	if (state->crtcs == NULL) {
+		perror("calloc");
+		return -1;
+	}
+	for (i = 0; i < state->n_outputs; i++) {
+		libcoopgamma_crtc_info_t info;
+		coopgamma_crtc_state_t *crtc = state->crtcs + state->n_crtcs;
+
+		crtc->filter.priority = state->priority;
+		crtc->filter.crtc = state->outputs[i].edid;
+		crtc->filter.class = PACKAGE "::redshift::standard";
+		crtc->filter.lifespan = lifespan;
+
+		if (libcoopgamma_get_gamma_info_sync(crtc->filter.crtc, &info, &state->ctx) < 0) {
+			int saved_errno = errno;
+			fprintf(stderr, _("failed to retrieve information for output `%s':\n"),
+				outputs[i]);
+			errno = saved_errno;
+			print_error(state);
+			return -1;
+		}
+		if (!info.cooperative) {
+			fprintf(stderr, _("coopgamma is not available\n"));
+			return -1;
+		}
+		if (info.supported == LIBCOOPGAMMA_NO) {
+			fprintf(stderr, _("output `%s' does not support gamma "
+					  "adjustments, skipping\n"), outputs[i]);
+			continue;
+		}
+
+		/* Get total size of the ramps */
+		switch (info.depth) {
+#define X(SUFFIX, TYPE, MAX, TRUE_MAX, DEPTH)\
+		case DEPTH:\
+			crtc->rampsize = sizeof(TYPE);\
+			break;
+		LIST_RAMPS_STOP_VALUE_TYPES
+#undef X
+		default:
+			if (info.depth > 0)
+				fprintf(stderr, _("output `%s' uses an unsupported depth "
+						  "for its gamma ramps: %i bits, skipping\n"),
+					outputs[i], info.depth);
+			else
+				fprintf(stderr, _("output `%s' uses an unrecognised depth, "
+						  "for its gamma ramps, with the code %i, "
+						  "skipping\n"), outputs[i], info.depth);
+			continue;
+		}
+		crtc->rampsize *= info.red_size + info.green_size + info.blue_size;
+
+		crtc->filter.depth = info.depth;
+		crtc->filter.ramps.u8.red_size = info.red_size;
+		crtc->filter.ramps.u8.green_size = info.green_size;
+		crtc->filter.ramps.u8.blue_size = info.blue_size;
+		crtc->plain_ramps.u8.red_size = info.red_size;
+		crtc->plain_ramps.u8.green_size = info.green_size;
+		crtc->plain_ramps.u8.blue_size = info.blue_size;
+
+		/* Initialise plain ramp and working ramp */
+#define float f
+#define double d
+		switch (info.depth) {
+#define X(SUFFIX, TYPE, MAX, TRUE_MAX, DEPTH)\
+		case DEPTH:\
+			r = libcoopgamma_ramps_initialise(&crtc->filter.ramps.SUFFIX);\
+			if (r < 0) {\
+				perror("libcoopgamma_ramps_initialise");\
+				return -1;\
+			}\
+			r = libcoopgamma_ramps_initialise(&crtc->plain_ramps.SUFFIX);\
+			if (r < 0) {\
+				perror("libcoopgamma_ramps_initialise");\
+				return -1;\
+			}\
+			for (j = 0; j < crtc->plain_ramps.SUFFIX.red_size; j++) {\
+				d = j;\
+				d /= crtc->plain_ramps.SUFFIX.red_size;\
+				crtc->plain_ramps.SUFFIX.red[j] = d * TRUE_MAX;\
+			}\
+			for (j = 0; j < crtc->plain_ramps.SUFFIX.green_size; j++) {\
+				d = j;\
+				d /= crtc->plain_ramps.SUFFIX.green_size;\
+				crtc->plain_ramps.SUFFIX.green[j] = d * TRUE_MAX;\
+			}\
+			for (j = 0; j < crtc->plain_ramps.SUFFIX.blue_size; j++) {\
+				d = j;\
+				d /= crtc->plain_ramps.SUFFIX.blue_size;\
+				crtc->plain_ramps.SUFFIX.blue[j] = d * TRUE_MAX;\
+			}\
+			break;
+		LIST_RAMPS_STOP_VALUE_TYPES
+#undef X
+		default:
+			abort();
+		}
+#undef float
+#undef double
+
+		state->outputs[i].edid = NULL;
+		state->n_crtcs++;
+	}
+
+	free(state->outputs);
+	state->outputs = NULL;
+	state->n_outputs = 0;
+
+	return 0;
+}
+
+void
+coopgamma_free(coopgamma_state_t *state)
+{
+	free(state->methods);
+	state->methods = NULL;
+	free(state->method);
+	state->method = NULL;
+	free(state->site);
+	state->site = NULL;
+
+	while (state->n_crtcs--) {
+		state->crtcs[state->n_crtcs].filter.class = NULL;
+		libcoopgamma_filter_destroy(&state->crtcs[state->n_crtcs].filter);
+		libcoopgamma_ramps_destroy(&state->crtcs[state->n_crtcs].plain_ramps);
+	}
+	state->n_crtcs = 0;
+	free(state->crtcs);
+	state->crtcs = NULL;
+
+	libcoopgamma_context_destroy(&state->ctx, 1);
+	while (state->n_outputs--)
+		free(state->outputs[state->n_outputs].edid);
+	state->n_outputs = 0;
+	free(state->outputs);
+	state->outputs = NULL;
+}
+
+void
+coopgamma_print_help(FILE *f)
+{
+	fputs(_("Adjust gamma ramps with coopgamma.\n"), f);
+	fputs("\n", f);
+
+	/* TRANSLATORS: coopgamma help output
+	   left column must not be translated */
+	fputs(_("  edid=EDID      \tEDID of monitor to apply adjustments to, enter "
+		"`list' to list available monitors\n"
+		"  crtc=N         \tIndex of CRTC to apply adjustments to\n"
+		"  priority=N     \tThe application order of the adjustments, "
+		"default value is 576460752303423488.\n"
+		"  method=METHOD  \tUnderlaying adjustment method, enter "
+		"`list' to list available methods\n"
+		"  display=DISPLAY\tThe display to apply adjustments to\n"),
+	      f);
+	fputs("\n", f);
+}
+
+int
+coopgamma_set_option(coopgamma_state_t *state, const char *key, const char *value)
+{
+	size_t i;
+	char *end;
+	long long int priority;
+
+	if (!strcasecmp(key, "priority")) {
+		errno = 0;
+		priority = strtoll(value, &end, 10);
+		if (errno || *end || priority < INT64_MIN || priority > INT64_MAX) {
+			fprintf(stderr, _("value of method parameter `crtc' "
+					  "must be a integer in [%lli, %lli]\n"),
+				(long long int)INT64_MIN, (long long int)INT64_MAX);
+			return -1;
+		}
+		state->priority = priority;
+	} else if (!strcasecmp(key, "method")) {
+		if (state->method != NULL) {
+			fprintf(stderr, _("method parameter `method' "
+					  "can only be used once\n"));
+			return -1;
+		}
+		if (!strcasecmp(value, "list")) {
+			/* TRANSLATORS: coopgamma help output
+			   the word "coopgamma" must not be translated */
+			printf(_("Available adjustment methods for coopgamma:\n"));
+			for (i = 0; state->methods[i]; i++)
+				printf("  %s\n", state->methods[i]);
+			if (ferror(stdout)) {
+				perror("printf");
+				exit(EXIT_FAILURE);
+			}
+			exit(EXIT_SUCCESS);
+		}
+		state->method = strdup(value);
+		if (state->method == NULL) {
+			perror("strdup");
+			return -1;
+		}
+	} else if (!strcasecmp(key, "display")) {
+		if (state->site != NULL) {
+			fprintf(stderr, _("method parameter `display' "
+					  "can only be used once\n"));
+			return -1;
+		}
+		state->site = strdup(value);
+		if (state->site == NULL) {
+			perror("strdup");
+			return -1;
+		}
+	} else if (!strcasecmp(key, "edid") || !strcasecmp(key, "crtc")) {
+		if (state->n_outputs == state->a_outputs) {
+			state->a_outputs += 8;
+			state->outputs = realloc(state->outputs,
+						 state->a_outputs * sizeof(*state->outputs));
+			if (state->outputs == NULL) {
+				perror("realloc");
+				return -1;
+			}
+		}
+		if (!strcasecmp(key, "edid")) {
+			state->outputs[state->n_outputs].edid = strdup(value);
+			if (state->outputs[state->n_outputs].edid == NULL) {
+				perror("strdup");
+				return -1;
+			}
+			if (!strcasecmp(state->outputs[state->n_outputs].edid, "list"))
+				state->list_outputs = 1;
+		} else {
+			state->outputs[state->n_outputs].edid = NULL;
+			errno = 0;
+			state->outputs[state->n_outputs].index = (size_t)strtoul(value, &end, 10);
+			if (!*end && errno == ERANGE &&
+			    state->outputs[state->n_outputs].index == SIZE_MAX) {
+				state->outputs[state->n_outputs].index = SIZE_MAX;
+			} else if (errno || *end) {
+				fprintf(stderr, _("value of method parameter `crtc' "
+						  "must be a non-negative integer\n"));
+				return -1;
+			}
+		}
+		state->n_outputs++;
+	} else {
+		fprintf(stderr, _("Unknown method parameter: `%s'.\n"), key);
+		return -1;
+	}
+
+	return 0;
+}
+
+void
+coopgamma_restore(coopgamma_state_t *state)
+{
+	size_t i;
+	for (i = 0; i < state->n_crtcs; i++)
+		state->crtcs[i].filter.lifespan = LIBCOOPGAMMA_REMOVE;
+	update(state);
+	for (i = 0; i < state->n_crtcs; i++)
+		state->crtcs[i].filter.lifespan = LIBCOOPGAMMA_UNTIL_DEATH;
+}
+
+int
+coopgamma_set_temperature(coopgamma_state_t *state, const color_setting_t *setting)
+{
+	libcoopgamma_filter_t *filter;
+	libcoopgamma_filter_t *last_filter = NULL;
+	size_t i;
+
+	for (i = 0; i < state->n_crtcs; i++, last_filter = filter) {
+		filter = &state->crtcs[i].filter;
+
+		/* Copy ramps for previous CRTC if its ramps is of same size and depth */
+		if (last_filter != NULL &&
+		    last_filter->ramps.u8.red_size   == filter->ramps.u8.red_size &&
+		    last_filter->ramps.u8.green_size == filter->ramps.u8.green_size &&
+		    last_filter->ramps.u8.blue_size  == filter->ramps.u8.blue_size) {
+			memcpy(filter->ramps.u8.red, last_filter->ramps.u8.red,
+			       state->crtcs[i].rampsize);
+			continue;
+		}
+
+		/* Otherwise, create calculate the ramps */
+		memcpy(filter->ramps.u8.red, state->crtcs[i].plain_ramps.u8.red,
+		       state->crtcs[i].rampsize);
+		switch (filter->depth) {
+#define X(SUFFIX, TYPE, MAX, TRUE_MAX, DEPTH)\
+		case DEPTH:\
+			colorramp_fill_##SUFFIX((void *)(filter->ramps.u8.red),\
+						(void *)(filter->ramps.u8.green),\
+						(void *)(filter->ramps.u8.blue),\
+						filter->ramps.u8.red_size,\
+						filter->ramps.u8.green_size,\
+						filter->ramps.u8.blue_size,\
+						setting);\
+			break;
+		LIST_RAMPS_STOP_VALUE_TYPES
+#undef X
+		default:
+			abort();
+		}
+	}
+
+	return update(state);
+}
diff --git a/src/gamma-coopgamma.h b/src/gamma-coopgamma.h
new file mode 100644
index 0000000..2fd65d3
--- /dev/null
+++ b/src/gamma-coopgamma.h
@@ -0,0 +1,66 @@
+/* gamma-coopgamma.h -- coopgamma gamma adjustment header
+   This file is part of Redshift.
+
+   Redshift is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   Redshift is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with Redshift.  If not, see <http://www.gnu.org/licenses/>.
+
+   Copyright (c) 2016  Mattias Andrée <maandree@member.fsf.org>
+*/
+
+#ifndef REDSHIFT_GAMMA_COOPGAMMA_H
+#define REDSHIFT_GAMMA_COOPGAMMA_H
+
+#include <libcoopgamma.h>
+
+#include "redshift.h"
+
+
+typedef struct {
+	char *edid;
+	size_t index;
+} coopgamma_output_id_t;  
+
+typedef struct {
+	libcoopgamma_filter_t filter;
+	libcoopgamma_ramps_t plain_ramps;
+	size_t rampsize;
+} coopgamma_crtc_state_t;
+
+typedef struct {
+	libcoopgamma_context_t ctx;
+	coopgamma_crtc_state_t *crtcs;
+	size_t n_crtcs;
+	char **methods;
+	char *method;
+	char *site;
+	int64_t priority;
+	int list_outputs;
+	coopgamma_output_id_t *outputs;
+	size_t n_outputs;
+	size_t a_outputs;
+} coopgamma_state_t;
+
+
+int coopgamma_init(coopgamma_state_t *state);
+int coopgamma_start(coopgamma_state_t *state, program_mode_t mode);
+void coopgamma_free(coopgamma_state_t *state);
+
+void coopgamma_print_help(FILE *f);
+int coopgamma_set_option(coopgamma_state_t *state, const char *key, const char *value);
+
+void coopgamma_restore(coopgamma_state_t *state);
+int coopgamma_set_temperature(coopgamma_state_t *state,
+			      const color_setting_t *setting);
+
+
+#endif /* ! REDSHIFT_GAMMA_COOPGAMMA_H */
diff --git a/src/gamma-drm.c b/src/gamma-drm.c
index c2ac4bd..9fc6354 100644
--- a/src/gamma-drm.c
+++ b/src/gamma-drm.c
@@ -55,7 +55,7 @@ drm_init(drm_state_t *state)
 }
 
 int
-drm_start(drm_state_t *state)
+drm_start(drm_state_t *state, program_mode_t mode)
 {
 	/* Acquire access to a graphics card. */
 	long maxlen = strlen(DRM_DIR_NAME) + strlen(DRM_DEV_NAME) + 10;
@@ -244,7 +244,7 @@ int
 drm_set_temperature(drm_state_t *state, const color_setting_t *setting)
 {
 	drm_crtc_state_t *crtcs = state->crtcs;
-	int last_gamma_size = 0;
+	uint32_t last_gamma_size = 0;
 	uint16_t *r_gamma = NULL;
 	uint16_t *g_gamma = NULL;
 	uint16_t *b_gamma = NULL;
@@ -270,16 +270,16 @@ drm_set_temperature(drm_state_t *state, const color_setting_t *setting)
 		}
 
 		/* Initialize gamma ramps to pure state */
-		int ramp_size = crtcs->gamma_size;
-		for (int i = 0; i < ramp_size; i++) {
+		uint32_t ramp_size = crtcs->gamma_size;
+		for (uint32_t i = 0; i < ramp_size; i++) {
 			uint16_t value = (double)i/ramp_size * (UINT16_MAX+1);
 			r_gamma[i] = value;
 			g_gamma[i] = value;
 			b_gamma[i] = value;
 		}
 
-		colorramp_fill(r_gamma, g_gamma, b_gamma, crtcs->gamma_size,
-			       setting);
+		colorramp_fill_u16(r_gamma, g_gamma, b_gamma, crtcs->gamma_size,
+				   crtcs->gamma_size, crtcs->gamma_size, setting);
 		drmModeCrtcSetGamma(state->fd, crtcs->crtc_id, crtcs->gamma_size,
 				    r_gamma, g_gamma, b_gamma);
 	}
diff --git a/src/gamma-drm.h b/src/gamma-drm.h
index ae97d00..6b9fe24 100644
--- a/src/gamma-drm.h
+++ b/src/gamma-drm.h
@@ -31,7 +31,7 @@
 typedef struct {
 	int crtc_num;
 	int crtc_id;
-	int gamma_size;
+	int64_t gamma_size;
 	uint16_t* r_gamma;
 	uint16_t* g_gamma;
 	uint16_t* b_gamma;
@@ -47,7 +47,7 @@ typedef struct {
 
 
 int drm_init(drm_state_t *state);
-int drm_start(drm_state_t *state);
+int drm_start(drm_state_t *state, program_mode_t mode);
 void drm_free(drm_state_t *state);
 
 void drm_print_help(FILE *f);
diff --git a/src/gamma-dummy.c b/src/gamma-dummy.c
index ba62d93..5c67b58 100644
--- a/src/gamma-dummy.c
+++ b/src/gamma-dummy.c
@@ -37,7 +37,7 @@ gamma_dummy_init(void *state)
 }
 
 int
-gamma_dummy_start(void *state)
+gamma_dummy_start(void *state, program_mode_t mode)
 {
 	fputs(_("WARNING: Using dummy gamma method! Display will not be affected by this gamma method.\n"), stderr);
 	return 0;
diff --git a/src/gamma-dummy.h b/src/gamma-dummy.h
index 3e58ec1..91376ff 100644
--- a/src/gamma-dummy.h
+++ b/src/gamma-dummy.h
@@ -24,7 +24,7 @@
 
 
 int gamma_dummy_init(void *state);
-int gamma_dummy_start(void *state);
+int gamma_dummy_start(void *state, program_mode_t mode);
 void gamma_dummy_free(void *state);
 
 void gamma_dummy_print_help(FILE *f);
diff --git a/src/gamma-quartz.c b/src/gamma-quartz.c
index 6691c91..a4fe283 100644
--- a/src/gamma-quartz.c
+++ b/src/gamma-quartz.c
@@ -47,7 +47,7 @@ quartz_init(quartz_state_t *state)
 }
 
 int
-quartz_start(quartz_state_t *state)
+quartz_start(quartz_state_t *state, program_mode_t mode)
 {
 	int r;
 	CGError error;
@@ -208,7 +208,7 @@ quartz_set_temperature_for_display(quartz_state_t *state, int display,
 	}
 
 	colorramp_fill_float(gamma_r, gamma_g, gamma_b, ramp_size,
-			     setting);
+			     ramp_size, ramp_size, setting);
 
 	CGError error =
 		CGSetDisplayTransferByTable(display, ramp_size,
diff --git a/src/gamma-quartz.h b/src/gamma-quartz.h
index cd29d54..84350ce 100644
--- a/src/gamma-quartz.h
+++ b/src/gamma-quartz.h
@@ -41,7 +41,7 @@ typedef struct {
 
 
 int quartz_init(quartz_state_t *state);
-int quartz_start(quartz_state_t *state);
+int quartz_start(quartz_state_t *state, program_mode_t mode);
 void quartz_free(quartz_state_t *state);
 
 void quartz_print_help(FILE *f);
diff --git a/src/gamma-randr.c b/src/gamma-randr.c
index 6fa2bc6..6d9032b 100644
--- a/src/gamma-randr.c
+++ b/src/gamma-randr.c
@@ -90,7 +90,7 @@ randr_init(randr_state_t *state)
 }
 
 int
-randr_start(randr_state_t *state)
+randr_start(randr_state_t *state, program_mode_t mode)
 {
 	xcb_generic_error_t *error;
 
@@ -348,8 +348,8 @@ randr_set_temperature_for_crtc(randr_state_t *state, int crtc_num,
 		}
 	}
 
-	colorramp_fill(gamma_r, gamma_g, gamma_b, ramp_size,
-		       setting);
+	colorramp_fill_u16(gamma_r, gamma_g, gamma_b, ramp_size,
+			   ramp_size, ramp_size, setting);
 
 	/* Set new gamma ramps */
 	xcb_void_cookie_t gamma_set_cookie =
diff --git a/src/gamma-randr.h b/src/gamma-randr.h
index 093c41f..387e7d8 100644
--- a/src/gamma-randr.h
+++ b/src/gamma-randr.h
@@ -48,7 +48,7 @@ typedef struct {
 
 
 int randr_init(randr_state_t *state);
-int randr_start(randr_state_t *state);
+int randr_start(randr_state_t *state, program_mode_t mode);
 void randr_free(randr_state_t *state);
 
 void randr_print_help(FILE *f);
diff --git a/src/gamma-vidmode.c b/src/gamma-vidmode.c
index c9682d2..96fe43c 100644
--- a/src/gamma-vidmode.c
+++ b/src/gamma-vidmode.c
@@ -57,7 +57,7 @@ vidmode_init(vidmode_state_t *state)
 }
 
 int
-vidmode_start(vidmode_state_t *state)
+vidmode_start(vidmode_state_t *state, program_mode_t mode)
 {
 	int r;
 	int screen_num = state->screen_num;
@@ -202,8 +202,8 @@ vidmode_set_temperature(vidmode_state_t *state,
 		}
 	}
 
-	colorramp_fill(gamma_r, gamma_g, gamma_b, state->ramp_size,
-		       setting);
+	colorramp_fill_u16(gamma_r, gamma_g, gamma_b, state->ramp_size,
+			   state->ramp_size, state->ramp_size, setting);
 
 	/* Set new gamma ramps */
 	r = XF86VidModeSetGammaRamp(state->display, state->screen_num,
diff --git a/src/gamma-vidmode.h b/src/gamma-vidmode.h
index 4b6cecc..c768d30 100644
--- a/src/gamma-vidmode.h
+++ b/src/gamma-vidmode.h
@@ -37,7 +37,7 @@ typedef struct {
 
 
 int vidmode_init(vidmode_state_t *state);
-int vidmode_start(vidmode_state_t *state);
+int vidmode_start(vidmode_state_t *state, program_mode_t mode);
 void vidmode_free(vidmode_state_t *state);
 
 void vidmode_print_help(FILE *f);
diff --git a/src/gamma-w32gdi.c b/src/gamma-w32gdi.c
index c518fe6..a4d4a60 100644
--- a/src/gamma-w32gdi.c
+++ b/src/gamma-w32gdi.c
@@ -49,7 +49,7 @@ w32gdi_init(w32gdi_state_t *state)
 }
 
 int
-w32gdi_start(w32gdi_state_t *state)
+w32gdi_start(w32gdi_state_t *state, program_mode_t mode)
 {
 	BOOL r;
 
@@ -183,8 +183,8 @@ w32gdi_set_temperature(w32gdi_state_t *state,
 		}
 	}
 
-	colorramp_fill(gamma_r, gamma_g, gamma_b, GAMMA_RAMP_SIZE,
-		       setting);
+	colorramp_fill_u16(gamma_r, gamma_g, gamma_b, GAMMA_RAMP_SIZE,
+			   GAMMA_RAMP_SIZE, GAMMA_RAMP_SIZE, setting);
 
 	/* Set new gamma ramps */
 	r = SetDeviceGammaRamp(hDC, gamma_ramps);
diff --git a/src/gamma-w32gdi.h b/src/gamma-w32gdi.h
index 6e73cd1..7f3c089 100644
--- a/src/gamma-w32gdi.h
+++ b/src/gamma-w32gdi.h
@@ -33,7 +33,7 @@ typedef struct {
 
 
 int w32gdi_init(w32gdi_state_t *state);
-int w32gdi_start(w32gdi_state_t *state);
+int w32gdi_start(w32gdi_state_t *state, program_mode_t mode);
 void w32gdi_free(w32gdi_state_t *state);
 
 void w32gdi_print_help(FILE *f);
diff --git a/src/redshift.c b/src/redshift.c
index bf741bb..423ad5c 100644
--- a/src/redshift.c
+++ b/src/redshift.c
@@ -58,6 +58,10 @@
 
 #include "gamma-dummy.h"
 
+#ifdef ENABLE_COOPGAMMA
+# include "gamma-coopgamma.h"
+#endif
+
 #ifdef ENABLE_DRM
 # include "gamma-drm.h"
 #endif
@@ -98,6 +102,9 @@
 
 /* Union of state data for gamma adjustment methods */
 typedef union {
+#ifdef ENABLE_COOPGAMMA
+	coopgamma_state_t coopgamma;
+#endif
 #ifdef ENABLE_DRM
 	drm_state_t drm;
 #endif
@@ -118,6 +125,18 @@ typedef union {
 
 /* Gamma adjustment method structs */
 static const gamma_method_t gamma_methods[] = {
+#ifdef ENABLE_COOPGAMMA
+	{
+		"coopgamma", 1,
+		(gamma_method_init_func *)coopgamma_init,
+		(gamma_method_start_func *)coopgamma_start,
+		(gamma_method_free_func *)coopgamma_free,
+		(gamma_method_print_help_func *)coopgamma_print_help,
+		(gamma_method_set_option_func *)coopgamma_set_option,
+		(gamma_method_restore_func *)coopgamma_restore,
+		(gamma_method_set_temperature_func *)coopgamma_set_temperature
+	},
+#endif
 #ifdef ENABLE_DRM
 	{
 		"drm", 0,
@@ -292,15 +311,6 @@ static const location_provider_t location_providers[] = {
 #define SLEEP_DURATION        5000
 #define SLEEP_DURATION_SHORT  100
 
-/* Program modes. */
-typedef enum {
-	PROGRAM_MODE_CONTINUAL,
-	PROGRAM_MODE_ONE_SHOT,
-	PROGRAM_MODE_PRINT,
-	PROGRAM_MODE_RESET,
-	PROGRAM_MODE_MANUAL
-} program_mode_t;
-
 /* Transition scheme.
    The solar elevations at which the transition begins/ends,
    and the association color settings. */
@@ -606,9 +616,9 @@ provider_try_start(const location_provider_t *provider,
 }
 
 static int
-method_try_start(const gamma_method_t *method,
-		 gamma_state_t *state,
-		 config_ini_state_t *config, char *args)
+method_try_start(const gamma_method_t *method, gamma_state_t *state,
+		 program_mode_t mode, config_ini_state_t *config,
+		 char *args)
 {
 	int r;
 
@@ -673,7 +683,7 @@ method_try_start(const gamma_method_t *method,
 	}
 
 	/* Start method. */
-	r = method->start(state);
+	r = method->start(state, mode);
 	if (r < 0) {
 		method->free(state);
 		fprintf(stderr, _("Failed to start adjustment method %s.\n"),
@@ -1488,8 +1498,8 @@ main(int argc, char *argv[])
 	if (mode != PROGRAM_MODE_PRINT) {
 		if (method != NULL) {
 			/* Use method specified on command line. */
-			r = method_try_start(method, &state, &config_state,
-					     method_args);
+			r = method_try_start(method, &state, mode,
+					     &config_state, method_args);
 			if (r < 0) exit(EXIT_FAILURE);
 		} else {
 			/* Try all methods, use the first that works. */
@@ -1497,7 +1507,8 @@ main(int argc, char *argv[])
 				const gamma_method_t *m = &gamma_methods[i];
 				if (!m->autostart) continue;
 
-				r = method_try_start(m, &state, &config_state, NULL);
+				r = method_try_start(m, &state, mode,
+						     &config_state, NULL);
 				if (r < 0) {
 					fputs(_("Trying next method...\n"), stderr);
 					continue;
diff --git a/src/redshift.h b/src/redshift.h
index bac8e34..91d9d0d 100644
--- a/src/redshift.h
+++ b/src/redshift.h
@@ -24,6 +24,15 @@
 #include <stdlib.h>
 
 
+/* Program modes. */
+typedef enum {
+	PROGRAM_MODE_CONTINUAL,
+	PROGRAM_MODE_ONE_SHOT,
+	PROGRAM_MODE_PRINT,
+	PROGRAM_MODE_RESET,
+	PROGRAM_MODE_MANUAL
+} program_mode_t;
+
 /* Location */
 typedef struct {
 	float lat;
@@ -48,7 +57,7 @@ typedef struct {
 
 /* Gamma adjustment method */
 typedef int gamma_method_init_func(void *state);
-typedef int gamma_method_start_func(void *state);
+typedef int gamma_method_start_func(void *state, program_mode_t mode);
 typedef void gamma_method_free_func(void *state);
 typedef void gamma_method_print_help_func(FILE *f);
 typedef int gamma_method_set_option_func(void *state, const char *key,