path: root/bgdraw.c

#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/XKBlib.h>
#include <X11/keysym.h>
#include <X11/cursorfont.h>
#include <X11/extensions/Xinerama.h>

#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"

#define STB_IMAGE_RESIZE_IMPLEMENTATION
#include "stb_image_resize.h"

#include <sys/time.h>
#include <unistd.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((a) >= (b) ? (a) : (b))
#define ARRLEN(x) (sizeof(x) / sizeof((x)[0]))

#define OOM_CHECK(p) do { if ((p) == NULL) die("Out of memory\n"); } while (0)

struct image {
	char *name;
	char *path;
	int ox, oy;
	int x, y;
	int w, h;
	int channels;

	XImage **frames;
	int *durations;
	int framei, framecnt;
	float frametime;
	time_t last_frame;

	struct image *next;
};

static void die(const char *fmtstr, ...);

static void monitor_offset(int num, int *x, int *y);
static void convert_rgb_bgr(uint8_t *pix, int width, int height,
	int stride, int pixlen);

static void draw_img(struct image *img);
static void draw(void);

static void load(const char *path);

static bool load_attrs(FILE *file, struct image *img, int *lineno);

static void load_img(struct image *img);
static void free_img(struct image *img);

static const char *config_path;
static bool debug;

static struct image *images;

static Display *display;
static Screen *screen;
static Window root;
static Visual *vis;
static GC gc;

void
die(const char *fmtstr, ...)
{
	va_list ap;

	va_start(ap, fmtstr);
	vfprintf(stderr, fmtstr, ap);
	va_end(ap);

	exit(1);
}

void
monitor_offset(int num, int *x, int *y)
{
	XineramaScreenInfo *info;
	int mcount, screen;

	if (!XineramaIsActive(display))
		die("No monitor support\n");

	if (!(info = XineramaQueryScreens(display, &mcount)))
		die("Failed to query xinerama\n");

	if (num < 0 || num > mcount)
		die("Monitor number out of range\n");

	*x = info[num].x_org;
	*y = info[num].y_org;
}

void
convert_rgb_bgr(uint8_t *pix, int width, int height, int stride, int pixlen)
{
	uint8_t tmp, *cpix;
	int x, y;

	for (y = 0; y < height; y++) {
		for (x = 0; x < width; x++) {
			cpix = &pix[y * stride + x * pixlen];
			tmp = cpix[0];
			cpix[0] = cpix[2];
			cpix[2] = tmp;
		}
	}
}

void
draw_img(struct image *img)
{
	if (debug) printf("DRAW %s\n", img->name);
	XPutImage(display, root, gc, img->frames[img->framei], 0, 0,
		img->x, img->y, img->w, img->h);
}

void
draw(void)
{
	struct image *img;

	for (img = images; img; img = img->next)
		draw_img(img);
}

void
load(const char *path)
{
	struct image img;
	struct image **next;
	int lineno;
	FILE *file;

	file = fopen(path, "r");
	if (!file) die("Failed to open path: %s\n", path);

	images = NULL;
	next = &images;
	lineno = 1;
	while (!feof(file)) {
		memset(&img, 0, sizeof(struct image));
		img.last_frame = 0;

		if (!load_attrs(file, &img, &lineno))
			break; /* EOF */

		img.x += img.ox;
		img.y += img.oy;

		load_img(&img);

		*next = malloc(sizeof(struct image));
		OOM_CHECK(*next);
		memcpy(*next, &img, sizeof(struct image));
		next = &((*next)->next);
	}

	fclose(file);
}

bool
load_attrs(FILE *file, struct image *img, int *lineno)
{
	char *key, *val;
	char line[256];
	char *tok, end;
	bool partial;

	partial = false;
	while (fgets(line, sizeof(line), file)) {
		tok = strchr(line, '\n');
		if (tok) *tok = '\0';

		if (!strcmp(line, "")) {
			if (partial) return true;
			continue;
		}

		if (line[0] == '#')
			continue;

		partial = true;

		if (!img->name) {
			end = '\0';
			if (sscanf(line, "[%m[-_a-zA-Z0-9]]%c",
					&img->name, &end) != 1 || end)
				die("Invalid title line %i:\n%s %c\n",
					*lineno, line, end);
			continue;
		}

		tok = strchr(line, ' ');
		if (!tok) die("[%s] Invalid line %i: %s\n",
				img->name, *lineno, line);
		*tok = '\0';

		key = line;
		val = tok + 1;

		if (!strcmp(key, "pos")) {
			tok = strchr(val, 'x');
			if (!tok) die("[%s] Invalid pos: %s\n",
					img->name, val);
			*tok = '\0';

			img->x = atoi(val);
			img->y = atoi(tok + 1);
		} else if (!strcmp(key, "size")) {
			tok = strchr(val, 'x');
			if (!tok) die("[%s] Invalid size: %s\n",
					img->name, val);
			*tok = '\0';

			if ((img->w = atoi(val)) <= 0)
				die("[%s] Invalid width: %s\n",
					img->name, val);

			if ((img->h = atoi(tok + 1)) <= 0)
				die("[%s] Invalid height: %s\n",
					img->name, tok + 1);
		} else if (!strcmp(key, "monitor")) {
			monitor_offset(atoi(val), &img->ox, &img->oy);
		} else if (!strcmp(key, "frametime")) {
			img->frametime = atof(val);
		} else if (!strcmp(key, "path")) {
			img->path = strdup(val);
			OOM_CHECK(img->path);
		} else {
			die("[%s] Invalid line %i:\n%s\n",
				img->name, *lineno, line);
		}

		(*lineno)++;
	}

	return partial;
}

void
load_img(struct image *img)
{
	char *args[4] = { NULL };
	int width, height, i;
	void *pix, *rpix;
	stbi__context ctx;
	stbi__result_info info;
	stbi__gif gif;
	uint8_t *frames;
	FILE *file;

	if (debug) printf("LOAD %s\n", img->name);

	if (!(file = stbi__fopen(img->path, "rb")))
		die("[%s] Path does not exist\n", img->name);

	stbi__start_file(&ctx, file);

	if (stbi__gif_test(&ctx)) {
		frames = stbi__load_gif_main(&ctx, &img->durations,
			&width, &height, &img->framecnt, &img->channels, 4);
		if (!frames || !img->framecnt)
			die("[%s] Failed to load gif image\n");

		img->frames = malloc(sizeof(XImage*) * img->framecnt);
		OOM_CHECK(img->frames);

		for (i = 0; i < img->framecnt; i++) {
			pix = frames + width * height * 4 * i;

			rpix = malloc(img->w * img->h * 4);
			OOM_CHECK(rpix);
			if (!stbir_resize_uint8(pix, width, height, 0,
					rpix, img->w, img->h, 0, 4))
				die("[%s] Failed to resize image\n", img->name);

			convert_rgb_bgr(rpix, img->w, img->h, img->w * 4, 4);

			img->frames[i] = XCreateImage(display, vis,
				24, ZPixmap, 0, rpix,
				img->w, img->h, 32, 0);
			if (!img->frames[i]) die("Failed to create XImage\n");
		}

		STBI_FREE(frames);
	} else {
		pix = stbi__load_main(&ctx, &width, &height,
			&img->channels, 4, &info, 8);
		if (!pix) die("[%s] Failed to load image\n", img->name);

		if (!img->w || !img->h) {
			img->w = width;
			img->h = height;
		}

		rpix = malloc(img->w * img->h * 4);
		OOM_CHECK(rpix);
		if (!stbir_resize_uint8(pix, width, height, 0,
				rpix, img->w, img->h, 0, 4))
			die("[%s] Failed to resize image\n", img->name);

		img->durations = NULL;
		img->frames = malloc(sizeof(XImage*));
		OOM_CHECK(img->frames);
		img->frames[0] = XCreateImage(display, vis, 24,
			ZPixmap, 0, rpix, img->w, img->h, 32, 0);
		if (!img->frames[0]) die("Failed to create XImage\n");

		free(pix);
	}

	for (i = 0; i < img->framecnt; i++) {
		if (img->frametime)
			img->durations[i] = img->frametime * 100;
		else
			img->durations[i] = img->durations[i] / 10;
	}

	img->framei = 0;

	fclose(file);
}

void
free_img(struct image *img)
{
	int i;

	free(img->name);
	free(img->path);
	for (i = 0; i < img->framecnt; i++) {
		free(img->frames[i]->data);
		XFree(img->frames[i]);
	}
	STBI_FREE(img->durations);
}

void
init(void)
{
	display = XOpenDisplay(NULL);
	if (!display) die("Failed to open display\n");

	screen = XDefaultScreenOfDisplay(display);
	if (!screen) die("Failed to get screen\n");

	vis = DefaultVisualOfScreen(screen);
	root = RootWindowOfScreen(screen);

	gc = XCreateGC(display, root, 0, NULL);

	XSelectInput(display, root, ExposureMask);

	XSync(display, True);

	load(config_path);
}

void
deinit(void)
{
	struct image *img, *next;

	for (img = images; img; ) {
		next = img->next;
		free_img(img);
		free(img);
		img = next;
	}

	XCloseDisplay(display);
}

int
main(int argc, const char *argv[])
{
	struct image *img;
	const char **arg;
	struct timeval tv, nowtv;
	XEvent event;
	time_t now;
	bool done;
	fd_set fds;
	int xfd;

	debug = false;
	config_path = "drawrc";
	for (arg = argv + 1; *arg; arg++) {
		if (!strcmp(*arg, "-d")) {
			debug = true;
		} else if (!strcmp(*arg, "-c")) {
			config_path = *(++arg);
		} else {
			die("USAGE: bgdraw [-d] [-c CONFIG]\n");
		}
	}

	init();

	draw();

	done = false;
	xfd = XConnectionNumber(display);
	while (!done) {
		FD_ZERO(&fds);
		FD_SET(xfd, &fds);

		tv.tv_usec = 50000;
		tv.tv_sec = 0;

		/* wait for X event or timer */
		select(xfd + 1, &fds, NULL, NULL, &tv);

		/* handle exposure events */
		while (XPending(display)) {
			XNextEvent(display, &event);
			switch (event.type) {
			case Expose:
				draw();
				break;
			}
		}

		/* handle reloads */
		gettimeofday(&nowtv, NULL);
		now = nowtv.tv_sec * 100 + nowtv.tv_usec / 10000;
		for (img = images; img; img = img->next) {
			if (img->durations && img->last_frame
					+ img->durations[img->framei] < now) {
				img->last_frame = now;
				draw_img(img);

				img->framei++;
				if (img->framei == img->framecnt)
					img->framei = 0;
			}
		}
	}

	deinit();
}