1 files changed, 203 insertions, 223 deletions

diff --git a/src/redshift.c b/src/redshift.c
index 04c6c77..77cabb8 100644
--- a/src/redshift.c
+++ b/src/redshift.c
@@ -1,4 +1,5 @@
-/* redshift-ng - Automatically adjust display colour temperature according the Sun
+/*-
+ * 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>
@@ -18,42 +19,54 @@
  */
 #include "common.h"
 
-/* poll.h is not available on Windows but there is no Windows location provider
- * using polling. On Windows, we just define some stubs to make things compile.
+
+/**
+ * The number of milliseconds to sleep normally between colour updates
  */
-#ifndef WINDOWS
-# include <poll.h>
-#else
-# define POLLIN 0
-struct pollfd {
-	int fd;
-	short events;
-	short revents;
-};
-int poll(struct pollfd *fds, int nfds, int timeout) { abort(); }
-#endif
+#define SLEEP_DURATION  5000U
 
+/**
+ * The number of milliseconds to sleep between each step during
+ * fade between large colour settings
+ */
+#define SLEEP_DURATION_SHORT  25U
 
-/* Duration of sleep between screen updates (milliseconds). */
-#define SLEEP_DURATION        5000
-#define SLEEP_DURATION_SHORT  100
+/**
+ * The fade time, for when making large changes in colour
+ * settings, divided by `SLEEP_DURATION_SHORT`
+ */
+#define FADE_LENGTH  160U
 
-/* Length of fade in numbers of short sleep durations. */
-#define FADE_LENGTH  40
 
+/**
+ * The user's current geographical location
+ */
+static struct location location;
 
-#if defined(__GNUC__)
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-static int
-exact_eq(double a, double b)
-{
-	return a == b;
-}
-#if defined(__GNUC__)
-# pragma GCC diagnostic pop
-#endif
+/**
+ * Whether the location provider is available
+ */
+static int location_available;
+
+/**
+ * State of location provider, `NULL` if none
+ */
+static LOCATION_STATE *provider_state;
+
+/**
+ * Locaiton provider functions
+ */
+static const struct location_provider *provider;
+
+/**
+ * State of the gamma ramp adjustment method, `NULL` if none (print mode)
+ */
+static GAMMA_STATE *method_state;
+
+/**
+ * Gamma ramp adjustment functions
+ */
+static const struct gamma_method *method;
 
 
 /**
@@ -124,14 +137,12 @@ print_period(enum period period, double day_level)
  * Get the current period of day and the colour settings
  * applicable to the current time of the day
  * 
- * @param  location       Geographical user location
  * @param  colour_out     Output parameter for the colour settings
  * @param  period_out     Output parameter for the period of the day
  * @param  day_level_out  Output parameter for the dayness level
  */
 static void
-get_colour_settings(const struct location *location, struct colour_setting *colour_out,
-                    enum period *period_out, double *day_level_out)
+get_colour_settings(struct colour_setting *colour_out, enum period *period_out, double *day_level_out)
 {
 	time_t time_offset;
 	double t, elevation;
@@ -148,7 +159,7 @@ get_colour_settings(const struct location *location, struct colour_setting *colo
 		*day_level_out = fma(t, scheme.time.periods->diff_over_duration, scheme.time.periods->day_level);
 
 	} else if (scheme.type == SOLAR_SCHEME) {
-		if (libred_solar_elevation(location->latitude, location->longitude, &elevation))
+		if (libred_solar_elevation(location.latitude, location.longitude, &elevation))
 			eprintf("libred_solar_elevation:");
 		if (verbose) {
 			/* TRANSLATORS: Append degree symbol if possible. */
@@ -158,7 +169,7 @@ get_colour_settings(const struct location *location, struct colour_setting *colo
 
 	} else {
 		/* Static scheme, no dayness-level or peroid; day_settings == nigh_settings, use either */
-		*day_level_out = NAN;
+		*day_level_out = FNAN;
 		*period_out = PERIOD_NONE;
 		*colour_out = day_settings;
 		return;
@@ -200,201 +211,167 @@ ease_fade(double t)
 }
 
 
-/* Run continual mode loop
-   This is the main loop of the continual mode which keeps track of the
-   current time and continuously updates the screen to the appropriate
-   colour temperature. */
+#ifndef WINDOWS /* we don't have poll on Windows, but neither do with have any dynamic location providers  */
+/**
+ * Get the current location
+ * 
+ * The function will return once any of the following has occured:
+ * - the specified timeout duration has elapsed,
+ * - a location message has been received (could be location or error), or
+ * - a signal(7) was received
+ * 
+ * @param  timeout      The number of milliseconds to wait before
+ *                      returning without updating the location
+ * @param  location_fd  File descriptor to wait on to receive input event
+ */
 static void
-run_continual_mode(const struct location_provider *provider, LOCATION_STATE *location_state,
-                   const struct gamma_method *method, GAMMA_STATE *method_state, int use_fade,
-                   int preserve_gamma)
+pull_location(unsigned int timeout, int location_fd)
 {
-	int done = 0;
-	int prev_disabled = 1;
-	int disabled = 0;
-	int location_available = 1;
-	struct colour_setting fade_start_interp;
-	struct colour_setting prev_target_interp;
-	struct colour_setting interp;
-	struct location loc;
-
-	/* Short fade parameters */
-	int fade_length = 0;
-	int fade_time = 0;
-
-	/* Save previous parameters so we can avoid printing status updates if
-	 * the values did not change. */
-	enum period prev_period = PERIOD_NONE;
-
-	install_signal_handlers();
-
-	/* Previous target colour setting and current actual colour setting.
-	 * Actual colour setting takes into account the current colour fade. */
-	prev_target_interp = COLOUR_SETTING_NEUTRAL;
-
-	interp = COLOUR_SETTING_NEUTRAL;
-
-	loc = (struct location){NAN, NAN};
-	if (scheme.type == SOLAR_SCHEME) {
-		weprintf(_("Waiting for initial location to become available..."));
+	struct pollfd pollfds[1];
+	struct location new_location;
+	int r, new_available;
+
+	/* Await new location information */
+	pollfds[0].fd = location_fd;
+	pollfds[0].events = POLLIN;
+	r = poll(pollfds, 1, (int)timeout);
+	if (r < 0) {
+#ifndef WINDOWS
+		if (errno == EINTR)
+			return;
+#endif
+		weprintf("poll:");
+		eprintf(_("Unable to get location from provider."));
+	} else if (!r) {
+		return;
+	}
 
-		if (get_location(provider, location_state, -1, &loc) < 0)
-			eprintf(_("Unable to get location from provider."));
+	/* Get new location and availability information */
+	if (provider->fetch(provider_state, &new_location, &new_available) < 0)
+		eprintf(_("Unable to get location from provider."));
+	if (new_available < location_available) {
+		weprintf(_("Location is temporarily unavailable; using previous"
+			   " location until it becomes available..."));
+		location_available = 0;
+		return;
+	}
 
-		if (!location_is_valid(&loc))
+	/* Store and announce new location */
+	if (new_available > location_available ||
+	    !exact_eq(new_location.latitude, location.latitude) ||
+	    !exact_eq(new_location.longitude, location.longitude)) {
+		location_available = 1;
+		location = new_location;
+		print_location(&location);
+		if (!location_is_valid(&location))
 			eprintf(_("Invalid location returned from provider."));
-
-		print_location(&loc);
 	}
+}
+#endif
 
-	if (verbose) {
-		printf(_("Color temperature: %luK\n"), interp.temperature);
-		printf(_("Brightness: %.2f\n"), interp.brightness);
-	}
 
-	/* Continuously adjust colour temperature */
-	for (;;) {
-		enum period period;
-		double day_level;
-		struct colour_setting target_interp;
-		int delay, loc_fd;
+/**
+ * Loop for `PROGRAM_MODE_CONTINUAL`
+ */
+static void
+run_continual_mode(void)
+{
+	enum period period, prev_period = PERIOD_NONE;
+	double day_level = FNAN, prev_day_level = FNAN;
+	int disabled = 0, prev_disabled = !disabled;
+	int done = 0;
+	struct colour_setting colour;
+	struct colour_setting target_colour, prev_target_colour;
+	struct colour_setting fade_start_colour;
+	unsigned int fade_length = 0;
+	unsigned int fade_time = 0;
+	unsigned int delay;
+	double fade_progress, eased_fade_progress;
+#ifndef WINDOWS
+	int location_fd;
+#endif
 
-		/* Check to see if disable signal was caught */
+	prev_target_colour = COLOUR_SETTING_NEUTRAL;
+	colour = COLOUR_SETTING_NEUTRAL;
+
+	for (;;) {
+		/* Act on signals */
 		if (disable && !done) {
-			disabled = !disabled;
+			disabled ^= 1;
 			disable = 0;
 		}
-
-		/* Check to see if exit signal was caught */
 		if (exiting) {
-			if (done)
+			if (done) /* TODO also if already disabled (fade complete) */
 				break; /* On second signal stop the ongoing fade */
 			done = 1;
 			disabled = 1;
 			exiting = 0;
 		}
-
-		/* Print status change */
 		if (verbose && disabled != prev_disabled)
 			printf(_("Status: %s\n"), disabled ? _("Disabled") : _("Enabled"));
-
 		prev_disabled = disabled;
 
-		get_colour_settings(&loc, &target_interp, &period, &day_level);
-
+		/* Get dayness level and corresponding colour settings */
 		if (disabled) {
 			period = PERIOD_NONE;
-			target_interp = COLOUR_SETTING_NEUTRAL;
+			target_colour = COLOUR_SETTING_NEUTRAL;
+		} else {
+			get_colour_settings(&target_colour, &period, &day_level);
 		}
-
-		if (done)
-			period = PERIOD_NONE;
-
-		/* Print period if it changed during this update,
-		 * or if we are in the transition period. In transition we
-		 * print the progress, so we always print it in
-		 * that case. */
-		if (verbose && (period != prev_period || period == PERIOD_TRANSITION))
+		if (verbose && (period != prev_period || !exact_eq(day_level, prev_day_level)))
 			print_period(period, day_level);
-
-		/* Activate hooks if period changed */
 		if (period != prev_period)
 			run_period_change_hooks(prev_period, period);
+		prev_period = period;
+		prev_day_level = day_level;
+		if (verbose) {
+			if (prev_target_colour.temperature != target_colour.temperature)
+				printf(_("Color temperature: %luK\n"), target_colour.temperature);
+			if (!exact_eq(prev_target_colour.brightness, target_colour.brightness))
+				printf(_("Brightness: %.2f\n"), target_colour.brightness);
+			if (memcmp(prev_target_colour.gamma, target_colour.gamma, sizeof(target_colour.gamma))) {
+				printf(_("Gamma: %.3f, %.3f, %.3f\n"),
+				       target_colour.gamma[0], target_colour.gamma[1], target_colour.gamma[2]);
+			}
+		}
 
-		/* Start fade if the parameter differences are too big to apply instantly */
-		if (use_fade && colour_setting_diff_is_major(&target_interp, fade_length ? &prev_target_interp : &interp)) {
+		/* Fade if the parameter differences are too big to apply instantly */
+		if (use_fade && colour_setting_diff_is_major(&target_colour, fade_length ? &prev_target_colour : &colour)) {
 			fade_length = FADE_LENGTH;
 			fade_time = 0;
-			fade_start_interp = interp;
+			fade_start_colour = colour;
 		}
-
-		/* Handle ongoing fade */
-		if (fade_length != 0) {
-			double frac = ++fade_time / (double)fade_length;
-			double alpha = CLAMP(0.0, ease_fade(frac), 1.0);
-
-			interpolate_colour_settings(&fade_start_interp, &target_interp, alpha, &interp);
-
-			if (fade_time > fade_length) {
+		if (fade_length) {
+			fade_progress = ++fade_time / (double)fade_length;
+			eased_fade_progress = ease_fade(fade_progress);
+			interpolate_colour_settings(&fade_start_colour, &target_colour, eased_fade_progress, &colour);
+			if (fade_time == fade_length) {
 				fade_time = 0;
 				fade_length = 0;
 			}
 		} else {
-			interp = target_interp;
+			colour = target_colour;
 		}
+		prev_target_colour = target_colour;
 
 		/* Break loop when done and final fade is over */
 		if (done && fade_length == 0)
 			break;
 
-		if (verbose) {
-			if (prev_target_interp.temperature != target_interp.temperature)
-				printf(_("Color temperature: %luK\n"), target_interp.temperature);
-			if (!exact_eq(prev_target_interp.brightness, target_interp.brightness))
-				printf(_("Brightness: %.2f\n"), target_interp.brightness);
-		}
-
-		/* Adjust temperature */
-		if (method->apply(method_state, &interp, preserve_gamma) < 0)
+		/* Adjust temperature and sleep */
+		if (method->apply(method_state, &colour, preserve_gamma) < 0)
 			eprintf(_("Temperature adjustment failed."));
-
-		/* Save period and target colour setting as previous */
-		prev_period = period;
-		prev_target_interp = target_interp;
-
-		/* Sleep length depends on whether a fade is ongoing */
 		delay = fade_length ? SLEEP_DURATION_SHORT : SLEEP_DURATION;
-
-		/* Update location */
-		loc_fd = scheme.type == SOLAR_SCHEME ? provider->get_fd(location_state) : -1;
-
-		if (loc_fd >= 0) {
-			struct pollfd pollfds[1];
-			struct location new_loc;
-			int r, new_available;
-
-			/* Provider is dynamic */
-			pollfds[0].fd = loc_fd;
-			pollfds[0].events = POLLIN;
-			r = poll(pollfds, 1, delay);
-			if (r < 0) {
 #ifndef WINDOWS
-				if (errno == EINTR)
-					continue;
+		location_fd = scheme.type == SOLAR_SCHEME ? provider->get_fd(provider_state) : -1;
+		if (location_fd >= 0)
+			pull_location(delay, location_fd);
+		else
 #endif
-				weprintf("poll:");
-				eprintf(_("Unable to get location from provider."));
-			} else if (!r) {
-				continue;
-			}
-
-			/* Get new location and availability information */
-			if (provider->fetch(location_state, &new_loc, &new_available) < 0)
-				eprintf(_("Unable to get location from provider."));
-
-			if (!new_available && new_available != location_available) {
-				weprintf(_("Location is temporarily unavailable; using previous"
-				           " location until it becomes available..."));
-			}
-
-			if (new_available &&
-			    (!exact_eq(new_loc.latitude, loc.latitude) ||
-			     !exact_eq(new_loc.longitude, loc.longitude) ||
-			     new_available != location_available)) {
-				loc = new_loc;
-				print_location(&loc);
-			}
-
-			location_available = new_available;
-
-			if (!location_is_valid(&loc))
-				eprintf(_("Invalid location returned from provider."));
-		} else {
 			millisleep(delay);
-		}
+		/* SLEEP_DURATION_SHORT is short enough for remaining time after interruption to be ignored */
 	}
 
-	/* Restore saved gamma ramps */
 	method->restore(method_state);
 }
 
@@ -403,15 +380,13 @@ int
 main(int argc, char *argv[])
 {
 	struct settings settings;
-	GAMMA_STATE *method_state = NULL;
-	LOCATION_STATE *location_state = NULL;
-	struct location loc = {NAN, NAN};
 	double day_level;
 	enum period period;
 	struct colour_setting colour;
 
 	argv0 = argv[0];
 
+	/* Set up localisation */
 #ifdef ENABLE_NLS
 	setlocale(LC_CTYPE, "");
 	setlocale(LC_MESSAGES, "");
@@ -419,63 +394,68 @@ main(int argc, char *argv[])
 	textdomain(PACKAGE);
 #endif
 
+	/* Get configurations and configure */
 	load_settings(&settings, argc, argv);
-	if (scheme.type == SOLAR_SCHEME)
-		acquire_location_provider(&settings, &location_state);
-	if (mode != PROGRAM_MODE_PRINT)
+	if (scheme.type == SOLAR_SCHEME) {
+		acquire_location_provider(&settings, &provider_state);
+		provider = settings.provider;
+	}
+	if (mode != PROGRAM_MODE_PRINT) {
 		acquire_adjustment_method(&settings, &method_state);
+		method = settings.method;
+	}
 	config_ini_free(&settings.config);
 
-	switch (mode) {
-	case PROGRAM_MODE_ONE_SHOT:
-	case PROGRAM_MODE_PRINT:
-	case PROGRAM_MODE_RESET:
-		if (scheme.type == SOLAR_SCHEME) {
-			weprintf(_("Waiting for current location to become available..."));
-
-			if (get_location(settings.provider, location_state, -1, &loc) < 0)
-				eprintf(_("Unable to get location from provider."));
-
-			if (!location_is_valid(&loc))
-				exit(1);
+	/* Set up interprocess communication */
+	install_signal_handlers();
 
-			print_location(&loc);
-		}
+	/* Get location if required */
+	if (scheme.type == SOLAR_SCHEME) {
+		if (provider->get_fd(provider_state) >= 0)
+			weprintf(_("Waiting for current location to become available..."));
+		if (get_location(provider, provider_state, -1, &location) < 0)
+			eprintf(_("Unable to get location from provider."));
+		if (!location_is_valid(&location))
+			eprintf(_("Invalid location returned from provider."));
+		print_location(&location);
+		location_available = 1;
+	}
 
-		get_colour_settings(&loc, &colour, &period, &day_level);
+	/* Get and print colour to set or if continual mode the initial colour */
+	get_colour_settings(&colour, &period, &day_level); /* needed in contiual mode for `period` and `day_level` */
+	if (mode == PROGRAM_MODE_CONTINUAL)
+		colour = COLOUR_SETTING_NEUTRAL;
+	if (verbose || mode == PROGRAM_MODE_PRINT) {
+		if (scheme.type != STATIC_SCHEME)
+			print_period(period, day_level);
+		printf(_("Color temperature: %luK\n"), colour.temperature);
+		printf(_("Brightness: %.2f\n"), colour.brightness);
+		printf(_("Gamma: %.3f, %.3f, %.3f\n"), colour.gamma[0], colour.gamma[1], colour.gamma[2]);
+	}
 
-		if (verbose || mode == PROGRAM_MODE_PRINT) {
-			if (scheme.type != STATIC_SCHEME)
-				print_period(period, day_level);
-			printf(_("Color temperature: %luK\n"), colour.temperature);
-			printf(_("Brightness: %.2f\n"), colour.brightness);
-			if (mode == PROGRAM_MODE_PRINT)
-				break;
-		}
+	switch (mode) {
+	case PROGRAM_MODE_PRINT:
+		break;
 
-		if (settings.method->apply(method_state, &colour, settings.preserve_gamma.value) < 0)
+	case PROGRAM_MODE_ONE_SHOT:
+	case PROGRAM_MODE_RESET:
+		if (method->apply(method_state, &colour, preserve_gamma) < 0)
 			eprintf(_("Temperature adjustment failed."));
-
-#ifndef WINDOWS
-		/* In Quartz (OSX) the gamma adjustments will automatically revert when
-		 * the process exits. Therefore, we have to loop until Ctrl+C is received. */
-		if (!strcmp(settings.method->name, "quartz")) {
+		if (method->autoreset) {
 			weprintf(_("Press ctrl-c to stop..."));
 			while (!exiting)
 				pause();
 		}
-#endif
 		break;
 
 	case PROGRAM_MODE_CONTINUAL:
-		run_continual_mode(settings.provider, location_state, settings.method, method_state,
-		                   settings.use_fade.value, settings.preserve_gamma.value);
+		run_continual_mode();
 		break;
 	}
 
 	if (method_state)
-		settings.method->free(method_state);
-	if (location_state)
-		settings.provider->free(location_state);
+		method->free(method_state);
+	if (provider_state)
+		provider->free(provider_state);
 	return 0;
 }