/** * cg-tools -- Cooperative gamma-enabled tools * Copyright (C) 2016 Mattias Andrée (maandree@kth.se) * * This program 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. * * This program 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 this program. If not, see <http://www.gnu.org/licenses/>. */ #define _DEFAULT_SOURCE #define _BSD_SOURCE #include "cg-base.h" #include <libclut.h> #include <alloca.h> #include <errno.h> #include <inttypes.h> #include <poll.h> #include <signal.h> #include <stdio.h> #include <stdlib.h> #include <string.h> /** * The process's name */ const char* argv0 = NULL; /** * The libcoopgamma context */ libcoopgamma_context_t cg; /** * The names of the selected CRTC:s */ char** crtcs = NULL; /** * Gamma ramp updates for each CRTC */ filter_update_t* crtc_updates = NULL; /** * CRTC and monitor information about * each selected CRTC and connect monitor */ libcoopgamma_crtc_info_t* crtc_info = NULL; /** * The number of selected CRTC:s */ size_t crtcs_n = 0; /** * Contexts for asynchronous ramp updates */ static libcoopgamma_async_context_t* asyncs = NULL; /** * The number of pending receives */ static size_t pending_recvs = 0; /** * Whether message must be flushed */ static int flush_pending = 0; /** * Data used to sort CRTC:s */ struct crtc_sort_data { /** * The gamma ramp type */ libcoopgamma_depth_t depth; /** * Should be 0 */ int __padding; /** * The size of the red gamma ramp */ size_t red_size; /** * The size of the green gamma ramp */ size_t green_size; /** * The size of the blue gamma ramp */ size_t blue_size; /** * The index of the CRTC */ size_t index; }; /** * Compare two instances of `crtc_sort_data` * * @param a_ Return -1 if this one is lower * @param b_ Return +1 if this one is higher * @return See `a_` and `b_`, only -1 or +1 can be returned */ static int crtc_sort_data_cmp(const void* a_, const void* b_) { const struct crtc_sort_data* a = a_; const struct crtc_sort_data* b = b_; int cmp = memcmp(a, b, sizeof(*a) - sizeof(a->index)); return cmp ? cmp : a->index < b->index ? -1 : +1; } /** * Make elements in `crtc_updates` slaves where appropriate * * @return Zero on success, -1 on error */ int make_slaves(void) { struct crtc_sort_data* data; size_t i, j, n = 0, master = 0, master_i; data = alloca(crtcs_n * sizeof(*data)); memset(data, 0, crtcs_n * sizeof(*data)); for (i = 0; i < crtcs_n; i++) { if (!(crtc_info[i].supported)) continue; data[n].depth = crtc_updates[i].filter.depth; data[n].red_size = crtc_updates[i].filter.ramps.u8.red_size; data[n].green_size = crtc_updates[i].filter.ramps.u8.green_size; data[n].blue_size = crtc_updates[i].filter.ramps.u8.blue_size; data[n].index = i; n++; } qsort(data, n, sizeof(*data), crtc_sort_data_cmp); if (n == 0) return 0; master_i = data[0].index; for (i = 1; i < n; i++) if (memcmp(data + i, data + master, sizeof(*data) - sizeof(data->index))) { if (master + 1 < i) { crtc_updates[master_i].slaves = calloc(i - master, sizeof(size_t)); if (crtc_updates[master_i].slaves == NULL) return -1; for (j = 1; master + j < i; j++) crtc_updates[master_i].slaves[j - 1] = data[master + j].index; } master = i; master_i = data[master].index; } else { libcoopgamma_ramps_destroy(&(crtc_updates[data[i].index].filter.ramps.u8)); crtc_updates[data[i].index].master = 0; crtc_updates[data[i].index].filter.ramps.u8 = crtc_updates[master_i].filter.ramps.u8; } if (master + 1 < i) { crtc_updates[master_i].slaves = calloc(i - master, sizeof(size_t)); if (crtc_updates[master_i].slaves == NULL) return -1; for (j = 1; master + j < i; j++) crtc_updates[master_i].slaves[j - 1] = data[master + j].index; } return 0; } /** * Update a filter and synchronise calls * * @param index The index of the CRTC * @param timeout The number of milliseconds a call to `poll` may block, * -1 if it may block forever * @return 1: Success, no pending synchronisations * 0: Success, with still pending synchronisations * -1: Error, `errno` set * -2: Error, `cg.error` set * * @throws EINTR Call to `poll` was interrupted by a signal * @throws EAGAIN Call to `poll` timed out */ int update_filter(size_t index, int timeout) { filter_update_t* filter = crtc_updates + index; if (!(filter->synced) || filter->failed) abort(); pending_recvs += 1; if (libcoopgamma_set_gamma_send(&(filter->filter), &cg, asyncs + index) < 0) switch (errno) { case EINTR: case EAGAIN: #if EAGAIN != EWOULDBLOCK case EWOULDBLOCK: #endif flush_pending = 1; break; default: return -1; } filter->synced = 0; return synchronise(timeout); } /** * Synchronised calls * * @param timeout The number of milliseconds a call to `poll` may block, * -1 if it may block forever * @return 1: Success, no pending synchronisations * 0: Success, with still pending synchronisations * -1: Error, `errno` set * -2: Error, `cg.error` set * * @throws EINTR Call to `poll` was interrupted by a signal * @throws EAGAIN Call to `poll` timed out */ int synchronise(int timeout) { struct pollfd pollfd; size_t selected; pollfd.fd = cg.fd; pollfd.events = POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI; if (flush_pending > 0) pollfd.events |= POLLOUT; pollfd.revents = 0; if (poll(&pollfd, (nfds_t)1, timeout) < 0) return -1; if (pollfd.revents & (POLLOUT | POLLERR | POLLHUP | POLLNVAL)) { if (libcoopgamma_flush(&cg) < 0) goto sync; flush_pending = 0; } if ((timeout < 0) && (pending_recvs > 0)) if (!(pollfd.revents & (POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI))) { pollfd.revents = 0; if (poll(&pollfd, (nfds_t)1, -1) < 0) return -1; } sync: if (pollfd.revents & (POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI | POLLERR | POLLHUP | POLLNVAL)) for (;;) { if (libcoopgamma_synchronise(&cg, asyncs, crtcs_n, &selected) < 0) { if (errno == 0) continue; else goto fail; } if (crtc_updates[selected].synced) continue; crtc_updates[selected].synced = 1; pending_recvs -= 1; if (libcoopgamma_set_gamma_recv(&cg, asyncs + selected) < 0) { if (cg.error.server_side) { crtc_updates[selected].error = cg.error; crtc_updates[selected].failed = 1; memset(&(cg.error), 0, sizeof(cg.error)); } else goto cg_fail; } } return pending_recvs == 0; cg_fail: return -2; fail: switch (errno) { case EINTR: case EAGAIN: #if EAGAIN != EWOULDBLOCK case EWOULDBLOCK: #endif return pending_recvs == 0; default: return -1; } } /** * Initialise the process, specifically * reset the signal mask and signal handlers * * @return Zero on success, -1 on error */ static int initialise_proc(void) { sigset_t sigmask; int sig; for (sig = 1; sig < _NSIG; sig++) if (signal(sig, SIG_DFL) == SIG_ERR) if (sig == SIGCHLD) return -1; if (sigemptyset(&sigmask) < 0) return -1; if (sigprocmask(SIG_SETMASK, &sigmask, NULL) < 0) return -1; return 0; } /** * Print, to stdout, a list of all * recognised adjustment methods * * @return Zero on success, -1 on error */ static int list_methods(void) { char** list; size_t i; list = libcoopgamma_get_methods(); if (list == NULL) return -1; for (i = 0; list[i]; i++) printf("%s\n", list[i]); free(list); if (fflush(stdout) < 0) return -1; return 0; } /** * Print, to stdout, a list of all CRTC:s * * A connection to the coopgamma server * must have been made * * @return Zero on success, -1 on error, -2 * on libcoopgamma error */ static int list_crtcs(void) { char** list; size_t i; list = libcoopgamma_get_crtcs_sync(&cg); if (list == NULL) return -2; for (i = 0; list[i]; i++) printf("%s\n", list[i]); free(list); if (fflush(stdout) < 0) return -1; return 0; } /** * Fill the list of CRTC information * * @return Zero on success, -1 on error, -2 * on libcoopgamma error */ static int get_crtc_info(void) { size_t i, unsynced = 0, selected; char* synced; int saved_errno, need_flush = 0; struct pollfd pollfd; synced = alloca(crtcs_n * sizeof(*synced)); memset(synced, 0, crtcs_n * sizeof(*synced)); i = 0; pollfd.fd = cg.fd; pollfd.events = POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI; while ((unsynced > 0) || (i < crtcs_n)) { wait: if (i < crtcs_n) pollfd.events |= POLLOUT; else pollfd.events &= ~POLLOUT; pollfd.revents = 0; if (poll(&pollfd, (nfds_t)1, -1) < 0) goto fail; if (pollfd.revents & (POLLOUT | POLLERR | POLLHUP | POLLNVAL)) { if (need_flush && (libcoopgamma_flush(&cg) < 0)) goto send_fail; need_flush = 0; for (; i < crtcs_n; i++) if (unsynced++, libcoopgamma_get_gamma_info_send(crtcs[i], &cg, asyncs + i) < 0) goto send_fail; goto send_done; send_fail: switch (errno) { case EINTR: case EAGAIN: #if EAGAIN != EWOULDBLOCK case EWOULDBLOCK: #endif i++; need_flush = 1; break; default: goto fail; } } send_done: if ((unsynced == 0) && (i == crtcs_n)) break; if (pollfd.revents & (POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI)) while (unsynced > 0) switch (libcoopgamma_synchronise(&cg, asyncs, i, &selected)) { case 0: if (synced[selected]) { libcoopgamma_skip_message(&cg); break; } synced[selected] = 1; unsynced -= 1; if (libcoopgamma_get_gamma_info_recv(crtc_info + selected, &cg, asyncs + selected) < 0) goto cg_fail; break; case -1: switch (errno) { case 0: break; case EINTR: case EAGAIN: #if EAGAIN != EWOULDBLOCK case EWOULDBLOCK: #endif goto wait; default: goto fail; } break; } } return 0; fail: return -1; cg_fail: return -2; } /** * -M METHOD * Select adjustment method. If METHOD is "?", * available methods will be printed to stdout. * * -S SITE * Select site (display server instance). * * -c CRTC * Select CRT controller. If CRTC is "?", CRTC:s * will be printed to stdout. * * This option can be used multiple times. If it * is not used at all, all CRTC:s will be selected. * * -p PRIORITY * Select the priority for the filter, this should * be a signed two's-complement integer. If * PRIORITY is "?", the default priority for the * program is printed to stdout. * * -R RULE * The rule of the filter, that is, the last part * of the class which is its identifier. If RULE * is "?" the default rule is printed to stdout, * if RULE is "??" the default class is printed * to stdout. * * @param argc The number of command line arguments * @param argv The command line arguments * @return 0 on success, 1 on error */ int main(int argc, char* argv[]) { int stage = 0; int dealloc_crtcs = 0; int rc = 0; char* method = NULL; char* site = NULL; size_t crtcs_i = 0; int64_t priority = default_priority; char* prio = NULL; char* rule = NULL; char* class = default_class; int explicit_crtcs = 0; argv0 = *argv++, argc--; if (initialise_proc() < 0) goto fail; crtcs = alloca(argc * sizeof(*crtcs)); for (; *argv; argv++, argc--) { char* args = *argv; char opt[3]; if (!strcmp(args, "--")) { argv++, argc--; break; } opt[0] = *args++; opt[2] = '\0'; if ((*opt != '-') && (*opt != '+')) break; while (*args) { char* arg; int at_end; opt[1] = *args++; arg = args; if ((at_end = !*arg)) arg = argv[1]; if (!strcmp(opt, "-M")) { if ((method != NULL) || ((method = arg) == NULL)) usage(); } else if (!strcmp(opt, "-S")) { if ((site != NULL) || ((site = arg) == NULL)) usage(); } else if (!strcmp(opt, "-c")) { if (arg == NULL) usage(); crtcs[crtcs_i++] = arg; explicit_crtcs = 1; } else if (!strcmp(opt, "-p")) { if ((prio != NULL) || ((prio = arg) == NULL)) usage(); } else if (!strcmp(opt, "-R")) { if ((rule != NULL) || ((rule = arg) == NULL)) usage(); } else switch (handle_opt(opt, arg)) { case 0: goto next_opt; case 1: break; default: goto fail; } argv += at_end; argc -= at_end; break; next_opt:; } } crtcs_n = crtcs_i; crtcs[crtcs_i] = NULL; if (handle_args(argc, argv, method, site, crtcs, prio, rule) < 0) goto fail; if ((prio != NULL) && !strcmp(prio, "?")) { printf("%" PRIi64 "\n", priority); return 0; } else if (prio != NULL) priority = (int64_t)atoll(prio); if ((rule != NULL) && !strcmp(rule, "??")) { printf("%s\n", class); return 0; } else if ((rule != NULL) && !strcmp(rule, "?")) { printf("%s\n", strstr(strstr(class, "::") + 2, "::") + 2); return 0; } else if (rule != NULL) { char* p = strstr(strstr(class, "::") + 2, "::") + 2; size_t n = (size_t)(p - class); class = alloca(strlen(rule) + n + (size_t)1); memcpy(class, default_class, n); strcpy(class + n, rule); if (strchr(class, '\n')) { fprintf(stderr, "%s: LF character is not allowed in the filter's class\n", argv0); goto custom_fail; } } if ((method != NULL) && !strcmp(method, "?")) { if (list_methods() < 0) goto fail; return 0; } if (libcoopgamma_context_initialise(&cg) < 0) goto fail; stage++; if (libcoopgamma_connect(method, site, &cg) < 0) { fprintf(stderr, "%s: server failed to initialise\n", argv0); goto custom_fail; } stage++; while (crtcs_i--) if (!strcmp(crtcs[crtcs_i], "?")) switch (list_crtcs()) { case 0: goto done; case -1: goto fail; default: goto cg_fail; } if (crtcs_n == 0) { crtcs = libcoopgamma_get_crtcs_sync(&cg); if (crtcs == NULL) goto cg_fail; dealloc_crtcs = 1; for (; crtcs[crtcs_n] != NULL; crtcs_n++); } if (crtcs_n == 0) { fprintf(stderr, "%s: no CRTC:s are available\n", argv0); goto custom_fail; } crtc_info = alloca(crtcs_n * sizeof(*crtc_info)); memset(crtc_info, 0, crtcs_n * sizeof(*crtc_info)); for (crtcs_i = 0; crtcs_i < crtcs_n; crtcs_i++) if (libcoopgamma_crtc_info_initialise(crtc_info + crtcs_i) < 0) goto cg_fail; if (libcoopgamma_set_nonblocking(&cg, 1) < 0) goto fail; asyncs = alloca(crtcs_n * sizeof(*asyncs)); memset(asyncs, 0, crtcs_n * sizeof(*asyncs)); for (crtcs_i = 0; crtcs_i < crtcs_n; crtcs_i++) if (libcoopgamma_async_context_initialise(asyncs + crtcs_i) < 0) goto fail; switch (get_crtc_info()) { case 0: break; case -1: goto fail; case -2: goto cg_fail; } for (crtcs_i = 0; crtcs_i < crtcs_n; crtcs_i++) { if (explicit_crtcs && !(crtc_info[crtcs_i].supported)) fprintf(stderr, "%s: warning: gamma adjustments not supported on CRTC: %s\n", argv0, crtcs[crtcs_i]); if (crtc_info[crtcs_i].cooperative == 0) fprintf(stderr, "%s: warning: cooperative gamma server not running for CRTC: %s\n", argv0, crtcs[crtcs_i]); } crtc_updates = alloca(crtcs_n * sizeof(*crtc_updates)); memset(crtc_updates, 0, crtcs_n * sizeof(*crtc_updates)); for (crtcs_i = 0; crtcs_i < crtcs_n; crtcs_i++) { if (libcoopgamma_filter_initialise(&(crtc_updates[crtcs_i].filter)) < 0) goto fail; if (libcoopgamma_error_initialise(&(crtc_updates[crtcs_i].error)) < 0) goto fail; crtc_updates[crtcs_i].synced = 1; crtc_updates[crtcs_i].failed = 0; crtc_updates[crtcs_i].master = 1; crtc_updates[crtcs_i].slaves = NULL; crtc_updates[crtcs_i].filter.crtc = crtcs[crtcs_i]; crtc_updates[crtcs_i].filter.class = class; crtc_updates[crtcs_i].filter.priority = priority; crtc_updates[crtcs_i].filter.depth = crtc_info[crtcs_i].depth; crtc_updates[crtcs_i].filter.ramps.u8.red_size = crtc_info[crtcs_i].red_size; crtc_updates[crtcs_i].filter.ramps.u8.green_size = crtc_info[crtcs_i].green_size; crtc_updates[crtcs_i].filter.ramps.u8.blue_size = crtc_info[crtcs_i].blue_size; switch (crtc_updates[crtcs_i].filter.depth) { #define X(CONST, MEMBER, MAX, TYPE)\ case CONST:\ libcoopgamma_ramps_initialise(&(crtc_updates[crtcs_i].filter.ramps.MEMBER));\ libclut_start_over(&(crtc_updates[crtcs_i].filter.ramps.MEMBER), MAX, TYPE, 1, 1, 1);\ break; LIST_DEPTHS #undef X default: fprintf(stderr, "%s: internal error: gamma ramp type is unrecognised: %i\n", argv0, crtc_updates[crtcs_i].filter.depth); goto custom_fail; } } switch (start()) { case 0: break; case -1: goto fail; case -2: goto cg_fail; case -3: goto custom_fail; } for (crtcs_i = 0; crtcs_i < crtcs_n; crtcs_i++) if (crtc_updates[crtcs_i].failed) { const char* side = cg.error.server_side ? "server" : "client"; const char* crtc = crtc_updates[crtcs_i].filter.crtc; if (cg.error.custom) { if ((cg.error.number != 0) || (cg.error.description != NULL)) fprintf(stderr, "%s: %s-side error number %" PRIu64 " for CRTC %s: %s\n", argv0, side, cg.error.number, crtc, cg.error.description); else if (cg.error.number != 0) fprintf(stderr, "%s: %s-side error number %" PRIu64 " for CRTC %s\n", argv0, side, cg.error.number, crtc); else if (cg.error.description != NULL) fprintf(stderr, "%s: %s-side error for CRTC %s: %s\n", argv0, side, crtc, cg.error.description); } else if (cg.error.description != NULL) fprintf(stderr, "%s: %s-side error for CRTC %s: %s\n", argv0, side, crtc, cg.error.description); else fprintf(stderr, "%s: %s-side error for CRTC %s: %s\n", argv0, side, crtc, strerror(cg.error.number)); } done: if (dealloc_crtcs) free(crtcs); if (crtc_info != NULL) for (crtcs_i = 0; crtcs_i < crtcs_n; crtcs_i++) libcoopgamma_crtc_info_destroy(crtc_info + crtcs_i); if (asyncs != NULL) for (crtcs_i = 0; crtcs_i < crtcs_n; crtcs_i++) libcoopgamma_async_context_destroy(asyncs + crtcs_i); if (stage >= 1) libcoopgamma_context_destroy(&cg, stage >= 2); if (crtc_updates != NULL) for (crtcs_i = 0; crtcs_i < crtcs_n; crtcs_i++) { if (crtc_updates[crtcs_i].master == 0) memset(&(crtc_updates[crtcs_i].filter.ramps.u8), 0, sizeof(crtc_updates[crtcs_i].filter.ramps.u8)); crtc_updates[crtcs_i].filter.crtc = NULL; crtc_updates[crtcs_i].filter.class = NULL; libcoopgamma_filter_destroy(&(crtc_updates[crtcs_i].filter)); libcoopgamma_error_destroy(&(crtc_updates[crtcs_i].error)); free(crtc_updates[crtcs_i].slaves); } return rc; custom_fail: rc = 1; goto done; fail: rc = 1; perror(argv0); goto done; cg_fail: rc = 1; { const char* side = cg.error.server_side ? "server" : "client"; if (cg.error.custom) { if ((cg.error.number != 0) || (cg.error.description != NULL)) fprintf(stderr, "%s: %s-side error number %" PRIu64 ": %s\n", argv0, side, cg.error.number, cg.error.description); else if (cg.error.number != 0) fprintf(stderr, "%s: %s-side error number %" PRIu64 "\n", argv0, side, cg.error.number); else if (cg.error.description != NULL) fprintf(stderr, "%s: %s-side error: %s\n", argv0, side, cg.error.description); } else if (cg.error.description != NULL) fprintf(stderr, "%s: %s-side error: %s\n", argv0, side, cg.error.description); else fprintf(stderr, "%s: %s-side error: %s\n", argv0, side, strerror(cg.error.number)); } goto done; }