Wayland screenshot

1 files changed, 1076 insertions, 5 deletions

diff --git a/reduced_system_layer.c b/reduced_system_layer.c
index 07e633e..99c3e72 100644
--- a/reduced_system_layer.c
+++ b/reduced_system_layer.c
@@ -47,7 +47,6 @@
 //    - Window
 //      - Wayland
 //      - Windows graphics
-//      - Screenshot
 //    - Sound
 //      - Windows audio
 //      - Recording
@@ -97,6 +96,7 @@
 //    - Anti-aliasing
 //  - System
 //    - Window - X11, Web
+//      - Screenshot
 //    - Sound - ALSA, Web
 //    - Networking
 //      - Unix UDP sockets
@@ -599,6 +599,9 @@ void p_event_loop(void);
 //  Clipboard
 void p_clipboard_write(i64 size, c8 *data);
 
+//  Take a screenshot
+void p_screenshot(i64 max_num_pixels, i64 *width, i64 *height, vec4_f32 *pixels);
+
 //  Sound
 void p_handle_sound(void);
 void p_queue_sound(i64 delay_in_samples, i64 num_samples, f32 *frames);
@@ -757,6 +760,14 @@ static u32 rgb_u32_from_f32_(vec3_f32 c) {
   return (r << 16) | (g << 8) | b;
 }
 
+static vec3_f32 rgb_f32_from_u32_(u32 c) {
+  return (vec3_f32) {
+    .x = ((c >> 16) & 0xff) / 255.f,
+    .y = ((c >>  8) & 0xff) / 255.f,
+    .z = ( c        & 0xff) / 255.f,
+  };
+}
+
 static i64 average_frame_duration_(i64 duration) {
   _frame_duration[_frame_index] = duration;
   _frame_index = (_frame_index + 1) % NUM_FRAMES_AVERAGED;
@@ -1436,11 +1447,988 @@ void p_queue_sound(i64 delay_in_samples, i64 num_samples, f32 *frames) {
 
 //  ================================================================
 //
+//  Wayland
+//
+//  ================================================================
+
+#if defined(__linux__) && !defined(NO_WAYLAND)
+
+#include <sys/mman.h>
+#include <wayland-client.h>
+#include <wayland-util.h>
+
+struct wl_buffer;
+struct wl_output;
+struct zwlr_screencopy_frame_v1;
+struct zwlr_screencopy_manager_v1;
+
+#ifndef ZWLR_SCREENCOPY_MANAGER_V1_INTERFACE
+#define ZWLR_SCREENCOPY_MANAGER_V1_INTERFACE
+extern const struct wl_interface zwlr_screencopy_manager_v1_interface;
+#endif
+#ifndef ZWLR_SCREENCOPY_FRAME_V1_INTERFACE
+#define ZWLR_SCREENCOPY_FRAME_V1_INTERFACE
+extern const struct wl_interface zwlr_screencopy_frame_v1_interface;
+#endif
+
+#define ZWLR_SCREENCOPY_MANAGER_V1_CAPTURE_OUTPUT 0
+#define ZWLR_SCREENCOPY_MANAGER_V1_CAPTURE_OUTPUT_REGION 1
+#define ZWLR_SCREENCOPY_MANAGER_V1_DESTROY 2
+
+
+#define ZWLR_SCREENCOPY_MANAGER_V1_CAPTURE_OUTPUT_SINCE_VERSION 1
+#define ZWLR_SCREENCOPY_MANAGER_V1_CAPTURE_OUTPUT_REGION_SINCE_VERSION 1
+#define ZWLR_SCREENCOPY_MANAGER_V1_DESTROY_SINCE_VERSION 1
+
+static void
+zwlr_screencopy_manager_v1_set_user_data(struct zwlr_screencopy_manager_v1 *zwlr_screencopy_manager_v1, void *user_data)
+{
+  wl_proxy_set_user_data((struct wl_proxy *) zwlr_screencopy_manager_v1, user_data);
+}
+
+static void *
+zwlr_screencopy_manager_v1_get_user_data(struct zwlr_screencopy_manager_v1 *zwlr_screencopy_manager_v1)
+{
+  return wl_proxy_get_user_data((struct wl_proxy *) zwlr_screencopy_manager_v1);
+}
+
+static u32
+zwlr_screencopy_manager_v1_get_version(struct zwlr_screencopy_manager_v1 *zwlr_screencopy_manager_v1)
+{
+  return wl_proxy_get_version((struct wl_proxy *) zwlr_screencopy_manager_v1);
+}
+
+static struct zwlr_screencopy_frame_v1 *
+zwlr_screencopy_manager_v1_capture_output(struct zwlr_screencopy_manager_v1 *zwlr_screencopy_manager_v1, i32 overlay_cursor, struct wl_output *output)
+{
+  struct wl_proxy *frame;
+
+  frame = wl_proxy_marshal_flags((struct wl_proxy *) zwlr_screencopy_manager_v1,
+       ZWLR_SCREENCOPY_MANAGER_V1_CAPTURE_OUTPUT, &zwlr_screencopy_frame_v1_interface, wl_proxy_get_version((struct wl_proxy *) zwlr_screencopy_manager_v1), 0, NULL, overlay_cursor, output);
+
+  return (struct zwlr_screencopy_frame_v1 *) frame;
+}
+
+static struct zwlr_screencopy_frame_v1 *
+zwlr_screencopy_manager_v1_capture_output_region(struct zwlr_screencopy_manager_v1 *zwlr_screencopy_manager_v1, i32 overlay_cursor, struct wl_output *output, i32 x, i32 y, i32 width, i32 height)
+{
+  struct wl_proxy *frame;
+
+  frame = wl_proxy_marshal_flags((struct wl_proxy *) zwlr_screencopy_manager_v1,
+       ZWLR_SCREENCOPY_MANAGER_V1_CAPTURE_OUTPUT_REGION, &zwlr_screencopy_frame_v1_interface, wl_proxy_get_version((struct wl_proxy *) zwlr_screencopy_manager_v1), 0, NULL, overlay_cursor, output, x, y, width, height);
+
+  return (struct zwlr_screencopy_frame_v1 *) frame;
+}
+
+static void
+zwlr_screencopy_manager_v1_destroy(struct zwlr_screencopy_manager_v1 *zwlr_screencopy_manager_v1)
+{
+  wl_proxy_marshal_flags((struct wl_proxy *) zwlr_screencopy_manager_v1,
+       ZWLR_SCREENCOPY_MANAGER_V1_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) zwlr_screencopy_manager_v1), WL_MARSHAL_FLAG_DESTROY);
+}
+
+#ifndef ZWLR_SCREENCOPY_FRAME_V1_ERROR_ENUM
+#define ZWLR_SCREENCOPY_FRAME_V1_ERROR_ENUM
+enum zwlr_screencopy_frame_v1_error {
+  ZWLR_SCREENCOPY_FRAME_V1_ERROR_ALREADY_USED = 0,
+  ZWLR_SCREENCOPY_FRAME_V1_ERROR_INVALID_BUFFER = 1,
+};
+#endif
+
+#ifndef ZWLR_SCREENCOPY_FRAME_V1_FLAGS_ENUM
+#define ZWLR_SCREENCOPY_FRAME_V1_FLAGS_ENUM
+enum zwlr_screencopy_frame_v1_flags {
+  ZWLR_SCREENCOPY_FRAME_V1_FLAGS_Y_INVERT = 1,
+};
+#endif
+
+struct zwlr_screencopy_frame_v1_listener {
+  void (*buffer)(void *data,
+           struct zwlr_screencopy_frame_v1 *zwlr_screencopy_frame_v1,
+           u32 format,
+           u32 width,
+           u32 height,
+           u32 stride);
+  void (*flags)(void *data,
+          struct zwlr_screencopy_frame_v1 *zwlr_screencopy_frame_v1,
+          u32 flags);
+  void (*ready)(void *data,
+          struct zwlr_screencopy_frame_v1 *zwlr_screencopy_frame_v1,
+          u32 tv_sec_hi,
+          u32 tv_sec_lo,
+          u32 tv_nsec);
+  void (*failed)(void *data,
+           struct zwlr_screencopy_frame_v1 *zwlr_screencopy_frame_v1);
+};
+
+static int
+zwlr_screencopy_frame_v1_add_listener(struct zwlr_screencopy_frame_v1 *zwlr_screencopy_frame_v1,
+              const struct zwlr_screencopy_frame_v1_listener *listener, void *data)
+{
+  return wl_proxy_add_listener((struct wl_proxy *) zwlr_screencopy_frame_v1,
+             (void (**)(void)) listener, data);
+}
+
+#define ZWLR_SCREENCOPY_FRAME_V1_COPY 0
+#define ZWLR_SCREENCOPY_FRAME_V1_DESTROY 1
+
+#define ZWLR_SCREENCOPY_FRAME_V1_BUFFER_SINCE_VERSION 1
+#define ZWLR_SCREENCOPY_FRAME_V1_FLAGS_SINCE_VERSION 1
+#define ZWLR_SCREENCOPY_FRAME_V1_READY_SINCE_VERSION 1
+#define ZWLR_SCREENCOPY_FRAME_V1_FAILED_SINCE_VERSION 1
+
+#define ZWLR_SCREENCOPY_FRAME_V1_COPY_SINCE_VERSION 1
+#define ZWLR_SCREENCOPY_FRAME_V1_DESTROY_SINCE_VERSION 1
+
+static void
+zwlr_screencopy_frame_v1_set_user_data(struct zwlr_screencopy_frame_v1 *zwlr_screencopy_frame_v1, void *user_data)
+{
+  wl_proxy_set_user_data((struct wl_proxy *) zwlr_screencopy_frame_v1, user_data);
+}
+
+static void *
+zwlr_screencopy_frame_v1_get_user_data(struct zwlr_screencopy_frame_v1 *zwlr_screencopy_frame_v1)
+{
+  return wl_proxy_get_user_data((struct wl_proxy *) zwlr_screencopy_frame_v1);
+}
+
+static u32
+zwlr_screencopy_frame_v1_get_version(struct zwlr_screencopy_frame_v1 *zwlr_screencopy_frame_v1)
+{
+  return wl_proxy_get_version((struct wl_proxy *) zwlr_screencopy_frame_v1);
+}
+
+static void
+zwlr_screencopy_frame_v1_copy(struct zwlr_screencopy_frame_v1 *zwlr_screencopy_frame_v1, struct wl_buffer *buffer)
+{
+  wl_proxy_marshal_flags((struct wl_proxy *) zwlr_screencopy_frame_v1,
+       ZWLR_SCREENCOPY_FRAME_V1_COPY, NULL, wl_proxy_get_version((struct wl_proxy *) zwlr_screencopy_frame_v1), 0, buffer);
+}
+
+static void
+zwlr_screencopy_frame_v1_destroy(struct zwlr_screencopy_frame_v1 *zwlr_screencopy_frame_v1)
+{
+  wl_proxy_marshal_flags((struct wl_proxy *) zwlr_screencopy_frame_v1,
+       ZWLR_SCREENCOPY_FRAME_V1_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) zwlr_screencopy_frame_v1), WL_MARSHAL_FLAG_DESTROY);
+}
+
+struct wl_output;
+struct zxdg_output_manager_v1;
+struct zxdg_output_v1;
+
+#ifndef ZXDG_OUTPUT_MANAGER_V1_INTERFACE
+#define ZXDG_OUTPUT_MANAGER_V1_INTERFACE
+extern const struct wl_interface zxdg_output_manager_v1_interface;
+#endif
+#ifndef ZXDG_OUTPUT_V1_INTERFACE
+#define ZXDG_OUTPUT_V1_INTERFACE
+extern const struct wl_interface zxdg_output_v1_interface;
+#endif
+
+#define ZXDG_OUTPUT_MANAGER_V1_DESTROY 0
+#define ZXDG_OUTPUT_MANAGER_V1_GET_XDG_OUTPUT 1
+
+#define ZXDG_OUTPUT_MANAGER_V1_DESTROY_SINCE_VERSION 1
+#define ZXDG_OUTPUT_MANAGER_V1_GET_XDG_OUTPUT_SINCE_VERSION 1
+
+static void
+zxdg_output_manager_v1_set_user_data(struct zxdg_output_manager_v1 *zxdg_output_manager_v1, void *user_data)
+{
+  wl_proxy_set_user_data((struct wl_proxy *) zxdg_output_manager_v1, user_data);
+}
+
+static void *
+zxdg_output_manager_v1_get_user_data(struct zxdg_output_manager_v1 *zxdg_output_manager_v1)
+{
+  return wl_proxy_get_user_data((struct wl_proxy *) zxdg_output_manager_v1);
+}
+
+static u32
+zxdg_output_manager_v1_get_version(struct zxdg_output_manager_v1 *zxdg_output_manager_v1)
+{
+  return wl_proxy_get_version((struct wl_proxy *) zxdg_output_manager_v1);
+}
+
+static void
+zxdg_output_manager_v1_destroy(struct zxdg_output_manager_v1 *zxdg_output_manager_v1)
+{
+  wl_proxy_marshal_flags((struct wl_proxy *) zxdg_output_manager_v1,
+       ZXDG_OUTPUT_MANAGER_V1_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) zxdg_output_manager_v1), WL_MARSHAL_FLAG_DESTROY);
+}
+
+static struct zxdg_output_v1 *
+zxdg_output_manager_v1_get_xdg_output(struct zxdg_output_manager_v1 *zxdg_output_manager_v1, struct wl_output *output)
+{
+  struct wl_proxy *id;
+
+  id = wl_proxy_marshal_flags((struct wl_proxy *) zxdg_output_manager_v1,
+       ZXDG_OUTPUT_MANAGER_V1_GET_XDG_OUTPUT, &zxdg_output_v1_interface, wl_proxy_get_version((struct wl_proxy *) zxdg_output_manager_v1), 0, NULL, output);
+
+  return (struct zxdg_output_v1 *) id;
+}
+
+struct zxdg_output_v1_listener {
+  void (*logical_position)(void *data,
+         struct zxdg_output_v1 *zxdg_output_v1,
+         i32 x,
+         i32 y);
+  void (*logical_size)(void *data,
+           struct zxdg_output_v1 *zxdg_output_v1,
+           i32 width,
+           i32 height);
+  void (*done)(void *data,
+         struct zxdg_output_v1 *zxdg_output_v1);
+  void (*name)(void *data,
+         struct zxdg_output_v1 *zxdg_output_v1,
+         c8 const *name);
+  void (*description)(void *data,
+          struct zxdg_output_v1 *zxdg_output_v1,
+          c8 const *description);
+};
+
+static int
+zxdg_output_v1_add_listener(struct zxdg_output_v1 *zxdg_output_v1,
+          const struct zxdg_output_v1_listener *listener, void *data)
+{
+  return wl_proxy_add_listener((struct wl_proxy *) zxdg_output_v1,
+             (void (**)(void)) listener, data);
+}
+
+#define ZXDG_OUTPUT_V1_DESTROY 0
+
+#define ZXDG_OUTPUT_V1_LOGICAL_POSITION_SINCE_VERSION 1
+#define ZXDG_OUTPUT_V1_LOGICAL_SIZE_SINCE_VERSION 1
+#define ZXDG_OUTPUT_V1_DONE_SINCE_VERSION 1
+#define ZXDG_OUTPUT_V1_NAME_SINCE_VERSION 2
+#define ZXDG_OUTPUT_V1_DESCRIPTION_SINCE_VERSION 2
+
+#define ZXDG_OUTPUT_V1_DESTROY_SINCE_VERSION 1
+
+static void
+zxdg_output_v1_set_user_data(struct zxdg_output_v1 *zxdg_output_v1, void *user_data)
+{
+  wl_proxy_set_user_data((struct wl_proxy *) zxdg_output_v1, user_data);
+}
+
+static void *
+zxdg_output_v1_get_user_data(struct zxdg_output_v1 *zxdg_output_v1)
+{
+  return wl_proxy_get_user_data((struct wl_proxy *) zxdg_output_v1);
+}
+
+static u32
+zxdg_output_v1_get_version(struct zxdg_output_v1 *zxdg_output_v1)
+{
+  return wl_proxy_get_version((struct wl_proxy *) zxdg_output_v1);
+}
+
+static void
+zxdg_output_v1_destroy(struct zxdg_output_v1 *zxdg_output_v1)
+{
+  wl_proxy_marshal_flags((struct wl_proxy *) zxdg_output_v1,
+       ZXDG_OUTPUT_V1_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) zxdg_output_v1), WL_MARSHAL_FLAG_DESTROY);
+}
+
+#ifndef __has_attribute
+# define __has_attribute(x) 0  /* Compatibility with non-clang compilers. */
+#endif
+
+#if (__has_attribute(visibility) || defined(__GNUC__) && __GNUC__ >= 4)
+#define WL_PRIVATE __attribute__ ((visibility("hidden")))
+#else
+#define WL_PRIVATE
+#endif
+
+extern const struct wl_interface wl_buffer_interface;
+extern const struct wl_interface wl_output_interface;
+extern const struct wl_interface zwlr_screencopy_frame_v1_interface;
+
+static const struct wl_interface *wlr_screencopy_unstable_v1_types[] = {
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+  &zwlr_screencopy_frame_v1_interface,
+  NULL,
+  &wl_output_interface,
+  &zwlr_screencopy_frame_v1_interface,
+  NULL,
+  &wl_output_interface,
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+  &wl_buffer_interface,
+};
+
+static const struct wl_message zwlr_screencopy_manager_v1_requests[] = {
+  { "capture_output", "nio", wlr_screencopy_unstable_v1_types + 4 },
+  { "capture_output_region", "nioiiii", wlr_screencopy_unstable_v1_types + 7 },
+  { "destroy", "", wlr_screencopy_unstable_v1_types + 0 },
+};
+
+WL_PRIVATE const struct wl_interface zwlr_screencopy_manager_v1_interface = {
+  "zwlr_screencopy_manager_v1", 1,
+  3, zwlr_screencopy_manager_v1_requests,
+  0, NULL,
+};
+
+static const struct wl_message zwlr_screencopy_frame_v1_requests[] = {
+  { "copy", "o", wlr_screencopy_unstable_v1_types + 14 },
+  { "destroy", "", wlr_screencopy_unstable_v1_types + 0 },
+};
+
+static const struct wl_message zwlr_screencopy_frame_v1_events[] = {
+  { "buffer", "uuuu", wlr_screencopy_unstable_v1_types + 0 },
+  { "flags", "u", wlr_screencopy_unstable_v1_types + 0 },
+  { "ready", "uuu", wlr_screencopy_unstable_v1_types + 0 },
+  { "failed", "", wlr_screencopy_unstable_v1_types + 0 },
+};
+
+WL_PRIVATE const struct wl_interface zwlr_screencopy_frame_v1_interface = {
+  "zwlr_screencopy_frame_v1", 1,
+  2, zwlr_screencopy_frame_v1_requests,
+  4, zwlr_screencopy_frame_v1_events,
+};
+
+#ifndef __has_attribute
+# define __has_attribute(x) 0  /* Compatibility with non-clang compilers. */
+#endif
+
+#if (__has_attribute(visibility) || defined(__GNUC__) && __GNUC__ >= 4)
+#define WL_PRIVATE __attribute__ ((visibility("hidden")))
+#else
+#define WL_PRIVATE
+#endif
+
+extern const struct wl_interface wl_output_interface;
+extern const struct wl_interface zxdg_output_v1_interface;
+
+static const struct wl_interface *xdg_output_unstable_v1_types[] = {
+  NULL,
+  NULL,
+  &zxdg_output_v1_interface,
+  &wl_output_interface,
+};
+
+static const struct wl_message zxdg_output_manager_v1_requests[] = {
+  { "destroy", "", xdg_output_unstable_v1_types + 0 },
+  { "get_xdg_output", "no", xdg_output_unstable_v1_types + 2 },
+};
+
+WL_PRIVATE const struct wl_interface zxdg_output_manager_v1_interface = {
+  "zxdg_output_manager_v1", 3,
+  2, zxdg_output_manager_v1_requests,
+  0, NULL,
+};
+
+static const struct wl_message zxdg_output_v1_requests[] = {
+  { "destroy", "", xdg_output_unstable_v1_types + 0 },
+};
+
+static const struct wl_message zxdg_output_v1_events[] = {
+  { "logical_position", "ii", xdg_output_unstable_v1_types + 0 },
+  { "logical_size", "ii", xdg_output_unstable_v1_types + 0 },
+  { "done", "", xdg_output_unstable_v1_types + 0 },
+  { "name", "2s", xdg_output_unstable_v1_types + 0 },
+  { "description", "2s", xdg_output_unstable_v1_types + 0 },
+};
+
+WL_PRIVATE const struct wl_interface zxdg_output_v1_interface = {
+  "zxdg_output_v1", 3,
+  1, zxdg_output_v1_requests,
+  5, zxdg_output_v1_events,
+};
+
+//  ================================================================
+
+typedef struct {
+  struct wl_display *                display;
+  struct wl_registry *               registry;
+  struct wl_shm *                    shm;
+  struct zxdg_output_manager_v1 *    xdg_output_manager;
+  struct zwlr_screencopy_manager_v1 *screencopy_manager;
+  struct wl_list                     outputs;
+  u64                                n_done;
+} WL_State_;
+
+typedef struct {
+  struct wl_buffer *                 buffer;
+  void *                             data;
+  i32                                width;
+  i32                                height;
+  i32                                stride;
+  u64                                size;
+  enum wl_shm_format                 format;
+} WL_Buffer_;
+
+typedef struct {
+  i32 x, y;
+  i32 width, height;
+} WL_Box_;
+
+typedef struct {
+  WL_State_ *                      state;
+  struct wl_output *               output;
+  struct zxdg_output_v1 *          xdg_output;
+  struct wl_list                   link;
+  WL_Box_                          geometry;
+  enum wl_output_transform         transform;
+  i32                              scale;
+  WL_Box_                          local_geometry;
+  WL_Box_                          logical_geometry;
+  f64                              logical_scale;
+  c8 *                             name;
+  WL_Buffer_ *                     buffer;
+  struct zwlr_screencopy_frame_v1 *screencopy_frame;
+  u32                              screencopy_frame_flags;
+} WL_Output_;
+
+//  ================================================================
+
+b8 _Wayland_screenshot_status = 0;
+
+//  ================================================================
+
+static void get_output_layout_extents(WL_State_ *state, WL_Box_ *box) {
+  i32 x1 =  0x10000000, y1 =  0x10000000;
+  i32 x2 = -0x10000000, y2 = -0x10000000;
+
+  WL_Output_ *output;
+  wl_list_for_each(output, &state->outputs, link) {
+    if (output->logical_geometry.x < x1)
+      x1 = output->logical_geometry.x;
+    if (output->logical_geometry.y < y1)
+      y1 = output->logical_geometry.y;
+    if (output->logical_geometry.x + output->logical_geometry.width > x2)
+      x2 = output->logical_geometry.x + output->logical_geometry.width;
+    if (output->logical_geometry.y + output->logical_geometry.height > y2)
+      y2 = output->logical_geometry.y + output->logical_geometry.height;
+  }
+
+  box->x      = x1;
+  box->y      = y1;
+  box->width  = x2 - x1;
+  box->height = y2 - y1;
+}
+
+static void apply_output_transform(enum wl_output_transform transform, i32 *width, i32 *height) {
+  if ((transform & WL_OUTPUT_TRANSFORM_90) != 0) {
+    i32 tmp = *width;
+    *width  = *height;
+    *height = tmp;
+  }
+}
+
+static f64 get_output_rotation(enum wl_output_transform transform) {
+  switch (transform & ~WL_OUTPUT_TRANSFORM_FLIPPED) {
+    case WL_OUTPUT_TRANSFORM_90:  return M_PI / 2;
+    case WL_OUTPUT_TRANSFORM_180: return M_PI;
+    case WL_OUTPUT_TRANSFORM_270: return 3 * M_PI / 2;
+  }
+  return 0;
+}
+
+static i32 get_output_flipped(enum wl_output_transform transform) {
+  return (transform & WL_OUTPUT_TRANSFORM_FLIPPED) != 0 ? -1 : 1;
+}
+
+static void guess_output_logical_geometry(WL_Output_ *output) {
+  output->logical_geometry.x      = output->geometry.x;
+  output->logical_geometry.y      = output->geometry.y;
+  output->logical_geometry.width  = output->geometry.width / output->scale;
+  output->logical_geometry.height = output->geometry.height / output->scale;
+  apply_output_transform(
+    output->transform,
+    &output->logical_geometry.width,
+    &output->logical_geometry.height
+  );
+
+  output->logical_scale = output->scale;
+}
+
+static void randname(c8 *buf) {
+  struct timespec ts;
+  clock_gettime(CLOCK_REALTIME, &ts);
+  long r = ts.tv_nsec;
+  for (int i = 0; i < 6; ++i) {
+    buf[i] = 'A'+(r&15)+(r&16)*2;
+    r >>= 5;
+  }
+}
+
+static i32 anonymous_shm_open(void) {
+  c8  name[]  = "/SCR_XXXXXX";
+  i32 retries = 100;
+
+  do {
+    randname(name + sizeof name - 7);
+
+    --retries;
+
+    i32 fd = shm_open(name, O_RDWR | O_CREAT | O_EXCL, 0600);
+    if (fd >= 0) {
+      shm_unlink(name);
+      return fd;
+    }
+  } while (retries > 0 && errno == EEXIST);
+
+  LOG_ERROR("shm_open failed.\n");
+  return -1;
+}
+
+static i32 create_shm_file(off_t size) {
+  int fd = anonymous_shm_open();
+  if (fd < 0) {
+    return fd;
+  }
+
+  if (ftruncate(fd, size) < 0) {
+    close(fd);
+
+    LOG_ERROR("ftruncate failed.\n");
+    return -1;
+  }
+
+  return fd;
+}
+
+static WL_Buffer_ *create_buffer(struct wl_shm *shm, enum wl_shm_format format, i32 width, i32 height, i32 stride) {
+  u64 size = stride * height;
+
+  i32 fd = create_shm_file(size);
+  if (fd == -1) {
+    return NULL;
+  }
+
+  void *data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+  if (data == MAP_FAILED) {
+    close(fd);
+
+    LOG_ERROR("mmap failed.\n");
+    return NULL;
+  }
+
+  struct wl_shm_pool *pool      = wl_shm_create_pool(shm, fd, size);
+  struct wl_buffer *  wl_buffer = wl_shm_pool_create_buffer(pool, 0, width, height, stride, format);
+  wl_shm_pool_destroy(pool);
+
+  close(fd);
+
+  WL_Buffer_ *buffer = calloc(1, sizeof(WL_Buffer_));
+
+  if (buffer == NULL) {
+    LOG_ERROR("calloc failed.\n");
+    return NULL;
+  }
+
+  buffer->buffer = wl_buffer;
+  buffer->data   = data;
+  buffer->width  = width;
+  buffer->height = height;
+  buffer->stride = stride;
+  buffer->size   = size;
+  buffer->format = format;
+
+  return buffer;
+}
+
+static void destroy_buffer(WL_Buffer_ *buffer) {
+  if (buffer == NULL)
+    return;
+  munmap(buffer->data, buffer->size);
+  wl_buffer_destroy(buffer->buffer);
+  free(buffer);
+}
+
+static void screencopy_frame_handle_buffer(
+  void *                           data,
+  struct zwlr_screencopy_frame_v1 *frame,
+  u32                              format,
+  u32                              width,
+  u32                              height,
+  u32                              stride
+) {
+  WL_Output_ *output = data;
+
+  output->buffer = create_buffer(output->state->shm, format, width, height, stride);
+
+  if (output->buffer == NULL)
+    //  FAIL
+    return;
+
+  zwlr_screencopy_frame_v1_copy(frame, output->buffer->buffer);
+}
+
+static void screencopy_frame_handle_flags(
+  void *                           data,
+  struct zwlr_screencopy_frame_v1 *frame,
+  u32                              flags
+) {
+  WL_Output_ *output = data;
+  output->screencopy_frame_flags = flags;
+}
+
+static void screencopy_frame_handle_ready(
+  void *                           data,
+  struct zwlr_screencopy_frame_v1 *frame,
+  u32                              tv_sec_hi,
+  u32                              tv_sec_lo,
+  u32                              tv_nsec
+) {
+  WL_Output_ *output = data;
+  ++output->state->n_done;
+}
+
+static void screencopy_frame_handle_failed(
+  void *                           data,
+  struct zwlr_screencopy_frame_v1 *frame
+) {
+  WL_Output_ *output = data;
+  //  FAIL
+  LOG_ERROR("Screenshot copy failed.");
+}
+
+static struct zwlr_screencopy_frame_v1_listener screencopy_frame_listener = {
+  .buffer = screencopy_frame_handle_buffer,
+  .flags  = screencopy_frame_handle_flags,
+  .ready  = screencopy_frame_handle_ready,
+  .failed = screencopy_frame_handle_failed,
+};
+
+static void xdg_output_handle_logical_position(
+  void *                 data,
+  struct zxdg_output_v1 *xdg_output,
+  i32                    x,
+  i32                    y
+) {
+  WL_Output_ *output = data;
+
+  output->logical_geometry.x = x;
+  output->logical_geometry.y = y;
+}
+
+static void xdg_output_handle_logical_size(
+  void *                 data,
+  struct zxdg_output_v1 *xdg_output,
+  i32                    width,
+  i32                    height
+) {
+  WL_Output_ *output = data;
+
+  output->logical_geometry.width = width;
+  output->logical_geometry.height = height;
+}
+
+static void xdg_output_handle_done(
+  void *                 data,
+  struct zxdg_output_v1 *xdg_output
+) {
+  WL_Output_ *output = data;
+
+  i32 width  = output->geometry.width;
+  i32 height = output->geometry.height;
+  apply_output_transform(output->transform, &width, &height);
+  output->logical_scale = (f64) width / output->logical_geometry.width;
+}
+
+static void xdg_output_handle_name(
+  void *                 data,
+  struct zxdg_output_v1 *xdg_output,
+  c8 const *             name
+) {
+  WL_Output_ *output = data;
+  output->name = strdup(name);
+}
+
+static void xdg_output_handle_description(void *data, struct zxdg_output_v1 *xdg_output, c8 const *name) { }
+
+static void output_handle_geometry(
+  void *            data,
+  struct wl_output *wl_output,
+  i32               x,
+  i32               y,
+  i32               physical_width,
+  i32               physical_height,
+  i32               subpixel,
+  c8 const *      make,
+  c8 const *      model,
+  i32               transform
+) {
+  WL_Output_ *output = data;
+
+  output->geometry.x = x;
+  output->geometry.y = y;
+  output->transform = transform;
+}
+
+static void output_handle_mode(
+  void *            data,
+  struct wl_output *wl_output,
+  u32               flags,
+  i32               width,
+  i32               height,
+  i32               refresh
+) {
+  WL_Output_ *output = data;
+
+  if ((flags & WL_OUTPUT_MODE_CURRENT) != 0) {
+    output->geometry.width = width;
+    output->geometry.height = height;
+  }
+}
+
+static void output_handle_done(void *data, struct wl_output *wl_output) { }
+
+static void output_handle_scale(
+  void *            data,
+  struct wl_output *wl_output,
+  i32               factor
+) {
+  WL_Output_ *output = data;
+  output->scale = factor;
+}
+
+static void handle_global(
+  void *              data,
+  struct wl_registry *registry,
+  u32                 name,
+  c8 const *          interface,
+  u32                 version
+) {
+  WL_State_ *state = data;
+
+  if (strcmp(interface, wl_shm_interface.name) == 0)
+    state->shm = wl_registry_bind(registry, name, &wl_shm_interface, 1);
+  else if (strcmp(interface, zxdg_output_manager_v1_interface.name) == 0) {
+    u32 bind_version = (version > 2) ? 2 : version;
+    state->xdg_output_manager = wl_registry_bind(
+      registry,
+      name,
+      &zxdg_output_manager_v1_interface,
+      bind_version
+    );
+  } else if (strcmp(interface, wl_output_interface.name) == 0) {
+    WL_Output_ *output = calloc(1, sizeof(WL_Output_));
+    output->state  = state;
+    output->scale  = 1;
+    output->output =  wl_registry_bind(registry, name, &wl_output_interface, 3);
+    wl_output_add_listener(output->output, &(struct wl_output_listener) {
+      .geometry = output_handle_geometry,
+      .mode = output_handle_mode,
+      .done = output_handle_done,
+      .scale = output_handle_scale,
+    }, output);
+    wl_list_insert(&state->outputs, &output->link);
+  } else if (strcmp(interface, zwlr_screencopy_manager_v1_interface.name) == 0)
+    state->screencopy_manager = wl_registry_bind(
+      registry,
+      name,
+      &zwlr_screencopy_manager_v1_interface,
+      1
+    );
+}
+
+static void handle_global_remove(void *data, struct wl_registry *registry, u32 name) { }
+
+static struct wl_registry_listener _wayland_registry_listener = {
+  .global        = handle_global,
+  .global_remove = handle_global_remove,
+};
+
+static b8 is_empty_box(WL_Box_ *box) {
+  return box->width <= 0 || box->height <= 0;
+}
+
+static b8 intersect_box(WL_Box_ *a, WL_Box_ *b) {
+  if (is_empty_box(a) || is_empty_box(b)) {
+    return 0;
+  }
+
+  i32 x1 = fmax(a->x, b->x);
+  i32 y1 = fmax(a->y, b->y);
+  i32 x2 = fmin(a->x +  a->width, b->x + b->width);
+  i32 y2 = fmin(a->y + a->height, b->y + b->height);
+
+  WL_Box_ box = {
+    .x      = x1,
+    .y      = y1,
+    .width  = x2 - x1,
+    .height = y2 - y1,
+  };
+
+  return !is_empty_box(&box);
+}
+
+void wayland_screenshot_(i64 max_num_pixels, i64 *width, i64 *height, vec4_f32 *pixels) {
+  f32 scale                 = 1.0;
+  b8  use_greatest_scale    = 1;
+
+  WL_Box_ *geometry        = NULL;
+  c8 *     geometry_output = NULL;
+
+  WL_State_ state = {0};
+  wl_list_init(&state.outputs);
+
+  state.display = wl_display_connect(NULL);
+
+  if (state.display == NULL) {
+    LOG_ERROR("wl_display_connect failed.");
+    return;
+  }
+
+  state.registry = wl_display_get_registry(state.display);
+  wl_registry_add_listener(
+    state.registry,
+    &_wayland_registry_listener,
+    &state
+  );
+  wl_display_roundtrip(state.display);
+
+  if (state.shm == NULL) {
+    LOG_ERROR("Compositor does not support wl_shm.");
+    return;
+  }
+
+  if (wl_list_empty(&state.outputs)) {
+    LOG_ERROR("No wl_output.");
+    return;
+  }
+
+  if (state.xdg_output_manager != NULL) {
+    WL_Output_ *output;
+    wl_list_for_each(output, &state.outputs, link) {
+      output->xdg_output = zxdg_output_manager_v1_get_xdg_output(
+        state.xdg_output_manager,
+        output->output
+      );
+
+      zxdg_output_v1_add_listener(
+        output->xdg_output,
+        &(struct zxdg_output_v1_listener) {
+          .logical_position = xdg_output_handle_logical_position,
+          .logical_size     = xdg_output_handle_logical_size,
+          .done             = xdg_output_handle_done,
+          .name             = xdg_output_handle_name,
+          .description      = xdg_output_handle_description,
+        },
+        output
+      );
+    }
+
+    wl_display_roundtrip(state.display);
+  } else {
+    WL_Output_ *output;
+    wl_list_for_each(output, &state.outputs, link) {
+      guess_output_logical_geometry(output);
+    }
+  }
+
+  if (state.screencopy_manager == NULL) {
+    LOG_ERROR("Compositor does not support wlr-screencopy-unstable-v1.");
+    return;
+  }
+
+  if (geometry_output != NULL) {
+    WL_Output_ *output;
+    wl_list_for_each(output, &state.outputs, link) {
+      if (output->name != NULL && strcmp(output->name, geometry_output) == 0) {
+        geometry = calloc(1, sizeof(WL_Box_));
+        if (geometry == NULL) {
+          LOG_ERROR("calloc failed.\n");
+        } else
+          memcpy(geometry, &output->logical_geometry, sizeof(WL_Box_));
+      }
+    }
+
+    if (geometry == NULL) {
+      LOG_ERROR("Unknown output for: %s", geometry_output);
+      return;
+    }
+  }
+
+  u64 n_pending = 0;
+  WL_Output_ *output;
+  wl_list_for_each(output, &state.outputs, link) {
+    if (geometry != NULL && !intersect_box(geometry, &output->logical_geometry))
+      continue;
+    if (use_greatest_scale && output->logical_scale > scale)
+      scale = output->logical_scale;
+
+    output->screencopy_frame = zwlr_screencopy_manager_v1_capture_output(
+      state.screencopy_manager,
+      1,
+      output->output
+    );
+
+    zwlr_screencopy_frame_v1_add_listener(
+      output->screencopy_frame,
+      &screencopy_frame_listener,
+      output
+    );
+
+    ++n_pending;
+  }
+
+  if (n_pending == 0) {
+    LOG_ERROR("Supplied geometry did not intersect with any outputs.");
+    return;
+  }
+
+  b8 done = 0;
+  while (!done && wl_display_dispatch(state.display) != -1) {
+    done = (state.n_done == n_pending);
+  }
+  if (!done) {
+    LOG_ERROR("Failed to screenshoot all outputs.");
+    return;
+  }
+
+  if (geometry == NULL) {
+    geometry = calloc(1, sizeof(WL_Box_));
+    get_output_layout_extents(&state, geometry);
+  }
+
+  //
+  //  TODO:
+  //  SAVE
+  //
+  (void) get_output_flipped;
+  (void) get_output_rotation;
+
+  WL_Output_ *output_tmp;
+  wl_list_for_each_safe(output, output_tmp, &state.outputs, link) {
+    wl_list_remove(&output->link);
+    free(output->name);
+    if (output->screencopy_frame != NULL)
+      zwlr_screencopy_frame_v1_destroy(output->screencopy_frame);
+    destroy_buffer(output->buffer);
+    if (output->xdg_output != NULL)
+      zxdg_output_v1_destroy(output->xdg_output);
+    wl_output_release(output->output);
+    free(output);
+  }
+  zwlr_screencopy_manager_v1_destroy(state.screencopy_manager);
+  if (state.xdg_output_manager != NULL)
+    zxdg_output_manager_v1_destroy(state.xdg_output_manager);
+
+  wl_shm_destroy(state.shm);
+  wl_registry_destroy(state.registry);
+  wl_display_disconnect(state.display);
+
+  free(geometry);
+  free(geometry_output);
+}
+
+#endif // defined(__linux__) && !defined(NO_WAYLAND)
+
+//  ================================================================
+//
 //  X11
 //
 //  ================================================================
 
-#if defined(__linux__)
+#if defined(__linux__) && !defined(NO_X11)
 
 #include <sys/stat.h>
 #include <X11/Xlib.h>
@@ -1453,6 +2441,7 @@ void p_queue_sound(i64 delay_in_samples, i64 num_samples, f32 *frames) {
 static i64      _frame_time       = 0;
 static XImage   _image            = {0};
 static Display *_display          = NULL;
+static Window   _root_window      = 0;
 static GC       _gc               = NULL;
 static XIM      _im               = NULL;
 static XIC      _ic               = NULL;
@@ -1474,11 +2463,13 @@ static Atom     _dnd_action_copy  = 0;
 static Atom     _dnd_selection    = 0;
 static Atom     _text_uri_list    = 0;
 static Window   _dnd_source       = 0;
+static b8       _ignore_errors    = 0;
 
 static i16 _key_table        [MAX_NUM_KEYS]       = {0};
 static b8  _key_repeat       [MAX_NUM_KEYS]       = {0};
 static u32 _pixels_scaled    [MAX_NUM_PIXELS]     = {0};
 static u32 _pixels_internal  [MAX_NUM_PIXELS]     = {0};
+static c8  _error_buffer     [4096]               = {0};
 
 static b8 sub_str_eq_(c8 *a, c8 *b, i64 len) {
   for (i64 i = 0; i < len; ++i)
@@ -1487,10 +2478,21 @@ static b8 sub_str_eq_(c8 *a, c8 *b, i64 len) {
   return 1;
 }
 
+i32 x11_error_handler_(Display *display, XErrorEvent *event) {
+  if (!_ignore_errors) {
+    XGetErrorText(display, event->error_code, _error_buffer, sizeof _error_buffer - 1);
+    LOG_ERROR("X11: %s", _error_buffer);
+  }
+
+  return 0;
+}
+
 void p_init(void) {
   for (i64 i = 0; i < NUM_FRAMES_AVERAGED; ++i)
     _frame_duration[i] = (MIN_FRAME_DURATION + MAX_FRAME_DURATION) / 2;
 
+  XSetErrorHandler(x11_error_handler_);
+
   _display = XOpenDisplay(NULL);
 
   if (_display == NULL) {
@@ -1498,6 +2500,8 @@ void p_init(void) {
     return;
   }
 
+  _root_window = XDefaultRootWindow(_display);
+
   _key_table[XKeysymToKeycode(_display, XK_Left)]         = KEY_LEFT;
   _key_table[XKeysymToKeycode(_display, XK_Right)]        = KEY_RIGHT;
   _key_table[XKeysymToKeycode(_display, XK_Up)]           = KEY_UP;
@@ -1635,7 +2639,7 @@ void p_init(void) {
   i32 x = (display_width  - g_platform.frame_width)  / 2;
   i32 y = (display_height - g_platform.frame_height) / 2;
 
-  _window = XCreateWindow(_display, XDefaultRootWindow(_display), x, y, g_platform.frame_width, g_platform.frame_height, 0, depth, InputOutput, visual, CWEventMask, &(XSetWindowAttributes) { .event_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask | VisibilityChangeMask | FocusChangeMask | StructureNotifyMask | SubstructureNotifyMask, });
+  _window = XCreateWindow(_display, _root_window, x, y, g_platform.frame_width, g_platform.frame_height, 0, depth, InputOutput, visual, CWEventMask, &(XSetWindowAttributes) { .event_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask | VisibilityChangeMask | FocusChangeMask | StructureNotifyMask | SubstructureNotifyMask, });
 
   _im = XOpenIM(_display, NULL, NULL, NULL);
 
@@ -1713,7 +2717,6 @@ void p_cleanup(void) {
     XCloseDisplay (_display);
 
   _display = NULL;
-  _window  = 0;
 
   sockets_cleanup();
   sound_cleanup();
@@ -2229,7 +3232,65 @@ void p_clipboard_write(i64 size, c8 *data) {
     memcpy(g_platform.clipboard, data, g_platform.clipboard_size);
 }
 
-#endif // defined(__linux__)
+void x11_screenshot_(i64 max_num_pixels, i64 *width, i64 *height, vec4_f32 *pixels) {
+  if (width == NULL || height == NULL) {
+    LOG_ERROR("Invalid arguments.");
+    return;
+  }
+
+  *width  = 0;
+  *height = 0;
+
+  if (_display == NULL) {
+    LOG_ERROR("No display.");
+    return;
+  }
+
+  i32 screen         = DefaultScreen(_display);
+  i32 display_width  = DisplayWidth (_display, screen);
+  i32 display_height = DisplayHeight(_display, screen);
+
+  _ignore_errors = 1;
+
+  XImage *image = XGetImage(_display, _root_window, 0, 0, display_width, display_height, AllPlanes, ZPixmap);
+
+  _ignore_errors = 0;
+
+  if (image == NULL) {
+    #if !defined(NO_WAYLAND)
+    //  Fallback for Wayland.
+    wayland_screenshot_(max_num_pixels, width, height, pixels);
+    return;
+    #else
+    LOG_ERROR("XGetImage failed.");
+    return;
+    #endif
+  }
+
+  *width  = image->width;
+  *height = image->height;
+
+  if (pixels == NULL || image->width * image->height > max_num_pixels)
+    return;
+
+  for (i64 j = 0; j < image->height; ++j)
+    for (i64 i = 0; i < image->width; ++i) {
+      vec3_f32 f = rgb_f32_from_u32_(XGetPixel(image, i, j));
+
+      pixels[j * image->width + i] = (vec4_f32) {
+        .x = f.x,
+        .y = f.y,
+        .z = f.z,
+        .w = 1.f,
+      };
+    }
+}
+
+void p_screenshot(i64 max_num_pixels, i64 *width, i64 *height, vec4_f32 *pixels) {
+  x11_screenshot_(max_num_pixels, width, height, pixels);
+}
+
+#endif // defined(__linux__) && !defined(NO_X11)
 
 //  ================================================================
 //
@@ -2500,6 +3561,16 @@ void p_clipboard_write(i64 size, c8 *data) {
   p_clipboard_write_impl((i32) size, data);
 }
 
+void p_screenshot(i64 max_num_pixels, i64 *width, i64 *height, vec4_f32 *pixels) {
+  if (width == NULL || height == NULL) {
+    LOG_ERROR("Invalid arguments.");
+    return;
+  }
+
+  *width  = 0;
+  *height = 0;
+}
+
 void p_handle_sound(void) {
   g_platform.num_sound_samples_elapsed = sound_samples_elapsed_();
   _sound_position = (_sound_position + g_platform.num_sound_samples_elapsed * NUM_SOUND_CHANNELS) % MAX_NUM_SOUND_FRAMES;