aboutsummaryrefslogtreecommitdiffstats
path: root/src/backend-direct.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/backend-direct.c608
1 files changed, 608 insertions, 0 deletions
diff --git a/src/backend-direct.c b/src/backend-direct.c
new file mode 100644
index 0000000..d0a53eb
--- /dev/null
+++ b/src/backend-direct.c
@@ -0,0 +1,608 @@
+/*-
+ * redshift-ng - Automatically adjust display colour temperature according the Sun
+ *
+ * Copyright (c) 2009-2018 Jon Lund Steffensen <jonlst@gmail.com>
+ * Copyright (c) 2014-2016, 2025 Mattias Andrée <m@maandree.se>
+ *
+ * redshift-ng 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-ng 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-ng. If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "common.h"
+
+
+/**
+ * Union of libgamma gamma ramp structures
+ */
+union gamma_ramps {
+ /**
+ * Gamma ramp sizes
+ */
+ struct {
+ size_t red; /**< Size of the gamma ramp for the red channel */
+ size_t green; /**< Size of the gamma ramp for the green channel */
+ size_t blue; /**< Size of the gamma ramp for the blue channel */
+ } size;
+
+ /* Ramp structures */
+#define X(SUFFIX, RAMPS, TYPE, MAX, DEPTH)\
+ struct libgamma_gamma_##RAMPS RAMPS
+ LIST_RAMPS_STOP_VALUE_TYPES(X, ;);
+#undef X
+};
+
+
+/**
+ * State for partition (e.g. X screen or graphics card)
+ */
+struct partition_state {
+ /**
+ * libgamma state
+ */
+ struct libgamma_partition_state state;
+
+ /**
+ * Index of CRTC when indexing spans multiple X screens
+ */
+ size_t crtc_num_offset;
+};
+
+
+/**
+ * CRTC state
+ */
+struct crtc_state {
+ /**
+ * libgamma state
+ */
+ struct libgamma_crtc_state state;
+
+ /**
+ * Gamma ramp depth, 0 if uninitialised,
+ * -1 if single-precision float,
+ * -2 if double-precision float,
+ * otherwise the number of bits (of unsigned integer)
+ */
+ signed gamma_depth;
+
+ /**
+ * Gamma ramps used by the gamma adjustment function
+ */
+ union gamma_ramps gamma_ramps;
+
+ /**
+ * Original state of gamma ramps
+ */
+ union gamma_ramps saved_gamma_ramps;
+};
+
+
+struct gamma_state {
+ /**
+ * libgamma state for the site (e.g. X display)
+ */
+ struct libgamma_site_state site;
+
+ /**
+ * Whether the adjustment method supports multiple
+ * sites rather than just the default site
+ */
+ unsigned multiple_sites : 1;
+
+ /**
+ * Whether the adjustment method supports multiple partitions
+ * per site
+ */
+ unsigned multiple_partitions : 1;
+
+ /**
+ * Whether the adjustment method supports multiple CRTC:s
+ * per partition per site
+ */
+ unsigned multiple_crtcs : 1;
+
+ /**
+ * Whether partitions are graphics cards
+ */
+ unsigned partitions_are_graphics_cards : 1;
+
+ /**
+ * Whether a parition has been selected
+ */
+ unsigned partition_selected : 1;
+
+ /**
+ * Whether CRTCs have been selected
+ */
+ unsigned crtcs_selected : 1;
+
+ /**
+ * Selected parition (if `partition_selected`)
+ */
+ size_t selected_partition;
+
+ /**
+ * Number of selected CRTCs
+ */
+ size_t ncrtcs;
+
+ /**
+ * Number of selected parition
+ */
+ size_t npartitions;
+
+ /**
+ * Indices of selected CRTCs
+ */
+ size_t *selected_crtcs;
+
+ /**
+ * State for selected paritions
+ */
+ struct partition_state *partitions;
+
+ /**
+ * State for selected CRTCs
+ */
+ struct crtc_state *crtcs;
+};
+
+
+int
+direct_create(struct gamma_state **state_out, int method, const char *method_name)
+{
+ struct libgamma_method_capabilities caps;
+ struct gamma_state *state;
+ int err;
+
+ *state_out = NULL;
+
+ if (!libgamma_is_method_available(method)) {
+ weprintf(_("Adjustment method `%s' is not available"), method_name);
+ return -1;
+ }
+
+ err = libgamma_method_capabilities(&caps, sizeof(caps), method);
+ if (err) {
+ weprintf("libgamma_method_capabilities %s: %s", libgamma_const_of_method(method), libgamma_strerror(err));
+ return -1;
+ }
+
+ state = *state_out = ecalloc(1, sizeof(**state_out));
+ state->selected_crtcs = NULL;
+ state->partitions = NULL;
+ state->multiple_sites = caps.multiple_sites;
+ state->multiple_partitions = caps.multiple_partitions;
+ state->multiple_crtcs = caps.multiple_crtcs;
+ state->partitions_are_graphics_cards = caps.partitions_are_graphics_cards;
+
+ err = libgamma_site_initialise(&state->site, method, NULL);
+ if (err) {
+ weprintf("libgamma_site_initialise %s NULL: %s", libgamma_const_of_method(method), libgamma_strerror(err));
+ free(state);
+ *state_out = NULL;
+ return -1;
+ }
+
+ return 0;
+}
+
+
+int
+direct_set_partitions(struct gamma_state *state, const char *key, const char *value)
+{
+ const char *end;
+ uintmax_t num;
+
+ /* Check previously unspecified */
+ if (state->partition_selected)
+ weprintf(_("`%s' option specified multiple times, using last selection."), key);
+ state->partition_selected = 1;
+
+ /* Parse number */
+ errno = 0;
+ num = strtoumax(value, (void *)&end, 10);
+ state->selected_partition = (size_t)num;
+ if (num > (uintmax_t)SIZE_MAX || *end || !isdigit(*value) || errno)
+ eprintf(_("Invalid value of `%s' option: `%s'."), key, value);
+
+ return 0;
+}
+
+
+int
+direct_set_crtcs(struct gamma_state *state, const char *key, const char *value)
+{
+ const char *end, *p;
+ uintmax_t num;
+ size_t count;
+
+ /* Check previously unspecified */
+ if (state->crtcs_selected)
+ weprintf(_("`%s' option specified multiple times, using last selection."), key);
+ state->crtcs_selected = 1;
+
+ /* Check if all are selected */
+ state->ncrtcs = 0;
+ free(state->selected_crtcs);
+ state->selected_crtcs = NULL;
+ if (!*value || !strcasecmp(value, "all"))
+ return 0;
+
+ /* Get number count */
+ for (p = value, count = 1; *p; p++)
+ if (*p == ',')
+ count++;
+ state->selected_crtcs = ecalloc(count, sizeof(*state->selected_crtcs));
+
+ /* Parse numbers */
+ errno = 0;
+ for (p = value; *p; p = end) {
+ num = strtoumax(p, (void *)&end, 10);
+ state->selected_crtcs[state->ncrtcs++] = (size_t)num;
+ if (num > (uintmax_t)SIZE_MAX || (*end && *end != ',') || !isdigit(*p) || errno)
+ eprintf(_("Invalid value of `%s' option: `%s'."), key, value);
+ end = &end[*end == ','];
+ }
+
+ return 0;
+}
+
+
+int
+direct_start(struct gamma_state *state)
+{
+
+ struct libgamma_crtc_information crtc_info;
+ size_t crtc_num_offset = 0;
+ size_t crtcs_removed = 0;
+ size_t i, j, k, num, part;
+ int err;
+
+ /* Allocate partition states */
+ if (state->partition_selected) {
+ state->partitions = ecalloc(1, sizeof(*state->partitions));
+ state->partitions[0].state.partition = state->selected_partition;
+ state->partitions[0].state.data = NULL;
+ state->npartitions = 1;
+ } else if (!state->site.partitions_available) {
+ if (state->partitions_are_graphics_cards)
+ weprintf(_("No graphics card found."));
+ else
+ weprintf(_("No X screen found."));
+ return -1;
+ } else {
+ state->npartitions = state->site.partitions_available;
+ state->partitions = ecalloc(state->npartitions, sizeof(*state->partitions));
+ for (i = 0; i < state->npartitions; i++) {
+ state->partitions[i].state.partition = i;
+ state->partitions[i].state.data = NULL;
+ }
+ }
+
+ /* Initialise partitions */
+ for (i = 0; i < state->npartitions; i++) {
+ num = state->partitions[i].state.partition;
+ err = libgamma_partition_initialise(&state->partitions[i].state, &state->site, num);
+ if (err) {
+ weprintf("libgamma_partition_initialise %zu: %s", num, libgamma_strerror(err));
+ return -1;
+ }
+ state->partitions[i].crtc_num_offset = crtc_num_offset;
+ crtc_num_offset += state->partitions[i].state.crtcs_available;
+ }
+
+ /* Allocate CRTCs states and map to partition–CRTC pairs */
+ if (state->ncrtcs) {
+ state->crtcs = ecalloc(state->ncrtcs, sizeof(*state->crtcs));
+ for (i = 0; i < state->ncrtcs; i++) {
+ state->crtcs[i].state.data = NULL;
+ state->crtcs[i].state.crtc = state->selected_crtcs[i];
+ }
+ for (i = 0; i < state->ncrtcs; i++) {
+ for (j = 1; j < state->npartitions; j++)
+ if (state->crtcs[i].state.crtc < state->partitions[j].crtc_num_offset)
+ break;
+ state->crtcs[i].state.partition = &state->partitions[j - 1U].state;
+ }
+ } else if (!crtc_num_offset) {
+ weprintf(_("No CRTCs found."));
+ return -1;
+ } else {
+ state->ncrtcs = crtc_num_offset;
+ state->crtcs = ecalloc(state->ncrtcs, sizeof(*state->crtcs));
+ for (j = 0, i = 0; j < state->npartitions; j++) {
+ for (k = 0; k < state->partitions[j].state.crtcs_available; k++, i++) {
+ state->crtcs[i].state.data = NULL;
+ state->crtcs[i].state.partition = &state->partitions[j].state;
+ state->crtcs[i].state.crtc = k;
+ }
+ }
+ }
+
+ /* Initialise CRTCs and fetch original gamma adjustments */
+ for (i = 0; i < state->ncrtcs; i++) {
+ /* Get CRTC */
+ part = state->crtcs[i].state.partition->partition;
+ num = state->crtcs[i].state.crtc;
+ err = libgamma_crtc_initialise(&state->crtcs[i].state, state->crtcs[i].state.partition, num);
+ if (err) {
+ weprintf("libgamma_crtc_initialise %zu %zu: %s", part, num, libgamma_strerror(err));
+ return -1;
+ }
+
+ /* Get gamma ramp inforamtion for CRTC */
+ libgamma_get_crtc_information(&crtc_info, sizeof(crtc_info), &state->crtcs[i].state,
+ LIBGAMMA_CRTC_INFO_GAMMA_SIZE |
+ LIBGAMMA_CRTC_INFO_GAMMA_DEPTH |
+ LIBGAMMA_CRTC_INFO_GAMMA_SUPPORT);
+ if (crtc_info.gamma_size_error || crtc_info.gamma_depth_error) {
+ libgamma_crtc_destroy(&state->crtcs[i].state);
+ state->crtcs[i].state.data = NULL;
+ crtcs_removed++;
+ goto no_gamma_support;
+ }
+ if (!crtc_info.gamma_support_error && crtc_info.gamma_support == LIBGAMMA_NO) {
+ no_gamma_support:
+ if (state->multiple_crtcs) {
+ if (!state->multiple_partitions)
+ weprintf(_("Adjustments are not supported on CRTC %zu."), num);
+ else if (state->partitions_are_graphics_cards)
+ weprintf(_("Adjustments are not supported on CRTC %zu on graphics card %zu."), num, part);
+ else
+ weprintf(_("Adjustments are not supported on CRTC %zu on X screen %zu."), num, part);
+ } else {
+ if (!state->multiple_partitions)
+ weprintf(_("Adjustments are not supported."));
+ else if (state->partitions_are_graphics_cards)
+ weprintf(_("Adjustments are not supported on graphics card %zu."), part);
+ else
+ weprintf(_("Adjustments are not supported on X screen %zu."), part);
+ }
+ if (!state->crtcs[i].state.data)
+ goto next;
+ }
+
+ /* Initialise and fetch gamma adjustments */
+ state->crtcs[i].gamma_ramps.size.red = crtc_info.red_gamma_size;
+ state->crtcs[i].gamma_ramps.size.green = crtc_info.green_gamma_size;
+ state->crtcs[i].gamma_ramps.size.blue = crtc_info.blue_gamma_size;
+ state->crtcs[i].saved_gamma_ramps.size.red = crtc_info.red_gamma_size;
+ state->crtcs[i].saved_gamma_ramps.size.green = crtc_info.green_gamma_size;
+ state->crtcs[i].saved_gamma_ramps.size.blue = crtc_info.blue_gamma_size;
+ switch (crtc_info.gamma_depth) {
+#define X(SUFFIX, RAMPS, TYPE, MAX, DEPTH)\
+ case DEPTH:\
+ if (libgamma_gamma_##RAMPS##_initialise(&state->crtcs[i].gamma_ramps.RAMPS) ||\
+ libgamma_gamma_##RAMPS##_initialise(&state->crtcs[i].saved_gamma_ramps.RAMPS))\
+ eprintf("libgamma_gamma_"#RAMPS"_initialise:");\
+ j = 0;\
+ do {\
+ err = libgamma_crtc_get_gamma_##RAMPS(&state->crtcs[i].state,\
+ &state->crtcs[i].saved_gamma_ramps.RAMPS);\
+ } while (err && j++ < 10);\
+ if (!err) {\
+ state->crtcs[i].gamma_depth = DEPTH;\
+ break;\
+ }\
+ if (state->multiple_crtcs) {\
+ if (!state->multiple_partitions)\
+ weprintf(_("Could not get current adjustments for CRTC %zu."), num);\
+ else if (state->partitions_are_graphics_cards)\
+ weprintf(_("Could not get current adjustments for CRTC %zu on graphics card %zu."), num, part);\
+ else\
+ weprintf(_("Could not get current adjustments for CRTC %zu on X screen %zu."), num, part);\
+ } else {\
+ if (!state->multiple_partitions)\
+ weprintf(_("Could not get current adjustments."));\
+ else if (state->partitions_are_graphics_cards)\
+ weprintf(_("Could not get current adjustments for graphics card %zu."), part);\
+ else\
+ weprintf(_("Could not get current adjustments for X screen %zu."), part);\
+ }\
+ libgamma_gamma_##RAMPS##_destroy(&state->crtcs[i].gamma_ramps.RAMPS);\
+ libgamma_gamma_##RAMPS##_destroy(&state->crtcs[i].saved_gamma_ramps.RAMPS);\
+ libgamma_crtc_destroy(&state->crtcs[i].state);\
+ state->crtcs[i].state.data = NULL;\
+ crtcs_removed++;\
+ goto next
+
+ LIST_RAMPS_STOP_VALUE_TYPES(X, ;);
+#undef X
+
+ default:
+ if (state->multiple_crtcs) {
+ if (!state->multiple_partitions)
+ weprintf(_("Unsupported gamma ramp type on CRTC %zu."), num);
+ else if (state->partitions_are_graphics_cards)
+ weprintf(_("Unsupported gamma ramp type on CRTC %zu on graphics card %zu."), num, part);
+ else
+ weprintf(_("Unsupported gamma ramp type on CRTC %zu on X screen %zu."), num, part);
+ } else {
+ if (!state->multiple_partitions)
+ weprintf(_("Unsupported gamma ramp type."));
+ else if (state->partitions_are_graphics_cards)
+ weprintf(_("Unsupported gamma ramp type on graphics card %zu."), part);
+ else
+ weprintf(_("Unsupported gamma ramp type on X screen %zu."), part);
+ }
+ return -1;
+ }
+
+ next:
+ libgamma_crtc_information_destroy(&crtc_info);
+ }
+
+ /* Unlist removed CRTCs */
+ if (crtcs_removed) {
+ num = state->ncrtcs - crtcs_removed;
+ for (i = j = 0; crtcs_removed; i++, j++)
+ if (!state->crtcs[i].state.data)
+ break;
+ for (; crtcs_removed; i++) {
+ if (state->crtcs[i].state.data)
+ crtcs_removed--;
+ else
+ memmove(&state->crtcs[j++], &state->crtcs[i], sizeof(*state->crtcs));
+ }
+ memmove(&state->crtcs[j], &state->crtcs[i], (state->ncrtcs - i) * sizeof(*state->crtcs));
+ state->ncrtcs = num;
+ }
+ if (!state->ncrtcs) {
+ weprintf(_("No usable CRTCs available."));
+ return -1;
+ }
+
+ return 0;
+}
+
+
+int
+direct_apply(struct gamma_state *state, const struct colour_setting *setting, int preserve /* TODO */)
+{
+ size_t i, err_count = 0, crtc, part;
+ const char *errstr;
+ int err;
+
+ for (i = 0; i < state->ncrtcs; i++) {
+ switch (state->crtcs[i].gamma_depth) {
+#define X(SUFFIX, RAMPS, TYPE, MAX, DEPTH)\
+ case DEPTH:\
+ fill_ramps_##SUFFIX(state->crtcs[i].gamma_ramps.RAMPS.red,\
+ state->crtcs[i].gamma_ramps.RAMPS.green,\
+ state->crtcs[i].gamma_ramps.RAMPS.blue,\
+ state->crtcs[i].gamma_ramps.size.red,\
+ state->crtcs[i].gamma_ramps.size.green,\
+ state->crtcs[i].gamma_ramps.size.blue,\
+ setting);\
+ err = libgamma_crtc_set_gamma_##RAMPS(&state->crtcs[i].state, &state->crtcs[i].gamma_ramps.RAMPS);\
+ break
+
+ LIST_RAMPS_STOP_VALUE_TYPES(X, ;);
+#undef X
+
+ default:
+ err_count++;
+ err = 0;
+ break;
+ }
+
+ if (err) {
+ err_count++;
+ crtc = state->crtcs[i].state.crtc;
+ part = state->crtcs[i].state.partition->partition;
+ errstr = libgamma_strerror(err);
+ if (state->multiple_crtcs) {
+ if (!state->multiple_partitions)
+ weprintf(_("Unable to set adjustments for CRTC %zu: %s."), crtc, errstr);
+ else if (state->partitions_are_graphics_cards)
+ weprintf(_("Unable to set adjustments for CRTC %zu on graphics card %zu: %s."),
+ crtc, part, errstr);
+ else
+ weprintf(_("Unable to set adjustments for CRTC %zu on X screen %zu: %s."),
+ crtc, part, errstr);
+ } else {
+ if (!state->multiple_partitions)
+ weprintf(_("Unable to set adjustments: %s."), errstr);
+ else if (state->partitions_are_graphics_cards)
+ weprintf(_("Unable to set adjustments for graphics card %zu: %s."), part, errstr);
+ else
+ weprintf(_("Unable to set adjustments for X screen %zu: %s."), part, errstr);
+ }
+ }
+ }
+
+ return err_count == state->ncrtcs ? -1 : 0;
+}
+
+
+void
+direct_restore(struct gamma_state *state)
+{
+ size_t i, crtc, part;
+ const char *errstr;
+ int err;
+
+ for (i = 0; i < state->ncrtcs; i++) {
+ switch (state->crtcs[i].gamma_depth) {
+#define X(SUFFIX, RAMPS, TYPE, MAX, DEPTH)\
+ case DEPTH:\
+ err = libgamma_crtc_set_gamma_##RAMPS(&state->crtcs[i].state, &state->crtcs[i].saved_gamma_ramps.RAMPS);\
+ break
+
+ LIST_RAMPS_STOP_VALUE_TYPES(X, ;);
+#undef X
+
+ default:
+ err = 0;
+ break;
+ }
+
+ if (err) {
+ crtc = state->crtcs[i].state.crtc;
+ part = state->crtcs[i].state.partition->partition;
+ errstr = libgamma_strerror(err);
+ if (state->multiple_crtcs) {
+ if (!state->multiple_partitions)
+ weprintf(_("Unable to restore adjustments for CRTC %zu: %s."), crtc, errstr);
+ else if (state->partitions_are_graphics_cards)
+ weprintf(_("Unable to restore adjustments for CRTC %zu on graphics card %zu: %s."),
+ crtc, part, errstr);
+ else
+ weprintf(_("Unable to restore adjustments for CRTC %zu on X screen %zu: %s."),
+ crtc, part, errstr);
+ } else {
+ if (!state->multiple_partitions)
+ weprintf(_("Unable to restore adjustments: %s."), errstr);
+ else if (state->partitions_are_graphics_cards)
+ weprintf(_("Unable to restore adjustments for graphics card %zu: %s."), part, errstr);
+ else
+ weprintf(_("Unable to restore adjustments for X screen %zu: %s."), part, errstr);
+ }
+ }
+ }
+}
+
+
+void
+direct_free(struct gamma_state *state)
+{
+ size_t i;
+ if (state->crtcs) {
+ for (i = 0; i < state->ncrtcs; i++) {
+ switch (state->crtcs[i].gamma_depth) {
+#define X(SUFFIX, RAMPS, TYPE, MAX, DEPTH)\
+ case DEPTH:\
+ libgamma_gamma_##RAMPS##_destroy(&state->crtcs[i].gamma_ramps.RAMPS);\
+ libgamma_gamma_##RAMPS##_destroy(&state->crtcs[i].saved_gamma_ramps.RAMPS);\
+ break
+ LIST_RAMPS_STOP_VALUE_TYPES(X, ;);
+#undef X
+ default:
+ case 0: /* not initialised */
+ break;
+ }
+ if (state->crtcs[i].state.data)
+ libgamma_crtc_destroy(&state->crtcs[i].state);
+ }
+ free(state->crtcs);
+ }
+ if (state->partitions) {
+ for (i = 0; i < state->npartitions; i++)
+ if (state->partitions[i].state.data)
+ libgamma_partition_destroy(&state->partitions[i].state);
+ free(state->partitions);
+ }
+ free(state->selected_crtcs);
+ libgamma_site_destroy(&state->site);
+ free(state);
+}
generated by cgit v1.2.3-70-g09d2 (git 2.48.0) at 2025-04-05 17:45:10 +0000