/*- * redshift-ng - Automatically adjust display colour temperature according the Sun * * Copyright (c) 2009-2018 Jon Lund Steffensen * Copyright (c) 2014-2016, 2025 Mattias Andrée * * 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 . */ #include "common.h" #include #include #if defined(__GNUC__) # pragma GCC diagnostic ignored "-Waggregate-return" #endif #define RANDR_VERSION_MAJOR 1 #define RANDR_VERSION_MINOR 3 struct randr_crtc_state { xcb_randr_crtc_t crtc; unsigned int ramp_size; uint16_t *saved_ramps; }; struct gamma_state { xcb_connection_t *conn; xcb_screen_t *screen; int preferred_screen; int screen_num; int crtc_num_count; int *crtc_num; unsigned int crtc_count; struct randr_crtc_state *crtcs; }; static int randr_create(struct gamma_state **state_out) { xcb_randr_query_version_cookie_t ver_cookie; xcb_randr_query_version_reply_t *ver_reply; xcb_generic_error_t *error; struct gamma_state *state; int ec; /* Initialize state */ state = *state_out = emalloc(sizeof(**state_out)); state->screen_num = -1; state->crtc_num = NULL; state->crtc_num_count = 0; state->crtc_count = 0; state->crtcs = NULL; /* Open X server connection */ state->conn = xcb_connect(NULL, &state->preferred_screen); /* Query RandR version */ ver_cookie = xcb_randr_query_version(state->conn, RANDR_VERSION_MAJOR, RANDR_VERSION_MINOR); ver_reply = xcb_randr_query_version_reply(state->conn, ver_cookie, &error); /* TODO What does it mean when both error and ver_reply is NULL? Apparently, we have to check both to avoid seg faults. */ if (error || ver_reply == NULL) { ec = (error != 0) ? error->error_code : -1; weprintf(_("`%s' returned error %i."), "RANDR Query Version", ec); goto fail; } if (ver_reply->major_version != RANDR_VERSION_MAJOR || ver_reply->minor_version < RANDR_VERSION_MINOR) { weprintf(_("Unsupported RANDR version (%u.%u)."), ver_reply->major_version, ver_reply->minor_version); free(ver_reply); goto fail; } free(ver_reply); return 0; fail: xcb_disconnect(state->conn); free(state); *state_out = NULL; return -1; } static int randr_start(struct gamma_state *state) { xcb_generic_error_t *error; const xcb_setup_t *setup; xcb_screen_iterator_t iter; int i, screen_num; xcb_randr_get_screen_resources_current_cookie_t res_cookie; xcb_randr_get_screen_resources_current_reply_t *res_reply; xcb_randr_crtc_t *crtcs; screen_num = state->screen_num; if (screen_num < 0) screen_num = state->preferred_screen; /* Get screen */ setup = xcb_get_setup(state->conn); iter = xcb_setup_roots_iterator(setup); state->screen = NULL; for (i = 0; iter.rem > 0; i++) { if (i == screen_num) { state->screen = iter.data; break; } xcb_screen_next(&iter); } if (!state->screen) { weprintf(_("Screen %i could not be found."), screen_num); return -1; } /* Get list of CRTCs for the screen */ res_cookie = xcb_randr_get_screen_resources_current(state->conn, state->screen->root); res_reply = xcb_randr_get_screen_resources_current_reply(state->conn, res_cookie, &error); if (error) { weprintf(_("`%s' returned error %i."), "RANDR Get Screen Resources Current", error->error_code); return -1; } state->crtc_count = res_reply->num_crtcs; state->crtcs = ecalloc(state->crtc_count, sizeof(struct randr_crtc_state)); crtcs = xcb_randr_get_screen_resources_current_crtcs(res_reply); /* Save CRTC identifier in state */ for (i = 0; i < state->crtc_count; i++) state->crtcs[i].crtc = crtcs[i]; free(res_reply); /* Save size and gamma ramps of all CRTCs. Current gamma ramps are saved so we can restore them at program exit. */ for (i = 0; i < state->crtc_count; i++) { xcb_randr_crtc_t crtc = state->crtcs[i].crtc; xcb_randr_get_crtc_gamma_size_cookie_t gamma_size_cookie; xcb_randr_get_crtc_gamma_size_reply_t *gamma_size_reply; xcb_randr_get_crtc_gamma_cookie_t gamma_get_cookie; xcb_randr_get_crtc_gamma_reply_t *gamma_get_reply; uint16_t *gamma_r, *gamma_g, *gamma_b; unsigned int ramp_size; /* Request size of gamma ramps */ gamma_size_cookie = xcb_randr_get_crtc_gamma_size(state->conn, crtc); gamma_size_reply = xcb_randr_get_crtc_gamma_size_reply(state->conn, gamma_size_cookie, &error); if (error) { weprintf(_("`%s' returned error %i."), "RANDR Get CRTC Gamma Size", error->error_code); return -1; } ramp_size = gamma_size_reply->size; state->crtcs[i].ramp_size = ramp_size; free(gamma_size_reply); if (ramp_size == 0) { weprintf(_("Gamma ramp size too small: %zu"), (size_t)ramp_size); return -1; } /* Request current gamma ramps */ gamma_get_cookie = xcb_randr_get_crtc_gamma(state->conn, crtc); gamma_get_reply = xcb_randr_get_crtc_gamma_reply(state->conn, gamma_get_cookie, &error); if (error) { weprintf(_("`%s' returned error %i."), "RANDR Get CRTC Gamma", error->error_code); return -1; } gamma_r = xcb_randr_get_crtc_gamma_red(gamma_get_reply); gamma_g = xcb_randr_get_crtc_gamma_green(gamma_get_reply); gamma_b = xcb_randr_get_crtc_gamma_blue(gamma_get_reply); /* Allocate space for saved gamma ramps */ state->crtcs[i].saved_ramps = emalloc(3 * ramp_size * sizeof(uint16_t)); /* Copy gamma ramps into CRTC state */ memcpy(&state->crtcs[i].saved_ramps[0 * ramp_size], gamma_r, ramp_size * sizeof(uint16_t)); memcpy(&state->crtcs[i].saved_ramps[1 * ramp_size], gamma_g, ramp_size * sizeof(uint16_t)); memcpy(&state->crtcs[i].saved_ramps[2 * ramp_size], gamma_b, ramp_size * sizeof(uint16_t)); free(gamma_get_reply); } return 0; } static void randr_restore(struct gamma_state *state) { xcb_generic_error_t *error; int i; /* Restore CRTC gamma ramps */ for (i = 0; i < state->crtc_count; i++) { xcb_randr_crtc_t crtc = state->crtcs[i].crtc; unsigned int ramp_size = state->crtcs[i].ramp_size; uint16_t *gamma_r = &state->crtcs[i].saved_ramps[0*ramp_size]; uint16_t *gamma_g = &state->crtcs[i].saved_ramps[1*ramp_size]; uint16_t *gamma_b = &state->crtcs[i].saved_ramps[2*ramp_size]; /* Set gamma ramps */ xcb_void_cookie_t gamma_set_cookie = xcb_randr_set_crtc_gamma_checked(state->conn, crtc, ramp_size, gamma_r, gamma_g, gamma_b); error = xcb_request_check(state->conn, gamma_set_cookie); if (error) { weprintf(_("`%s' returned error %i."), "RANDR Set CRTC Gamma", error->error_code); weprintf(_("Unable to restore CRTC %i."), i); } } } static void randr_free(struct gamma_state *state) { int i; /* Free CRTC state */ for (i = 0; i < state->crtc_count; i++) free(state->crtcs[i].saved_ramps); free(state->crtcs); free(state->crtc_num); /* Close connection */ xcb_disconnect(state->conn); free(state); } static void randr_print_help(FILE *f) { fputs(_("Adjust gamma ramps with the X RANDR extension.\n"), f); fputs("\n", f); /* TRANSLATORS: RANDR help output left column must not be translated */ fputs(_(" screen=N\t\tX screen to apply adjustments to\n" " crtc=N\tList of comma separated CRTCs to apply" " adjustments to\n"), f); fputs("\n", f); } static int randr_set_option(struct gamma_state *state, const char *key, const char *value) { if (!strcasecmp(key, "screen")) { state->screen_num = atoi(value); } else if (!strcasecmp(key, "crtc")) { char *tail; int i, parsed; /* Check how many crtcs are configured */ const char *local_value = value; if (!*local_value || !strcasecmp(local_value, "all")) { state->crtc_num_count = 0; free(state->crtc_num); state->crtc_num = NULL; return 0; } for (;;) { errno = 0; parsed = strtol(local_value, &tail, 0); if (!parsed && (errno || tail == local_value)) { weprintf(_("Unable to read screen number: `%s'."), value); return -1; } state->crtc_num_count += 1; local_value = tail; if (*local_value == ',') local_value += 1; else if (!*local_value) break; } /* Configure all given crtcs */ state->crtc_num = calloc(state->crtc_num_count, sizeof(int)); local_value = value; for (i = 0; i < state->crtc_num_count; i++) { errno = 0; parsed = strtol(local_value, &tail, 0); if (parsed == 0 && (errno != 0 || tail == local_value)) return -1; state->crtc_num[i] = parsed; local_value = tail; if (*local_value == ',') local_value += 1; else if (!*local_value) break; } } else if (strcasecmp(key, "preserve") == 0) { weprintf(_("Parameter `%s' is now always on; use the `%s' command-line option to disable."), key, "-P"); } else { weprintf(_("Unknown method parameter: `%s'."), key); return -1; } return 0; } static int randr_apply_for_crtc(struct gamma_state *state, int crtc_num, const struct colour_setting *setting, int preserve) { xcb_randr_crtc_t crtc; xcb_void_cookie_t gamma_set_cookie; xcb_generic_error_t *error; unsigned int i, ramp_size; uint16_t *gamma_ramps, *gamma_r, *gamma_g, *gamma_b, value; if (crtc_num >= state->crtc_count || crtc_num < 0) { if (state->crtc_count > 1) weprintf(_("CRTC %i does not exist, valid CRTCs are [0, %i]."), crtc_num, (int)state->crtc_count - 1); else weprintf(_("CRTC %i does not exist, only CRTC 0 exists."), crtc_num); return -1; } crtc = state->crtcs[crtc_num].crtc; ramp_size = state->crtcs[crtc_num].ramp_size; /* Create new gamma ramps */ gamma_ramps = emalloc(3 * ramp_size * sizeof(uint16_t)); gamma_r = &gamma_ramps[0 * ramp_size]; gamma_g = &gamma_ramps[1 * ramp_size]; gamma_b = &gamma_ramps[2 * ramp_size]; if (preserve) { /* Initialize gamma ramps from saved state */ memcpy(gamma_ramps, state->crtcs[crtc_num].saved_ramps, 3 * ramp_size * sizeof(uint16_t)); } else { /* Initialize gamma ramps to pure state */ for (i = 0; i < ramp_size; i++) { value = (double)i / (ramp_size - 1) * UINT16_MAX; gamma_r[i] = value; gamma_g[i] = value; gamma_b[i] = value; } } fill_ramps_u16(gamma_r, gamma_g, gamma_b, ramp_size, ramp_size, ramp_size, setting); /* Set new gamma ramps */ gamma_set_cookie = xcb_randr_set_crtc_gamma_checked(state->conn, crtc, ramp_size, gamma_r, gamma_g, gamma_b); error = xcb_request_check(state->conn, gamma_set_cookie); if (error) { weprintf(_("`%s' returned error %i."), "RANDR Set CRTC Gamma", error->error_code); free(gamma_ramps); return -1; } free(gamma_ramps); return 0; } static int randr_apply(struct gamma_state *state, const struct colour_setting *setting, int preserve) { int i; /* If no CRTC numbers have been specified, set temperature on all CRTCs. */ if (!state->crtc_num_count) { for (i = 0; i < state->crtc_count; i++) if (randr_apply_for_crtc(state, i, setting, preserve) < 0) return -1; } else { for (i = 0; i < state->crtc_num_count; ++i) if (randr_apply_for_crtc(state, state->crtc_num[i], setting, preserve) < 0) return -1; } return 0; } const struct gamma_method randr_gamma_method = GAMMA_METHOD_INIT("randr", 1, 0, randr);