Commit 9f4ab07

@@ -0,0 +1,26 @@
+#ifndef _SWAY_BACKGROUND_IMAGE_H
+#define _SWAY_BACKGROUND_IMAGE_H
+#include <wayland-client.h>
+#include "cairo.h"
+
+enum background_mode {
+	BACKGROUND_MODE_STRETCH,
+	BACKGROUND_MODE_FILL,
+	BACKGROUND_MODE_FIT,
+	BACKGROUND_MODE_CENTER,
+	BACKGROUND_MODE_TILE,
+	BACKGROUND_MODE_SOLID_COLOR,
+	BACKGROUND_MODE_INVALID,
+};
+
+struct swaylock_surface;
+
+enum background_mode parse_background_mode(const char *mode);
+cairo_surface_t *load_background_image(const char *path);
+cairo_surface_t *load_background_from_buffer(void *buf, uint32_t format,
+		uint32_t width, uint32_t height, uint32_t stride, enum wl_output_transform transform);
+cairo_surface_t *scale_background_image(cairo_surface_t *image,
+		enum background_mode mode, int buffer_width, int buffer_height);
+void render_background_image(cairo_t *cairo, cairo_surface_t *image, double alpha);
+
+#endif

@@ -0,0 +1,24 @@
+#ifndef _SWAY_CAIRO_H
+#define _SWAY_CAIRO_H
+
+#include "config.h"
+#include <stdint.h>
+#include <cairo/cairo.h>
+#include <wayland-client.h>
+#if HAVE_GDK_PIXBUF
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#endif
+
+void cairo_set_source_u32(cairo_t *cairo, uint32_t color);
+cairo_subpixel_order_t to_cairo_subpixel_order(enum wl_output_subpixel subpixel);
+
+cairo_surface_t *cairo_surface_duplicate(cairo_surface_t *src);
+
+#if HAVE_GDK_PIXBUF
+
+cairo_surface_t* gdk_cairo_image_surface_create_from_pixbuf(
+		const GdkPixbuf *gdkbuf);
+
+#endif // HAVE_GDK_PIXBUF
+
+#endif

@@ -0,0 +1,18 @@
+#ifndef _SWAYLOCK_COMM_H
+#define _SWAYLOCK_COMM_H
+
+#include <stdbool.h>
+
+struct swaylock_password;
+
+bool spawn_comm_child(void);
+ssize_t read_comm_request(char **buf_ptr);
+bool write_comm_reply(bool success);
+// Requests the provided password to be checked. The password is always cleared
+// when the function returns.
+bool write_comm_request(struct swaylock_password *pw);
+bool read_comm_reply(void);
+// FD to poll for password authentication replies.
+int get_comm_reply_fd(void);
+
+#endif

@@ -0,0 +1,64 @@
+#ifndef _SWAYLOCK_EFFECTS_H
+#define _SWAYLOCK_EFFECTS_H
+
+#include <stdbool.h>
+
+#include "cairo.h"
+
+struct swaylock_effect_screen_pos {
+	float pos;
+	bool is_percent;
+};
+
+struct swaylock_effect {
+	union {
+		struct {
+			int radius, times;
+		} blur;
+		struct {
+			int factor;
+		} pixelate;
+		double scale;
+		struct {
+			double base;
+			double factor;
+		} vignette;
+		struct {
+			struct swaylock_effect_screen_pos x;
+			struct swaylock_effect_screen_pos y;
+			struct swaylock_effect_screen_pos w;
+			struct swaylock_effect_screen_pos h;
+			enum {
+				EFFECT_COMPOSE_GRAV_CENTER,
+				EFFECT_COMPOSE_GRAV_NW,
+				EFFECT_COMPOSE_GRAV_NE,
+				EFFECT_COMPOSE_GRAV_SW,
+				EFFECT_COMPOSE_GRAV_SE,
+				EFFECT_COMPOSE_GRAV_N,
+				EFFECT_COMPOSE_GRAV_S,
+				EFFECT_COMPOSE_GRAV_E,
+				EFFECT_COMPOSE_GRAV_W,
+			} gravity;
+			char *imgpath;
+		} compose;
+		char *custom;
+	} e;
+
+	enum {
+		EFFECT_BLUR,
+		EFFECT_PIXELATE,
+		EFFECT_SCALE,
+		EFFECT_GREYSCALE,
+		EFFECT_VIGNETTE,
+		EFFECT_COMPOSE,
+		EFFECT_CUSTOM,
+	} tag;
+};
+
+cairo_surface_t *swaylock_effects_run(cairo_surface_t *surface, int scale,
+		struct swaylock_effect *effects, int count);
+
+cairo_surface_t *swaylock_effects_run_timed(cairo_surface_t *surface, int scale,
+		struct swaylock_effect *effects, int count);
+
+#endif

@@ -0,0 +1,17 @@
+#ifndef _SWAYLOCK_FADE_H
+#define _SWAYLOCK_FADE_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+struct swaylock_fade {
+	float current_time;
+	float target_time;
+	uint32_t old_time;
+	double alpha;
+};
+
+void fade_update(struct swaylock_fade *fade, uint32_t time);
+bool fade_is_complete(struct swaylock_fade *fade);
+
+#endif

@@ -0,0 +1,42 @@
+#ifndef _SWAYLOCK_LOG_H
+#define _SWAYLOCK_LOG_H
+
+#include <stdarg.h>
+#include <string.h>
+#include <errno.h>
+
+enum log_importance {
+	LOG_SILENT = 0,
+	LOG_ERROR = 1,
+	LOG_INFO = 2,
+	LOG_DEBUG = 3,
+	LOG_TRACE = 4,
+	LOG_IMPORTANCE_LAST,
+};
+
+void swaylock_log_init(enum log_importance verbosity);
+
+#ifdef __GNUC__
+#define _ATTRIB_PRINTF(start, end) __attribute__((format(printf, start, end)))
+#else
+#define _ATTRIB_PRINTF(start, end)
+#endif
+
+void _swaylock_log(enum log_importance verbosity, const char *format, ...)
+	_ATTRIB_PRINTF(2, 3);
+
+void _swaylock_trace(const char *file, int line, const char *func);
+
+const char *_swaylock_strip_path(const char *filepath);
+
+#define swaylock_log(verb, fmt, ...) \
+	_swaylock_log(verb, "[%s:%d] " fmt, _swaylock_strip_path(__FILE__), \
+			__LINE__, ##__VA_ARGS__)
+
+#define swaylock_log_errno(verb, fmt, ...) \
+	swaylock_log(verb, fmt ": %s", ##__VA_ARGS__, strerror(errno))
+
+#define swaylock_trace() \
+	_swaylock_trace(__FILE__, __LINE__, __func__)
+
+#endif

@@ -0,0 +1,54 @@
+#ifndef _SWAY_LOOP_H
+#define _SWAY_LOOP_H
+#include <stdbool.h>
+
+/**
+ * This is an event loop system designed for sway clients, not sway itself.
+ *
+ * The loop consists of file descriptors and timers. Typically the Wayland
+ * display's file descriptor will be one of the fds in the loop.
+ */
+
+struct loop;
+struct loop_timer;
+
+/**
+ * Create an event loop.
+ */
+struct loop *loop_create(void);
+
+/**
+ * Destroy the event loop (eg. on program termination).
+ */
+void loop_destroy(struct loop *loop);
+
+/**
+ * Poll the event loop. This will block until one of the fds has data.
+ */
+void loop_poll(struct loop *loop);
+
+/**
+ * Add a file descriptor to the loop.
+ */
+void loop_add_fd(struct loop *loop, int fd, short mask,
+		void (*func)(int fd, short mask, void *data), void *data);
+
+/**
+ * Add a timer to the loop.
+ *
+ * When the timer expires, the timer will be removed from the loop and freed.
+ */
+struct loop_timer *loop_add_timer(struct loop *loop, int ms,
+		void (*callback)(void *data), void *data);
+
+/**
+ * Remove a file descriptor from the loop.
+ */
+bool loop_remove_fd(struct loop *loop, int fd);
+
+/**
+ * Remove a timer from the loop.
+ */
+bool loop_remove_timer(struct loop *loop, struct loop_timer *timer);
+
+#endif

@@ -0,0 +1,1 @@
+configure_file(output: 'config.h',  configuration: conf_data)

@@ -0,0 +1,9 @@
+#ifndef _SWAY_PASSWORD_BUFFER_H
+#define _SWAY_PASSWORD_BUFFER_H
+
+#include <stddef.h>
+
+char *password_buffer_create(size_t size);
+void password_buffer_destroy(char *buffer, size_t size);
+
+#endif

@@ -0,0 +1,22 @@
+#ifndef _SWAY_BUFFERS_H
+#define _SWAY_BUFFERS_H
+#include <cairo/cairo.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <wayland-client.h>
+
+struct pool_buffer {
+	struct wl_buffer *buffer;
+	cairo_surface_t *surface;
+	cairo_t *cairo;
+	uint32_t width, height;
+	void *data;
+	size_t size;
+	bool busy;
+};
+
+struct pool_buffer *get_next_buffer(struct wl_shm *shm,
+		struct pool_buffer pool[static 2], uint32_t width, uint32_t height);
+void destroy_buffer(struct pool_buffer *buffer);
+
+#endif

@@ -0,0 +1,32 @@
+#ifndef _SWAYLOCK_SEAT_H
+#define _SWAYLOCK_SEAT_H
+#include <xkbcommon/xkbcommon.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+struct loop;
+struct loop_timer;
+
+struct swaylock_xkb {
+	bool caps_lock;
+	bool control;
+	struct xkb_state *state;
+	struct xkb_context *context;
+	struct xkb_keymap *keymap;
+};
+
+struct swaylock_seat {
+	struct swaylock_state *state;
+	struct wl_pointer *pointer;
+	struct wl_keyboard *keyboard;
+	struct wl_touch *touch;
+	int32_t repeat_period_ms;
+	int32_t repeat_delay_ms;
+	uint32_t repeat_sym;
+	uint32_t repeat_codepoint;
+	struct loop_timer *repeat_timer;
+};
+
+extern const struct wl_seat_listener seat_listener;
+
+#endif

@@ -0,0 +1,183 @@
+#ifndef _SWAYLOCK_H
+#define _SWAYLOCK_H
+#include <stdbool.h>
+#include <stdint.h>
+#include <wayland-client.h>
+#include "background-image.h"
+#include "cairo.h"
+#include "pool-buffer.h"
+#include "seat.h"
+#include "effects.h"
+#include "fade.h"
+#include "wlr-layer-shell-unstable-v1-client-protocol.h"
+
+enum auth_state {
+	AUTH_STATE_IDLE,
+	AUTH_STATE_CLEAR,
+	AUTH_STATE_INPUT,
+	AUTH_STATE_INPUT_NOP,
+	AUTH_STATE_BACKSPACE,
+	AUTH_STATE_VALIDATING,
+	AUTH_STATE_INVALID,
+	AUTH_STATE_GRACE,
+};
+
+struct swaylock_colorset {
+	uint32_t input;
+	uint32_t cleared;
+	uint32_t caps_lock;
+	uint32_t verifying;
+	uint32_t wrong;
+};
+
+struct swaylock_colors {
+	uint32_t background;
+	uint32_t bs_highlight;
+	uint32_t key_highlight;
+	uint32_t caps_lock_bs_highlight;
+	uint32_t caps_lock_key_highlight;
+	uint32_t separator;
+	uint32_t layout_background;
+	uint32_t layout_border;
+	uint32_t layout_text;
+	struct swaylock_colorset inside;
+	struct swaylock_colorset line;
+	struct swaylock_colorset ring;
+	struct swaylock_colorset text;
+};
+
+struct swaylock_args {
+	struct swaylock_colors colors;
+	enum background_mode mode;
+	char *font;
+	uint32_t font_size;
+	uint32_t radius;
+	uint32_t thickness;
+	uint32_t indicator_x_position;
+	uint32_t indicator_y_position;
+	bool override_indicator_x_position;
+	bool override_indicator_y_position;
+	bool ignore_empty;
+	bool show_indicator;
+	bool show_caps_lock_text;
+	bool show_caps_lock_indicator;
+	bool show_keyboard_layout;
+	bool hide_keyboard_layout;
+	bool show_failed_attempts;
+	bool daemonize;
+	bool indicator_idle_visible;
+
+	bool screenshots;
+	struct swaylock_effect *effects;
+	int effects_count;
+	bool time_effects;
+	bool indicator;
+	bool clock;
+	char *timestr;
+	char *datestr;
+	uint32_t fade_in;
+	bool allow_fade;
+	bool password_submit_on_touch;
+	uint32_t password_grace_period;
+	bool password_grace_no_mouse;
+	bool password_grace_no_touch;
+
+	char *text_cleared;
+	char *text_caps_lock;
+	char *text_verifying;
+	char *text_wrong;
+};
+
+struct swaylock_password {
+	size_t len;
+	size_t buffer_len;
+	char *buffer;
+};
+
+struct swaylock_state {
+	struct loop *eventloop;
+	struct loop_timer *clear_indicator_timer; // clears the indicator
+	struct loop_timer *clear_password_timer;  // clears the password buffer
+	struct wl_display *display;
+	struct wl_compositor *compositor;
+	struct wl_subcompositor *subcompositor;
+	struct zwlr_layer_shell_v1 *layer_shell;
+	struct zwlr_input_inhibit_manager_v1 *input_inhibit_manager;
+	struct zwlr_screencopy_manager_v1 *screencopy_manager;
+	struct wl_shm *shm;
+	struct wl_list surfaces;
+	struct wl_list images;
+	cairo_surface_t *indicator_image;
+	struct swaylock_args args;
+	struct swaylock_password password;
+	struct swaylock_xkb xkb;
+	enum auth_state auth_state;
+	bool indicator_dirty;
+	int render_randnum;
+	int failed_attempts;
+	size_t n_screenshots_done;
+	bool run_display;
+	struct ext_session_lock_manager_v1 *ext_session_lock_manager_v1;
+	struct ext_session_lock_v1 *ext_session_lock_v1;
+};
+
+struct swaylock_surface {
+	cairo_surface_t *image;
+	cairo_surface_t *scaled_image;
+	struct {
+		uint32_t format, width, height, stride;
+		enum wl_output_transform transform;
+		void *data;
+		cairo_surface_t *original_image;
+		cairo_surface_t *scaled_image;
+		struct swaylock_image *image;
+	} screencopy;
+	struct swaylock_state *state;
+	struct wl_output *output;
+	uint32_t output_global_name;
+	struct wl_surface *surface;
+	struct wl_surface *child; // surface made into subsurface
+	struct wl_subsurface *subsurface;
+	struct zwlr_layer_surface_v1 *layer_surface;
+	struct zwlr_screencopy_frame_v1 *screencopy_frame;
+	struct ext_session_lock_surface_v1 *ext_session_lock_surface_v1;
+	struct pool_buffer buffers[2];
+	struct pool_buffer indicator_buffers[2];
+	struct swaylock_fade fade;
+	int events_pending;
+	bool configured;
+	bool frame_pending, dirty;
+	uint32_t width, height;
+	uint32_t indicator_width, indicator_height;
+	int32_t scale;
+	enum wl_output_subpixel subpixel;
+	enum wl_output_transform transform;
+	char *output_name;
+	struct wl_list link;
+};
+
+// There is exactly one swaylock_image for each -i argument
+struct swaylock_image {
+	char *path;
+	char *output_name;
+	cairo_surface_t *cairo_surface;
+	struct wl_list link;
+};
+
+void swaylock_handle_key(struct swaylock_state *state,
+		xkb_keysym_t keysym, uint32_t codepoint);
+void swaylock_handle_mouse(struct swaylock_state *state);
+void swaylock_handle_touch(struct swaylock_state *state);
+void render_frame_background(struct swaylock_surface *surface, bool commit);
+void render_background_fade(struct swaylock_surface *surface, uint32_t time);
+void render_frame(struct swaylock_surface *surface);
+void damage_surface(struct swaylock_surface *surface);
+void damage_state(struct swaylock_state *state);
+void clear_password_buffer(struct swaylock_password *pw);
+void schedule_indicator_clear(struct swaylock_state *state);
+
+void initialize_pw_backend(int argc, char **argv);
+void run_pw_backend_child(void);
+void clear_buffer(char *buf, size_t size);
+
+#endif

@@ -0,0 +1,41 @@
+#ifndef _SWAY_UNICODE_H
+#define _SWAY_UNICODE_H
+#include <stddef.h>
+#include <stdint.h>
+
+// Technically UTF-8 supports up to 6 byte codepoints, but Unicode itself
+// doesn't really bother with more than 4.
+#define UTF8_MAX_SIZE 4
+
+#define UTF8_INVALID 0x80
+
+/**
+ * Gets the size in bytes of the last utf8 character in a NULL terminated string
+ * This function does not validate that the buffer contains correct utf8 data;
+ * it merely looks for the first byte that correctly denotes the beginning of a
+ * utf8 character.
+ */
+int utf8_last_size(const char *str);
+
+/**
+ * Grabs the next UTF-8 character and advances the string pointer
+ */
+uint32_t utf8_decode(const char **str);
+
+/**
+ * Encodes a character as UTF-8 and returns the length of that character.
+ */
+size_t utf8_encode(char *str, uint32_t ch);
+
+/**
+ * Returns the size of the next UTF-8 character
+ */
+int utf8_size(const char *str);
+
+/**
+ * Returns the size of a UTF-8 character
+ */
+size_t utf8_chsize(uint32_t ch);
+
+#endif
+

@@ -0,0 +1,1 @@
+auth include login

@@ -0,0 +1,23 @@
+image: alpine/edge
+packages:
+  - meson
+  - cairo-dev
+  - wayland-dev
+  - wayland-protocols
+  - libxkbcommon-dev
+  - gdk-pixbuf-dev
+  - linux-pam-dev
+  - scdoc
+sources:
+  - https://github.com/swaywm/swaylock
+tasks:
+  - setup: |
+      cd swaylock
+      meson build
+  - build: |
+      cd swaylock
+      ninja -C build
+  - build-no-pam: |
+      cd swaylock
+      meson configure build -Dpam=disabled
+      ninja -C build

@@ -0,0 +1,22 @@
+# For the full list of code style requirements, see sway's CONTRIBUTING.md
+
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+
+[*.{c,h,cmake,txt}]
+indent_style = tab
+indent_size = 4
+
+[*.{xml,yml}]
+indent_style = space
+indent_size = 2
+
+[config]
+indent_style = space
+indent_size = 4
+
+[*.md]
+trim_trailing_whitespace = false

@@ -0,0 +1,1 @@
+build

@@ -0,0 +1,451 @@
+#define _DEFAULT_SOURCE
+#include <assert.h>
+#include "background-image.h"
+#include "cairo.h"
+#include "log.h"
+#include "swaylock.h"
+
+#ifdef __FreeBSD__
+#	include <sys/endian.h>
+#else
+#	include <endian.h>
+#endif
+
+// Cairo RGB24 uses 32 bits per pixel, as XRGB, in native endianness.
+// xrgb32_le uses 32 bits per pixel, as XRGB, little endian (BGRX big endian).
+void cairo_rgb24_from_xrgb32_le(unsigned char *buf, int width, int height, int stride) {
+	for (int y = 0; y < height; ++y) {
+		for (int x = 0; x < width; ++x) {
+			unsigned char *pix = buf + y * stride + x * 4;
+			*(uint32_t *)pix = 0 |
+				(uint32_t)pix[2] << 16 |
+				(uint32_t)pix[1] << 8 |
+				(uint32_t)pix[0];
+		}
+	}
+}
+
+// Cairo RGB24 uses 32 bits per pixel, as XRGB, in native endianness.
+// xbgr32_le uses 32 bits per pixel, as XBGR, little endian (RGBX big endian).
+void cairo_rgb24_from_xbgr32_le(unsigned char *buf, int width, int height, int stride) {
+	for (int y = 0; y < height; ++y) {
+		for (int x = 0; x < width; ++x) {
+			unsigned char *pix = buf + y * stride + x * 4;
+			*(uint32_t *)pix = 0 |
+				(uint32_t)pix[0] << 16 |
+				(uint32_t)pix[1] << 8 |
+				(uint32_t)pix[2];
+		}
+	}
+}
+
+void cairo_rgb24_from_xrgb2101010_le(unsigned char *buf, int width, int height, int stride) {
+	for (int y = 0; y < height; ++y) {
+		for (int x = 0; x < width; ++x) {
+			uint32_t *pix = (uint32_t *) (buf + y * stride + x * 4);
+			uint32_t color = le32toh(*pix);
+			*pix = 0 |
+				((color >> 22) & 0xFF) << 16 |
+				((color >> 12) & 0xFF) << 8 |
+				((color >> 2) & 0xFF);
+		}
+	}
+}
+
+void cairo_rgb24_from_xbgr2101010_le(unsigned char *buf, int width, int height, int stride) {
+	for (int y = 0; y < height; ++y) {
+		for (int x = 0; x < width; ++x) {
+			uint32_t *pix = (uint32_t *) (buf + y * stride + x * 4);
+			uint32_t color = le32toh(*pix);
+			*pix = 0 |
+				((color >> 2) & 0xFF) << 16 |
+				((color >> 12) & 0xFF) << 8 |
+				((color >> 22) & 0xFF);
+		}
+	}
+}
+
+void cairo_rgb24_from_rgbx1010102_le(unsigned char *buf, int width, int height, int stride) {
+	for (int y = 0; y < height; ++y) {
+		for (int x = 0; x < width; ++x) {
+			uint32_t *pix = (uint32_t *) (buf + y * stride + x * 4);
+			uint32_t color = le32toh(*pix);
+			*pix = 0 |
+				((color >> 24) & 0xFF) << 16 |
+				((color >> 14) & 0xFF) << 8 |
+				((color >> 4) & 0xFF);
+		}
+	}
+}
+
+void cairo_rgb24_from_bgrx1010102_le(unsigned char *buf, int width, int height, int stride) {
+	for (int y = 0; y < height; ++y) {
+		for (int x = 0; x < width; ++x) {
+			uint32_t *pix = (uint32_t *) (buf + y * stride + x * 4);
+			uint32_t color = le32toh(*pix);
+			*pix = 0 |
+				((color >> 4) & 0xFF) << 16 |
+				((color >> 14) & 0xFF) << 8 |
+				((color >> 24) & 0xFF);
+		}
+	}
+}
+
+// Cairo RGB24 uses 32 bits per pixel, as XRGB, in native endianness.
+// BGR888 uses 24 bits per pixel, as BGR, little endian.
+// 24-bit BGR format, [23:0] B:G:R little endian (From wayland-client-protocol.h)
+void cairo_rgb24_from_bgr888_le(unsigned char *buf, int width, int height, int stride) {
+	for (int y = 0; y < height; ++y) {
+		// Row from back to front to avoid overwriting data.
+		for (int x = width-1; x >= 0; --x) {
+			// 24 bits = 3 bytes, 32 bits = 4 bytes
+			unsigned char *srcpix = buf + y * stride + x * 3;
+			unsigned char *dstpix = buf + y * stride + x * 4;
+
+			*(uint32_t *)dstpix = 0 |
+				(uint32_t)srcpix[0] << 16 |
+				(uint32_t)srcpix[1] << 8 |
+				(uint32_t)srcpix[2];
+		}
+	}
+}
+
+// Swap red and blue values in Cairo RGB24
+void cairo_rgb24_swap_rb(unsigned char *buf, int width, int height, int stride) {
+	for (int y = 0; y < height; ++y) {
+		for (int x = 0; x < width; ++x) {
+			unsigned char *pix = buf + y * stride + x * 4;
+
+			*(uint32_t *)pix = 0 |
+				(uint32_t)pix[0] << 16 |
+				(uint32_t)pix[1] << 8 |
+				(uint32_t)pix[2];
+		}
+	}
+}
+
+enum background_mode parse_background_mode(const char *mode) {
+	if (strcmp(mode, "stretch") == 0) {
+		return BACKGROUND_MODE_STRETCH;
+	} else if (strcmp(mode, "fill") == 0) {
+		return BACKGROUND_MODE_FILL;
+	} else if (strcmp(mode, "fit") == 0) {
+		return BACKGROUND_MODE_FIT;
+	} else if (strcmp(mode, "center") == 0) {
+		return BACKGROUND_MODE_CENTER;
+	} else if (strcmp(mode, "tile") == 0) {
+		return BACKGROUND_MODE_TILE;
+	} else if (strcmp(mode, "solid_color") == 0) {
+		return BACKGROUND_MODE_SOLID_COLOR;
+	}
+	swaylock_log(LOG_ERROR, "Unsupported background mode: %s", mode);
+	return BACKGROUND_MODE_INVALID;
+}
+
+cairo_surface_t *load_background_from_buffer(void *buf, uint32_t format,
+		uint32_t width, uint32_t height, uint32_t stride, enum wl_output_transform transform) {
+	bool rotated =
+		transform == WL_OUTPUT_TRANSFORM_90 ||
+		transform == WL_OUTPUT_TRANSFORM_270 ||
+		transform == WL_OUTPUT_TRANSFORM_FLIPPED_90 ||
+		transform == WL_OUTPUT_TRANSFORM_FLIPPED_270;
+
+	cairo_surface_t *image;
+	if (rotated) {
+		image = cairo_image_surface_create(CAIRO_FORMAT_RGB24, height, width);
+	} else {
+		image = cairo_image_surface_create(CAIRO_FORMAT_RGB24, width, height);
+	}
+	if (image == NULL) {
+		swaylock_log(LOG_ERROR, "Failed to create image..");
+		return NULL;
+	}
+
+	unsigned char *destbuf = cairo_image_surface_get_data(image);
+	size_t destwidth = cairo_image_surface_get_width(image);
+	size_t destheight = cairo_image_surface_get_height(image);
+	size_t deststride = cairo_image_surface_get_stride(image);
+	unsigned char *srcbuf = buf;
+	size_t srcstride = stride;
+	size_t minstride = srcstride < deststride ? srcstride : deststride;
+
+	// Lots of these are mostly-copy-and-pasted, with a lot of boilerplate
+	// for each case.
+	// The only interesting differencess between a lot of these cases are
+	// the definitions of srcx and srcy.
+	// I don't think it's worth adding a macro to make this "cleaner" though,
+	// as that would obfuscate what's actually going on.
+	switch (transform) {
+	case WL_OUTPUT_TRANSFORM_NORMAL:
+		// In most cases, the transform is probably normal. Luckily, it can be
+		// done with just one big memcpy.
+		if (srcstride == deststride) {
+			memcpy(destbuf, srcbuf, destheight * deststride);
+		} else {
+			for (size_t y = 0; y < destheight; ++y) {
+				memcpy(destbuf + y * deststride, srcbuf + y * srcstride, minstride);
+			}
+		}
+		break;
+	case WL_OUTPUT_TRANSFORM_90:
+		for (size_t desty = 0; desty < destheight; ++desty) {
+			size_t srcx = desty;
+			for (size_t destx = 0; destx < destwidth; ++destx) {
+				size_t srcy = destwidth - destx - 1;
+				*((uint32_t *)(destbuf + desty * deststride) + destx) =
+					*((uint32_t *)(srcbuf + srcy * srcstride) + srcx);
+			}
+		}
+		break;
+	case WL_OUTPUT_TRANSFORM_180:
+		for (size_t desty = 0; desty < destheight; ++desty) {
+			size_t srcy = destheight - desty - 1;
+			for (size_t destx = 0; destx < destwidth; ++destx) {
+				size_t srcx = destwidth - destx - 1;
+				*((uint32_t *)(destbuf + desty * deststride) + destx) =
+					*((uint32_t *)(srcbuf + srcy * srcstride) + srcx);
+			}
+		}
+		break;
+	case WL_OUTPUT_TRANSFORM_270:
+		for (size_t desty = 0; desty < destheight; ++desty) {
+			size_t srcx = destheight - desty - 1;
+			for (size_t destx = 0; destx < destwidth; ++destx) {
+				size_t srcy = destx;
+				*((uint32_t *)(destbuf + desty * deststride) + destx) =
+					*((uint32_t *)(srcbuf + srcy * srcstride) + srcx);
+			}
+		}
+		break;
+	case WL_OUTPUT_TRANSFORM_FLIPPED:
+		for (size_t desty = 0; desty < destheight; ++desty) {
+			size_t srcy = desty;
+			for (size_t destx = 0; destx < destwidth; ++destx) {
+				size_t srcx = destwidth - destx - 1;
+				*((uint32_t *)(destbuf + desty * deststride) + destx) =
+					*((uint32_t *)(srcbuf + srcy * srcstride) + srcx);
+			}
+		}
+		break;
+	case WL_OUTPUT_TRANSFORM_FLIPPED_90:
+		for (size_t desty = 0; desty < destheight; ++desty) {
+			size_t srcx = desty;
+			for (size_t destx = 0; destx < destwidth; ++destx) {
+				size_t srcy = destx;
+				*((uint32_t *)(destbuf + desty * deststride) + destx) =
+					*((uint32_t *)(srcbuf + srcy * srcstride) + srcx);
+			}
+		}
+		break;
+	case WL_OUTPUT_TRANSFORM_FLIPPED_180:
+		for (size_t desty = 0; desty < destheight; ++desty) {
+			size_t srcy = destheight - desty - 1;
+			memcpy(destbuf + desty * deststride, srcbuf + srcy * srcstride, minstride);
+		}
+		break;
+	case WL_OUTPUT_TRANSFORM_FLIPPED_270:
+		for (size_t desty = 0; desty < destheight; ++desty) {
+			size_t srcx = destheight - desty - 1;
+			for (size_t destx = 0; destx < destwidth; ++destx) {
+				size_t srcy = destwidth - destx - 1;
+				*((uint32_t *)(destbuf + desty * deststride) + destx) =
+					*((uint32_t *)(srcbuf + srcy * srcstride) + srcx);
+			}
+		}
+		break;
+	}
+
+	switch (format) {
+	case WL_SHM_FORMAT_XBGR8888:
+	case WL_SHM_FORMAT_ABGR8888:
+		cairo_rgb24_from_xbgr32_le(
+				cairo_image_surface_get_data(image),
+				cairo_image_surface_get_width(image),
+				cairo_image_surface_get_height(image),
+				cairo_image_surface_get_stride(image));
+		break;
+	case WL_SHM_FORMAT_XRGB2101010:
+	case WL_SHM_FORMAT_ARGB2101010:
+		cairo_rgb24_from_xrgb2101010_le(
+				cairo_image_surface_get_data(image),
+				cairo_image_surface_get_width(image),
+				cairo_image_surface_get_height(image),
+				cairo_image_surface_get_stride(image));
+		break;
+	case WL_SHM_FORMAT_XBGR2101010:
+	case WL_SHM_FORMAT_ABGR2101010:
+		cairo_rgb24_from_xbgr2101010_le(
+				cairo_image_surface_get_data(image),
+				cairo_image_surface_get_width(image),
+				cairo_image_surface_get_height(image),
+				cairo_image_surface_get_stride(image));
+		break;
+	case WL_SHM_FORMAT_RGBX1010102:
+	case WL_SHM_FORMAT_RGBA1010102:
+		cairo_rgb24_from_rgbx1010102_le(
+				cairo_image_surface_get_data(image),
+				cairo_image_surface_get_width(image),
+				cairo_image_surface_get_height(image),
+				cairo_image_surface_get_stride(image));
+		break;
+	case WL_SHM_FORMAT_BGRX1010102:
+	case WL_SHM_FORMAT_BGRA1010102:
+		cairo_rgb24_from_bgrx1010102_le(
+				cairo_image_surface_get_data(image),
+				cairo_image_surface_get_width(image),
+				cairo_image_surface_get_height(image),
+				cairo_image_surface_get_stride(image));
+		break;
+	case WL_SHM_FORMAT_BGR888:
+	case WL_SHM_FORMAT_RGB888:
+			cairo_rgb24_from_bgr888_le(
+					cairo_image_surface_get_data(image),
+					cairo_image_surface_get_width(image),
+					cairo_image_surface_get_height(image),
+					cairo_image_surface_get_stride(image)
+					);
+			if (format == WL_SHM_FORMAT_RGB888) {
+				cairo_rgb24_swap_rb(
+						cairo_image_surface_get_data(image),
+						cairo_image_surface_get_width(image),
+						cairo_image_surface_get_height(image),
+						cairo_image_surface_get_stride(image)
+						);
+			}
+		break;
+	default:
+		swaylock_log(LOG_ERROR,
+				"Unknown pixel format: %u. Assuming XRGB32. Colors may look wrong.",
+				format);
+		// fallthrough
+	case WL_SHM_FORMAT_XRGB8888:
+	case WL_SHM_FORMAT_ARGB8888: {
+		// If we're little endian, we don't have to do anything
+		int test = 1;
+		bool is_little_endian = *(char *)&test == 1;
+		if (!is_little_endian) {
+			cairo_rgb24_from_xrgb32_le(
+					cairo_image_surface_get_data(image),
+					cairo_image_surface_get_width(image),
+					cairo_image_surface_get_height(image),
+					cairo_image_surface_get_stride(image));
+		}
+	}
+	}
+
+	return image;
+}
+
+cairo_surface_t *load_background_image(const char *path) {
+	cairo_surface_t *image;
+#if HAVE_GDK_PIXBUF
+	GError *err = NULL;
+	GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file(path, &err);
+	if (!pixbuf) {
+		swaylock_log(LOG_ERROR, "Failed to load background image (%s).",
+				err->message);
+		return NULL;
+	}
+	image = gdk_cairo_image_surface_create_from_pixbuf(pixbuf);
+	g_object_unref(pixbuf);
+#else
+	image = cairo_image_surface_create_from_png(path);
+#endif // HAVE_GDK_PIXBUF
+	if (!image) {
+		swaylock_log(LOG_ERROR, "Failed to read background image.");
+		return NULL;
+	}
+	if (cairo_surface_status(image) != CAIRO_STATUS_SUCCESS) {
+		swaylock_log(LOG_ERROR, "Failed to read background image: %s."
+#if !HAVE_GDK_PIXBUF
+				"\nSway was compiled without gdk_pixbuf support, so only"
+				"\nPNG images can be loaded. This is the likely cause."
+#endif // !HAVE_GDK_PIXBUF
+				, cairo_status_to_string(cairo_surface_status(image)));
+		return NULL;
+	}
+	return image;
+}
+
+cairo_surface_t *scale_background_image(cairo_surface_t *image,
+		enum background_mode mode, int buffer_width, int buffer_height) {
+	cairo_surface_t *target = cairo_image_surface_create(CAIRO_FORMAT_RGB24, buffer_width, buffer_height);
+	cairo_t *cairo = cairo_create(target);
+	double width = cairo_image_surface_get_width(image);
+	double height = cairo_image_surface_get_height(image);
+
+	switch (mode) {
+	case BACKGROUND_MODE_STRETCH:
+		cairo_scale(cairo,
+				(double)buffer_width / width,
+				(double)buffer_height / height);
+		cairo_set_source_surface(cairo, image, 0, 0);
+		break;
+	case BACKGROUND_MODE_FILL: {
+		double window_ratio = (double)buffer_width / buffer_height;
+		double bg_ratio = width / height;
+
+		if (window_ratio > bg_ratio) {
+			double scale = (double)buffer_width / width;
+			cairo_scale(cairo, scale, scale);
+			cairo_set_source_surface(cairo, image,
+					0, (double)buffer_height / 2 / scale - height / 2);
+		} else {
+			double scale = (double)buffer_height / height;
+			cairo_scale(cairo, scale, scale);
+			cairo_set_source_surface(cairo, image,
+					(double)buffer_width / 2 / scale - width / 2, 0);
+		}
+		break;
+	}
+	case BACKGROUND_MODE_FIT: {
+		double window_ratio = (double)buffer_width / buffer_height;
+		double bg_ratio = width / height;
+
+		if (window_ratio > bg_ratio) {
+			double scale = (double)buffer_height / height;
+			cairo_scale(cairo, scale, scale);
+			cairo_set_source_surface(cairo, image,
+					(double)buffer_width / 2 / scale - width / 2, 0);
+		} else {
+			double scale = (double)buffer_width / width;
+			cairo_scale(cairo, scale, scale);
+			cairo_set_source_surface(cairo, image,
+					0, (double)buffer_height / 2 / scale - height / 2);
+		}
+		break;
+	}
+	case BACKGROUND_MODE_CENTER:
+		/*
+		 * Align the unscaled image to integer pixel boundaries
+		 * in order to prevent loss of clarity (this only matters
+		 * for odd-sized images).
+		 */
+		cairo_set_source_surface(cairo, image,
+				(int)((double)buffer_width / 2 - width / 2),
+				(int)((double)buffer_height / 2 - height / 2));
+		break;
+	case BACKGROUND_MODE_TILE: {
+		cairo_pattern_t *pattern = cairo_pattern_create_for_surface(image);
+		cairo_pattern_set_extend(pattern, CAIRO_EXTEND_REPEAT);
+		cairo_set_source(cairo, pattern);
+		break;
+	}
+	case BACKGROUND_MODE_SOLID_COLOR:
+	case BACKGROUND_MODE_INVALID:
+		assert(0);
+		break;
+	}
+
+	cairo_pattern_set_filter(cairo_get_source(cairo), CAIRO_FILTER_BILINEAR);
+	cairo_paint(cairo);
+	cairo_destroy(cairo);
+	return target;
+}
+
+void render_background_image(cairo_t *cairo, cairo_surface_t *image, double alpha) {
+	cairo_save(cairo);
+	cairo_set_source_surface(cairo, image, 0, 0);
+	cairo_paint_with_alpha(cairo, alpha);
+	cairo_restore(cairo);
+}

@@ -0,0 +1,140 @@
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <cairo/cairo.h>
+#include "cairo.h"
+#if HAVE_GDK_PIXBUF
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#endif
+
+void cairo_set_source_u32(cairo_t *cairo, uint32_t color) {
+	cairo_set_source_rgba(cairo,
+			(color >> (3*8) & 0xFF) / 255.0,
+			(color >> (2*8) & 0xFF) / 255.0,
+			(color >> (1*8) & 0xFF) / 255.0,
+			(color >> (0*8) & 0xFF) / 255.0);
+}
+
+cairo_subpixel_order_t to_cairo_subpixel_order(enum wl_output_subpixel subpixel) {
+	switch (subpixel) {
+	case WL_OUTPUT_SUBPIXEL_HORIZONTAL_RGB:
+		return CAIRO_SUBPIXEL_ORDER_RGB;
+	case WL_OUTPUT_SUBPIXEL_HORIZONTAL_BGR:
+		return CAIRO_SUBPIXEL_ORDER_BGR;
+	case WL_OUTPUT_SUBPIXEL_VERTICAL_RGB:
+		return CAIRO_SUBPIXEL_ORDER_VRGB;
+	case WL_OUTPUT_SUBPIXEL_VERTICAL_BGR:
+		return CAIRO_SUBPIXEL_ORDER_VBGR;
+	default:
+		return CAIRO_SUBPIXEL_ORDER_DEFAULT;
+	}
+	return CAIRO_SUBPIXEL_ORDER_DEFAULT;
+}
+
+cairo_surface_t *cairo_surface_duplicate(cairo_surface_t *src) {
+	uint32_t stride = cairo_image_surface_get_stride(src);
+	uint32_t height = cairo_image_surface_get_height(src);
+	uint32_t width = cairo_image_surface_get_width(src);
+	cairo_format_t format = cairo_image_surface_get_format(src);
+
+	void *new_data = malloc(stride * height);
+	memcpy(new_data, cairo_image_surface_get_data(src), stride * height);
+
+	return cairo_image_surface_create_for_data(new_data, format, width, height, stride);
+}
+
+#if HAVE_GDK_PIXBUF
+cairo_surface_t* gdk_cairo_image_surface_create_from_pixbuf(const GdkPixbuf *gdkbuf) {
+	int chan = gdk_pixbuf_get_n_channels(gdkbuf);
+	if (chan < 3) {
+		return NULL;
+	}
+
+	const guint8* gdkpix = gdk_pixbuf_read_pixels(gdkbuf);
+	if (!gdkpix) {
+		return NULL;
+	}
+	gint w = gdk_pixbuf_get_width(gdkbuf);
+	gint h = gdk_pixbuf_get_height(gdkbuf);
+	int stride = gdk_pixbuf_get_rowstride(gdkbuf);
+
+	cairo_format_t fmt = (chan == 3) ? CAIRO_FORMAT_RGB24 : CAIRO_FORMAT_ARGB32;
+	cairo_surface_t * cs = cairo_image_surface_create (fmt, w, h);
+	cairo_surface_flush (cs);
+	if ( !cs || cairo_surface_status(cs) != CAIRO_STATUS_SUCCESS) {
+		return NULL;
+	}
+
+	int cstride = cairo_image_surface_get_stride(cs);
+	unsigned char * cpix = cairo_image_surface_get_data(cs);
+
+	if (chan == 3) {
+		int i;
+		for (i = h; i; --i) {
+			const guint8 *gp = gdkpix;
+			unsigned char *cp = cpix;
+			const guint8* end = gp + 3*w;
+			while (gp < end) {
+#if G_BYTE_ORDER == G_LITTLE_ENDIAN
+				cp[0] = gp[2];
+				cp[1] = gp[1];
+				cp[2] = gp[0];
+#else
+				cp[1] = gp[0];
+				cp[2] = gp[1];
+				cp[3] = gp[2];
+#endif
+				gp += 3;
+				cp += 4;
+			}
+			gdkpix += stride;
+			cpix += cstride;
+		}
+	} else {
+		/* premul-color = alpha/255 * color/255 * 255 = (alpha*color)/255
+		 * (z/255) = z/256 * 256/255     = z/256 (1 + 1/255)
+		 *         = z/256 + (z/256)/255 = (z + z/255)/256
+		 *         # recurse once
+		 *         = (z + (z + z/255)/256)/256
+		 *         = (z + z/256 + z/256/255) / 256
+		 *         # only use 16bit uint operations, loose some precision,
+		 *         # result is floored.
+		 *       ->  (z + z>>8)>>8
+		 *         # add 0x80/255 = 0.5 to convert floor to round
+		 *       =>  (z+0x80 + (z+0x80)>>8 ) >> 8
+		 * ------
+		 * tested as equal to lround(z/255.0) for uint z in [0..0xfe02]
+		 */
+#define PREMUL_ALPHA(x,a,b,z) \
+		G_STMT_START { z = a * b + 0x80; x = (z + (z >> 8)) >> 8; } \
+		G_STMT_END
+		int i;
+		for (i = h; i; --i) {
+			const guint8 *gp = gdkpix;
+			unsigned char *cp = cpix;
+			const guint8* end = gp + 4*w;
+			guint z1, z2, z3;
+			while (gp < end) {
+#if G_BYTE_ORDER == G_LITTLE_ENDIAN
+				PREMUL_ALPHA(cp[0], gp[2], gp[3], z1);
+				PREMUL_ALPHA(cp[1], gp[1], gp[3], z2);
+				PREMUL_ALPHA(cp[2], gp[0], gp[3], z3);
+				cp[3] = gp[3];
+#else
+				PREMUL_ALPHA(cp[1], gp[0], gp[3], z1);
+				PREMUL_ALPHA(cp[2], gp[1], gp[3], z2);
+				PREMUL_ALPHA(cp[3], gp[2], gp[3], z3);
+				cp[0] = gp[3];
+#endif
+				gp += 4;
+				cp += 4;
+			}
+			gdkpix += stride;
+			cpix += cstride;
+		}
+#undef PREMUL_ALPHA
+	}
+	cairo_surface_mark_dirty(cs);
+	return cs;
+}
+#endif // HAVE_GDK_PIXBUF

@@ -0,0 +1,109 @@
+#include <stdbool.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include "comm.h"
+#include "log.h"
+#include "swaylock.h"
+#include "password-buffer.h"
+
+static int comm[2][2] = {{-1, -1}, {-1, -1}};
+
+ssize_t read_comm_request(char **buf_ptr) {
+	size_t size;
+	ssize_t amt;
+	amt = read(comm[0][0], &size, sizeof(size));
+	if (amt == 0) {
+		return 0;
+	} else if (amt < 0) {
+		swaylock_log_errno(LOG_ERROR, "read pw request");
+		return -1;
+	}
+	swaylock_log(LOG_DEBUG, "received pw check request");
+	char *buf = password_buffer_create(size);
+	if (!buf) {
+		return -1;
+	}
+	size_t offs = 0;
+	do {
+		amt = read(comm[0][0], &buf[offs], size - offs);
+		if (amt <= 0) {
+			swaylock_log_errno(LOG_ERROR, "failed to read pw");
+			return -1;
+		}
+		offs += (size_t)amt;
+	} while (offs < size);
+
+	*buf_ptr = buf;
+	return size;
+}
+
+bool write_comm_reply(bool success) {
+	if (write(comm[1][1], &success, sizeof(success)) != sizeof(success)) {
+		swaylock_log_errno(LOG_ERROR, "failed to write pw check result");
+		return false;
+	}
+	return true;
+}
+
+bool spawn_comm_child(void) {
+	if (pipe(comm[0]) != 0) {
+		swaylock_log_errno(LOG_ERROR, "failed to create pipe");
+		return false;
+	}
+	if (pipe(comm[1]) != 0) {
+		swaylock_log_errno(LOG_ERROR, "failed to create pipe");
+		return false;
+	}
+	pid_t child = fork();
+	if (child < 0) {
+		swaylock_log_errno(LOG_ERROR, "failed to fork");
+		return false;
+	} else if (child == 0) {
+		close(comm[0][1]);
+		close(comm[1][0]);
+		run_pw_backend_child();
+	}
+	close(comm[0][0]);
+	close(comm[1][1]);
+	return true;
+}
+
+bool write_comm_request(struct swaylock_password *pw) {
+	bool result = false;
+
+	size_t len = pw->len + 1;
+	size_t offs = 0;
+	if (write(comm[0][1], &len, sizeof(len)) < 0) {
+		swaylock_log_errno(LOG_ERROR, "Failed to request pw check");
+		goto out;
+	}
+
+	do {
+		ssize_t amt = write(comm[0][1], &pw->buffer[offs], len - offs);
+		if (amt < 0) {
+			swaylock_log_errno(LOG_ERROR, "Failed to write pw buffer");
+			goto out;
+		}
+		offs += amt;
+	} while (offs < len);
+
+	result = true;
+
+out:
+	clear_password_buffer(pw);
+	return result;
+}
+
+bool read_comm_reply(void) {
+	bool result = false;
+	if (read(comm[1][0], &result, sizeof(result)) != sizeof(result)) {
+		swaylock_log_errno(LOG_ERROR, "Failed to read pw result");
+		result = false;
+	}
+	return result;
+}
+
+int get_comm_reply_fd(void) {
+	return comm[1][0];
+}

@@ -0,0 +1,757 @@
+#define _POSIX_C_SOURCE 200809
+#define _XOPEN_SOURCE 700
+#include <omp.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <dlfcn.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/wait.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <spawn.h>
+#include <time.h>
+#include <stdio.h>
+#include "effects.h"
+#include "log.h"
+
+// glib might or might not have already defined MIN,
+// depending on whether we have pixbuf or not...
+#ifndef MIN
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+#endif
+
+extern char **environ;
+
+static int screen_size_to_pix(struct swaylock_effect_screen_pos size, int screensize, int scale) {
+	if (size.is_percent) {
+		return (size.pos / 100.0) * screensize;
+	} else if (size.pos > 0) {
+		return size.pos * scale;
+	} else {
+		return size.pos;
+	}
+}
+
+static int screen_pos_to_pix(struct swaylock_effect_screen_pos pos, int screensize, int scale) {
+	int actual;
+	if (pos.is_percent) {
+		actual = (pos.pos / 100.0) * screensize;
+	} else {
+		actual = pos.pos * scale;
+	}
+
+	if (actual < 0) {
+		actual = screensize + actual;
+	}
+
+	return actual;
+}
+
+static const char *effect_name(struct swaylock_effect *effect) {
+	switch (effect->tag) {
+	case EFFECT_BLUR: return "blur";
+	case EFFECT_PIXELATE: return "pixelate";
+	case EFFECT_SCALE: return "scale";
+	case EFFECT_GREYSCALE: return "greyscale";
+	case EFFECT_VIGNETTE: return "vignette";
+	case EFFECT_COMPOSE: return "compose";
+	case EFFECT_CUSTOM: return effect->e.custom;
+	}
+
+	abort();
+}
+
+static void screen_pos_pair_to_pix(
+		struct swaylock_effect_screen_pos posx,
+		struct swaylock_effect_screen_pos posy,
+		int objwidth, int objheight,
+		int screenwidth, int screenheight, int scale, int gravity,
+		int *outx, int *outy) {
+	int x = screen_pos_to_pix(posx, screenwidth, scale);
+	int y = screen_pos_to_pix(posy, screenheight, scale);
+
+	// Adjust X
+	switch (gravity) {
+	case EFFECT_COMPOSE_GRAV_CENTER:
+	case EFFECT_COMPOSE_GRAV_N:
+	case EFFECT_COMPOSE_GRAV_S:
+		x -= objwidth / 2;
+		break;
+	case EFFECT_COMPOSE_GRAV_NW:
+	case EFFECT_COMPOSE_GRAV_SW:
+	case EFFECT_COMPOSE_GRAV_W:
+		break;
+	case EFFECT_COMPOSE_GRAV_NE:
+	case EFFECT_COMPOSE_GRAV_SE:
+	case EFFECT_COMPOSE_GRAV_E:
+		x -= objwidth;
+		break;
+	}
+
+	// Adjust Y
+	switch (gravity) {
+	case EFFECT_COMPOSE_GRAV_CENTER:
+	case EFFECT_COMPOSE_GRAV_W:
+	case EFFECT_COMPOSE_GRAV_E:
+		y -= objheight / 2;
+		break;
+	case EFFECT_COMPOSE_GRAV_NW:
+	case EFFECT_COMPOSE_GRAV_NE:
+	case EFFECT_COMPOSE_GRAV_N:
+		break;
+	case EFFECT_COMPOSE_GRAV_SW:
+	case EFFECT_COMPOSE_GRAV_SE:
+	case EFFECT_COMPOSE_GRAV_S:
+		y -= objheight;
+		break;
+	}
+
+	*outx = x;
+	*outy = y;
+}
+
+static uint32_t blend_pixels(float alpha, uint32_t srcpix, uint32_t destpix) {
+	uint8_t srcr = (srcpix & 0x00ff0000) >> 16;
+	uint8_t destr = (destpix & 0x00ff0000) >> 16;
+	uint8_t srcg = (srcpix & 0x0000ff00) >> 8;
+	uint8_t destg = (destpix & 0x0000ff00) >> 8;
+	uint8_t srcb = (srcpix & 0x000000ff) >> 0;
+	uint8_t destb = (destpix & 0x000000ff) >> 0;
+
+	return (uint32_t)0 |
+		(uint32_t)255 << 24 |
+		(uint32_t)(srcr + destr * (1 - alpha)) << 16 |
+		(uint32_t)(srcg + destg * (1 - alpha)) << 8 |
+		(uint32_t)(srcb + destb * (1 - alpha)) << 0;
+}
+
+static void blur_h(uint32_t *dest, uint32_t *src, int width, int height,
+		int radius) {
+	const int minradius = radius < width ? radius : width;
+
+#pragma omp parallel for
+	for (int y = 0; y < height; ++y) {
+		uint32_t *srow = src + y * width;
+		uint32_t *drow = dest + y * width;
+
+		// 'range' is float, because floating point division is usually faster
+		// than integer division.
+		int r_acc = 0;
+		int g_acc = 0;
+		int b_acc = 0;
+		float range = minradius;
+
+		// Accumulate the range (0..radius)
+		for (int x = 0; x < minradius; ++x) {
+			r_acc += (srow[x] & 0xff0000) >> 16;
+			g_acc += (srow[x] & 0x00ff00) >> 8;
+			b_acc += (srow[x] & 0x0000ff);
+		}
+
+		// Deal with the main body
+		for (int x = 0; x < width; ++x) {
+			if (x >= minradius) {
+				r_acc -= (srow[x - radius] & 0xff0000) >> 16;
+				g_acc -= (srow[x - radius] & 0x00ff00) >> 8;
+				b_acc -= (srow[x - radius] & 0x0000ff);
+				range -= 1;
+			}
+
+			if (x < width - minradius) {
+				r_acc += (srow[x + radius] & 0xff0000) >> 16;
+				g_acc += (srow[x + radius] & 0x00ff00) >> 8;
+				b_acc += (srow[x + radius] & 0x0000ff);
+				range += 1;
+			}
+
+			drow[x] = 0 |
+				(int)(r_acc / range) << 16 |
+				(int)(g_acc / range) << 8 |
+				(int)(b_acc / range);
+		}
+	}
+}
+
+static void blur_v(uint32_t *dest, uint32_t *src, int width, int height,
+		int radius) {
+	const int minradius = radius < height ? radius : height;
+
+#pragma omp parallel for
+	for (int x = 0; x < width; ++x) {
+		uint32_t *scol = src + x;
+		uint32_t *dcol = dest + x;
+
+		// 'range' is float, because floating point division is usually faster
+		// than integer division.
+		int r_acc = 0;
+		int g_acc = 0;
+		int b_acc = 0;
+		float range = minradius;
+
+		// Accumulate the range (0..radius)
+		for (int y = 0; y < minradius; ++y) {
+			r_acc += (scol[y * width] & 0xff0000) >> 16;
+			g_acc += (scol[y * width] & 0x00ff00) >> 8;
+			b_acc += (scol[y * width] & 0x0000ff);
+		}
+
+		// Deal with the main body
+		for (int y = 0; y < height; ++y) {
+			if (y >= minradius) {
+				r_acc -= (scol[(y - radius) * width] & 0xff0000) >> 16;
+				g_acc -= (scol[(y - radius) * width] & 0x00ff00) >> 8;
+				b_acc -= (scol[(y - radius) * width] & 0x0000ff);
+				range -= 1;
+			}
+
+			if (y < height - minradius) {
+				r_acc += (scol[(y + radius) * width] & 0xff0000) >> 16;
+				g_acc += (scol[(y + radius) * width] & 0x00ff00) >> 8;
+				b_acc += (scol[(y + radius) * width] & 0x0000ff);
+				range += 1;
+			}
+
+			dcol[y * width] = 0 |
+				(int)(r_acc / range) << 16 |
+				(int)(g_acc / range) << 8 |
+				(int)(b_acc / range);
+		}
+	}
+}
+
+static void blur_once(uint32_t *dest, uint32_t *src, uint32_t *scratch,
+		int width, int height, int radius) {
+	blur_h(scratch, src, width, height, radius);
+	blur_v(dest, scratch, width, height, radius);
+}
+
+// This effect_blur function, and the associated blur_* functions,
+// are my own adaptations of code in yvbbrjdr's i3lock-fancy-rapid:
+// https://github.com/yvbbrjdr/i3lock-fancy-rapid
+static void effect_blur(uint32_t *dest, uint32_t *src, int width, int height, int scale,
+		int radius, int times) {
+	uint32_t *origdest = dest;
+
+	uint32_t *scratch = malloc(width * height * sizeof(*scratch));
+	blur_once(dest, src, scratch, width, height, radius * scale);
+	for (int i = 0; i < times - 1; ++i) {
+		uint32_t *tmp = src;
+		src = dest;
+		dest = tmp;
+		blur_once(dest, src, scratch, width, height, radius * scale);
+	}
+	free(scratch);
+
+	// We're flipping between using dest and src;
+	// if the last buffer we used was src, copy that over to dest.
+	if (dest != origdest)
+		memcpy(origdest, dest, width * height * sizeof(*dest));
+}
+
+static void effect_pixelate(uint32_t *data, int width, int height, int scale, int factor) {
+	factor *= scale;
+#pragma omp parallel for
+	for (int y = 0; y < height / factor + 1; ++y) {
+		for (int x = 0; x < width / factor + 1; ++x) {
+			int total_r = 0, total_g = 0, total_b = 0;
+
+			int xstart = x * factor;
+			int ystart = y * factor;
+			int xlim = MIN(xstart + factor, width);
+			int ylim = MIN(ystart + factor, height);
+
+			// Average
+			for (int ry = ystart; ry < ylim; ++ry) {
+				for (int rx = xstart; rx < xlim; ++rx) {
+					int index = ry * width + rx;
+					total_r += (data[index] & 0xff0000) >> 16;
+					total_g += (data[index] & 0x00ff00) >> 8;
+					total_b += (data[index] & 0x0000ff);
+				}
+			}
+
+			int r = total_r / (factor * factor);
+			int g = total_g / (factor * factor);
+			int b = total_b / (factor * factor);
+
+			// Fill pixels
+			for (int ry = ystart; ry < ylim; ++ry) {
+				for (int rx = xstart; rx < xlim; ++rx) {
+					int index = ry * width + rx;
+					data[index] = r << 16 | g << 8 | b;
+				}
+			}
+		}
+	}
+}
+
+static void effect_scale(uint32_t *dest, uint32_t *src, int swidth, int sheight,
+		double scale) {
+	int dwidth = swidth * scale;
+	int dheight = sheight * scale;
+	double fact = 1.0 / scale;
+
+#pragma omp parallel for
+	for (int dy = 0; dy < dheight; ++dy) {
+		int sy = dy * fact;
+		if (sy >= sheight) continue;
+		for (int dx = 0; dx < dwidth; ++dx) {
+			int sx = dx * fact;
+			if (sx >= swidth) continue;
+			dest[dy * dwidth + dx] = src[sy * swidth + sx];
+		}
+	}
+}
+
+static void effect_greyscale(uint32_t *data, int width, int height) {
+#pragma omp parallel for
+	for (int y = 0; y < height; ++y) {
+		for (int x = 0; x < width; ++x) {
+			int index = y * width + x;
+			int r = (data[index] & 0xff0000) >> 16;
+			int g = (data[index] & 0x00ff00) >> 8;
+			int b = (data[index] & 0x0000ff);
+			int luma = 0.2989 * r + 0.5870 * g + 0.1140 * b;
+			if (luma < 0) luma = 0;
+			if (luma > 255) luma = 255;
+			luma &= 0xFF;
+			data[index] = luma << 16 | luma << 8 | luma;
+		}
+	}
+}
+
+static void effect_vignette(uint32_t *data, int width, int height,
+		double base, double factor) {
+	base = fmin(1, fmax(0, base));
+	factor = fmin(1 - base, fmax(0, factor));
+#pragma omp parallel for
+	for (int y = 0; y < height; ++y) {
+		for (int x = 0; x < width; ++x) {
+
+			double xf = (x * 1.0) / width;
+			double yf = (y * 1.0) / height;
+			double vignette_factor = base + factor
+				* 16 * xf * yf * (1.0 - xf) * (1.0 - yf);
+
+			int index = y * width + x;
+			int r = (data[index] & 0xff0000) >> 16;
+			int g = (data[index] & 0x00ff00) >> 8;
+			int b = (data[index] & 0x0000ff);
+
+			r = (int)(r * vignette_factor) & 0xFF;
+			g = (int)(g * vignette_factor) & 0xFF;
+			b = (int)(b * vignette_factor) & 0xFF;
+
+			data[index] = r << 16 | g << 8 | b;
+		}
+	}
+}
+
+static void effect_compose(uint32_t *data, int width, int height, int scale,
+		struct swaylock_effect_screen_pos posx,
+		struct swaylock_effect_screen_pos posy,
+		struct swaylock_effect_screen_pos posw,
+		struct swaylock_effect_screen_pos posh,
+		int gravity, char *imgpath) {
+#if !HAVE_GDK_PIXBUF
+	(void)&blend_pixels;
+	(void)&screen_size_to_pix;
+	(void)&screen_pos_pair_to_pix;
+	swaylock_log(LOG_ERROR, "Compose effect: Compiled without gdk_pixbuf support.\n");
+	return;
+#else
+	int imgw = screen_size_to_pix(posw, width, scale);
+	int imgh = screen_size_to_pix(posh, height, scale);
+	bool preserve_aspect = imgw < 0 || imgh < 0;
+
+	GError *err = NULL;
+	GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file_at_scale(
+			imgpath, imgw, imgh, preserve_aspect, &err);
+	if (!pixbuf) {
+		swaylock_log(LOG_ERROR, "Compose effect: Failed to load image file '%s' (%s).",
+				imgpath, err->message);
+		g_error_free(err);
+		return;
+	}
+
+	cairo_surface_t *image = gdk_cairo_image_surface_create_from_pixbuf(pixbuf);
+	g_object_unref(pixbuf);
+
+	int bufw = cairo_image_surface_get_width(image);
+	int bufh = cairo_image_surface_get_height(image);
+	uint32_t *bufdata = (uint32_t *)cairo_image_surface_get_data(image);
+	int bufstride = cairo_image_surface_get_stride(image) / 4;
+	bool bufalpha = cairo_image_surface_get_format(image) == CAIRO_FORMAT_ARGB32;
+
+	int imgx, imgy;
+	screen_pos_pair_to_pix(
+			posx, posy, bufw, bufh,
+			width, height, scale, gravity,
+			&imgx, &imgy);
+
+#pragma omp parallel for
+	for (int offy = 0; offy < bufh; ++offy) {
+		if (offy + imgy < 0 || offy + imgy > height)
+			continue;
+
+		for (int offx = 0; offx < bufw; ++offx) {
+			if (offx + imgx < 0 || offx + imgx > width)
+				continue;
+
+			size_t idx = (size_t)(offy + imgy) * width + (offx + imgx);
+			size_t bufidx = (size_t)offy * bufstride + (offx);
+
+			if (!bufalpha) {
+				data[idx] = bufdata[bufidx];
+			} else {
+				uint8_t alpha = (bufdata[bufidx] & 0xff000000) >> 24;
+				if (alpha == 255) {
+					data[idx] = bufdata[bufidx];
+				} else if (alpha != 0) {
+					data[idx] = blend_pixels(alpha / 255.0, bufdata[bufidx], data[idx]);
+				}
+			}
+		}
+	}
+
+	cairo_surface_destroy(image);
+#endif
+}
+
+static void effect_custom_run(uint32_t *data, int width, int height, int scale,
+		char *path) {
+	void *dl = dlopen(path, RTLD_LAZY);
+	if (dl == NULL) {
+		swaylock_log(LOG_ERROR, "Custom effect: %s", dlerror());
+		return;
+	}
+
+	void (*effect_func)(uint32_t *data, int width, int height, int scale) =
+		dlsym(dl, "swaylock_effect");
+	if (effect_func != NULL) {
+		effect_func(data, width, height, scale);
+		dlclose(dl);
+		return;
+	}
+
+	uint32_t (*pixel_func)(uint32_t pix, int x, int y, int width, int height) =
+		dlsym(dl, "swaylock_pixel");
+	if (pixel_func != NULL) {
+#pragma omp parallel for
+		for (int y = 0; y < height; ++y) {
+			for (int x = 0; x < width; ++x) {
+				data[y * width + x] =
+					pixel_func(data[y * width + x], x, y, width, height);
+			}
+		}
+
+		dlclose(dl);
+		return;
+	}
+
+	(void)dlsym(dl, "swaylock_effect"); // Change the result of dlerror()
+	swaylock_log(LOG_ERROR, "Custom effect: %s", dlerror());
+}
+
+static bool file_is_outdated(const char *input, const char *output) {
+	struct stat instat, outstat;
+	if (stat(input, &instat) < 0) {
+		return true;
+	}
+
+	if (stat(output, &outstat) < 0) {
+		return true;
+	}
+
+	if (instat.st_mtim.tv_sec > outstat.st_mtim.tv_sec) {
+		return true;
+	}
+
+	if (
+			instat.st_mtim.tv_sec == outstat.st_mtim.tv_sec &&
+			instat.st_mtim.tv_nsec >= outstat.st_mtim.tv_nsec) {
+		return true;
+	}
+
+	return false;
+}
+
+static char *effect_custom_compile(const char *path) {
+	static char *cachepath = NULL;
+	static size_t cachelen;
+	if (!cachepath) {
+		char *xdgdir = getenv("XDG_DATA_HOME");
+		if (xdgdir) {
+			cachepath = malloc(strlen(xdgdir) + strlen("/swaylock") + 1);
+			cachelen = sprintf(cachepath, "%s/swaylock", xdgdir);
+		} else {
+			char *homedir = getenv("HOME");
+			if (homedir == NULL) {
+				swaylock_log(LOG_ERROR,
+						"Can't compile custom effect; neither $HOME nor $XDG_CONFIG_HOME "
+						"is defined.");
+				return NULL;
+			}
+
+			cachepath = malloc(strlen(homedir) + strlen("/.cache/swaylock") + 1);
+			cachelen = sprintf(cachepath, "%s/.cache/swaylock", homedir);
+		}
+
+		if (mkdir(cachepath, 0777) < 0 && errno != EEXIST) {
+			swaylock_log(LOG_ERROR,
+					"Can't compile custom effect; mkdir %s failed: %s\n",
+					cachepath, strerror(errno));
+			free(cachepath);
+			cachepath = NULL;
+			return NULL;
+		}
+	}
+
+	// Find the true, absolute path of the input file
+	char *abspath = realpath(path, NULL);
+	size_t abspathlen = strlen(abspath);
+
+	char *outpath = malloc(cachelen + 1 + abspathlen + 3 + 1);
+	size_t outlen = sprintf(outpath, "%s/%s.so", cachepath, abspath);
+
+	// Sanitize
+	for (char *ch = outpath + cachelen + 1; ch < outpath + cachelen + 1 + abspathlen; ++ch) {
+		if (!(
+				(*ch >= 'a' && *ch <= 'z') ||
+				(*ch >= 'A' && *ch <= 'Z') ||
+				(*ch >= '0' && *ch <= '9') ||
+				(*ch == '.'))) {
+			*ch = '_';
+		}
+	}
+
+	if (!file_is_outdated(path, outpath)) {
+		free(abspath);
+		return outpath;
+	}
+
+	static const char *fmt = "cc -shared -g -O2 -march=native -fopenmp -o '%s' '%s' -lm";
+	char *cmd = malloc(strlen(fmt) + outlen - 2 + abspathlen - 2 + 1);
+	sprintf(cmd, fmt, outpath, abspath);
+	free(abspath);
+	fprintf(stderr, "Compiling custom effect: %s\n", cmd);
+
+	// Finally, compile.
+	int ret = system(cmd);
+	free(cmd);
+	if (ret != 0) {
+		if (ret == -1) {
+			swaylock_log(LOG_ERROR, "Custom effect: system(): %s", strerror(errno));
+			free(outpath);
+			return NULL;
+		} else {
+			swaylock_log(LOG_ERROR, "Custom effect compilation failed\n");
+			free(outpath);
+			return NULL;
+		}
+	}
+
+	return outpath;
+}
+
+static void effect_custom(uint32_t *data, int width, int height, int scale,
+		char *path) {
+	size_t pathlen = strlen(path);
+	if (pathlen > 3 && strcmp(path + pathlen - 3, ".so") == 0) {
+		effect_custom_run(data, width, height, scale, path);
+	} else if (pathlen > 2 && strcmp(path + pathlen - 2, ".c") == 0) {
+		char *compiled = effect_custom_compile(path);
+		if (compiled != NULL) {
+			effect_custom_run(data, width, height, scale, compiled);
+			free(compiled);
+		}
+	} else {
+		swaylock_log(
+			LOG_ERROR, "%s: Unknown file type for custom effect (expected .c or .so)",
+			path);
+	}
+}
+
+static cairo_surface_t *run_effect(cairo_surface_t *surface, int scale,
+		struct swaylock_effect *effect) {
+	switch (effect->tag) {
+	case EFFECT_BLUR: {
+		cairo_surface_t *surf = cairo_image_surface_create(
+				CAIRO_FORMAT_RGB24,
+				cairo_image_surface_get_width(surface),
+				cairo_image_surface_get_height(surface));
+
+		if (cairo_surface_status(surf) != CAIRO_STATUS_SUCCESS) {
+			swaylock_log(LOG_ERROR, "Failed to create surface for blur effect");
+			cairo_surface_destroy(surf);
+			break;
+		}
+
+		effect_blur(
+				(uint32_t *)cairo_image_surface_get_data(surf),
+				(uint32_t *)cairo_image_surface_get_data(surface),
+				cairo_image_surface_get_width(surface),
+				cairo_image_surface_get_height(surface),
+				scale,
+				effect->e.blur.radius, effect->e.blur.times);
+		cairo_surface_flush(surf);
+		cairo_surface_destroy(surface);
+		surface = surf;
+		break;
+	}
+
+	case EFFECT_PIXELATE: {
+		effect_pixelate(
+				(uint32_t *)cairo_image_surface_get_data(surface),
+				cairo_image_surface_get_width(surface),
+				cairo_image_surface_get_height(surface),
+				scale,
+				effect->e.pixelate.factor);
+		cairo_surface_flush(surface);
+		break;
+	}
+
+	case EFFECT_SCALE: {
+		cairo_surface_t *surf = cairo_image_surface_create(
+				CAIRO_FORMAT_RGB24,
+				cairo_image_surface_get_width(surface) * effect->e.scale,
+				cairo_image_surface_get_height(surface) * effect->e.scale);
+
+		if (cairo_surface_status(surf) != CAIRO_STATUS_SUCCESS) {
+			swaylock_log(LOG_ERROR, "Failed to create surface for scale effect");
+			cairo_surface_destroy(surf);
+			break;
+		}
+
+		effect_scale(
+				(uint32_t *)cairo_image_surface_get_data(surf),
+				(uint32_t *)cairo_image_surface_get_data(surface),
+				cairo_image_surface_get_width(surface),
+				cairo_image_surface_get_height(surface),
+				effect->e.scale);
+		cairo_surface_flush(surf);
+		cairo_surface_destroy(surface);
+		surface = surf;
+		break;
+	}
+
+	case EFFECT_GREYSCALE: {
+		effect_greyscale(
+				(uint32_t *)cairo_image_surface_get_data(surface),
+				cairo_image_surface_get_width(surface),
+				cairo_image_surface_get_height(surface));
+		cairo_surface_flush(surface);
+		break;
+	}
+
+	case EFFECT_VIGNETTE: {
+		effect_vignette(
+				(uint32_t *)cairo_image_surface_get_data(surface),
+				cairo_image_surface_get_width(surface),
+				cairo_image_surface_get_height(surface),
+				effect->e.vignette.base,
+				effect->e.vignette.factor);
+		cairo_surface_flush(surface);
+		break;
+	}
+
+	case EFFECT_COMPOSE: {
+		effect_compose(
+				(uint32_t *)cairo_image_surface_get_data(surface),
+				cairo_image_surface_get_width(surface),
+				cairo_image_surface_get_height(surface),
+				scale,
+				effect->e.compose.x, effect->e.compose.y,
+				effect->e.compose.w, effect->e.compose.h,
+				effect->e.compose.gravity, effect->e.compose.imgpath);
+		cairo_surface_flush(surface);
+		break;
+	}
+
+	case EFFECT_CUSTOM: {
+		effect_custom(
+				(uint32_t *)cairo_image_surface_get_data(surface),
+				cairo_image_surface_get_width(surface),
+				cairo_image_surface_get_height(surface),
+				scale,
+				effect->e.custom);
+		cairo_surface_flush(surface);
+		break;
+	} }
+
+	return surface;
+}
+
+static cairo_surface_t *ensure_format(cairo_surface_t *surface) {
+	if (cairo_image_surface_get_format(surface) == CAIRO_FORMAT_RGB24) {
+		return surface;
+	}
+
+	swaylock_log(LOG_DEBUG, "Have to convert surface to CAIRO_FORMAT_RGB24 from %i.",
+			(int)cairo_image_surface_get_format(surface));
+
+	cairo_surface_t *surf = cairo_image_surface_create(
+			CAIRO_FORMAT_RGB24,
+			cairo_image_surface_get_width(surface),
+			cairo_image_surface_get_height(surface));
+	if (cairo_surface_status(surf) != CAIRO_STATUS_SUCCESS) {
+		swaylock_log(LOG_ERROR, "Failed to create surface for scale effect");
+		cairo_surface_destroy(surf);
+		return NULL;
+	}
+
+	memcpy(
+			cairo_image_surface_get_data(surf),
+			cairo_image_surface_get_data(surface),
+			cairo_image_surface_get_stride(surface) * cairo_image_surface_get_height(surface));
+	cairo_surface_destroy(surface);
+	return surf;
+}
+
+cairo_surface_t *swaylock_effects_run(cairo_surface_t *surface, int scale,
+		struct swaylock_effect *effects, int count) {
+	surface = ensure_format(surface);
+	if (surface == NULL) return NULL;
+
+	for (int i = 0; i < count; ++i) {
+		struct swaylock_effect *effect = &effects[i];
+		surface = run_effect(surface, scale, effect);
+	}
+
+	return surface;
+}
+
+#define TIME_MSEC(tv) ((tv).tv_sec * 1000.0 + (tv).tv_nsec / 1000000.0)
+#define TIME_DELTA(first, last) (TIME_MSEC(last) - TIME_MSEC(first))
+
+cairo_surface_t *swaylock_effects_run_timed(cairo_surface_t *surface, int scale,
+		struct swaylock_effect *effects, int count) {
+	struct timespec start_tv;
+	clock_gettime(CLOCK_MONOTONIC, &start_tv);
+
+	surface = ensure_format(surface);
+	if (surface == NULL) return NULL;
+
+	fprintf(stderr, "Running %i effects:\n", count);
+	for (int i = 0; i < count; ++i) {
+		struct timespec effect_start_tv;
+		clock_gettime(CLOCK_MONOTONIC, &effect_start_tv);
+
+		struct swaylock_effect *effect = &effects[i];
+		surface = run_effect(surface, scale, effect);
+
+		struct timespec effect_end_tv;
+		clock_gettime(CLOCK_MONOTONIC, &effect_end_tv);
+		fprintf(stderr, "    %s: %fms\n", effect_name(effect),
+				TIME_DELTA(effect_start_tv, effect_end_tv));
+	}
+
+	struct timespec end_tv;
+	clock_gettime(CLOCK_MONOTONIC, &end_tv);
+	fprintf(stderr, "Effects took %fms.\n", TIME_DELTA(start_tv, end_tv));
+
+	return surface;
+}