diff --git a/README.md b/README.md index c408bdd..2e98730 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # wlsunset -Day/night gamma adjustments for Wayland compositors supporting wlr-gamma-control-unstable-v1. +Day/night gamma adjustments for Wayland compositors supporting `wlr-gamma-control-unstable-v1` & `xdg-output-unstable-v1`. # How to build and install diff --git a/main.c b/main.c index 38e0faa..6378a3c 100644 --- a/main.c +++ b/main.c @@ -14,8 +14,10 @@ #include #include +#include "xdg-output-unstable-v1-client-protocol.h" #include "wlr-gamma-control-unstable-v1-client-protocol.h" #include "color_math.h" +#include "str_vec.h" #if defined(SPEEDRUN) static time_t start = 0, offset = 0, multiplier = 1000; @@ -92,6 +94,8 @@ struct config { time_t sunrise; time_t sunset; time_t duration; + + struct str_vec output_names; }; enum state { @@ -117,6 +121,9 @@ struct context { bool new_output; struct wl_list outputs; timer_t timer; + + struct zwlr_gamma_control_manager_v1 *gamma_control_manager; + struct zxdg_output_manager_v1 *xdg_output_manager; }; struct output { @@ -124,12 +131,14 @@ struct output { struct context *context; struct wl_output *wl_output; + struct zxdg_output_v1 *xdg_output; struct zwlr_gamma_control_v1 *gamma_control; int table_fd; uint32_t id; uint32_t ramp_size; uint16_t *table; + char *name; }; static void print_trajectory(struct context *ctx) { @@ -354,7 +363,6 @@ static void update_timer(const struct context *ctx, timer_t timer, time_t now) { timer_settime(timer, TIMER_ABSTIME, &timerspec, NULL); } -static struct zwlr_gamma_control_manager_v1 *gamma_control_manager = NULL; static int create_anonymous_file(off_t size) { char template[] = "/tmp/wlsunset-shared-XXXXXX"; @@ -433,17 +441,63 @@ static const struct zwlr_gamma_control_v1_listener gamma_control_listener = { .failed = gamma_control_handle_failed, }; -static void setup_output(struct output *output) { +static void xdg_output_handle_logical_position(void *data, + struct zxdg_output_v1 *xdg_output, int32_t x, int32_t y) { + (void)data, (void)xdg_output, (void)x, (void)y; +} + +static void xdg_output_handle_logical_size(void *data, + struct zxdg_output_v1 *xdg_output, int32_t width, int32_t height) { + (void)data, (void)xdg_output, (void)width, (void)height; +} + +static void xdg_output_handle_done(void *data, + struct zxdg_output_v1 *xdg_output) { + (void)data, (void)xdg_output; +} + +static void xdg_output_handle_name(void *data, + struct zxdg_output_v1 *xdg_output, const char *name) { + (void)xdg_output; + struct output *output = data; + output->name = strdup(name); +} + +static void xdg_output_handle_description(void *data, + struct zxdg_output_v1 *xdg_output, const char *description) { + (void)data, (void)xdg_output, (void)description; +} + +static const struct zxdg_output_v1_listener xdg_output_listener = { + .logical_position = xdg_output_handle_logical_position, + .logical_size = xdg_output_handle_logical_size, + .done = xdg_output_handle_done, + .name = xdg_output_handle_name, + .description = xdg_output_handle_description, +}; + +static void setup_xdg_output(struct context *ctx, struct output *output) { + if (ctx->xdg_output_manager == NULL) { + fprintf(stderr, "skipping setup of output %d: xdg_output_manager is missing\n", + output->id); + return; + } + output->xdg_output = zxdg_output_manager_v1_get_xdg_output( + ctx->xdg_output_manager, output->wl_output); + zxdg_output_v1_add_listener(output->xdg_output, &xdg_output_listener, output); +} + +static void setup_gamma_control(struct context *ctx, struct output *output) { if (output->gamma_control != NULL) { return; } - if (gamma_control_manager == NULL) { + if (ctx->gamma_control_manager == NULL) { fprintf(stderr, "skipping setup of output %d: gamma_control_manager missing\n", output->id); return; } output->gamma_control = zwlr_gamma_control_manager_v1_get_gamma_control( - gamma_control_manager, output->wl_output); + ctx->gamma_control_manager, output->wl_output); zwlr_gamma_control_v1_add_listener(output->gamma_control, &gamma_control_listener, output); } @@ -461,10 +515,18 @@ static void registry_handle_global(void *data, struct wl_registry *registry, output->table_fd = -1; output->context = ctx; wl_list_insert(&ctx->outputs, &output->link); - setup_output(output); + + if (ctx->config.output_names.len > 0) { + setup_xdg_output(ctx, output); + } + setup_gamma_control(ctx, output); + } else if (ctx->config.output_names.len > 0 && strcmp(interface, + zxdg_output_manager_v1_interface.name) == 0) { + ctx->xdg_output_manager = wl_registry_bind(registry, name, + &zxdg_output_manager_v1_interface, version); } else if (strcmp(interface, zwlr_gamma_control_manager_v1_interface.name) == 0) { - gamma_control_manager = wl_registry_bind(registry, name, + ctx->gamma_control_manager = wl_registry_bind(registry, name, &zwlr_gamma_control_manager_v1_interface, 1); } } @@ -478,6 +540,9 @@ static void registry_handle_global_remove(void *data, if (output->id == name) { fprintf(stderr, "registry: removing output %d\n", name); wl_list_remove(&output->link); + if (output->xdg_output != NULL) { + zxdg_output_v1_destroy(output->xdg_output); + } if (output->gamma_control != NULL) { zwlr_gamma_control_v1_destroy(output->gamma_control); } @@ -508,21 +573,51 @@ static void fill_gamma_table(uint16_t *table, uint32_t ramp_size, double rw, } } -static void set_temperature(struct wl_list *outputs, int temp, double gamma) { +static void set_temperature(struct output *output, double rw, + double gw, double bw, double gamma) { + if (output->gamma_control == NULL || output->table_fd == -1) { + return; + } + fill_gamma_table(output->table, output->ramp_size, rw, gw, bw, gamma); + lseek(output->table_fd, 0, SEEK_SET); + zwlr_gamma_control_v1_set_gamma(output->gamma_control, + output->table_fd); +} + +static void set_temperature_all_outputs(struct wl_list *outputs, + struct config *cfg, int temp, double gamma) { double rw, gw, bw; calc_whitepoint(temp, &rw, &gw, &bw); - fprintf(stderr, "setting temperature to %d K\n", temp); + // If outputs specified by user, then set temperature only for them. + // Otherwise set temperature for all outputs. struct output *output; - wl_list_for_each(output, outputs, link) { - if (output->gamma_control == NULL || output->table_fd == -1) { - continue; + if (cfg->output_names.len > 0) { + for (size_t i = 0; i < cfg->output_names.len; ++i) { + bool output_exists = false; + wl_list_for_each(output, outputs, link) { + if (output->name && strcmp(output->name, cfg->output_names.data[i]) == 0) { + fprintf(stderr, + "setting temperature on '%s' to %d K\n", + output->name, temp); + set_temperature(output, rw, gw, bw, gamma); + output_exists = true; + break; + } + } + if (!output_exists) { + fprintf(stderr, "Output '%s' not found!\n", + cfg->output_names.data[i]); + } + + } + } else { + wl_list_for_each(output, outputs, link) { + fprintf(stderr, + "setting temperature on output '%d' to %d K\n", + output->id, temp); + set_temperature(output, rw, gw, bw, gamma); } - fill_gamma_table(output->table, output->ramp_size, - rw, gw, bw, gamma); - lseek(output->table_fd, 0, SEEK_SET); - zwlr_gamma_control_v1_set_gamma(output->gamma_control, - output->table_fd); } } @@ -631,7 +726,6 @@ static int setup_timer(struct context *ctx) { } static int wlrun(struct config cfg) { - // Initialize defaults struct context ctx = { .sun = { 0 }, @@ -639,6 +733,7 @@ static int wlrun(struct config cfg) { .state = STATE_INITIAL, .config = cfg, }; + if (!cfg.manual_time) { ctx.longitude_time_offset = longitude_time_offset(cfg.longitude); } @@ -659,14 +754,22 @@ static int wlrun(struct config cfg) { wl_registry_add_listener(registry, ®istry_listener, &ctx); wl_display_roundtrip(display); - if (gamma_control_manager == NULL) { + if (ctx.config.output_names.len > 0 && ctx.xdg_output_manager == NULL) { + fprintf(stderr, "compositor doesn't support xdg-output-unstable-v1\n"); + return EXIT_FAILURE; + } + + if (ctx.gamma_control_manager == NULL) { fprintf(stderr, "compositor doesn't support wlr-gamma-control-unstable-v1\n"); return EXIT_FAILURE; } struct output *output; wl_list_for_each(output, &ctx.outputs, link) { - setup_output(output); + if (ctx.config.output_names.len > 0) { + setup_xdg_output(&ctx, output); + } + setup_gamma_control(&ctx, output); } wl_display_roundtrip(display); @@ -675,7 +778,8 @@ static int wlrun(struct config cfg) { update_timer(&ctx, ctx.timer, now); int temp = get_temperature(&ctx, now); - set_temperature(&ctx.outputs, temp, ctx.config.gamma); + set_temperature_all_outputs(&ctx.outputs, &ctx.config, + temp, ctx.config.gamma); int old_temp = temp; while (display_dispatch(display, -1) != -1) { @@ -689,12 +793,14 @@ static int wlrun(struct config cfg) { if ((temp = get_temperature(&ctx, now)) != old_temp) { old_temp = temp; ctx.new_output = false; - set_temperature(&ctx.outputs, temp, - ctx.config.gamma); + set_temperature_all_outputs(&ctx.outputs, &ctx.config, + temp, ctx.config.gamma); } } else if (ctx.new_output) { ctx.new_output = false; - set_temperature(&ctx.outputs, temp, ctx.config.gamma); + + set_temperature_all_outputs(&ctx.outputs, &ctx.config, + temp, ctx.config.gamma); } } @@ -719,6 +825,9 @@ static int parse_time_of_day(const char *s, time_t *time) { static const char usage[] = "usage: %s [options]\n" " -h show this help message\n" " -v show the version number\n" +" -o name of output (display) to use,\n" +" by default all outputs are used\n" +" can be specified multiple times\n" " -t set low temperature (default: 4000)\n" " -T set high temperature (default: 6500)\n" " -l set latitude (e.g. 39.9)\n" @@ -741,10 +850,15 @@ int main(int argc, char *argv[]) { .low_temp = 4000, .gamma = 1.0, }; + str_vec_init(&config.output_names); + int ret = EXIT_FAILURE; int opt; - while ((opt = getopt(argc, argv, "hvt:T:l:L:S:s:d:g:")) != -1) { + while ((opt = getopt(argc, argv, "hvo:t:T:l:L:S:s:d:g:")) != -1) { switch (opt) { + case 'o': + str_vec_push(&config.output_names, optarg); + break; case 't': config.low_temp = strtol(optarg, NULL, 10); break; @@ -760,14 +874,14 @@ int main(int argc, char *argv[]) { case 'S': if (parse_time_of_day(optarg, &config.sunrise) != 0) { fprintf(stderr, "invalid time, expected HH:MM, got %s\n", optarg); - return EXIT_FAILURE; + goto end; } config.manual_time = true; break; case 's': if (parse_time_of_day(optarg, &config.sunset) != 0) { fprintf(stderr, "invalid time, expected HH:MM, got %s\n", optarg); - return EXIT_FAILURE; + goto end; } config.manual_time = true; break; @@ -779,38 +893,42 @@ int main(int argc, char *argv[]) { break; case 'v': printf("wlsunset version %s\n", WLSUNSET_VERSION); - return EXIT_SUCCESS; + ret = EXIT_SUCCESS; + goto end; case 'h': + ret = EXIT_SUCCESS; default: fprintf(stderr, usage, argv[0]); - return opt == 'h' ? EXIT_SUCCESS : EXIT_FAILURE; + goto end; } } if (config.high_temp <= config.low_temp) { fprintf(stderr, "high temp (%d) must be higher than low (%d) temp\n", config.high_temp, config.low_temp); - return EXIT_FAILURE; + goto end; } if (config.manual_time) { if (!isnan(config.latitude) || !isnan(config.longitude)) { fprintf(stderr, "latitude and longitude are not valid in manual time mode\n"); - return EXIT_FAILURE; + goto end; } } else { if (config.latitude > 90.0 || config.latitude < -90.0) { fprintf(stderr, "latitude (%lf) must be in interval [-90,90]\n", config.latitude); - return EXIT_FAILURE; + goto end; } config.latitude = RADIANS(config.latitude); if (config.longitude > 180.0 || config.longitude < -180.0) { fprintf(stderr, "longitude (%lf) must be in interval [-180,180]\n", config.longitude); - return EXIT_FAILURE; + goto end; } config.longitude = RADIANS(config.longitude); } - - return wlrun(config); + ret = wlrun(config); +end: + str_vec_free(&config.output_names); + return ret; } diff --git a/meson.build b/meson.build index 9a02caf..0b13e4e 100644 --- a/meson.build +++ b/meson.build @@ -37,8 +37,8 @@ scanner = find_program('wayland-scanner') scanner_private_code = generator(scanner, output: '@BASENAME@-protocol.c', arguments: ['private-code', '@INPUT@', '@OUTPUT@']) scanner_client_header = generator(scanner, output: '@BASENAME@-client-protocol.h', arguments: ['client-header', '@INPUT@', '@OUTPUT@']) -protocols_src = [scanner_private_code.process('wlr-gamma-control-unstable-v1.xml')] -protocols_headers = [scanner_client_header.process('wlr-gamma-control-unstable-v1.xml')] +protocols_src = [scanner_private_code.process('wlr-gamma-control-unstable-v1.xml', 'xdg-output-unstable-v1.xml')] +protocols_headers = [scanner_client_header.process('wlr-gamma-control-unstable-v1.xml', 'xdg-output-unstable-v1.xml')] wl_client = dependency('wayland-client') wl_protocols = dependency('wayland-protocols') @@ -51,7 +51,7 @@ rt = cc.find_library('rt') executable( 'wlsunset', - ['main.c', 'color_math.c'], + ['main.c', 'color_math.c', 'str_vec.c'], dependencies: [wl_client, protocols_dep, m, rt], install: true, ) diff --git a/str_vec.c b/str_vec.c new file mode 100644 index 0000000..eb87b51 --- /dev/null +++ b/str_vec.c @@ -0,0 +1,29 @@ +#include +#include + +#include "str_vec.h" + +void str_vec_init(struct str_vec *vec) { + vec->data = NULL; + vec->len = 0; +} + +void str_vec_push(struct str_vec *vec, const char *new_str) { + ++vec->len; + vec->data = realloc(vec->data, vec->len * sizeof(char*)); + vec->data[vec->len - 1] = strdup(new_str); +} + +void str_vec_free(struct str_vec *vec) { + if (vec == NULL) { + return; + } + for (size_t i = 0; i < vec->len; ++i) { + if (vec->data[i] != NULL) { + free(vec->data[i]); + } + } + free(vec->data); + vec->data = NULL; + vec->len = 0; +} diff --git a/str_vec.h b/str_vec.h new file mode 100644 index 0000000..f361b39 --- /dev/null +++ b/str_vec.h @@ -0,0 +1,15 @@ +#ifndef STR_VEC_H +#define STR_VEC_H + +#include + +struct str_vec { + char **data; + size_t len; +}; + +void str_vec_init(struct str_vec *vec); +void str_vec_push(struct str_vec *vec, const char *new_str); +void str_vec_free(struct str_vec *vec); + +#endif //STR_VEC_H diff --git a/xdg-output-unstable-v1.xml b/xdg-output-unstable-v1.xml new file mode 100644 index 0000000..9a5b790 --- /dev/null +++ b/xdg-output-unstable-v1.xml @@ -0,0 +1,220 @@ + + + + + Copyright © 2017 Red Hat Inc. + + Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice (including the next + paragraph) shall be included in all copies or substantial portions of the + Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. + + + + This protocol aims at describing outputs in a way which is more in line + with the concept of an output on desktop oriented systems. + + Some information are more specific to the concept of an output for + a desktop oriented system and may not make sense in other applications, + such as IVI systems for example. + + Typically, the global compositor space on a desktop system is made of + a contiguous or overlapping set of rectangular regions. + + Some of the information provided in this protocol might be identical + to their counterparts already available from wl_output, in which case + the information provided by this protocol should be preferred to their + equivalent in wl_output. The goal is to move the desktop specific + concepts (such as output location within the global compositor space, + the connector name and types, etc.) out of the core wl_output protocol. + + Warning! The protocol described in this file is experimental and + backward incompatible changes may be made. Backward compatible + changes may be added together with the corresponding interface + version bump. + Backward incompatible changes are done by bumping the version + number in the protocol and interface names and resetting the + interface version. Once the protocol is to be declared stable, + the 'z' prefix and the version number in the protocol and + interface names are removed and the interface version number is + reset. + + + + + A global factory interface for xdg_output objects. + + + + + Using this request a client can tell the server that it is not + going to use the xdg_output_manager object anymore. + + Any objects already created through this instance are not affected. + + + + + + This creates a new xdg_output object for the given wl_output. + + + + + + + + + An xdg_output describes part of the compositor geometry. + + This typically corresponds to a monitor that displays part of the + compositor space. + + For objects version 3 onwards, after all xdg_output properties have been + sent (when the object is created and when properties are updated), a + wl_output.done event is sent. This allows changes to the output + properties to be seen as atomic, even if they happen via multiple events. + + + + + Using this request a client can tell the server that it is not + going to use the xdg_output object anymore. + + + + + + The position event describes the location of the wl_output within + the global compositor space. + + The logical_position event is sent after creating an xdg_output + (see xdg_output_manager.get_xdg_output) and whenever the location + of the output changes within the global compositor space. + + + + + + + + The logical_size event describes the size of the output in the + global compositor space. + + For example, a surface without any buffer scale, transformation + nor rotation set, with the size matching the logical_size will + have the same size as the corresponding output when displayed. + + Most regular Wayland clients should not pay attention to the + logical size and would rather rely on xdg_shell interfaces. + + Some clients such as Xwayland, however, need this to configure + their surfaces in the global compositor space as the compositor + may apply a different scale from what is advertised by the output + scaling property (to achieve fractional scaling, for example). + + For example, for a wl_output mode 3840×2160 and a scale factor 2: + + - A compositor not scaling the surface buffers will advertise a + logical size of 3840×2160, + + - A compositor automatically scaling the surface buffers will + advertise a logical size of 1920×1080, + + - A compositor using a fractional scale of 1.5 will advertise a + logical size of 2560×1440. + + For example, for a wl_output mode 1920×1080 and a 90 degree rotation, + the compositor will advertise a logical size of 1080x1920. + + The logical_size event is sent after creating an xdg_output + (see xdg_output_manager.get_xdg_output) and whenever the logical + size of the output changes, either as a result of a change in the + applied scale or because of a change in the corresponding output + mode(see wl_output.mode) or transform (see wl_output.transform). + + + + + + + + This event is sent after all other properties of an xdg_output + have been sent. + + This allows changes to the xdg_output properties to be seen as + atomic, even if they happen via multiple events. + + For objects version 3 onwards, this event is deprecated. Compositors + are not required to send it anymore and must send wl_output.done + instead. + + + + + + + + Many compositors will assign names to their outputs, show them to the + user, allow them to be configured by name, etc. The client may wish to + know this name as well to offer the user similar behaviors. + + The naming convention is compositor defined, but limited to + alphanumeric characters and dashes (-). Each name is unique among all + wl_output globals, but if a wl_output global is destroyed the same name + may be reused later. The names will also remain consistent across + sessions with the same hardware and software configuration. + + Examples of names include 'HDMI-A-1', 'WL-1', 'X11-1', etc. However, do + not assume that the name is a reflection of an underlying DRM + connector, X11 connection, etc. + + The name event is sent after creating an xdg_output (see + xdg_output_manager.get_xdg_output). This event is only sent once per + xdg_output, and the name does not change over the lifetime of the + wl_output global. + + + + + + + Many compositors can produce human-readable descriptions of their + outputs. The client may wish to know this description as well, to + communicate the user for various purposes. + + The description is a UTF-8 string with no convention defined for its + contents. Examples might include 'Foocorp 11" Display' or 'Virtual X11 + output via :1'. + + The description event is sent after creating an xdg_output (see + xdg_output_manager.get_xdg_output) and whenever the description + changes. The description is optional, and may not be sent at all. + + For objects of version 2 and lower, this event is only sent once per + xdg_output, and the description does not change over the lifetime of + the wl_output global. + + + + + +