/* See LICENSE file for copyright and license details. */
#include "arg.h"
#include <libcoopgamma.h>
#include <errno.h>
#include <inttypes.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/**
* The libcoopgamma context
*/
static libcoopgamma_context_t cg;
/**
* Filter query
*/
static libcoopgamma_filter_query_t query;
/**
* The class of the filter to print
*/
static char *class = NULL;
/**
* Print usage information and exit
*/
static void
usage(void)
{
fprintf(stderr,
"usage: %s [-M method] [-S site] [-h high] [-l low] [-f class] -c crtc\n",
argv0);
exit(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)
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)
return -2;
for (i = 0; list[i]; i++)
printf("%s\n", list[i]);
free(list);
if (fflush(stdout) < 0)
return -1;
return 0;
}
/**
* Print, to stdout, information about
* the selected CRTC
*
* @return Zero on success, -1 on error, -2
* on libcoopgamma error, -3 on error
* with error message already printed
*/
static int
print_info(void)
{
libcoopgamma_crtc_info_t info;
libcoopgamma_filter_table_t table;
const char *str;
int saved_errno, ret = 0;
size_t i;
if (libcoopgamma_crtc_info_initialise(&info) < 0)
return -1;
if (libcoopgamma_filter_table_initialise(&table) < 0) {
saved_errno = errno;
libcoopgamma_crtc_info_destroy(&info);
errno = saved_errno;
return -1;
}
if (libcoopgamma_get_gamma_info_sync(query.crtc, &info, &cg) < 0)
goto cg_fail;
printf("Cooperative gamma server running: %s\n",
info.cooperative ? "yes" : "no");
printf("Gamma adjustments supported: %s\n",
info.supported == LIBCOOPGAMMA_MAYBE ? "maybe" : info.supported ? "yes" : "no");
printf("Gamma ramps stops (red green blue): %zu %zu %zu\n",
info.red_size, info.green_size, info.blue_size);
switch (info.depth) {
case LIBCOOPGAMMA_DOUBLE: str = "double-precision floating-point"; break;
case LIBCOOPGAMMA_FLOAT: str = "single-precision floating-point"; break;
case LIBCOOPGAMMA_UINT8: str = "unsigned 8-bit integer"; break;
case LIBCOOPGAMMA_UINT16: str = "unsigned 16-bit integer"; break;
case LIBCOOPGAMMA_UINT32: str = "unsigned 32-bit integer"; break;
case LIBCOOPGAMMA_UINT64: str = "unsigned 64-bit integer"; break;
default:
errno = EPROTO;
goto fail;
}
printf("Gamma ramps stops value type: %s\n", str);
if (info.colourspace != LIBCOOPGAMMA_UNKNOWN) {
switch (info.colourspace) {
case LIBCOOPGAMMA_SRGB: str = "sRGB"; break;
case LIBCOOPGAMMA_RGB: str = "non-standard RGB"; break;
case LIBCOOPGAMMA_NON_RGB: str = "non-RGB multicolour"; break;
case LIBCOOPGAMMA_GREY: str = "monochrome or singlecolour scale"; break;
case LIBCOOPGAMMA_UNKNOWN:
default:
errno = EPROTO;
goto fail;
}
printf("Monitor's colourspace: %s\n", str);
}
if (info.have_gamut) {
printf("Monitor's red colour (x, y): %lf, %lf\n",
info.red_x / (double)1024, info.red_y / (double)1024);
printf("Monitor's green colour (x, y): %lf, %lf\n",
info.green_x / (double)1024, info.green_y / (double)1024);
printf("Monitor's blue colour (x, y): %lf, %lf\n",
info.blue_x / (double)1024, info.blue_y / (double)1024);
printf("Monitor's white point (x, y): %lf, %lf\n",
info.white_x / (double)1024, info.white_y / (double)1024);
}
if (libcoopgamma_get_gamma_sync(&query, &table, &cg) < 0)
goto cg_fail;
if (table.red_size != info.red_size || table.green_size != info.green_size ||
table.blue_size != info.blue_size || table.depth != info.depth) {
fprintf(stderr, "%s: gamma ramp structure changed between queries\n", argv0);
goto custom_fail;
}
printf("Filters: %zu\n", table.filter_count);
for (i = 0; i < table.filter_count; i++) {
printf(" Filter %zu:\n", i);
printf(" Priority: %" PRIi64 "\n", table.filters[i].priority);
printf(" Class: %s\n", table.filters[i].class);
}
done:
saved_errno = errno;
libcoopgamma_crtc_info_destroy(&info);
libcoopgamma_filter_table_destroy(&table);
errno = saved_errno;
return ret;
fail:
ret = -1;
goto done;
cg_fail:
ret = -2;
goto done;
custom_fail:
ret = -3;
goto done;
}
/**
* Print, to stdout, the ramps of the select
* filter on the select CRTC
*
* @return Zero on success, -1 on error, -2
* on libcoopgamma error, -3 on error
* with error message already printed
*/
static int
print_filter(void)
{
libcoopgamma_filter_table_t table;
libcoopgamma_ramps_t *restrict ramps;
int saved_errno, ret = 0;
size_t i, n;
if (libcoopgamma_filter_table_initialise(&table) < 0)
return -1;
if (libcoopgamma_get_gamma_sync(&query, &table, &cg) < 0)
goto cg_fail;
if (query.coalesce) {
i = 0;
} else {
for (i = 0; i < table.filter_count; i++)
if (!strcmp(table.filters[i].class, class))
break;
}
if (i == table.filter_count) {
fprintf(stderr, "%s: selected filter does not exist on selected CRTC\n", argv0);
goto custom_fail;
}
ramps = &table.filters[i].ramps;
n = table.red_size;
if (n < table.green_size)
n = table.green_size;
if (n < table.blue_size)
n = table.blue_size;
switch (table.depth) {
#define X(CONST, MEMBER, TYPE, FORMAT, DASH)\
case CONST:\
for (i = 0; i < n; i++) {\
if (i < ramps->MEMBER.red_size)\
printf("%" FORMAT " ", (TYPE)(ramps->MEMBER.red[i]));\
else\
printf(DASH " ");\
\
if (i < ramps->MEMBER.green_size)\
printf("%" FORMAT " ", (TYPE)(ramps->MEMBER.green[i]));\
else\
printf(DASH " ");\
\
if (i < ramps->MEMBER.blue_size)\
printf("%" FORMAT "\n", (TYPE)(ramps->MEMBER.blue[i]));\
else\
printf(DASH "\n");\
} \
break
X(LIBCOOPGAMMA_DOUBLE, d, double, "lf", "----");
X(LIBCOOPGAMMA_FLOAT, f, double, "lf", "----");
X(LIBCOOPGAMMA_UINT8, u8, uint8_t, "02" PRIx8, "--");
X(LIBCOOPGAMMA_UINT16, u16, uint16_t, "04" PRIx16, "----");
X(LIBCOOPGAMMA_UINT32, u32, uint32_t, "08" PRIx32, "--------");
X(LIBCOOPGAMMA_UINT64, u64, uint64_t, "016" PRIx64, "----------------");
#undef X
default:
errno = EPROTO;
goto fail;
}
done:
saved_errno = errno;
libcoopgamma_filter_table_destroy(&table);
errno = saved_errno;
return ret;
fail:
ret = -1;
goto done;
cg_fail:
ret = -2;
goto done;
custom_fail:
ret = -3;
goto done;
}
/**
* -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.
*
* -h HIGH
* Suppress filter with higher priority than HIGH.
*
* -l LOW
* Suppress filter with lower priority than LOW.
*
* -f CLASS
* Print gamma ramps of the filter with class CLASS
* on the selected CRTC. If CLASS is "*" all filters
* with a priority in [LOW, HIGH] are coalesced.
*
* @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, haveh = 0, havel = 0;
int rc = 0;
char *method = NULL;
char *site = NULL;
const char *side;
query.high_priority = INT64_MAX;
query.low_priority = INT64_MIN;
query.crtc = NULL;
query.coalesce = 0;
ARGBEGIN {
case 'M':
if (method)
usage();
method = EARGF(usage());
break;
case 'S':
if (site)
usage();
site = EARGF(usage());
break;
case 'c':
if (query.crtc)
usage();
query.crtc = EARGF(usage());
break;
case 'h':
if (haveh++)
usage();
query.high_priority = (int64_t)atoll(EARGF(usage()));
break;
case 'l':
if (havel++)
usage();
query.low_priority = (int64_t)atoll(EARGF(usage()));
break;
case 'f':
if (class)
usage();
class = EARGF(usage());
if (class[0] == '*' && class[1] == '\0')
query.coalesce = 1;
break;
default:
usage();
}
ARGEND;
if (argc)
usage();
if (initialise_proc() < 0)
goto fail;
if (method && !strcmp(method, "?")) {
if (site || query.crtc)
usage();
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++;
if (!query.crtc)
usage();
if (!strcmp(query.crtc, "?")) {
switch (list_crtcs()) {
case 0:
goto done;
case -1:
goto fail;
default:
goto cg_fail;
}
}
switch (class ? print_filter() : print_info()) {
case 0:
goto done;
case -1:
goto fail;
case -2:
goto cg_fail;
default:
goto custom_fail;
}
fflush(stdout);
if (ferror(stdout))
goto fail;
if (fclose(stdout) < 0)
goto fail;
done:
if (stage >= 1)
libcoopgamma_context_destroy(&cg, stage >= 2);
return rc;
custom_fail:
rc = 1;
goto done;
fail:
rc = 1;
perror(argv0);
goto done;
cg_fail:
rc = 1;
side = cg.error.server_side ? "server" : "client";
if (cg.error.custom) {
if (cg.error.number || cg.error.description) {
fprintf(stderr, "%s: %s-side error number %" PRIu64 ": %s\n",
argv0, side, cg.error.number, cg.error.description);
} else if (cg.error.number) {
fprintf(stderr, "%s: %s-side error number %" PRIu64 "\n", argv0, side, cg.error.number);
} else if (cg.error.description) {
fprintf(stderr, "%s: %s-side error: %s\n", argv0, side, cg.error.description);
}
} else if (cg.error.description) {
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((int)cg.error.number));
}
goto done;
}
