path: root/src/redshift.c

/* 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>
 * 
 * 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 <http://www.gnu.org/licenses/>.
 */
#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.
 */
#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


/* Duration of sleep between screen updates (milliseconds). */
#define SLEEP_DURATION        5000
#define SLEEP_DURATION_SHORT  100

/* Length of fade in numbers of short sleep durations. */
#define FADE_LENGTH  40


/* Names of periods of day */
static const char *period_names[] = {
	/* TRANSLATORS: Name printed when period of day is unknown */
	N_("None"),
	N_("Daytime"),
	N_("Night"),
	N_("Transition")
};


#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


/**
 * Suspend the process for a short time
 *
 * The process may be resumed earily, specifically
 * if it receives a signal
 * 
 * @param  msecs  The number of milliseconds to sleep
 */
static void
millisleep(unsigned int msecs)
{
#ifdef WINDOWS
	Sleep(msecs); /* TODO [Windows] not interruptible */
#else
	struct timespec ts;
	ts.tv_sec = (time_t)(msecs / 1000U);
	ts.tv_nsec = (long)(msecs % 1000U) * 1000000L;
	nanosleep(&ts, NULL);
#endif
}


/* Return number of seconds since midnight from timestamp. */
static time_t
get_time_since_midnight(void)
{
	time_t t = time(NULL);
	struct tm tm;
	localtime_r(&t, &tm);
	t  = (time_t)tm.tm_sec;
	t += (time_t)tm.tm_min * 60;
	t += (time_t)tm.tm_hour * 3600;
	return t;
}

/* Print verbose description of the given period. */
static void
print_period(enum period period, double day_level)
{
	if (period == PERIOD_TRANSITION)
		printf(_("Period: %s (%.2f%% day)\n"), gettext(period_names[period]), day_level * 100);
	else
		printf(_("Period: %s\n"), gettext(period_names[period]));
}

/* Print location */
static void
print_location(const struct location *location)
{
	/* TRANSLATORS: Abbreviation for `north' */
	const char *north = _("N");
	/* TRANSLATORS: Abbreviation for `south' */
	const char *south = _("S");
	/* TRANSLATORS: Abbreviation for `east' */
	const char *east = _("E");
	/* TRANSLATORS: Abbreviation for `west' */
	const char *west = _("W");

	/* TRANSLATORS: Append degree symbols after %f if possible.
	   The string following each number is an abreviation for
	   north, source, east or west (N, S, E, W). */
	printf(_("Location: %.2f %s, %.2f %s\n"),
	       fabs(location->latitude), location->latitude >= 0.0 ? north : south,
	       fabs(location->longitude), location->longitude >= 0.0 ? east : west);
}

/* Interpolate colour setting structs given alpha. */
static void
interpolate_colour_settings(const struct colour_setting *first, const struct colour_setting *second,
                            double alpha, struct colour_setting *result)
{
	int i;
	alpha = CLAMP(0.0, alpha, 1.0);
	result->temperature = (1.0 - alpha) * first->temperature + alpha * second->temperature;
	result->brightness  = (1.0 - alpha) * first->brightness  + alpha * second->brightness;
	for (i = 0; i < 3; i++)
		result->gamma[i] = (1.0 - alpha) * first->gamma[i] + alpha * second->gamma[i];
}

/* Return 1 if colour settings have major differences, otherwise 0.
   Used to determine if a fade should be applied in continual mode. */
static int
colour_setting_diff_is_major(const struct colour_setting *first, const struct colour_setting *second)
{
	return MAX(first->temperature, second->temperature) - MIN(first->temperature, second->temperature) > 25UL ||
	       fabs(first->brightness - second->brightness) > 0.1 ||
	       fabs(first->gamma[0] - second->gamma[0]) > 0.1 ||
	       fabs(first->gamma[1] - second->gamma[1]) > 0.1 ||
	       fabs(first->gamma[2] - second->gamma[2]) > 0.1;
}

/**
 * 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
 * @param  verbose        Whether the application is running in verbose mode
 */
static void
get_colour_settings(const struct location *location, struct colour_setting *colour_out,
                    enum period *period_out, double *day_level_out, int verbose)
{
	time_t time_offset;
	double t, elevation;

	/* Get dayness level */
	if (scheme.type == CLOCK_SCHEME) {
		time_offset = get_time_since_midnight();
		while (time_offset >= scheme.time.periods->next->start)
			scheme.time.periods = scheme.time.periods->next;
		time_offset -= scheme.time.periods->start;
		if (time_offset < 0)
			time_offset += ONE_DAY;
		t = (double)time_offset;
		*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))
			eprintf("libred_solar_elevation:");
		if (verbose) {
			/* TRANSLATORS: Append degree symbol if possible. */
			printf(_("Solar elevation: %f\n"), elevation);
		}
		*day_level_out = (elevation - scheme.elevation.low) / scheme.elevation.range;

	} else {
		/* Static scheme, no dayness-level or peroid; day_settings == nigh_settings, use either */
		*day_level_out = NAN;
		*period_out = PERIOD_NONE;
		*colour_out = day_settings;
		return;
	}

	/* Clamp dayness level and get colour */
	if (*day_level_out <= 0.0) {
		*day_level_out = 0.0;
		*period_out = PERIOD_NIGHT;
		*colour_out = night_settings;

	} else if (*day_level_out >= 1.0) {
		*day_level_out = 1.0;
		*period_out = PERIOD_DAYTIME;
		*colour_out = day_settings;

	} else {
		*period_out = PERIOD_TRANSITION;
		interpolate_colour_settings(&night_settings, &day_settings, *day_level_out, colour_out);
	}
}


/* Check whether location is valid.
   Prints error message on stderr and returns 0 if invalid, otherwise
   returns 1. */
static int
location_is_valid(const struct location *location)
{
	if (!WITHIN(MIN_LATITUDE, location->latitude, MAX_LATITUDE)) {
		/* TRANSLATORS: Append degree symbols if possible. */
		weprintf(_("Latitude must be between %.1f and %.1f."), MIN_LATITUDE, MAX_LATITUDE);
		return 0;
	}
	if (!WITHIN(MIN_LONGITUDE, location->longitude, MAX_LONGITUDE)) {
		/* TRANSLATORS: Append degree symbols if possible. */
		weprintf(_("Longitude must be between %.1f and %.1f."), MIN_LONGITUDE, MAX_LONGITUDE);
		return 0;
	}
	return 1;
}

/* Easing function for fade.
   See https://github.com/mietek/ease-tween */
static double
ease_fade(double t)
{
	if (t <= 0) return 0;
	if (t >= 1) return 1;
	return 1.0042954579734844 * exp(
		-6.4041738958415664 * exp(-7.2908241330981340 * 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. */
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, int verbose)
{
	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..."));

		/* Get initial location from provider */
		if (get_location(provider, location_state, -1, &loc) < 0)
			eprintf(_("Unable to get location from provider."));

		if (!location_is_valid(&loc))
			eprintf(_("Invalid location returned from provider."));

		print_location(&loc);
	}

	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;

		/* Check to see if disable signal was caught */
		if (disable && !done) {
			disabled = !disabled;
			disable = 0;
		}

		/* Check to see if exit signal was caught */
		if (exiting) {
			if (done)
				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, verbose);

		if (disabled) {
			period = PERIOD_NONE;
			target_interp = COLOUR_SETTING_NEUTRAL;
		}

		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))
			print_period(period, day_level);

		/* Activate hooks if period changed */
		if (period != prev_period)
			run_period_change_hooks(prev_period, period);

		/* 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_length = FADE_LENGTH;
			fade_time = 0;
			fade_start_interp = interp;
		}

		/* 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) {
				fade_time = 0;
				fade_length = 0;
			}
		} else {
			interp = target_interp;
		}

		/* 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->set_temperature(method_state, &interp, 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;
#endif
				weprintf("poll:");
				eprintf(_("Unable to get location from provider."));
			} else if (!r) {
				continue;
			}

			/* Get new location and availability information. */
			if (provider->handle(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);
		}
	}

	/* Restore saved gamma ramps */
	method->restore(method_state);
}


int
main(int argc, char *argv[])
{
	struct settings settings;
	GAMMA_STATE *method_state;
	LOCATION_STATE *location_state;
	struct location loc = {NAN, NAN};
	double day_level;
	enum period period;
	struct colour_setting colour;

	argv0 = argv[0];

#ifdef ENABLE_NLS
	setlocale(LC_CTYPE, "");
	setlocale(LC_MESSAGES, "");
	bindtextdomain(PACKAGE, LOCALEDIR);
	textdomain(PACKAGE);
#endif

	load_settings(&settings, argc, argv);

	/* Initialize location provider if needed. If provider is NULL
	   try all providers until one that works is found. */

	/* Location is not needed for reset mode and manual mode. */
	if (settings.scheme_type == SOLAR_SCHEME)
		acquire_location_provider(&settings, &location_state);

	/* Initialize gamma adjustment method. If method is NULL
	   try all methods until one that works is found. */

	/* Gamma adjustment not needed for print mode */
	if (settings.mode != PROGRAM_MODE_PRINT)
		acquire_adjustment_method(&settings, &method_state);

	config_ini_free(&settings.config);

	switch (settings.mode) {
	case PROGRAM_MODE_ONE_SHOT:
	case PROGRAM_MODE_PRINT:
		if (settings.scheme_type == SOLAR_SCHEME) {
			weprintf(_("Waiting for current location to become available..."));

			/* Wait for location provider. */
			if (get_location(settings.provider, location_state, -1, &loc) < 0)
				eprintf(_("Unable to get location from provider."));

			if (!location_is_valid(&loc))
				exit(1);

			print_location(&loc);
		}

		get_colour_settings(&loc, &colour, &period, &day_level, settings.verbose);

		if (settings.verbose || settings.mode == PROGRAM_MODE_PRINT) {
			if (settings.scheme_type != STATIC_SCHEME)
				print_period(period, day_level);
			printf(_("Color temperature: %luK\n"), colour.temperature);
			printf(_("Brightness: %.2f\n"), colour.brightness);
		}

		if (settings.mode == PROGRAM_MODE_PRINT)
			break;

	apply:
		if (settings.method->set_temperature(method_state, &colour, settings.preserve_gamma.value) < 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")) {
			weprintf(_("Press ctrl-c to stop..."));
			while (!exiting)
				pause();
		}
#endif
		break;

	case PROGRAM_MODE_MANUAL:
		/* TODO interpolate for current time if a value range has been specified */
		colour = day_settings;
		if (settings.verbose)
			printf(_("Color temperature: %luK\n"), colour.temperature);
		goto apply;

	case PROGRAM_MODE_RESET:
		colour = COLOUR_SETTING_NEUTRAL;
		settings.preserve_gamma.value = 0;
		goto apply;

	case PROGRAM_MODE_CONTINUAL:
		run_continual_mode(settings.provider, location_state, settings.method, method_state,
		                   settings.use_fade.value, settings.preserve_gamma.value, settings.verbose);
		break;
	}

	if (settings.mode != PROGRAM_MODE_PRINT)
		settings.method->free(method_state);
	if (scheme.type == SOLAR_SCHEME)
		settings.provider->free(location_state);
	return 0;
}