Set up input handling

main.c

@@ -2,7 +2,9 @@
 
 #include <assert.h>
 #include <fcntl.h>
+#include <linux/input.h>
 #include <stdint.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/ioctl.h>
@@ -12,6 +14,8 @@
 #include <xf86drm.h>
 #include <xf86drmMode.h>
 
+#define MAX(a, b) ((a) < (b) ? (b) : (a))
+
 typedef struct {
 	uint32_t *buf;
 	uint32_t handle;
@@ -20,7 +24,10 @@ typedef struct {
 	uint32_t size;
 } fb_info_t;
 
-fb_info_t fb_init(int fd, drmModeModeInfo mode)
+static fb_info_t fbs[2];
+static int front = 0, back = 1;
+
+static fb_info_t fb_init(int drm_fd, drmModeModeInfo mode)
 {
 	int err;
 
@@ -29,21 +36,22 @@ fb_info_t fb_init(int fd, drmModeModeInfo mode)
 		.height = mode.vdisplay,
 		.bpp = 32,
 	};
-	err = ioctl(fd, DRM_IOCTL_MODE_CREATE_DUMB, &create);
+	err = ioctl(drm_fd, DRM_IOCTL_MODE_CREATE_DUMB, &create);
 	assert(err != -1);
 
 	uint32_t id;
 	err = drmModeAddFB(
-	    fd, create.width, create.height, 24, 32, create.pitch, create.handle,
+	    drm_fd, create.width, create.height, 24, 32, create.pitch,
-	    &id);
+	    create.handle, &id);
 	assert(err == 0);
 
 	struct drm_mode_map_dumb map = { .handle = create.handle };
-	err = ioctl(fd, DRM_IOCTL_MODE_MAP_DUMB, &map);
+	err = ioctl(drm_fd, DRM_IOCTL_MODE_MAP_DUMB, &map);
 	assert(err != -1);
 
 	uint32_t *buf = mmap(
-	    0, create.size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, map.offset);
+	    0, create.size, PROT_READ | PROT_WRITE, MAP_SHARED, drm_fd,
+	    map.offset);
 	assert(buf != MAP_FAILED);
 
 	return (fb_info_t) {
@@ -55,84 +63,110 @@ fb_info_t fb_init(int fd, drmModeModeInfo mode)
 	};
 }
 
-void fb_cleanup(int fd, fb_info_t fb)
+static void fb_cleanup(int drm_fd, fb_info_t fb)
 {
 	munmap(fb.buf, fb.size);
-	drmModeRmFB(fd, fb.id);
+	drmModeRmFB(drm_fd, fb.id);
 	struct drm_mode_destroy_dumb delete = { .handle = fb.handle };
-	ioctl(fd, DRM_IOCTL_MODE_DESTROY_DUMB, &delete);
+	ioctl(drm_fd, DRM_IOCTL_MODE_DESTROY_DUMB, &delete);
 }
 
 static void page_flip_handler(int, unsigned, unsigned, unsigned, void *)
 {
 }
 
+static void swap_buffers(int drm_fd, uint32_t crtc_id)
+{
+	const int err = drmModePageFlip(
+	    drm_fd, crtc_id, fbs[back].id, DRM_MODE_PAGE_FLIP_EVENT, nullptr);
+	assert(err == 0);
+
+	front = (front + 1) & 1;
+	back = (back + 1) & 1;
+}
+
 int main()
 {
 	int err;
 
-	const int fd = open("/dev/dri/card1", O_RDWR | O_CLOEXEC);
+	const int input_fd = open("/dev/input/event0", O_RDONLY);
-	assert(fd != -1);
+	assert(input_fd != -1);
 
-	drmModeRes *res = drmModeGetResources(fd);
+	const int drm_fd = open("/dev/dri/card1", O_RDWR | O_CLOEXEC);
+	assert(drm_fd != -1);
+
+	drmModeRes *res = drmModeGetResources(drm_fd);
 	assert(res != nullptr);
-	drmModeConnector *conn = drmModeGetConnector(fd, res->connectors[0]);
+	drmModeConnector *conn = drmModeGetConnector(drm_fd, res->connectors[0]);
 	assert(conn != nullptr);
 	drmModeModeInfo mode = conn->modes[0];
 	uint32_t conn_id = conn->connector_id;
 
-	fb_info_t fbs[2] = {
+	fbs[0] = fb_init(drm_fd, mode);
-		fb_init(fd, mode),
+	fbs[1] = fb_init(drm_fd, mode);
-		fb_init(fd, mode),
-	};
-	int front = 0, back = 1;
 
 	err = drmModeSetCrtc(
-	    fd, res->crtcs[0], fbs[front].id, 0, 0, &conn_id, 1, &mode);
+	    drm_fd, res->crtcs[0], fbs[front].id, 0, 0, &conn_id, 1, &mode);
 	assert(err == 0);
-	drmModeCrtc *crtc = drmModeGetCrtc(fd, res->crtcs[0]);
+	drmModeCrtc *crtc = drmModeGetCrtc(drm_fd, res->crtcs[0]);
 	assert(crtc != nullptr);
 
+	memset(fbs[back].buf, 0, fbs[back].size);
+	swap_buffers(drm_fd, crtc->crtc_id);
+
+	const int max_fd = MAX(input_fd, drm_fd);
 	fd_set set;
-	FD_ZERO(&set);
+	bool running = true;
-	FD_SET(fd, &set);
+	uint64_t frame = 0;
+	while (running) {
+		FD_ZERO(&set);
+		FD_SET(input_fd, &set);
+		FD_SET(drm_fd, &set);
+		select(max_fd + 1, &set, nullptr, nullptr, nullptr);
 
-	drmEventContext ev = {
+		if (FD_ISSET(input_fd, &set)) {
-		.version = DRM_EVENT_CONTEXT_VERSION,
+			struct input_event ev;
-		.page_flip_handler = page_flip_handler,
+			const int len = read(input_fd, &ev, sizeof(ev));
-	};
+			assert(len == sizeof(ev));
 
-	for (uint64_t frame = 0; frame < (10 * 60); ++frame) {
+			if (ev.type == EV_KEY && ev.value >= 0 && ev.value <= 2) {
-		for (int y = 0; y < mode.vdisplay; ++y) {
+				if (ev.code == KEY_Q && ev.value == 1)
-			for (int x = 0; x < mode.hdisplay; ++x) {
+					running = false;
-				const uint8_t r = (x + frame) % 256;
-				const uint8_t g = (y + frame) & 256;
-				const uint8_t b = (x + y + frame) % 256;
-				fbs[back].buf[y * (fbs[back].pitch / 4) + x]
-				    = (r << 16) | (g << 8) | b;
 			}
 		}
 
-		drmModePageFlip(
+		if (FD_ISSET(drm_fd, &set)) {
-		    fd, crtc->crtc_id, fbs[back].id, DRM_MODE_PAGE_FLIP_EVENT,
+			drmEventContext ev = {
-		    nullptr);
+				.version = DRM_EVENT_CONTEXT_VERSION,
-		select(fd + 1, &set, nullptr, nullptr, nullptr);
+				.page_flip_handler = page_flip_handler,
-		drmHandleEvent(fd, &ev);
+			};
+			drmHandleEvent(drm_fd, &ev);
 
-		front = (front + 1) & 1;
+			for (int y = 0; y < mode.vdisplay; ++y) {
-		back = (back + 1) & 1;
+				for (int x = 0; x < mode.hdisplay; ++x) {
+					const uint8_t r = (x + frame) % 256;
+					const uint8_t g = (y + frame) % 256;
+					const uint8_t b = (x + y + frame) % 256;
+					fbs[back].buf[y * (fbs[back].pitch / 4) + x]
+					    = (r << 16) | (g << 8) | b;
+				}
+			}
+
+			swap_buffers(drm_fd, crtc->crtc_id);
+			++frame;
+		}
 	}
 
 	drmModeSetCrtc(
-	    fd, crtc->crtc_id, crtc->buffer_id, crtc->x, crtc->y, &conn_id, 1,
+	    drm_fd, crtc->crtc_id, crtc->buffer_id, crtc->x, crtc->y, &conn_id,
-	    &crtc->mode);
+	    1, &crtc->mode);
 
-	fb_cleanup(fd, fbs[0]);
+	fb_cleanup(drm_fd, fbs[0]);
-	fb_cleanup(fd, fbs[1]);
+	fb_cleanup(drm_fd, fbs[1]);
 	drmModeFreeCrtc(crtc);
 	drmModeFreeConnector(conn);
 	drmModeFreeResources(res);
-	close(fd);
+	close(drm_fd);
 
 	return 0;
 }