sucklessConfigs

graphics.c (128226B)

---

 /* The MIT License
 
    Copyright (c) 2021-2024 Sergei Grechanik <sergei.grechanik@gmail.com>
 
    Permission is hereby granted, free of charge, to any person obtaining
    a copy of this software and associated documentation files (the
    "Software"), to deal in the Software without restriction, including
    without limitation the rights to use, copy, modify, merge, publish,
    distribute, sublicense, and/or sell copies of the Software, and to
    permit persons to whom the Software is furnished to do so, subject to
    the following conditions:
 
    The above copyright notice and this permission notice shall be
    included in all copies or substantial portions of the Software.
 
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
    BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
    ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
    CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
    SOFTWARE.
 */
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // This file implements a subset of the kitty graphics protocol.
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 #define _POSIX_C_SOURCE 200809L
 
 #include <zlib.h>
 #include <Imlib2.h>
 #include <X11/Xlib.h>
 #include <X11/extensions/Xrender.h>
 #include <assert.h>
 #include <ctype.h>
 #include <spawn.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <time.h>
 #include <unistd.h>
 #include <errno.h>
 
 #include "graphics.h"
 #include "khash.h"
 #include "kvec.h"
 
 extern char **environ;
 
 #define MAX_FILENAME_SIZE 256
 #define MAX_INFO_LEN 256
 #define MAX_IMAGE_RECTS 20
 
 /// The type used in this file to represent time. Used both for time differences
 /// and absolute times (as milliseconds since an arbitrary point in time, see
 /// `initialization_time`).
 typedef int64_t Milliseconds;
 
 enum ScaleMode {
 	SCALE_MODE_UNSET = 0,
 	/// Stretch or shrink the image to fill the box, ignoring aspect ratio.
 	SCALE_MODE_FILL = 1,
 	/// Preserve aspect ratio and fit to width or to height so that the
 	/// whole image is visible.
 	SCALE_MODE_CONTAIN = 2,
 	/// Do not scale. The image may be cropped if the box is too small.
 	SCALE_MODE_NONE = 3,
 	/// Do not scale, unless the box is too small, in which case the image
 	/// will be shrunk like with `SCALE_MODE_CONTAIN`.
 	SCALE_MODE_NONE_OR_CONTAIN = 4,
 };
 
 enum AnimationState {
 	ANIMATION_STATE_UNSET = 0,
 	/// The animation is stopped. Display the current frame, but don't
 	/// advance to the next one.
 	ANIMATION_STATE_STOPPED = 1,
 	/// Run the animation to then end, then wait for the next frame.
 	ANIMATION_STATE_LOADING = 2,
 	/// Run the animation in a loop.
 	ANIMATION_STATE_LOOPING = 3,
 };
 
 /// The status of an image. Each image uploaded to the terminal is cached on
 /// disk, then it is loaded to ram when needed.
 enum ImageStatus {
 	STATUS_UNINITIALIZED = 0,
 	STATUS_UPLOADING = 1,
 	STATUS_UPLOADING_ERROR = 2,
 	STATUS_UPLOADING_SUCCESS = 3,
 	STATUS_RAM_LOADING_ERROR = 4,
 	STATUS_RAM_LOADING_IN_PROGRESS = 5,
 	STATUS_RAM_LOADING_SUCCESS = 6,
 };
 
 const char *image_status_strings[6] = {
 	"STATUS_UNINITIALIZED",
 	"STATUS_UPLOADING",
 	"STATUS_UPLOADING_ERROR",
 	"STATUS_UPLOADING_SUCCESS",
 	"STATUS_RAM_LOADING_ERROR",
 	"STATUS_RAM_LOADING_SUCCESS",
 };
 
 enum ImageUploadingFailure {
 	ERROR_OVER_SIZE_LIMIT = 1,
 	ERROR_CANNOT_OPEN_CACHED_FILE = 2,
 	ERROR_UNEXPECTED_SIZE = 3,
 	ERROR_CANNOT_COPY_FILE = 4,
 };
 
 const char *image_uploading_failure_strings[5] = {
 	"NO_ERROR",
 	"ERROR_OVER_SIZE_LIMIT",
 	"ERROR_CANNOT_OPEN_CACHED_FILE",
 	"ERROR_UNEXPECTED_SIZE",
 	"ERROR_CANNOT_COPY_FILE",
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // We use the following structures to represent images and placements:
 //
 //   - Image: this is the main structure representing an image, usually created
 //     by actions 'a=t', 'a=T`. Each image has an id (image id aka client id,
 //     specified by 'i='). An image may have multiple frames (ImageFrame) and
 //     placements (ImagePlacement).
 //
 //   - ImageFrame: represents a single frame of an image, usually created by
 //     the action 'a=f' (and the first frame is created with the image itself).
 //     Each frame has an index and also:
 //     - a file containing the frame data (considered to be "on disk", although
 //       it's probably in tmpfs),
 //     - an imlib object containing the fully composed frame (i.e. the frame
 //       data from the file composed onto the background frame or color). It is
 //       not ready for display yet, because it needs to be scaled and uploaded
 //       to the X server.
 //
 //   - ImagePlacement: represents a placement of an image, created by 'a=p' and
 //     'a=T'. Each placement has an id (placement id, specified by 'p='). Also
 //     each placement has an array of pixmaps: one for each frame of the image.
 //     Each pixmap is a scaled and uploaded image ready to be displayed.
 //
 // Images are store in the `images` hash table, mapping image ids to Image
 // objects (allocated on the heap).
 //
 // Placements are stored in the `placements` hash table of each Image object,
 // mapping placement ids to ImagePlacement objects (also allocated on the heap).
 //
 // ImageFrames are stored in the `first_frame` field and in the
 // `frames_beyond_the_first` array of each Image object. They are stored by
 // value, so ImageFrame pointer may be invalidated when frames are
 // added/deleted, be careful.
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 struct Image;
 struct ImageFrame;
 struct ImagePlacement;
 
 KHASH_MAP_INIT_INT(id2image, struct Image *)
 KHASH_MAP_INIT_INT(id2placement, struct ImagePlacement *)
 
 typedef struct ImageFrame {
 	/// The image this frame belongs to.
 	struct Image *image;
 	/// The 1-based index of the frame. Zero if the frame isn't initialized.
 	int index;
 	/// The last time when the frame was displayed or otherwise touched.
 	Milliseconds atime;
 	/// The background color of the frame in the 0xRRGGBBAA format.
 	uint32_t background_color;
 	/// The index of the background frame. Zero to use the color instead.
 	int background_frame_index;
 	/// The duration of the frame in milliseconds.
 	int gap;
 	/// The expected size of the frame image file (specified with 'S='),
 	/// used to check if uploading succeeded.
 	unsigned expected_size;
 	/// Format specification (see the `f=` key).
 	int format;
 	/// Pixel width and height of the non-composed (on-disk) frame data. May
 	/// differ from the image (i.e. first frame) dimensions.
 	int data_pix_width, data_pix_height;
 	/// The offset of the frame relative to the first frame.
 	int x, y;
 	/// Compression mode (see the `o=` key).
 	char compression;
 	/// The status (see `ImageStatus`).
 	char status;
 	/// The reason of uploading failure (see `ImageUploadingFailure`).
 	char uploading_failure;
 	/// Whether failures and successes should be reported ('q=').
 	char quiet;
 	/// Whether to blend the frame with the background or replace it.
 	char blend;
 	/// The file corresponding to the on-disk cache, used when uploading.
 	FILE *open_file;
 	/// The size of the corresponding file cached on disk.
 	unsigned disk_size;
 	/// The imlib object containing the fully composed frame. It's not
 	/// scaled for screen display yet.
 	Imlib_Image imlib_object;
 } ImageFrame;
 
 typedef struct Image {
 	/// The client id (the one specified with 'i='). Must be nonzero.
 	uint32_t image_id;
 	/// The client id specified in the query command (`a=q`). This one must
 	/// be used to create the response if it's non-zero.
 	uint32_t query_id;
 	/// The number specified in the transmission command (`I=`). If
 	/// non-zero, it may be used to identify the image instead of the
 	/// image_id, and it also should be mentioned in responses.
 	uint32_t image_number;
 	/// The last time when the image was displayed or otherwise touched.
 	Milliseconds atime;
 	/// The total duration of the animation in milliseconds.
 	int total_duration;
 	/// The total size of cached image files for all frames.
 	int total_disk_size;
 	/// The global index of the creation command. Used to decide which image
 	/// is newer if they have the same image number.
 	uint64_t global_command_index;
 	/// The 1-based index of the currently displayed frame.
 	int current_frame;
 	/// The state of the animation, see `AnimationState`.
 	char animation_state;
 	/// The absolute time that is assumed to be the start of the current
 	/// frame (in ms since initialization).
 	Milliseconds current_frame_time;
 	/// The absolute time of the last redraw (in ms since initialization).
 	/// Used to check whether it's the first time we draw the image in the
 	/// current redraw cycle.
 	Milliseconds last_redraw;
 	/// The absolute time of the next redraw (in ms since initialization).
 	/// 0 means no redraw is scheduled.
 	Milliseconds next_redraw;
 	/// The unscaled pixel width and height of the image. Usually inherited
 	/// from the first frame.
 	int pix_width, pix_height;
 	/// The first frame.
 	ImageFrame first_frame;
 	/// The array of frames beyond the first one.
 	kvec_t(ImageFrame) frames_beyond_the_first;
 	/// Image placements.
 	khash_t(id2placement) *placements;
 	/// The default placement.
 	uint32_t default_placement;
 	/// The initial placement id, specified with the transmission command,
 	/// used to report success or failure.
 	uint32_t initial_placement_id;
 } Image;
 
 typedef struct ImagePlacement {
 	/// The image this placement belongs to.
 	Image *image;
 	/// The id of the placement. Must be nonzero.
 	uint32_t placement_id;
 	/// The last time when the placement was displayed or otherwise touched.
 	Milliseconds atime;
 	/// The 1-based index of the protected pixmap. We protect a pixmap in
 	/// gr_load_pixmap to avoid unloading it right after it was loaded.
 	int protected_frame;
 	/// Whether the placement is used only for Unicode placeholders.
 	char virtual;
 	/// The scaling mode (see `ScaleMode`).
 	char scale_mode;
 	/// Height and width in cells.
 	uint16_t rows, cols;
 	/// Top-left corner of the source rectangle ('x=' and 'y=').
 	int src_pix_x, src_pix_y;
 	/// Height and width of the source rectangle (zero if full image).
 	int src_pix_width, src_pix_height;
 	/// The image appropriately scaled and uploaded to the X server. This
 	/// pixmap is premultiplied by alpha.
 	Pixmap first_pixmap;
 	/// The array of pixmaps beyond the first one.
 	kvec_t(Pixmap) pixmaps_beyond_the_first;
 	/// The dimensions of the cell used to scale the image. If cell
 	/// dimensions are changed (font change), the image will be rescaled.
 	uint16_t scaled_cw, scaled_ch;
 	/// If true, do not move the cursor when displaying this placement
 	/// (non-virtual placements only).
 	char do_not_move_cursor;
 } ImagePlacement;
 
 /// A rectangular piece of an image to be drawn.
 typedef struct {
 	uint32_t image_id;
 	uint32_t placement_id;
 	/// The position of the rectangle in pixels.
 	int screen_x_pix, screen_y_pix;
 	/// The starting row on the screen.
 	int screen_y_row;
 	/// The part of the whole image to be drawn, in cells. Starts are
 	/// zero-based, ends are exclusive.
 	int img_start_col, img_end_col, img_start_row, img_end_row;
 	/// The current cell width and height in pixels.
 	int cw, ch;
 	/// Whether colors should be inverted.
 	int reverse;
 } ImageRect;
 
 /// Executes `code` for each frame of an image. Example:
 ///
 ///     foreach_frame(image, frame, {
 ///         printf("Frame %d\n", frame->index);
 ///     });
 ///
 #define foreach_frame(image, framevar, code) { size_t __i; \
 	for (__i = 0; __i <= kv_size((image).frames_beyond_the_first); ++__i) { \
 		ImageFrame *framevar = \
 			__i == 0 ? &(image).first_frame \
 			: &kv_A((image).frames_beyond_the_first, __i - 1); \
 		code; \
 	} }
 
 /// Executes `code` for each pixmap of a placement. Example:
 ///
 ///     foreach_pixmap(placement, pixmap, {
 ///         ...
 ///     });
 ///
 #define foreach_pixmap(placement, pixmapvar, code) { size_t __i; \
 	for (__i = 0; __i <= kv_size((placement).pixmaps_beyond_the_first); ++__i) { \
 		Pixmap pixmapvar = \
 			__i == 0 ? (placement).first_pixmap \
 			: kv_A((placement).pixmaps_beyond_the_first, __i - 1); \
 		code; \
 	} }
 
 
 static Image *gr_find_image(uint32_t image_id);
 static void gr_get_frame_filename(ImageFrame *frame, char *out, size_t max_len);
 static void gr_delete_image(Image *img);
 static void gr_check_limits();
 static char *gr_base64dec(const char *src, size_t *size);
 static void sanitize_str(char *str, size_t max_len);
 static const char *sanitized_filename(const char *str);
 
 /// The array of image rectangles to draw. It is reset each frame.
 static ImageRect image_rects[MAX_IMAGE_RECTS] = {{0}};
 /// The known images (including the ones being uploaded).
 static khash_t(id2image) *images = NULL;
 /// The total number of placements in all images.
 static unsigned total_placement_count = 0;
 /// The total size of all image files stored in the on-disk cache.
 static int64_t images_disk_size = 0;
 /// The total size of all images and placements loaded into ram.
 static int64_t images_ram_size = 0;
 /// The id of the last loaded image.
 static uint32_t last_image_id = 0;
 /// Current cell width and heigh in pixels.
 static int current_cw = 0, current_ch = 0;
 /// The id of the currently uploaded image (when using direct uploading).
 static uint32_t current_upload_image_id = 0;
 /// The index of the frame currently being uploaded.
 static int current_upload_frame_index = 0;
 /// The time when the graphics module was initialized.
 static struct timespec initialization_time = {0};
 /// The time when the current frame drawing started, used for debugging fps and
 /// to calculate the current frame for animations.
 static Milliseconds drawing_start_time;
 /// The global index of the current command.
 static uint64_t global_command_counter = 0;
 /// The next redraw times for each row of the terminal. Used for animations.
 /// 0 means no redraw is scheduled.
 static kvec_t(Milliseconds) next_redraw_times = {0, 0, NULL};
 /// The number of files loaded in the current redraw cycle.
 static int this_redraw_cycle_loaded_files = 0;
 /// The number of pixmaps loaded in the current redraw cycle.
 static int this_redraw_cycle_loaded_pixmaps = 0;
 
 /// The directory where the cache files are stored.
 static char cache_dir[MAX_FILENAME_SIZE - 16];
 
 /// The table used for color inversion.
 static unsigned char reverse_table[256];
 
 // Declared in the header.
 GraphicsDebugMode graphics_debug_mode = GRAPHICS_DEBUG_NONE;
 char graphics_display_images = 1;
 GraphicsCommandResult graphics_command_result = {0};
 int graphics_next_redraw_delay = INT_MAX;
 
 // Defined in config.h
 extern const char graphics_cache_dir_template[];
 extern unsigned graphics_max_single_image_file_size;
 extern unsigned graphics_total_file_cache_size;
 extern unsigned graphics_max_single_image_ram_size;
 extern unsigned graphics_max_total_ram_size;
 extern unsigned graphics_max_total_placements;
 extern double graphics_excess_tolerance_ratio;
 extern unsigned graphics_animation_min_delay;
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // Basic helpers.
 ////////////////////////////////////////////////////////////////////////////////
 
 #define MIN(a, b)		((a) < (b) ? (a) : (b))
 #define MAX(a, b)		((a) < (b) ? (b) : (a))
 
 /// Returns the difference between `end` and `start` in milliseconds.
 static int64_t gr_timediff_ms(const struct timespec *end,
 			      const struct timespec *start) {
 	return (end->tv_sec - start->tv_sec) * 1000 +
 	       (end->tv_nsec - start->tv_nsec) / 1000000;
 }
 
 /// Returns the current time in milliseconds since the initialization.
 static Milliseconds gr_now_ms() {
 	struct timespec now;
 	clock_gettime(CLOCK_MONOTONIC, &now);
 	return gr_timediff_ms(&now, &initialization_time);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Logging.
 ////////////////////////////////////////////////////////////////////////////////
 
 #define GR_LOG(...) \
 	do { if(graphics_debug_mode) fprintf(stderr, __VA_ARGS__); } while(0)
 
 ////////////////////////////////////////////////////////////////////////////////
 // Basic image management functions (create, delete, find, etc).
 ////////////////////////////////////////////////////////////////////////////////
 
 /// Returns the 1-based index of the last frame. Note that you may want to use
 /// `gr_last_uploaded_frame_index` instead since the last frame may be not
 /// fully uploaded yet.
 static inline int gr_last_frame_index(Image *img) {
 	return kv_size(img->frames_beyond_the_first) + 1;
 }
 
 /// Returns the frame with the given index. Returns NULL if the index is out of
 /// bounds. The index is 1-based.
 static ImageFrame *gr_get_frame(Image *img, int index) {
 	if (!img)
 		return NULL;
 	if (index == 1)
 		return &img->first_frame;
 	if (2 <= index && index <= gr_last_frame_index(img))
 		return &kv_A(img->frames_beyond_the_first, index - 2);
 	return NULL;
 }
 
 /// Returns the last frame of the image. Returns NULL if `img` is NULL.
 static ImageFrame *gr_get_last_frame(Image *img) {
 	if (!img)
 		return NULL;
 	return gr_get_frame(img, gr_last_frame_index(img));
 }
 
 /// Returns the 1-based index of the last frame or the second-to-last frame if
 /// the last frame is not fully uploaded yet.
 static inline int gr_last_uploaded_frame_index(Image *img) {
 	int last_index = gr_last_frame_index(img);
 	if (last_index > 1 &&
 	    gr_get_frame(img, last_index)->status < STATUS_UPLOADING_SUCCESS)
 		return last_index - 1;
 	return last_index;
 }
 
 /// Returns the pixmap for the frame with the given index. Returns 0 if the
 /// index is out of bounds. The index is 1-based.
 static Pixmap gr_get_frame_pixmap(ImagePlacement *placement, int index) {
 	if (index == 1)
 		return placement->first_pixmap;
 	if (2 <= index &&
 	    index <= kv_size(placement->pixmaps_beyond_the_first) + 1)
 		return kv_A(placement->pixmaps_beyond_the_first, index - 2);
 	return 0;
 }
 
 /// Sets the pixmap for the frame with the given index. The index is 1-based.
 /// The array of pixmaps is resized if needed.
 static void gr_set_frame_pixmap(ImagePlacement *placement, int index,
 				Pixmap pixmap) {
 	if (index == 1) {
 		placement->first_pixmap = pixmap;
 		return;
 	}
 	// Resize the array if needed.
 	size_t old_size = kv_size(placement->pixmaps_beyond_the_first);
 	if (old_size < index - 1) {
 		kv_a(Pixmap, placement->pixmaps_beyond_the_first, index - 2);
 		for (size_t i = old_size; i < index - 1; i++)
 			kv_A(placement->pixmaps_beyond_the_first, i) = 0;
 	}
 	kv_A(placement->pixmaps_beyond_the_first, index - 2) = pixmap;
 }
 
 /// Finds the image corresponding to the client id. Returns NULL if cannot find.
 static Image *gr_find_image(uint32_t image_id) {
 	khiter_t k = kh_get(id2image, images, image_id);
 	if (k == kh_end(images))
 		return NULL;
 	Image *res = kh_value(images, k);
 	return res;
 }
 
 /// Finds the newest image corresponding to the image number. Returns NULL if
 /// cannot find.
 static Image *gr_find_image_by_number(uint32_t image_number) {
 	if (image_number == 0)
 		return NULL;
 	Image *newest_img = NULL;
 	Image *img = NULL;
 	kh_foreach_value(images, img, {
 		if (img->image_number == image_number &&
 		    (!newest_img || newest_img->global_command_index <
 					    img->global_command_index))
 			newest_img = img;
 	});
 	if (!newest_img)
 		GR_LOG("Image number %u not found\n", image_number);
 	else
 		GR_LOG("Found image number %u, its id is %u\n", image_number,
 		       img->image_id);
 	return newest_img;
 }
 
 /// Finds the placement corresponding to the id. If the placement id is 0,
 /// returns some default placement.
 static ImagePlacement *gr_find_placement(Image *img, uint32_t placement_id) {
 	if (!img)
 		return NULL;
 	if (placement_id == 0) {
 		// Try to get the default placement.
 		ImagePlacement *dflt = NULL;
 		if (img->default_placement != 0)
 			dflt = gr_find_placement(img, img->default_placement);
 		if (dflt)
 			return dflt;
 		// If there is no default placement, return the first one and
 		// set it as the default.
 		kh_foreach_value(img->placements, dflt, {
 			img->default_placement = dflt->placement_id;
 			return dflt;
 		});
 		// If there are no placements, return NULL.
 		return NULL;
 	}
 	khiter_t k = kh_get(id2placement, img->placements, placement_id);
 	if (k == kh_end(img->placements))
 		return NULL;
 	ImagePlacement *res = kh_value(img->placements, k);
 	return res;
 }
 
 /// Finds the placement by image id and placement id.
 static ImagePlacement *gr_find_image_and_placement(uint32_t image_id,
 						   uint32_t placement_id) {
 	return gr_find_placement(gr_find_image(image_id), placement_id);
 }
 
 /// Writes the name of the on-disk cache file to `out`. `max_len` should be the
 /// size of `out`. The name will be something like
 /// "/tmp/st-images-xxx/img-ID-FRAME".
 static void gr_get_frame_filename(ImageFrame *frame, char *out,
 				  size_t max_len) {
 	snprintf(out, max_len, "%s/img-%.3u-%.3u", cache_dir,
 		 frame->image->image_id, frame->index);
 }
 
 /// Returns the (estimation) of the RAM size used by the frame right now.
 static unsigned gr_frame_current_ram_size(ImageFrame *frame) {
 	if (!frame->imlib_object)
 		return 0;
 	return (unsigned)frame->image->pix_width * frame->image->pix_height * 4;
 }
 
 /// Returns the (estimation) of the RAM size used by a single frame pixmap.
 static unsigned gr_placement_single_frame_ram_size(ImagePlacement *placement) {
 	return (unsigned)placement->rows * placement->cols *
 	       placement->scaled_ch * placement->scaled_cw * 4;
 }
 
 /// Returns the (estimation) of the RAM size used by the placemenet right now.
 static unsigned gr_placement_current_ram_size(ImagePlacement *placement) {
 	unsigned single_frame_size =
 		gr_placement_single_frame_ram_size(placement);
 	unsigned result = 0;
 	foreach_pixmap(*placement, pixmap, {
 		if (pixmap)
 			result += single_frame_size;
 	});
 	return result;
 }
 
 /// Unload the frame from RAM (i.e. delete the corresponding imlib object).
 /// If the on-disk file of the frame is preserved, it can be reloaded later.
 static void gr_unload_frame(ImageFrame *frame) {
 	if (!frame->imlib_object)
 		return;
 
 	unsigned frame_ram_size = gr_frame_current_ram_size(frame);
 	images_ram_size -= frame_ram_size;
 
 	imlib_context_set_image(frame->imlib_object);
 	imlib_free_image_and_decache();
 	frame->imlib_object = NULL;
 
 	GR_LOG("After unloading image %u frame %u (atime %ld ms ago) "
 	       "ram: %ld KiB  (- %u KiB)\n",
 	       frame->image->image_id, frame->index,
 	       drawing_start_time - frame->atime, images_ram_size / 1024,
 	       frame_ram_size / 1024);
 }
 
 /// Unload all frames of the image.
 static void gr_unload_all_frames(Image *img) {
 	foreach_frame(*img, frame, {
 		gr_unload_frame(frame);
 	});
 }
 
 /// Unload the placement from RAM (i.e. free all of the corresponding pixmaps).
 /// If the on-disk files or imlib objects of the corresponding image are
 /// preserved, the placement can be reloaded later.
 static void gr_unload_placement(ImagePlacement *placement) {
 	unsigned placement_ram_size = gr_placement_current_ram_size(placement);
 	images_ram_size -= placement_ram_size;
 
 	Display *disp = imlib_context_get_display();
 	foreach_pixmap(*placement, pixmap, {
 		if (pixmap)
 			XFreePixmap(disp, pixmap);
 	});
 
 	placement->first_pixmap = 0;
 	placement->pixmaps_beyond_the_first.n = 0;
 	placement->scaled_ch = placement->scaled_cw = 0;
 
 	GR_LOG("After unloading placement %u/%u (atime %ld ms ago) "
 	       "ram: %ld KiB  (- %u KiB)\n",
 	       placement->image->image_id, placement->placement_id,
 	       drawing_start_time - placement->atime, images_ram_size / 1024,
 	       placement_ram_size / 1024);
 }
 
 /// Unload a single pixmap of the placement from RAM.
 static void gr_unload_pixmap(ImagePlacement *placement, int frameidx) {
 	Pixmap pixmap = gr_get_frame_pixmap(placement, frameidx);
 	if (!pixmap)
 		return;
 
 	Display *disp = imlib_context_get_display();
 	XFreePixmap(disp, pixmap);
 	gr_set_frame_pixmap(placement, frameidx, 0);
 	images_ram_size -= gr_placement_single_frame_ram_size(placement);
 
 	GR_LOG("After unloading pixmap %ld of "
 	       "placement %u/%u (atime %ld ms ago) "
 	       "frame %u (atime %ld ms ago) "
 	       "ram: %ld KiB  (- %u KiB)\n",
 	       pixmap, placement->image->image_id, placement->placement_id,
 	       drawing_start_time - placement->atime, frameidx,
 	       drawing_start_time -
 		       gr_get_frame(placement->image, frameidx)->atime,
 	       images_ram_size / 1024,
 	       gr_placement_single_frame_ram_size(placement) / 1024);
 }
 
 /// Deletes the on-disk cache file corresponding to the frame. The in-ram image
 /// object (if it exists) is not deleted, placements are not unloaded either.
 static void gr_delete_imagefile(ImageFrame *frame) {
 	// It may still be being loaded. Close the file in this case.
 	if (frame->open_file) {
 		fclose(frame->open_file);
 		frame->open_file = NULL;
 	}
 
 	if (frame->disk_size == 0)
 		return;
 
 	char filename[MAX_FILENAME_SIZE];
 	gr_get_frame_filename(frame, filename, MAX_FILENAME_SIZE);
 	remove(filename);
 
 	unsigned disk_size = frame->disk_size;
 	images_disk_size -= disk_size;
 	frame->image->total_disk_size -= disk_size;
 	frame->disk_size = 0;
 
 	GR_LOG("After deleting image file %u frame %u (atime %ld ms ago) "
 	       "disk: %ld KiB  (- %u KiB)\n",
 	       frame->image->image_id, frame->index,
 	       drawing_start_time - frame->atime, images_disk_size / 1024,
 	       disk_size / 1024);
 }
 
 /// Deletes all on-disk cache files of the image (for each frame).
 static void gr_delete_imagefiles(Image *img) {
 	foreach_frame(*img, frame, {
 		gr_delete_imagefile(frame);
 	});
 }
 
 /// Deletes the given placement: unloads, frees the object, but doesn't change
 /// the `placements` hash table.
 static void gr_delete_placement_keep_id(ImagePlacement *placement) {
 	if (!placement)
 		return;
 	GR_LOG("Deleting placement %u/%u\n", placement->image->image_id,
 	       placement->placement_id);
 	gr_unload_placement(placement);
 	kv_destroy(placement->pixmaps_beyond_the_first);
 	free(placement);
 	total_placement_count--;
 }
 
 /// Deletes all placements of `img`.
 static void gr_delete_all_placements(Image *img) {
 	ImagePlacement *placement = NULL;
 	kh_foreach_value(img->placements, placement, {
 		gr_delete_placement_keep_id(placement);
 	});
 	kh_clear(id2placement, img->placements);
 }
 
 /// Deletes the given image: unloads, deletes the file, frees the Image object,
 /// but doesn't change the `images` hash table.
 static void gr_delete_image_keep_id(Image *img) {
 	if (!img)
 		return;
 	GR_LOG("Deleting image %u\n", img->image_id);
 	foreach_frame(*img, frame, {
 		gr_delete_imagefile(frame);
 		gr_unload_frame(frame);
 	});
 	kv_destroy(img->frames_beyond_the_first);
 	gr_delete_all_placements(img);
 	kh_destroy(id2placement, img->placements);
 	free(img);
 }
 
 /// Deletes the given image: unloads, deletes the file, frees the Image object,
 /// and also removes it from `images`.
 static void gr_delete_image(Image *img) {
 	if (!img)
 		return;
 	uint32_t id = img->image_id;
 	gr_delete_image_keep_id(img);
 	khiter_t k = kh_get(id2image, images, id);
 	kh_del(id2image, images, k);
 }
 
 /// Deletes the given placement: unloads, frees the object, and also removes it
 /// from `placements`.
 static void gr_delete_placement(ImagePlacement *placement) {
 	if (!placement)
 		return;
 	uint32_t id = placement->placement_id;
 	Image *img = placement->image;
 	gr_delete_placement_keep_id(placement);
 	khiter_t k = kh_get(id2placement, img->placements, id);
 	kh_del(id2placement, img->placements, k);
 }
 
 /// Deletes all images and clears `images`.
 static void gr_delete_all_images() {
 	Image *img = NULL;
 	kh_foreach_value(images, img, {
 		gr_delete_image_keep_id(img);
 	});
 	kh_clear(id2image, images);
 }
 
 /// Update the atime of the image.
 static void gr_touch_image(Image *img) {
 	img->atime = gr_now_ms();
 }
 
 /// Update the atime of the frame.
 static void gr_touch_frame(ImageFrame *frame) {
 	frame->image->atime = frame->atime = gr_now_ms();
 }
 
 /// Update the atime of the placement. Touches the images too.
 static void gr_touch_placement(ImagePlacement *placement) {
 	placement->image->atime = placement->atime = gr_now_ms();
 }
 
 /// Creates a new image with the given id. If an image with that id already
 /// exists, it is deleted first. If the provided id is 0, generates a
 /// random id.
 static Image *gr_new_image(uint32_t id) {
 	if (id == 0) {
 		do {
 			id = rand();
 			// Avoid IDs that don't need full 32 bits.
 		} while ((id & 0xFF000000) == 0 || (id & 0x00FFFF00) == 0 ||
 			 gr_find_image(id));
 		GR_LOG("Generated random image id %u\n", id);
 	}
 	Image *img = gr_find_image(id);
 	gr_delete_image_keep_id(img);
 	GR_LOG("Creating image %u\n", id);
 	img = malloc(sizeof(Image));
 	memset(img, 0, sizeof(Image));
 	img->placements = kh_init(id2placement);
 	int ret;
 	khiter_t k = kh_put(id2image, images, id, &ret);
 	kh_value(images, k) = img;
 	img->image_id = id;
 	gr_touch_image(img);
 	img->global_command_index = global_command_counter;
 	return img;
 }
 
 /// Creates a new frame at the end of the frame array. It may be the first frame
 /// if there are no frames yet.
 static ImageFrame *gr_append_new_frame(Image *img) {
 	ImageFrame *frame = NULL;
 	if (img->first_frame.index == 0 &&
 	    kv_size(img->frames_beyond_the_first) == 0) {
 		frame = &img->first_frame;
 		frame->index = 1;
 	} else {
 		frame = kv_pushp(ImageFrame, img->frames_beyond_the_first);
 		memset(frame, 0, sizeof(ImageFrame));
 		frame->index = kv_size(img->frames_beyond_the_first) + 1;
 	}
 	frame->image = img;
 	gr_touch_frame(frame);
 	GR_LOG("Appending frame %d to image %u\n", frame->index, img->image_id);
 	return frame;
 }
 
 /// Creates a new placement with the given id. If a placement with that id
 /// already exists, it is deleted first. If the provided id is 0, generates a
 /// random id.
 static ImagePlacement *gr_new_placement(Image *img, uint32_t id) {
 	if (id == 0) {
 		do {
 			// Currently we support only 24-bit IDs.
 			id = rand() & 0xFFFFFF;
 			// Avoid IDs that need only one byte.
 		} while ((id & 0x00FFFF00) == 0 || gr_find_placement(img, id));
 	}
 	ImagePlacement *placement = gr_find_placement(img, id);
 	gr_delete_placement_keep_id(placement);
 	GR_LOG("Creating placement %u/%u\n", img->image_id, id);
 	placement = malloc(sizeof(ImagePlacement));
 	memset(placement, 0, sizeof(ImagePlacement));
 	total_placement_count++;
 	int ret;
 	khiter_t k = kh_put(id2placement, img->placements, id, &ret);
 	kh_value(img->placements, k) = placement;
 	placement->image = img;
 	placement->placement_id = id;
 	gr_touch_placement(placement);
 	if (img->default_placement == 0)
 		img->default_placement = id;
 	return placement;
 }
 
 static int64_t ceil_div(int64_t a, int64_t b) {
 	return (a + b - 1) / b;
 }
 
 /// Computes the best number of rows and columns for a placement if it's not
 /// specified, and also adjusts the source rectangle size.
 static void gr_infer_placement_size_maybe(ImagePlacement *placement) {
 	// The size of the image.
 	int image_pix_width = placement->image->pix_width;
 	int image_pix_height = placement->image->pix_height;
 	// Negative values are not allowed. Quietly set them to 0.
 	if (placement->src_pix_x < 0)
 		placement->src_pix_x = 0;
 	if (placement->src_pix_y < 0)
 		placement->src_pix_y = 0;
 	if (placement->src_pix_width < 0)
 		placement->src_pix_width = 0;
 	if (placement->src_pix_height < 0)
 		placement->src_pix_height = 0;
 	// If the source rectangle is outside the image, truncate it.
 	if (placement->src_pix_x > image_pix_width)
 		placement->src_pix_x = image_pix_width;
 	if (placement->src_pix_y > image_pix_height)
 		placement->src_pix_y = image_pix_height;
 	// If the source rectangle is not specified, use the whole image. If
 	// it's partially outside the image, truncate it.
 	if (placement->src_pix_width == 0 ||
 	    placement->src_pix_x + placement->src_pix_width > image_pix_width)
 		placement->src_pix_width =
 			image_pix_width - placement->src_pix_x;
 	if (placement->src_pix_height == 0 ||
 	    placement->src_pix_y + placement->src_pix_height > image_pix_height)
 		placement->src_pix_height =
 			image_pix_height - placement->src_pix_y;
 
 	if (placement->cols != 0 && placement->rows != 0)
 		return;
 	if (placement->src_pix_width == 0 || placement->src_pix_height == 0)
 		return;
 	if (current_cw == 0 || current_ch == 0)
 		return;
 
 	// If no size is specified, use the image size.
 	if (placement->cols == 0 && placement->rows == 0) {
 		placement->cols =
 			ceil_div(placement->src_pix_width, current_cw);
 		placement->rows =
 			ceil_div(placement->src_pix_height, current_ch);
 		return;
 	}
 
 	// Some applications specify only one of the dimensions.
 	if (placement->scale_mode == SCALE_MODE_CONTAIN) {
 		// If we preserve aspect ratio and fit to width/height, the most
 		// logical thing is to find the minimum size of the
 		// non-specified dimension that allows the image to fit the
 		// specified dimension.
 		if (placement->cols == 0) {
 			placement->cols = ceil_div(
 				placement->src_pix_width * placement->rows *
 					current_ch,
 				placement->src_pix_height * current_cw);
 			return;
 		}
 		if (placement->rows == 0) {
 			placement->rows =
 				ceil_div(placement->src_pix_height *
 						 placement->cols * current_cw,
 					 placement->src_pix_width * current_ch);
 			return;
 		}
 	} else {
 		// Otherwise we stretch the image or preserve the original size.
 		// In both cases we compute the best number of columns from the
 		// pixel size and cell size.
 		// TODO: In the case of stretching it's not the most logical
 		//       thing to do, may need to revisit in the future.
 		//       Currently we switch to SCALE_MODE_CONTAIN when only one
 		//       of the dimensions is specified, so this case shouldn't
 		//       happen in practice.
 		if (!placement->cols)
 			placement->cols =
 				ceil_div(placement->src_pix_width, current_cw);
 		if (!placement->rows)
 			placement->rows =
 				ceil_div(placement->src_pix_height, current_ch);
 	}
 }
 
 /// Adjusts the current frame index if enough time has passed since the display
 /// of the current frame. Also computes the time of the next redraw of this
 /// image (`img->next_redraw`). The current time is passed as an argument so
 /// that all animations are in sync.
 static void gr_update_frame_index(Image *img, Milliseconds now) {
 	if (img->current_frame == 0) {
 		img->current_frame_time = now;
 		img->current_frame = 1;
 		img->next_redraw = now + MAX(1, img->first_frame.gap);
 		return;
 	}
 	// If the animation is stopped, show the current frame.
 	if (!img->animation_state ||
 	    img->animation_state == ANIMATION_STATE_STOPPED ||
 	    img->animation_state == ANIMATION_STATE_UNSET) {
 		// The next redraw is never (unless the state is changed).
 		img->next_redraw = 0;
 		return;
 	}
 	int last_uploaded_frame_index = gr_last_uploaded_frame_index(img);
 	// If we are loading and we reached the last frame, show the last frame.
 	if (img->animation_state == ANIMATION_STATE_LOADING &&
 	    img->current_frame == last_uploaded_frame_index) {
 		// The next redraw is never (unless the state is changed or
 		// frames are added).
 		img->next_redraw = 0;
 		return;
 	}
 
 	// Check how many milliseconds passed since the current frame was shown.
 	int passed_ms = now - img->current_frame_time;
 	// If the animation is looping and too much time has passes, we can
 	// make a shortcut.
 	if (img->animation_state == ANIMATION_STATE_LOOPING &&
 	    img->total_duration > 0 && passed_ms >= img->total_duration) {
 		passed_ms %= img->total_duration;
 		img->current_frame_time = now - passed_ms;
 	}
 	// Find the next frame.
 	int original_frame_index = img->current_frame;
 	while (1) {
 		ImageFrame *frame = gr_get_frame(img, img->current_frame);
 		if (!frame) {
 			// The frame doesn't exist, go to the first frame.
 			img->current_frame = 1;
 			img->current_frame_time = now;
 			img->next_redraw = now + MAX(1, img->first_frame.gap);
 			return;
 		}
 		if (frame->gap >= 0 && passed_ms < frame->gap) {
 			// Not enough time has passed, we are still in the same
 			// frame, and it's not a gapless frame.
 			img->next_redraw =
 				img->current_frame_time + MAX(1, frame->gap);
 			return;
 		}
 		// Otherwise go to the next frame.
 		passed_ms -= MAX(0, frame->gap);
 		if (img->current_frame >= last_uploaded_frame_index) {
 			// It's the last frame, if the animation is loading,
 			// remain on it.
 			if (img->animation_state == ANIMATION_STATE_LOADING) {
 				img->next_redraw = 0;
 				return;
 			}
 			// Otherwise the animation is looping.
 			img->current_frame = 1;
 			// TODO: Support finite number of loops.
 		} else {
 			img->current_frame++;
 		}
 		// Make sure we don't get stuck in an infinite loop.
 		if (img->current_frame == original_frame_index) {
 			// We looped through all frames, but haven't reached the
 			// next frame yet. This may happen if too much time has
 			// passed since the last redraw or all the frames are
 			// gapless. Just move on to the next frame.
 			img->current_frame++;
 			if (img->current_frame >
 			    last_uploaded_frame_index)
 				img->current_frame = 1;
 			img->current_frame_time = now;
 			img->next_redraw = now + MAX(
 				1, gr_get_frame(img, img->current_frame)->gap);
 			return;
 		}
 		// Adjust the start time of the frame. The next redraw time will
 		// be set in the next iteration.
 		img->current_frame_time += MAX(0, frame->gap);
 	}
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Unloading and deleting images to save resources.
 ////////////////////////////////////////////////////////////////////////////////
 
 /// A helper to compare frames by atime for qsort.
 static int gr_cmp_frames_by_atime(const void *a, const void *b) {
 	ImageFrame *frame_a = *(ImageFrame *const *)a;
 	ImageFrame *frame_b = *(ImageFrame *const *)b;
 	if (frame_a->atime == frame_b->atime)
 		return frame_a->image->global_command_index -
 		       frame_b->image->global_command_index;
 	return frame_a->atime - frame_b->atime;
 }
 
 /// A helper to compare images by atime for qsort.
 static int gr_cmp_images_by_atime(const void *a, const void *b) {
 	Image *img_a = *(Image *const *)a;
 	Image *img_b = *(Image *const *)b;
 	if (img_a->atime == img_b->atime)
 		return img_a->global_command_index -
 		       img_b->global_command_index;
 	return img_a->atime - img_b->atime;
 }
 
 /// A helper to compare placements by atime for qsort.
 static int gr_cmp_placements_by_atime(const void *a, const void *b) {
 	ImagePlacement *p_a = *(ImagePlacement **)a;
 	ImagePlacement *p_b = *(ImagePlacement **)b;
 	if (p_a->atime == p_b->atime)
 		return p_a->image->global_command_index -
 		       p_b->image->global_command_index;
 	return p_a->atime - p_b->atime;
 }
 
 typedef kvec_t(Image *) ImageVec;
 typedef kvec_t(ImagePlacement *) ImagePlacementVec;
 typedef kvec_t(ImageFrame *) ImageFrameVec;
 
 /// Returns an array of pointers to all images sorted by atime.
 static ImageVec gr_get_images_sorted_by_atime() {
 	ImageVec vec;
 	kv_init(vec);
 	if (kh_size(images) == 0)
 		return vec;
 	kv_resize(Image *, vec, kh_size(images));
 	Image *img = NULL;
 	kh_foreach_value(images, img, { kv_push(Image *, vec, img); });
 	qsort(vec.a, kv_size(vec), sizeof(Image *), gr_cmp_images_by_atime);
 	return vec;
 }
 
 /// Returns an array of pointers to all placements sorted by atime.
 static ImagePlacementVec gr_get_placements_sorted_by_atime() {
 	ImagePlacementVec vec;
 	kv_init(vec);
 	if (total_placement_count == 0)
 		return vec;
 	kv_resize(ImagePlacement *, vec, total_placement_count);
 	Image *img = NULL;
 	ImagePlacement *placement = NULL;
 	kh_foreach_value(images, img, {
 		kh_foreach_value(img->placements, placement, {
 			kv_push(ImagePlacement *, vec, placement);
 		});
 	});
 	qsort(vec.a, kv_size(vec), sizeof(ImagePlacement *),
 	      gr_cmp_placements_by_atime);
 	return vec;
 }
 
 /// Returns an array of pointers to all frames sorted by atime.
 static ImageFrameVec gr_get_frames_sorted_by_atime() {
 	ImageFrameVec frames;
 	kv_init(frames);
 	Image *img = NULL;
 	kh_foreach_value(images, img, {
 		foreach_frame(*img, frame, {
 			kv_push(ImageFrame *, frames, frame);
 		});
 	});
 	qsort(frames.a, kv_size(frames), sizeof(ImageFrame *),
 	      gr_cmp_frames_by_atime);
 	return frames;
 }
 
 /// An object that can be unloaded from RAM.
 typedef struct {
 	/// Some score, probably based on access time. The lower the score, the
 	/// more likely that the object should be unloaded.
 	int64_t score;
 	union {
 		ImagePlacement *placement;
 		ImageFrame *frame;
 	};
 	/// If zero, the object is the imlib object of `frame`, if non-zero,
 	/// the object is a pixmap of `frameidx`-th frame of `placement`.
 	int frameidx;
 } UnloadableObject;
 
 typedef kvec_t(UnloadableObject) UnloadableObjectVec;
 
 /// A helper to compare unloadable objects by score for qsort.
 static int gr_cmp_unloadable_objects(const void *a, const void *b) {
 	UnloadableObject *obj_a = (UnloadableObject *)a;
 	UnloadableObject *obj_b = (UnloadableObject *)b;
 	return obj_a->score - obj_b->score;
 }
 
 /// Unloads an unloadable object from RAM.
 static void gr_unload_object(UnloadableObject *obj) {
 	if (obj->frameidx) {
 		if (obj->placement->protected_frame == obj->frameidx)
 			return;
 		gr_unload_pixmap(obj->placement, obj->frameidx);
 	} else {
 		gr_unload_frame(obj->frame);
 	}
 }
 
 /// Returns the recency threshold for an image. Frames that were accessed within
 /// this threshold from now are considered recent and may be handled
 /// differently because we may need them again very soon.
 static Milliseconds gr_recency_threshold(Image *img) {
 	return img->total_duration * 2 + 1000;
 }
 
 /// Creates an unloadable object for the imlib object of a frame.
 static UnloadableObject gr_unloadable_object_for_frame(Milliseconds now,
 						       ImageFrame *frame) {
 	UnloadableObject obj = {0};
 	obj.frameidx = 0;
 	obj.frame = frame;
 	Milliseconds atime = frame->atime;
 	obj.score = atime;
 	if (atime >= now - gr_recency_threshold(frame->image)) {
 		// This is a recent frame, probably from an active animation.
 		// Score it above `now` to prefer unloading non-active frames.
 		// Randomize the score because it's not very clear in which
 		// order we want to unload them: reloading a frame may require
 		// reloading other frames.
 		obj.score = now + 1000 + rand() % 1000;
 	}
 	return obj;
 }
 
 /// Creates an unloadable object for a pixmap.
 static UnloadableObject
 gr_unloadable_object_for_pixmap(Milliseconds now, ImageFrame *frame,
 				ImagePlacement *placement) {
 	UnloadableObject obj = {0};
 	obj.frameidx = frame->index;
 	obj.placement = placement;
 	obj.score = placement->atime;
 	// Since we don't store pixmap atimes, use the
 	// oldest atime of the frame and the placement.
 	Milliseconds atime = MIN(placement->atime, frame->atime);
 	obj.score = atime;
 	if (atime >= now - gr_recency_threshold(frame->image)) {
 		// This is a recent pixmap, probably from an active animation.
 		// Score it above `now` to prefer unloading non-active frames.
 		// Also assign higher scores to frames that are closer to the
 		// current frame (more likely to be used soon).
 		int num_frames = gr_last_frame_index(frame->image);
 		int dist = frame->index - frame->image->current_frame;
 		if (dist < 0)
 			dist += num_frames;
 		obj.score =
 			now + 1000 + (num_frames - dist) * 1000 / num_frames;
 		// If the pixmap is much larger than the imlib image, prefer to
 		// unload the pixmap by adding up to -1000 to the score. If the
 		// imlib image is larger, add up to +1000.
 		float imlib_size = gr_frame_current_ram_size(frame);
 		float pixmap_size =
 			gr_placement_single_frame_ram_size(placement);
 		obj.score +=
 			2000 * (imlib_size / (imlib_size + pixmap_size) - 0.5);
 	}
 	return obj;
 }
 
 /// Returns an array of unloadable objects sorted by score.
 static UnloadableObjectVec
 gr_get_unloadable_objects_sorted_by_score(Milliseconds now) {
 	UnloadableObjectVec objects;
 	kv_init(objects);
 	Image *img = NULL;
 	ImagePlacement *placement = NULL;
 	kh_foreach_value(images, img, {
 		foreach_frame(*img, frame, {
 			if (!frame->imlib_object)
 				continue;
 			kv_push(UnloadableObject, objects,
 				gr_unloadable_object_for_frame(now, frame));
 			int frameidx = frame->index;
 			kh_foreach_value(img->placements, placement, {
 				if (!gr_get_frame_pixmap(placement, frameidx))
 					continue;
 				kv_push(UnloadableObject, objects,
 					gr_unloadable_object_for_pixmap(
 						now, frame, placement));
 			});
 		});
 	});
 	qsort(objects.a, kv_size(objects), sizeof(UnloadableObject),
 	      gr_cmp_unloadable_objects);
 	return objects;
 }
 
 /// Returns the limit adjusted by the excess tolerance ratio.
 static inline unsigned apply_tolerance(unsigned limit) {
 	return limit + (unsigned)(limit * graphics_excess_tolerance_ratio);
 }
 
 /// Checks RAM and disk cache limits and deletes/unloads some images.
 static void gr_check_limits() {
 	Milliseconds now = gr_now_ms();
 	ImageVec images_sorted = {0};
 	ImagePlacementVec placements_sorted = {0};
 	ImageFrameVec frames_sorted = {0};
 	UnloadableObjectVec objects_sorted = {0};
 	int images_begin = 0;
 	int placements_begin = 0;
 	char changed = 0;
 	// First reduce the number of images if there are too many.
 	if (kh_size(images) > apply_tolerance(graphics_max_total_placements)) {
 		GR_LOG("Too many images: %d\n", kh_size(images));
 		changed = 1;
 		images_sorted = gr_get_images_sorted_by_atime();
 		int to_delete = kv_size(images_sorted) -
 				graphics_max_total_placements;
 		for (; images_begin < to_delete; images_begin++)
 			gr_delete_image(images_sorted.a[images_begin]);
 	}
 	// Then reduce the number of placements if there are too many.
 	if (total_placement_count >
 	    apply_tolerance(graphics_max_total_placements)) {
 		GR_LOG("Too many placements: %d\n", total_placement_count);
 		changed = 1;
 		placements_sorted = gr_get_placements_sorted_by_atime();
 		int to_delete = kv_size(placements_sorted) -
 				graphics_max_total_placements;
 		for (; placements_begin < to_delete; placements_begin++) {
 			ImagePlacement *placement =
 				placements_sorted.a[placements_begin];
 			if (placement->protected_frame)
 				break;
 			gr_delete_placement(placement);
 		}
 	}
 	// Then reduce the size of the image file cache. The files correspond to
 	// image frames.
 	if (images_disk_size >
 	    apply_tolerance(graphics_total_file_cache_size)) {
 		GR_LOG("Too big disk cache: %ld KiB\n",
 		       images_disk_size / 1024);
 		changed = 1;
 		frames_sorted = gr_get_frames_sorted_by_atime();
 		for (int i = 0; i < kv_size(frames_sorted); i++) {
 			if (images_disk_size <= graphics_total_file_cache_size)
 				break;
 			gr_delete_imagefile(kv_A(frames_sorted, i));
 		}
 	}
 	// Then unload images from RAM.
 	if (images_ram_size > apply_tolerance(graphics_max_total_ram_size)) {
 		changed = 1;
 		int frames_begin = 0;
 		GR_LOG("Too much ram: %ld KiB\n", images_ram_size / 1024);
 		objects_sorted = gr_get_unloadable_objects_sorted_by_score(now);
 		for (int i = 0; i < kv_size(objects_sorted); i++) {
 			if (images_ram_size <= graphics_max_total_ram_size)
 				break;
 			gr_unload_object(&kv_A(objects_sorted, i));
 		}
 	}
 	if (changed) {
 		GR_LOG("After cleaning:  ram: %ld KiB  disk: %ld KiB  "
 		       "img count: %d  placement count: %d\n",
 		       images_ram_size / 1024, images_disk_size / 1024,
 		       kh_size(images), total_placement_count);
 	}
 	kv_destroy(images_sorted);
 	kv_destroy(placements_sorted);
 	kv_destroy(frames_sorted);
 	kv_destroy(objects_sorted);
 }
 
 /// Unloads all images by user request.
 void gr_unload_images_to_reduce_ram() {
 	Image *img = NULL;
 	ImagePlacement *placement = NULL;
 	kh_foreach_value(images, img, {
 		kh_foreach_value(img->placements, placement, {
 			if (placement->protected_frame)
 				continue;
 			gr_unload_placement(placement);
 		});
 		gr_unload_all_frames(img);
 	});
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Image loading.
 ////////////////////////////////////////////////////////////////////////////////
 
 /// Copies `num_pixels` pixels (not bytes!) from a buffer `from` to an imlib2
 /// image data `to`. The format may be 24 (RGB) or 32 (RGBA), and it's converted
 /// to imlib2's representation, which is 0xAARRGGBB (having BGRA memory layout
 /// on little-endian architectures).
 static inline void gr_copy_pixels(DATA32 *to, unsigned char *from, int format,
 				  size_t num_pixels) {
 	size_t pixel_size = format == 24 ? 3 : 4;
 	if (format == 32) {
 		for (unsigned i = 0; i < num_pixels; ++i) {
 			unsigned byte_i = i * pixel_size;
 			to[i] = ((DATA32)from[byte_i + 2]) |
 				((DATA32)from[byte_i + 1]) << 8 |
 				((DATA32)from[byte_i]) << 16 |
 				((DATA32)from[byte_i + 3]) << 24;
 		}
 	} else {
 		for (unsigned i = 0; i < num_pixels; ++i) {
 			unsigned byte_i = i * pixel_size;
 			to[i] = ((DATA32)from[byte_i + 2]) |
 				((DATA32)from[byte_i + 1]) << 8 |
 				((DATA32)from[byte_i]) << 16 | 0xFF000000;
 		}
 	}
 }
 
 /// Loads uncompressed RGB or RGBA image data from a file.
 static void gr_load_raw_pixel_data_uncompressed(DATA32 *data, FILE *file,
 						int format,
 						size_t total_pixels) {
 	unsigned char chunk[BUFSIZ];
 	size_t pixel_size = format == 24 ? 3 : 4;
 	size_t chunk_size_pix = BUFSIZ / 4;
 	size_t chunk_size_bytes = chunk_size_pix * pixel_size;
 	size_t bytes = total_pixels * pixel_size;
 	for (size_t chunk_start_pix = 0; chunk_start_pix < total_pixels;
 	     chunk_start_pix += chunk_size_pix) {
 		size_t read_size = fread(chunk, 1, chunk_size_bytes, file);
 		size_t read_pixels = read_size / pixel_size;
 		if (chunk_start_pix + read_pixels > total_pixels)
 			read_pixels = total_pixels - chunk_start_pix;
 		gr_copy_pixels(data + chunk_start_pix, chunk, format,
 			       read_pixels);
 	}
 }
 
 #define COMPRESSED_CHUNK_SIZE BUFSIZ
 #define DECOMPRESSED_CHUNK_SIZE (BUFSIZ * 4)
 
 /// Loads compressed RGB or RGBA image data from a file.
 static int gr_load_raw_pixel_data_compressed(DATA32 *data, FILE *file,
 					     int format, size_t total_pixels) {
 	size_t pixel_size = format == 24 ? 3 : 4;
 	unsigned char compressed_chunk[COMPRESSED_CHUNK_SIZE];
 	unsigned char decompressed_chunk[DECOMPRESSED_CHUNK_SIZE];
 
 	z_stream strm;
 	strm.zalloc = Z_NULL;
 	strm.zfree = Z_NULL;
 	strm.opaque = Z_NULL;
 	strm.next_out = decompressed_chunk;
 	strm.avail_out = DECOMPRESSED_CHUNK_SIZE;
 	strm.avail_in = 0;
 	strm.next_in = Z_NULL;
 	int ret = inflateInit(&strm);
 	if (ret != Z_OK)
 	    return 1;
 
 	int error = 0;
 	int progress = 0;
 	size_t total_copied_pixels = 0;
 	while (1) {
 		// If we don't have enough data in the input buffer, try to read
 		// from the file.
 		if (strm.avail_in <= COMPRESSED_CHUNK_SIZE / 4) {
 			// Move the existing data to the beginning.
 			memmove(compressed_chunk, strm.next_in, strm.avail_in);
 			strm.next_in = compressed_chunk;
 			// Read more data.
 			size_t bytes_read = fread(
 				compressed_chunk + strm.avail_in, 1,
 				COMPRESSED_CHUNK_SIZE - strm.avail_in, file);
 			strm.avail_in += bytes_read;
 			if (bytes_read != 0)
 				progress = 1;
 		}
 
 		// Try to inflate the data.
 		int ret = inflate(&strm, Z_SYNC_FLUSH);
 		if (ret == Z_MEM_ERROR || ret == Z_DATA_ERROR) {
 			error = 1;
 			fprintf(stderr,
 				"error: could not decompress the image, error "
 				"%s\n",
 				ret == Z_MEM_ERROR ? "Z_MEM_ERROR"
 						   : "Z_DATA_ERROR");
 			break;
 		}
 
 		// Copy the data from the output buffer to the image.
 		size_t full_pixels =
 			(DECOMPRESSED_CHUNK_SIZE - strm.avail_out) / pixel_size;
 		// Make sure we don't overflow the image.
 		if (full_pixels > total_pixels - total_copied_pixels)
 			full_pixels = total_pixels - total_copied_pixels;
 		if (full_pixels > 0) {
 			// Copy pixels.
 			gr_copy_pixels(data, decompressed_chunk, format,
 				       full_pixels);
 			data += full_pixels;
 			total_copied_pixels += full_pixels;
 			if (total_copied_pixels >= total_pixels) {
 				// We filled the whole image, there may be some
 				// data left, but we just truncate it.
 				break;
 			}
 			// Move the remaining data to the beginning.
 			size_t copied_bytes = full_pixels * pixel_size;
 			size_t leftover =
 				(DECOMPRESSED_CHUNK_SIZE - strm.avail_out) -
 				copied_bytes;
 			memmove(decompressed_chunk,
 				decompressed_chunk + copied_bytes, leftover);
 			strm.next_out -= copied_bytes;
 			strm.avail_out += copied_bytes;
 			progress = 1;
 		}
 
 		// If we haven't made any progress, then we have reached the end
 		// of both the file and the inflated data.
 		if (!progress)
 			break;
 		progress = 0;
 	}
 
 	inflateEnd(&strm);
 	return error;
 }
 
 #undef COMPRESSED_CHUNK_SIZE
 #undef DECOMPRESSED_CHUNK_SIZE
 
 /// Load the image from a file containing raw pixel data (RGB or RGBA), the data
 /// may be compressed.
 static Imlib_Image gr_load_raw_pixel_data(ImageFrame *frame,
 					  const char *filename) {
 	size_t total_pixels = frame->data_pix_width * frame->data_pix_height;
 	if (total_pixels * 4 > graphics_max_single_image_ram_size) {
 		fprintf(stderr,
 			"error: image %u frame %u is too big too load: %zu > %u\n",
 			frame->image->image_id, frame->index, total_pixels * 4,
 			graphics_max_single_image_ram_size);
 		return NULL;
 	}
 
 	FILE* file = fopen(filename, "rb");
 	if (!file) {
 		fprintf(stderr,
 			"error: could not open image file: %s\n",
 			sanitized_filename(filename));
 		return NULL;
 	}
 
 	Imlib_Image image = imlib_create_image(frame->data_pix_width,
 					       frame->data_pix_height);
 	if (!image) {
 		fprintf(stderr,
 			"error: could not create an image of size %d x %d\n",
 			frame->data_pix_width, frame->data_pix_height);
 		fclose(file);
 		return NULL;
 	}
 
 	imlib_context_set_image(image);
 	imlib_image_set_has_alpha(1);
 	DATA32* data = imlib_image_get_data();
 
 	// The default format is 32.
 	int format = frame->format ? frame->format : 32;
 
 	if (frame->compression == 0) {
 		gr_load_raw_pixel_data_uncompressed(data, file, format,
 						    total_pixels);
 	} else {
 		int ret = gr_load_raw_pixel_data_compressed(data, file, format,
 							    total_pixels);
 		if (ret != 0) {
 			imlib_image_put_back_data(data);
 			imlib_free_image();
 			fclose(file);
 			return NULL;
 		}
 	}
 
 	fclose(file);
 	imlib_image_put_back_data(data);
 	return image;
 }
 
 /// Loads the unscaled frame into RAM as an imlib object. The frame imlib object
 /// is fully composed on top of the background frame. If the frame is already
 /// loaded, does nothing. Loading may fail, in which case the status of the
 /// frame will be set to STATUS_RAM_LOADING_ERROR.
 static void gr_load_imlib_object(ImageFrame *frame) {
 	if (frame->imlib_object)
 		return;
 
 	// If the image is uninitialized or uploading has failed, or the file
 	// has been deleted, we cannot load the image.
 	if (frame->status < STATUS_UPLOADING_SUCCESS)
 		return;
 	if (frame->disk_size == 0) {
 		if (frame->status != STATUS_RAM_LOADING_ERROR) {
 			fprintf(stderr,
 				"error: cached image was deleted: %u frame %u\n",
 				frame->image->image_id, frame->index);
 		}
 		frame->status = STATUS_RAM_LOADING_ERROR;
 		return;
 	}
 
 	// Prevent recursive dependences between frames.
 	if (frame->status == STATUS_RAM_LOADING_IN_PROGRESS) {
 		fprintf(stderr,
 			"error: recursive loading of image %u frame %u\n",
 			frame->image->image_id, frame->index);
 		frame->status = STATUS_RAM_LOADING_ERROR;
 		return;
 	}
 	frame->status = STATUS_RAM_LOADING_IN_PROGRESS;
 
 	// Load the background frame if needed. Hopefully it's not recursive.
 	ImageFrame *bg_frame = NULL;
 	if (frame->background_frame_index) {
 		bg_frame = gr_get_frame(frame->image,
 					frame->background_frame_index);
 		if (!bg_frame) {
 			fprintf(stderr,
 				"error: could not find background "
 				"frame %d for image %u frame %d\n",
 				frame->background_frame_index,
 				frame->image->image_id, frame->index);
 			frame->status = STATUS_RAM_LOADING_ERROR;
 			return;
 		}
 		gr_load_imlib_object(bg_frame);
 		if (!bg_frame->imlib_object) {
 			fprintf(stderr,
 				"error: could not load background frame %d for "
 				"image %u frame %d\n",
 				frame->background_frame_index,
 				frame->image->image_id, frame->index);
 			frame->status = STATUS_RAM_LOADING_ERROR;
 			return;
 		}
 	}
 
 	// Load the frame data image.
 	Imlib_Image frame_data_image = NULL;
 	char filename[MAX_FILENAME_SIZE];
 	gr_get_frame_filename(frame, filename, MAX_FILENAME_SIZE);
 	GR_LOG("Loading image: %s\n", sanitized_filename(filename));
 	if (frame->format == 100 || frame->format == 0)
 		frame_data_image = imlib_load_image(filename);
 	if (frame->format == 32 || frame->format == 24 ||
 	    (!frame_data_image && frame->format == 0))
 		frame_data_image = gr_load_raw_pixel_data(frame, filename);
 	this_redraw_cycle_loaded_files++;
 
 	if (!frame_data_image) {
 		if (frame->status != STATUS_RAM_LOADING_ERROR) {
 			fprintf(stderr, "error: could not load image: %s\n",
 				sanitized_filename(filename));
 		}
 		frame->status = STATUS_RAM_LOADING_ERROR;
 		return;
 	}
 
 	imlib_context_set_image(frame_data_image);
 	int frame_data_width = imlib_image_get_width();
 	int frame_data_height = imlib_image_get_height();
 	GR_LOG("Successfully loaded, size %d x %d\n", frame_data_width,
 	       frame_data_height);
 	// If imlib loading succeeded, and it is the first frame, set the
 	// information about the original image size, unless it's already set.
 	if (frame->index == 1 && frame->image->pix_width == 0 &&
 	    frame->image->pix_height == 0) {
 		frame->image->pix_width = frame_data_width;
 		frame->image->pix_height = frame_data_height;
 	}
 
 	int image_width = frame->image->pix_width;
 	int image_height = frame->image->pix_height;
 
 	// Compose the image with the background color or frame.
 	if (frame->background_color != 0 || bg_frame ||
 	    image_width != frame_data_width ||
 	    image_height != frame_data_height) {
 		GR_LOG("Composing the frame bg = 0x%08X, bgframe = %d\n",
 		       frame->background_color, frame->background_frame_index);
 		Imlib_Image composed_image = imlib_create_image(
 			image_width, image_height);
 		imlib_context_set_image(composed_image);
 		imlib_image_set_has_alpha(1);
 		imlib_context_set_anti_alias(0);
 
 		// Start with the background frame or color.
 		imlib_context_set_blend(0);
 		if (bg_frame && bg_frame->imlib_object) {
 			imlib_blend_image_onto_image(
 				bg_frame->imlib_object, 1, 0, 0,
 				image_width, image_height, 0, 0,
 				image_width, image_height);
 		} else {
 			int r = (frame->background_color >> 24) & 0xFF;
 			int g = (frame->background_color >> 16) & 0xFF;
 			int b = (frame->background_color >> 8) & 0xFF;
 			int a = frame->background_color & 0xFF;
 			imlib_context_set_color(r, g, b, a);
 			imlib_image_fill_rectangle(0, 0, image_width,
 						   image_height);
 		}
 
 		// Blend the frame data image onto the background.
 		imlib_context_set_blend(1);
 		imlib_blend_image_onto_image(
 			frame_data_image, 1, 0, 0, frame->data_pix_width,
 			frame->data_pix_height, frame->x, frame->y,
 			frame->data_pix_width, frame->data_pix_height);
 
 		// Free the frame data image.
 		imlib_context_set_image(frame_data_image);
 		imlib_free_image();
 
 		frame_data_image = composed_image;
 	}
 
 	frame->imlib_object = frame_data_image;
 
 	images_ram_size += gr_frame_current_ram_size(frame);
 	frame->status = STATUS_RAM_LOADING_SUCCESS;
 
 	GR_LOG("After loading image %u frame %d ram: %ld KiB  (+ %u KiB)\n",
 	       frame->image->image_id, frame->index,
 	       images_ram_size / 1024, gr_frame_current_ram_size(frame) / 1024);
 }
 
 /// Premultiplies the alpha channel of the image data. The data is an array of
 /// pixels such that each pixel is a 32-bit integer in the format 0xAARRGGBB.
 static void gr_premultiply_alpha(DATA32 *data, size_t num_pixels) {
 	for (size_t i = 0; i < num_pixels; ++i) {
 		DATA32 pixel = data[i];
 		unsigned char a = pixel >> 24;
 		if (a == 0) {
 			data[i] = 0;
 		} else if (a != 255) {
 			unsigned char b = (pixel & 0xFF) * a / 255;
 			unsigned char g = ((pixel >> 8) & 0xFF) * a / 255;
 			unsigned char r = ((pixel >> 16) & 0xFF) * a / 255;
 			data[i] = (a << 24) | (r << 16) | (g << 8) | b;
 		}
 	}
 }
 
 /// Creates a pixmap for the frame of an image placement. The pixmap contain the
 /// image data correctly scaled and fit to the box defined by the number of
 /// rows/columns of the image placement and the provided cell dimensions in
 /// pixels. If the placement is already loaded, it will be reloaded only if the
 /// cell dimensions have changed.
 Pixmap gr_load_pixmap(ImagePlacement *placement, int frameidx, int cw, int ch) {
 	Image *img = placement->image;
 	ImageFrame *frame = gr_get_frame(img, frameidx);
 
 	// Update the atime uncoditionally.
 	gr_touch_placement(placement);
 	if (frame)
 		gr_touch_frame(frame);
 
 	// If cw or ch are different, unload all the pixmaps.
 	if (placement->scaled_cw != cw || placement->scaled_ch != ch) {
 		gr_unload_placement(placement);
 		placement->scaled_cw = cw;
 		placement->scaled_ch = ch;
 	}
 
 	// If it's already loaded, do nothing.
 	Pixmap pixmap = gr_get_frame_pixmap(placement, frameidx);
 	if (pixmap)
 		return pixmap;
 
 	GR_LOG("Loading placement: %u/%u frame %u\n", img->image_id,
 	       placement->placement_id, frameidx);
 
 	// Load the imlib object for the frame.
 	if (!frame) {
 		fprintf(stderr,
 			"error: could not find frame %u for image %u\n",
 			frameidx, img->image_id);
 		return 0;
 	}
 	gr_load_imlib_object(frame);
 	if (!frame->imlib_object)
 		return 0;
 
 	// Infer the placement size if needed.
 	gr_infer_placement_size_maybe(placement);
 
 	// Create the scaled image. This is temporary, we will scale it
 	// appropriately, upload to the X server, and then delete immediately.
 	int scaled_w = (int)placement->cols * cw;
 	int scaled_h = (int)placement->rows * ch;
 	if (scaled_w * scaled_h * 4 > graphics_max_single_image_ram_size) {
 		fprintf(stderr,
 			"error: placement %u/%u would be too big to load: %d x "
 			"%d x 4 > %u\n",
 			img->image_id, placement->placement_id, scaled_w,
 			scaled_h, graphics_max_single_image_ram_size);
 		return 0;
 	}
 	Imlib_Image scaled_image = imlib_create_image(scaled_w, scaled_h);
 	if (!scaled_image) {
 		fprintf(stderr,
 			"error: imlib_create_image(%d, %d) returned "
 			"null\n",
 			scaled_w, scaled_h);
 		return 0;
 	}
 	imlib_context_set_image(scaled_image);
 	imlib_image_set_has_alpha(1);
 
 	// First fill the scaled image with the transparent color.
 	imlib_context_set_blend(0);
 	imlib_context_set_color(0, 0, 0, 0);
 	imlib_image_fill_rectangle(0, 0, scaled_w, scaled_h);
 	imlib_context_set_anti_alias(1);
 	imlib_context_set_blend(1);
 
 	// The source rectangle.
 	int src_x = placement->src_pix_x;
 	int src_y = placement->src_pix_y;
 	int src_w = placement->src_pix_width;
 	int src_h = placement->src_pix_height;
 	// Whether the box is too small to use the true size of the image.
 	char box_too_small = scaled_w < src_w || scaled_h < src_h;
 	char mode = placement->scale_mode;
 
 	// Then blend the original image onto the transparent background.
 	if (src_w <= 0 || src_h <= 0) {
 		fprintf(stderr, "warning: image of zero size\n");
 	} else if (mode == SCALE_MODE_FILL) {
 		imlib_blend_image_onto_image(frame->imlib_object, 1, src_x,
 					     src_y, src_w, src_h, 0, 0,
 					     scaled_w, scaled_h);
 	} else if (mode == SCALE_MODE_NONE ||
 		   (mode == SCALE_MODE_NONE_OR_CONTAIN && !box_too_small)) {
 		imlib_blend_image_onto_image(frame->imlib_object, 1, src_x,
 					     src_y, src_w, src_h, 0, 0, src_w,
 					     src_h);
 	} else {
 		if (mode != SCALE_MODE_CONTAIN &&
 		    mode != SCALE_MODE_NONE_OR_CONTAIN) {
 			fprintf(stderr,
 				"warning: unknown scale mode %u, using "
 				"'contain' instead\n",
 				mode);
 		}
 		int dest_x, dest_y;
 		int dest_w, dest_h;
 		if (scaled_w * src_h > src_w * scaled_h) {
 			// If the box is wider than the original image, fit to
 			// height.
 			dest_h = scaled_h;
 			dest_y = 0;
 			dest_w = src_w * scaled_h / src_h;
 			dest_x = (scaled_w - dest_w) / 2;
 		} else {
 			// Otherwise, fit to width.
 			dest_w = scaled_w;
 			dest_x = 0;
 			dest_h = src_h * scaled_w / src_w;
 			dest_y = (scaled_h - dest_h) / 2;
 		}
 		imlib_blend_image_onto_image(frame->imlib_object, 1, src_x,
 					     src_y, src_w, src_h, dest_x,
 					     dest_y, dest_w, dest_h);
 	}
 
 	// XRender needs the alpha channel premultiplied.
 	DATA32 *data = imlib_image_get_data();
 	gr_premultiply_alpha(data, scaled_w * scaled_h);
 
 	// Upload the image to the X server.
 	Display *disp = imlib_context_get_display();
 	Visual *vis = imlib_context_get_visual();
 	Colormap cmap = imlib_context_get_colormap();
 	Drawable drawable = imlib_context_get_drawable();
 	if (!drawable)
 		drawable = DefaultRootWindow(disp);
 	pixmap = XCreatePixmap(disp, drawable, scaled_w, scaled_h, 32);
 	XVisualInfo visinfo;
 	XMatchVisualInfo(disp, DefaultScreen(disp), 32, TrueColor, &visinfo);
 	XImage *ximage = XCreateImage(disp, visinfo.visual, 32, ZPixmap, 0,
 				      (char *)data, scaled_w, scaled_h, 32, 0);
 	GC gc = XCreateGC(disp, pixmap, 0, NULL);
 	XPutImage(disp, pixmap, gc, ximage, 0, 0, 0, 0, scaled_w,
 		  scaled_h);
 	XFreeGC(disp, gc);
 	// XDestroyImage will free the data as well, but it is managed by imlib,
 	// so set it to NULL.
 	ximage->data = NULL;
 	XDestroyImage(ximage);
 	imlib_image_put_back_data(data);
 	imlib_free_image();
 
 	// Assign the pixmap to the frame and increase the ram size.
 	gr_set_frame_pixmap(placement, frameidx, pixmap);
 	images_ram_size += gr_placement_single_frame_ram_size(placement);
 	this_redraw_cycle_loaded_pixmaps++;
 
 	GR_LOG("After loading placement %u/%u frame %d ram: %ld KiB  (+ %u "
 	       "KiB)\n",
 	       frame->image->image_id, placement->placement_id, frame->index,
 	       images_ram_size / 1024,
 	       gr_placement_single_frame_ram_size(placement) / 1024);
 
 	// Free up ram if needed, but keep the pixmap we've loaded no matter
 	// what.
 	placement->protected_frame = frameidx;
 	gr_check_limits();
 	placement->protected_frame = 0;
 
 	return pixmap;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Initialization and deinitialization.
 ////////////////////////////////////////////////////////////////////////////////
 
 /// Creates a temporary directory.
 static int gr_create_cache_dir() {
 	strncpy(cache_dir, graphics_cache_dir_template, sizeof(cache_dir));
 	if (!mkdtemp(cache_dir)) {
 		fprintf(stderr,
 			"error: could not create temporary dir from template "
 			"%s\n",
 			sanitized_filename(cache_dir));
 		return 0;
 	}
 	fprintf(stderr, "Graphics cache directory: %s\n", cache_dir);
 	return 1;
 }
 
 /// Checks whether `tmp_dir` exists and recreates it if it doesn't.
 static void gr_make_sure_tmpdir_exists() {
 	struct stat st;
 	if (stat(cache_dir, &st) == 0 && S_ISDIR(st.st_mode))
 		return;
 	fprintf(stderr,
 		"error: %s is not a directory, will need to create a new "
 		"graphics cache directory\n",
 		sanitized_filename(cache_dir));
 	gr_create_cache_dir();
 }
 
 /// Initialize the graphics module.
 void gr_init(Display *disp, Visual *vis, Colormap cm) {
 	// Set the initialization time.
 	clock_gettime(CLOCK_MONOTONIC, &initialization_time);
 
 	// Create the temporary dir.
 	if (!gr_create_cache_dir())
 		abort();
 
 	// Initialize imlib.
 	imlib_context_set_display(disp);
 	imlib_context_set_visual(vis);
 	imlib_context_set_colormap(cm);
 	imlib_context_set_anti_alias(1);
 	imlib_context_set_blend(1);
 	// Imlib2 checks only the file name when caching, which is not enough
 	// for us since we reuse file names. Disable caching.
 	imlib_set_cache_size(0);
 
 	// Prepare for color inversion.
 	for (size_t i = 0; i < 256; ++i)
 		reverse_table[i] = 255 - i;
 
 	// Create data structures.
 	images = kh_init(id2image);
 	kv_init(next_redraw_times);
 
 	atexit(gr_deinit);
 }
 
 /// Deinitialize the graphics module.
 void gr_deinit() {
 	// Remove the cache dir.
 	remove(cache_dir);
 	kv_destroy(next_redraw_times);
 	if (images) {
 		// Delete all images.
 		gr_delete_all_images();
 		// Destroy the data structures.
 		kh_destroy(id2image, images);
 		images = NULL;
 	}
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Dumping, debugging, and image preview.
 ////////////////////////////////////////////////////////////////////////////////
 
 /// Returns a string containing a time difference in a human-readable format.
 /// Uses a static buffer, so be careful.
 static const char *gr_ago(Milliseconds diff) {
 	static char result[32];
 	double seconds = (double)diff / 1000.0;
 	if (seconds < 1)
 		snprintf(result, sizeof(result), "%.2f sec ago", seconds);
 	else if (seconds < 60)
 		snprintf(result, sizeof(result), "%d sec ago", (int)seconds);
 	else if (seconds < 3600)
 		snprintf(result, sizeof(result), "%d min %d sec ago",
 			 (int)(seconds / 60), (int)(seconds) % 60);
 	else {
 		snprintf(result, sizeof(result), "%d hr %d min %d sec ago",
 			 (int)(seconds / 3600), (int)(seconds) % 3600 / 60,
 			 (int)(seconds) % 60);
 	}
 	return result;
 }
 
 /// Prints to `file` with an indentation of `ind` spaces.
 static void fprintf_ind(FILE *file, int ind, const char *format, ...) {
 	fprintf(file, "%*s", ind, "");
 	va_list args;
 	va_start(args, format);
 	vfprintf(file, format, args);
 	va_end(args);
 }
 
 /// Dumps the image info to `file` with an indentation of `ind` spaces.
 static void gr_dump_image_info(FILE *file, Image *img, int ind) {
 	if (!img) {
 		fprintf_ind(file, ind, "Image is NULL\n");
 		return;
 	}
 	Milliseconds now = gr_now_ms();
 	fprintf_ind(file, ind, "Image %u\n", img->image_id);
 	ind += 4;
 	fprintf_ind(file, ind, "number: %u\n", img->image_number);
 	fprintf_ind(file, ind, "global command index: %lu\n",
 		img->global_command_index);
 	fprintf_ind(file, ind, "accessed: %ld  %s\n", img->atime,
 		    gr_ago(now - img->atime));
 	fprintf_ind(file, ind, "pix size: %ux%u\n", img->pix_width,
 		    img->pix_height);
 	fprintf_ind(file, ind, "cur frame start time: %ld  %s\n",
 		    img->current_frame_time,
 		    gr_ago(now - img->current_frame_time));
 	if (img->next_redraw)
 		fprintf_ind(file, ind, "next redraw: %ld  in %ld ms\n",
 			    img->next_redraw, img->next_redraw - now);
 	fprintf_ind(file, ind, "total disk size: %u KiB\n",
 		img->total_disk_size / 1024);
 	fprintf_ind(file, ind, "total duration: %d\n", img->total_duration);
 	fprintf_ind(file, ind, "frames: %d\n", gr_last_frame_index(img));
 	fprintf_ind(file, ind, "cur frame: %d\n", img->current_frame);
 	fprintf_ind(file, ind, "animation state: %d\n", img->animation_state);
 	fprintf_ind(file, ind, "default_placement: %u\n",
 		    img->default_placement);
 }
 
 /// Dumps the frame info to `file` with an indentation of `ind` spaces.
 static void gr_dump_frame_info(FILE *file, ImageFrame *frame, int ind) {
 	if (!frame) {
 		fprintf_ind(file, ind, "Frame is NULL\n");
 		return;
 	}
 	Milliseconds now = gr_now_ms();
 	fprintf_ind(file, ind, "Frame %d\n", frame->index);
 	ind += 4;
 	if (frame->index == 0) {
 		fprintf_ind(file, ind, "NOT INITIALIZED\n");
 		return;
 	}
 	if (frame->uploading_failure)
 		fprintf_ind(file, ind, "uploading failure: %s\n",
 			    image_uploading_failure_strings
 				    [frame->uploading_failure]);
 	fprintf_ind(file, ind, "gap: %d\n", frame->gap);
 	fprintf_ind(file, ind, "accessed: %ld  %s\n", frame->atime,
 		    gr_ago(now - frame->atime));
 	fprintf_ind(file, ind, "data pix size: %ux%u\n", frame->data_pix_width,
 		    frame->data_pix_height);
 	char filename[MAX_FILENAME_SIZE];
 	gr_get_frame_filename(frame, filename, MAX_FILENAME_SIZE);
 	if (access(filename, F_OK) != -1)
 		fprintf_ind(file, ind, "file: %s\n",
 			    sanitized_filename(filename));
 	else
 		fprintf_ind(file, ind, "not on disk\n");
 	fprintf_ind(file, ind, "disk size: %u KiB\n", frame->disk_size / 1024);
 	if (frame->imlib_object) {
 		unsigned ram_size = gr_frame_current_ram_size(frame);
 		fprintf_ind(file, ind,
 			    "loaded into ram, size: %d "
 			    "KiB\n",
 			    ram_size / 1024);
 	} else {
 		fprintf_ind(file, ind, "not loaded into ram\n");
 	}
 }
 
 /// Dumps the placement info to `file` with an indentation of `ind` spaces.
 static void gr_dump_placement_info(FILE *file, ImagePlacement *placement,
 				   int ind) {
 	if (!placement) {
 		fprintf_ind(file, ind, "Placement is NULL\n");
 		return;
 	}
 	Milliseconds now = gr_now_ms();
 	fprintf_ind(file, ind, "Placement %u\n", placement->placement_id);
 	ind += 4;
 	fprintf_ind(file, ind, "accessed: %ld  %s\n", placement->atime,
 		    gr_ago(now - placement->atime));
 	fprintf_ind(file, ind, "scale_mode: %u\n", placement->scale_mode);
 	fprintf_ind(file, ind, "size: %u cols x %u rows\n", placement->cols,
 		    placement->rows);
 	fprintf_ind(file, ind, "cell size: %ux%u\n", placement->scaled_cw,
 		    placement->scaled_ch);
 	fprintf_ind(file, ind, "ram per frame: %u KiB\n",
 		    gr_placement_single_frame_ram_size(placement) / 1024);
 	unsigned ram_size = gr_placement_current_ram_size(placement);
 	fprintf_ind(file, ind, "ram size: %d KiB\n", ram_size / 1024);
 }
 
 /// Dumps placement pixmaps to `file` with an indentation of `ind` spaces.
 static void gr_dump_placement_pixmaps(FILE *file, ImagePlacement *placement,
 				      int ind) {
 	if (!placement)
 		return;
 	int frameidx = 1;
 	foreach_pixmap(*placement, pixmap, {
 		fprintf_ind(file, ind, "Frame %d pixmap %lu\n", frameidx,
 			    pixmap);
 		++frameidx;
 	});
 }
 
 /// Dumps the internal state (images and placements) to stderr.
 void gr_dump_state() {
 	FILE *file = stderr;
 	int ind = 0;
 	fprintf_ind(file, ind, "======= Graphics module state dump =======\n");
 	fprintf_ind(file, ind,
 		"sizeof(Image) = %lu  sizeof(ImageFrame) = %lu  "
 		"sizeof(ImagePlacement) = %lu\n",
 		sizeof(Image), sizeof(ImageFrame), sizeof(ImagePlacement));
 	fprintf_ind(file, ind, "Image count: %u\n", kh_size(images));
 	fprintf_ind(file, ind, "Placement count: %u\n", total_placement_count);
 	fprintf_ind(file, ind, "Estimated RAM usage: %ld KiB\n",
 		images_ram_size / 1024);
 	fprintf_ind(file, ind, "Estimated Disk usage: %ld KiB\n",
 		images_disk_size / 1024);
 
 	Milliseconds now = gr_now_ms();
 
 	int64_t images_ram_size_computed = 0;
 	int64_t images_disk_size_computed = 0;
 
 	Image *img = NULL;
 	ImagePlacement *placement = NULL;
 	kh_foreach_value(images, img, {
 		fprintf_ind(file, ind, "----------------\n");
 		gr_dump_image_info(file, img, 0);
 		int64_t total_disk_size_computed = 0;
 		int total_duration_computed = 0;
 		foreach_frame(*img, frame, {
 			gr_dump_frame_info(file, frame, 4);
 			if (frame->image != img)
 				fprintf_ind(file, 8,
 					    "ERROR: WRONG IMAGE POINTER\n");
 			total_duration_computed += frame->gap;
 			images_disk_size_computed += frame->disk_size;
 			total_disk_size_computed += frame->disk_size;
 			if (frame->imlib_object)
 				images_ram_size_computed +=
 					gr_frame_current_ram_size(frame);
 		});
 		if (img->total_disk_size != total_disk_size_computed) {
 			fprintf_ind(file, ind,
 				"    ERROR: total_disk_size is %u, but "
 				"computed value is %ld\n",
 				img->total_disk_size, total_disk_size_computed);
 		}
 		if (img->total_duration != total_duration_computed) {
 			fprintf_ind(file, ind,
 				"    ERROR: total_duration is %d, but computed "
 				"value is %d\n",
 				img->total_duration, total_duration_computed);
 		}
 		kh_foreach_value(img->placements, placement, {
 			gr_dump_placement_info(file, placement, 4);
 			if (placement->image != img)
 				fprintf_ind(file, 8,
 					    "ERROR: WRONG IMAGE POINTER\n");
 			fprintf_ind(file, 8,
 				    "Pixmaps:\n");
 			gr_dump_placement_pixmaps(file, placement, 12);
 			unsigned ram_size =
 				gr_placement_current_ram_size(placement);
 			images_ram_size_computed += ram_size;
 		});
 	});
 	if (images_ram_size != images_ram_size_computed) {
 		fprintf_ind(file, ind,
 			"ERROR: images_ram_size is %ld, but computed value "
 			"is %ld\n",
 			images_ram_size, images_ram_size_computed);
 	}
 	if (images_disk_size != images_disk_size_computed) {
 		fprintf_ind(file, ind,
 			"ERROR: images_disk_size is %ld, but computed value "
 			"is %ld\n",
 			images_disk_size, images_disk_size_computed);
 	}
 	fprintf_ind(file, ind, "===========================================\n");
 }
 
 /// Executes `command` with the name of the file corresponding to `image_id` as
 /// the argument. Executes xmessage with an error message on failure.
 // TODO: Currently we do this for the first frame only. Not sure what to do with
 //       animations.
 void gr_preview_image(uint32_t image_id, const char *exec) {
 	char command[256];
 	size_t len;
 	Image *img = gr_find_image(image_id);
 	if (img) {
 		ImageFrame *frame = &img->first_frame;
 		char filename[MAX_FILENAME_SIZE];
 		gr_get_frame_filename(frame, filename, MAX_FILENAME_SIZE);
 		if (frame->disk_size == 0) {
 			len = snprintf(command, 255,
 				       "xmessage 'Image with id=%u is not "
 				       "fully copied to %s'",
 				       image_id, sanitized_filename(filename));
 		} else {
 			len = snprintf(command, 255, "%s %s &", exec,
 				       sanitized_filename(filename));
 		}
 	} else {
 		len = snprintf(command, 255,
 			       "xmessage 'Cannot find image with id=%u'",
 			       image_id);
 	}
 	if (len > 255) {
 		fprintf(stderr, "error: command too long: %s\n", command);
 		snprintf(command, 255, "xmessage 'error: command too long'");
 	}
 	if (system(command) != 0) {
 		fprintf(stderr, "error: could not execute command %s\n",
 			command);
 	}
 }
 
 /// Executes `<st> -e less <file>` where <file> is the name of a temporary file
 /// containing the information about an image and placement, and <st> is
 /// specified with `st_executable`.
 void gr_show_image_info(uint32_t image_id, uint32_t placement_id,
 			uint32_t imgcol, uint32_t imgrow,
 			char is_classic_placeholder, int32_t diacritic_count,
 			char *st_executable) {
 	char filename[MAX_FILENAME_SIZE];
 	snprintf(filename, sizeof(filename), "%s/info-%u", cache_dir, image_id);
 	FILE *file = fopen(filename, "w");
 	if (!file) {
 		perror("fopen");
 		return;
 	}
 	// Basic information about the cell.
 	fprintf(file, "image_id = %u = 0x%08X\n", image_id, image_id);
 	fprintf(file, "placement_id = %u = 0x%08X\n", placement_id, placement_id);
 	fprintf(file, "column = %d, row = %d\n", imgcol, imgrow);
 	fprintf(file, "classic/unicode placeholder = %s\n",
 		is_classic_placeholder ? "classic" : "unicode");
 	fprintf(file, "original diacritic count = %d\n", diacritic_count);
 	// Information about the image and the placement.
 	Image *img = gr_find_image(image_id);
 	ImagePlacement *placement = gr_find_placement(img, placement_id);
 	gr_dump_image_info(file, img, 0);
 	gr_dump_placement_info(file, placement, 0);
 	if (img) {
 		fprintf(file, "Frames:\n");
 		foreach_frame(*img, frame, {
 			gr_dump_frame_info(file, frame, 4);
 		});
 	}
 	if (placement) {
 		fprintf(file, "Placement pixmaps:\n");
 		gr_dump_placement_pixmaps(file, placement, 4);
 	}
 	fclose(file);
 	char *argv[] = {st_executable, "-e", "less", filename, NULL};
 	if (posix_spawnp(NULL, st_executable, NULL, NULL, argv, environ) != 0) {
 		perror("posix_spawnp");
 		return;
 	}
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Appending and displaying image rectangles.
 ////////////////////////////////////////////////////////////////////////////////
 
 /// Displays debug information in the rectangle using colors col1 and col2.
 static void gr_displayinfo(Drawable buf, ImageRect *rect, int col1, int col2,
 			   const char *message) {
 	int w_pix = (rect->img_end_col - rect->img_start_col) * rect->cw;
 	int h_pix = (rect->img_end_row - rect->img_start_row) * rect->ch;
 	Display *disp = imlib_context_get_display();
 	GC gc = XCreateGC(disp, buf, 0, NULL);
 	char info[MAX_INFO_LEN];
 	if (rect->placement_id)
 		snprintf(info, MAX_INFO_LEN, "%s%u/%u [%d:%d)x[%d:%d)", message,
 			 rect->image_id, rect->placement_id,
 			 rect->img_start_col, rect->img_end_col,
 			 rect->img_start_row, rect->img_end_row);
 	else
 		snprintf(info, MAX_INFO_LEN, "%s%u [%d:%d)x[%d:%d)", message,
 			 rect->image_id, rect->img_start_col, rect->img_end_col,
 			 rect->img_start_row, rect->img_end_row);
 	XSetForeground(disp, gc, col1);
 	XDrawString(disp, buf, gc, rect->screen_x_pix + 4,
 		    rect->screen_y_pix + h_pix - 3, info, strlen(info));
 	XSetForeground(disp, gc, col2);
 	XDrawString(disp, buf, gc, rect->screen_x_pix + 2,
 		    rect->screen_y_pix + h_pix - 5, info, strlen(info));
 	XFreeGC(disp, gc);
 }
 
 /// Draws a rectangle (bounding box) for debugging.
 static void gr_showrect(Drawable buf, ImageRect *rect) {
 	int w_pix = (rect->img_end_col - rect->img_start_col) * rect->cw;
 	int h_pix = (rect->img_end_row - rect->img_start_row) * rect->ch;
 	Display *disp = imlib_context_get_display();
 	GC gc = XCreateGC(disp, buf, 0, NULL);
 	XSetForeground(disp, gc, 0xFF00FF00);
 	XDrawRectangle(disp, buf, gc, rect->screen_x_pix, rect->screen_y_pix,
 		       w_pix - 1, h_pix - 1);
 	XSetForeground(disp, gc, 0xFFFF0000);
 	XDrawRectangle(disp, buf, gc, rect->screen_x_pix + 1,
 		       rect->screen_y_pix + 1, w_pix - 3, h_pix - 3);
 	XFreeGC(disp, gc);
 }
 
 /// Updates the next redraw time for the given row. Resizes the
 /// next_redraw_times array if needed.
 static void gr_update_next_redraw_time(int row, Milliseconds next_redraw) {
 	if (next_redraw == 0)
 		return;
 	if (row >= kv_size(next_redraw_times)) {
 		size_t old_size = kv_size(next_redraw_times);
 		kv_a(Milliseconds, next_redraw_times, row);
 		for (size_t i = old_size; i <= row; ++i)
 			kv_A(next_redraw_times, i) = 0;
 	}
 	Milliseconds old_value = kv_A(next_redraw_times, row);
 	if (old_value == 0 || old_value > next_redraw)
 		kv_A(next_redraw_times, row) = next_redraw;
 }
 
 /// Draws the given part of an image.
 static void gr_drawimagerect(Drawable buf, ImageRect *rect) {
 	ImagePlacement *placement =
 		gr_find_image_and_placement(rect->image_id, rect->placement_id);
 	// If the image does not exist or image display is switched off, draw
 	// the bounding box.
 	if (!placement || !graphics_display_images) {
 		gr_showrect(buf, rect);
 		if (graphics_debug_mode == GRAPHICS_DEBUG_LOG_AND_BOXES)
 			gr_displayinfo(buf, rect, 0xFF000000, 0xFFFFFFFF, "");
 		return;
 	}
 
 	Image *img = placement->image;
 
 	if (img->last_redraw < drawing_start_time) {
 		// This is the first time we draw this image in this redraw
 		// cycle. Update the frame index we are going to display. Note
 		// that currently all image placements are synchronized.
 		int old_frame = img->current_frame;
 		gr_update_frame_index(img, drawing_start_time);
 		img->last_redraw = drawing_start_time;
 	}
 
 	// Adjust next redraw times for the rows of this image rect.
 	if (img->next_redraw) {
 		for (int row = rect->screen_y_row;
 		     row <= rect->screen_y_row + rect->img_end_row -
 					  rect->img_start_row - 1; ++row) {
 			gr_update_next_redraw_time(
 				row, img->next_redraw);
 		}
 	}
 
 	// Load the frame.
 	Pixmap pixmap = gr_load_pixmap(placement, img->current_frame, rect->cw,
 				       rect->ch);
 
 	// If the image couldn't be loaded, display the bounding box.
 	if (!pixmap) {
 		gr_showrect(buf, rect);
 		if (graphics_debug_mode == GRAPHICS_DEBUG_LOG_AND_BOXES)
 			gr_displayinfo(buf, rect, 0xFF000000, 0xFFFFFFFF, "");
 		return;
 	}
 
 	int src_x = rect->img_start_col * rect->cw;
 	int src_y = rect->img_start_row * rect->ch;
 	int width = (rect->img_end_col - rect->img_start_col) * rect->cw;
 	int height = (rect->img_end_row - rect->img_start_row) * rect->ch;
 	int dst_x = rect->screen_x_pix;
 	int dst_y = rect->screen_y_pix;
 
 	// Display the image.
 	Display *disp = imlib_context_get_display();
 	Visual *vis = imlib_context_get_visual();
 
 	// Create an xrender picture for the window.
 	XRenderPictFormat *win_format =
 		XRenderFindVisualFormat(disp, vis);
 	Picture window_pic =
 		XRenderCreatePicture(disp, buf, win_format, 0, NULL);
 
 	// If needed, invert the image pixmap. Note that this naive approach of
 	// inverting the pixmap is not entirely correct, because the pixmap is
 	// premultiplied. But the result is good enough to visually indicate
 	// selection.
 	if (rect->reverse) {
 		unsigned pixmap_w =
 			(unsigned)placement->cols * placement->scaled_cw;
 		unsigned pixmap_h =
 			(unsigned)placement->rows * placement->scaled_ch;
 		Pixmap invpixmap =
 			XCreatePixmap(disp, buf, pixmap_w, pixmap_h, 32);
 		XGCValues gcv = {.function = GXcopyInverted};
 		GC gc = XCreateGC(disp, invpixmap, GCFunction, &gcv);
 		XCopyArea(disp, pixmap, invpixmap, gc, 0, 0, pixmap_w,
 			  pixmap_h, 0, 0);
 		XFreeGC(disp, gc);
 		pixmap = invpixmap;
 	}
 
 	// Create a picture for the image pixmap.
 	XRenderPictFormat *pic_format =
 		XRenderFindStandardFormat(disp, PictStandardARGB32);
 	Picture pixmap_pic =
 		XRenderCreatePicture(disp, pixmap, pic_format, 0, NULL);
 
 	// Composite the image onto the window. In the reverse mode we ignore
 	// the alpha channel of the image because the naive inversion above
 	// seems to invert the alpha channel as well.
 	int pictop = rect->reverse ? PictOpSrc : PictOpOver;
 	XRenderComposite(disp, pictop, pixmap_pic, 0, window_pic,
 			 src_x, src_y, src_x, src_y, dst_x, dst_y, width,
 			 height);
 
 	// Free resources
 	XRenderFreePicture(disp, pixmap_pic);
 	XRenderFreePicture(disp, window_pic);
 	if (rect->reverse)
 		XFreePixmap(disp, pixmap);
 
 	// In debug mode always draw bounding boxes and print info.
 	if (graphics_debug_mode == GRAPHICS_DEBUG_LOG_AND_BOXES) {
 		gr_showrect(buf, rect);
 		gr_displayinfo(buf, rect, 0xFF000000, 0xFFFFFFFF, "");
 	}
 }
 
 /// Removes the given image rectangle.
 static void gr_freerect(ImageRect *rect) { memset(rect, 0, sizeof(ImageRect)); }
 
 /// Returns the bottom coordinate of the rect.
 static int gr_getrectbottom(ImageRect *rect) {
 	return rect->screen_y_pix +
 	       (rect->img_end_row - rect->img_start_row) * rect->ch;
 }
 
 /// Prepare for image drawing. `cw` and `ch` are dimensions of the cell.
 void gr_start_drawing(Drawable buf, int cw, int ch) {
 	current_cw = cw;
 	current_ch = ch;
 	this_redraw_cycle_loaded_files = 0;
 	this_redraw_cycle_loaded_pixmaps = 0;
 	drawing_start_time = gr_now_ms();
 	imlib_context_set_drawable(buf);
 }
 
 /// Finish image drawing. This functions will draw all the rectangles left to
 /// draw.
 void gr_finish_drawing(Drawable buf) {
 	// Draw and then delete all known image rectangles.
 	for (size_t i = 0; i < MAX_IMAGE_RECTS; ++i) {
 		ImageRect *rect = &image_rects[i];
 		if (!rect->image_id)
 			continue;
 		gr_drawimagerect(buf, rect);
 		gr_freerect(rect);
 	}
 
 	// Compute the delay until the next redraw as the minimum of the next
 	// redraw delays for all rows.
 	Milliseconds drawing_end_time = gr_now_ms();
 	graphics_next_redraw_delay = INT_MAX;
 	for (int row = 0; row < kv_size(next_redraw_times); ++row) {
 		Milliseconds row_next_redraw = kv_A(next_redraw_times, row);
 		if (row_next_redraw > 0) {
 			int delay = MAX(graphics_animation_min_delay,
 					row_next_redraw - drawing_end_time);
 			graphics_next_redraw_delay =
 				MIN(graphics_next_redraw_delay, delay);
 		}
 	}
 
 	// In debug mode display additional info.
 	if (graphics_debug_mode) {
 		int milliseconds = drawing_end_time - drawing_start_time;
 
 		Display *disp = imlib_context_get_display();
 		GC gc = XCreateGC(disp, buf, 0, NULL);
 		const char *debug_mode_str =
 			graphics_debug_mode == GRAPHICS_DEBUG_LOG_AND_BOXES
 				? "(boxes shown) "
 				: "";
 		int redraw_delay = graphics_next_redraw_delay == INT_MAX
 					   ? -1
 					   : graphics_next_redraw_delay;
 		char info[MAX_INFO_LEN];
 		snprintf(info, MAX_INFO_LEN,
 			 "%sRender time: %d ms  ram %ld K  disk %ld K  count "
 			 "%d  cell %dx%d  delay %d",
 			 debug_mode_str, milliseconds, images_ram_size / 1024,
 			 images_disk_size / 1024, kh_size(images), current_cw,
 			 current_ch, redraw_delay);
 		XSetForeground(disp, gc, 0xFF000000);
 		XFillRectangle(disp, buf, gc, 0, 0, 600, 16);
 		XSetForeground(disp, gc, 0xFFFFFFFF);
 		XDrawString(disp, buf, gc, 0, 14, info, strlen(info));
 		XFreeGC(disp, gc);
 
 		if (milliseconds > 0) {
 			fprintf(stderr, "%s  (loaded %d files, %d pixmaps)\n",
 				info, this_redraw_cycle_loaded_files,
 				this_redraw_cycle_loaded_pixmaps);
 		}
 	}
 
 	// Check the limits in case we have used too much ram for placements.
 	gr_check_limits();
 }
 
 // Add an image rectangle to the list of rectangles to draw.
 void gr_append_imagerect(Drawable buf, uint32_t image_id, uint32_t placement_id,
 			 int img_start_col, int img_end_col, int img_start_row,
 			 int img_end_row, int x_col, int y_row, int x_pix,
 			 int y_pix, int cw, int ch, int reverse) {
 	current_cw = cw;
 	current_ch = ch;
 
 	ImageRect new_rect;
 	new_rect.image_id = image_id;
 	new_rect.placement_id = placement_id;
 	new_rect.img_start_col = img_start_col;
 	new_rect.img_end_col = img_end_col;
 	new_rect.img_start_row = img_start_row;
 	new_rect.img_end_row = img_end_row;
 	new_rect.screen_y_row = y_row;
 	new_rect.screen_x_pix = x_pix;
 	new_rect.screen_y_pix = y_pix;
 	new_rect.ch = ch;
 	new_rect.cw = cw;
 	new_rect.reverse = reverse;
 
 	// Display some red text in debug mode.
 	if (graphics_debug_mode == GRAPHICS_DEBUG_LOG_AND_BOXES)
 		gr_displayinfo(buf, &new_rect, 0xFF000000, 0xFFFF0000, "? ");
 
 	// If it's the empty image (image_id=0) or an empty rectangle, do
 	// nothing.
 	if (image_id == 0 || img_end_col - img_start_col <= 0 ||
 	    img_end_row - img_start_row <= 0)
 		return;
 	// Try to find a rect to merge with.
 	ImageRect *free_rect = NULL;
 	for (size_t i = 0; i < MAX_IMAGE_RECTS; ++i) {
 		ImageRect *rect = &image_rects[i];
 		if (rect->image_id == 0) {
 			if (!free_rect)
 				free_rect = rect;
 			continue;
 		}
 		if (rect->image_id != image_id ||
 		    rect->placement_id != placement_id || rect->cw != cw ||
 		    rect->ch != ch || rect->reverse != reverse)
 			continue;
 		// We only support the case when the new stripe is added to the
 		// bottom of an existing rectangle and they are perfectly
 		// aligned.
 		if (rect->img_end_row == img_start_row &&
 		    gr_getrectbottom(rect) == y_pix) {
 			if (rect->img_start_col == img_start_col &&
 			    rect->img_end_col == img_end_col &&
 			    rect->screen_x_pix == x_pix) {
 				rect->img_end_row = img_end_row;
 				return;
 			}
 		}
 	}
 	// If we haven't merged the new rect with any existing rect, and there
 	// is no free rect, we have to render one of the existing rects.
 	if (!free_rect) {
 		for (size_t i = 0; i < MAX_IMAGE_RECTS; ++i) {
 			ImageRect *rect = &image_rects[i];
 			if (!free_rect || gr_getrectbottom(free_rect) >
 						  gr_getrectbottom(rect))
 				free_rect = rect;
 		}
 		gr_drawimagerect(buf, free_rect);
 		gr_freerect(free_rect);
 	}
 	// Start a new rectangle in `free_rect`.
 	*free_rect = new_rect;
 }
 
 /// Mark rows containing animations as dirty if it's time to redraw them. Must
 /// be called right after `gr_start_drawing`.
 void gr_mark_dirty_animations(int *dirty, int rows) {
 	if (rows < kv_size(next_redraw_times))
 		kv_size(next_redraw_times) = rows;
 	if (rows * 2 < kv_max(next_redraw_times))
 		kv_resize(Milliseconds, next_redraw_times, rows);
 	for (int i = 0; i < MIN(rows, kv_size(next_redraw_times)); ++i) {
 		if (dirty[i]) {
 			kv_A(next_redraw_times, i) = 0;
 			continue;
 		}
 		Milliseconds next_update = kv_A(next_redraw_times, i);
 		if (next_update > 0 && next_update <= drawing_start_time) {
 			dirty[i] = 1;
 			kv_A(next_redraw_times, i) = 0;
 		}
 	}
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Command parsing and handling.
 ////////////////////////////////////////////////////////////////////////////////
 
 /// A parsed kitty graphics protocol command.
 typedef struct {
 	/// The command itself, without the 'G'.
 	char *command;
 	/// The payload (after ';').
 	char *payload;
 	/// 'a=', may be 't', 'q', 'f', 'T', 'p', 'd', 'a'.
 	char action;
 	/// 'q=', 1 to suppress OK response, 2 to suppress errors too.
 	int quiet;
 	/// 'f=', use 24 or 32 for raw pixel data, 100 to autodetect with
 	/// imlib2. If 'f=0', will try to load with imlib2, then fallback to
 	/// 32-bit pixel data.
 	int format;
 	/// 'o=', may be 'z' for RFC 1950 ZLIB.
 	int compression;
 	/// 't=', may be 'f', 't' or 'd'.
 	char transmission_medium;
 	/// 'd='
 	char delete_specifier;
 	/// 's=', 'v=', if 'a=t' or 'a=T', used only when 'f=24' or 'f=32'.
 	/// When 'a=f', this is the size of the frame rectangle when composed on
 	/// top of another frame.
 	int frame_pix_width, frame_pix_height;
 	/// 'x=', 'y=' - top-left corner of the source rectangle.
 	int src_pix_x, src_pix_y;
 	/// 'w=', 'h=' - width and height of the source rectangle.
 	int src_pix_width, src_pix_height;
 	/// 'r=', 'c='
 	int rows, columns;
 	/// 'i='
 	uint32_t image_id;
 	/// 'I='
 	uint32_t image_number;
 	/// 'p='
 	uint32_t placement_id;
 	/// 'm=', may be 0 or 1.
 	int more;
 	/// True if either 'm=0' or 'm=1' is specified.
 	char is_data_transmission;
 	/// True if turns out that this command is a continuation of a data
 	/// transmission and not the first one for this image. Populated by
 	/// `gr_handle_transmit_command`.
 	char is_direct_transmission_continuation;
 	/// 'S=', used to check the size of uploaded data.
 	int size;
 	/// 'U=', whether it's a virtual placement for Unicode placeholders.
 	int virtual;
 	/// 'C=', if true, do not move the cursor when displaying this placement
 	/// (non-virtual placements only).
 	char do_not_move_cursor;
 	// ---------------------------------------------------------------------
 	// Animation-related fields. Their keys often overlap with keys of other
 	// commands, so these make sense only if the action is 'a=f' (frame
 	// transmission) or 'a=a' (animation control).
 	//
 	// 'x=' and 'y=', the relative position of the frame image when it's
 	// composed on top of another frame.
 	int frame_dst_pix_x, frame_dst_pix_y;
 	/// 'X=', 'X=1' to replace colors instead of alpha blending on top of
 	/// the background color or frame.
 	char replace_instead_of_blending;
 	/// 'Y=', the background color in the 0xRRGGBBAA format (still
 	/// transmitted as a decimal number).
 	uint32_t background_color;
 	/// (Only for 'a=f'). 'c=', the 1-based index of the background frame.
 	int background_frame;
 	/// (Only for 'a=a'). 'c=', sets the index of the current frame.
 	int current_frame;
 	/// 'r=', the 1-based index of the frame to edit.
 	int edit_frame;
 	/// 'z=', the duration of the frame. Zero if not specified, negative if
 	/// the frame is gapless (i.e. skipped).
 	int gap;
 	/// (Only for 'a=a'). 's=', if non-zero, sets the state of the
 	/// animation, 1 to stop, 2 to run in loading mode, 3 to loop.
 	int animation_state;
 	/// (Only for 'a=a'). 'v=', if non-zero, sets the number of times the
 	/// animation will loop. 1 to loop infinitely, N to loop N-1 times.
 	int loops;
 } GraphicsCommand;
 
 /// Replaces all non-printed characters in `str` with '?' and truncates the
 /// string to `max_size`, maybe inserting ellipsis at the end.
 static void sanitize_str(char *str, size_t max_size) {
 	assert(max_size >= 4);
 	for (size_t i = 0; i < max_size; ++i) {
 		unsigned c = str[i];
 		if (c == '\0')
 			return;
 		if (c >= 128 || !isprint(c))
 			str[i] = '?';
 	}
 	str[max_size - 1] = '\0';
 	str[max_size - 2] = '.';
 	str[max_size - 3] = '.';
 	str[max_size - 4] = '.';
 }
 
 /// A non-destructive version of `sanitize_str`. Uses a static buffer, so be
 /// careful.
 static const char *sanitized_filename(const char *str) {
 	static char buf[MAX_FILENAME_SIZE];
 	strncpy(buf, str, sizeof(buf));
 	sanitize_str(buf, sizeof(buf));
 	return buf;
 }
 
 /// Creates a response to the current command in `graphics_command_result`.
 static void gr_createresponse(uint32_t image_id, uint32_t image_number,
 			      uint32_t placement_id, const char *msg) {
 	if (!image_id && !image_number && !placement_id) {
 		// Nobody expects the response in this case, so just print it to
 		// stderr.
 		fprintf(stderr,
 			"error: No image id or image number or placement_id, "
 			"but still there is a response: %s\n",
 			msg);
 		return;
 	}
 	char *buf = graphics_command_result.response;
 	size_t maxlen = MAX_GRAPHICS_RESPONSE_LEN;
 	size_t written;
 	written = snprintf(buf, maxlen, "\033_G");
 	buf += written;
 	maxlen -= written;
 	if (image_id) {
 		written = snprintf(buf, maxlen, "i=%u,", image_id);
 		buf += written;
 		maxlen -= written;
 	}
 	if (image_number) {
 		written = snprintf(buf, maxlen, "I=%u,", image_number);
 		buf += written;
 		maxlen -= written;
 	}
 	if (placement_id) {
 		written = snprintf(buf, maxlen, "p=%u,", placement_id);
 		buf += written;
 		maxlen -= written;
 	}
 	buf[-1] = ';';
 	written = snprintf(buf, maxlen, "%s\033\\", msg);
 	buf += written;
 	maxlen -= written;
 	buf[-2] = '\033';
 	buf[-1] = '\\';
 }
 
 /// Creates the 'OK' response to the current command, unless suppressed or a
 /// non-final data transmission.
 static void gr_reportsuccess_cmd(GraphicsCommand *cmd) {
 	if (cmd->quiet < 1 && !cmd->more)
 		gr_createresponse(cmd->image_id, cmd->image_number,
 				  cmd->placement_id, "OK");
 }
 
 /// Creates the 'OK' response to the current command (unless suppressed).
 static void gr_reportsuccess_frame(ImageFrame *frame) {
 	uint32_t id = frame->image->query_id ? frame->image->query_id
 					     : frame->image->image_id;
 	if (frame->quiet < 1)
 		gr_createresponse(id, frame->image->image_number,
 				  frame->image->initial_placement_id, "OK");
 }
 
 /// Creates an error response to the current command (unless suppressed).
 static void gr_reporterror_cmd(GraphicsCommand *cmd, const char *format, ...) {
 	char errmsg[MAX_GRAPHICS_RESPONSE_LEN];
 	graphics_command_result.error = 1;
 	va_list args;
 	va_start(args, format);
 	vsnprintf(errmsg, MAX_GRAPHICS_RESPONSE_LEN, format, args);
 	va_end(args);
 
 	fprintf(stderr, "%s  in command: %s\n", errmsg, cmd->command);
 	if (cmd->quiet < 2)
 		gr_createresponse(cmd->image_id, cmd->image_number,
 				  cmd->placement_id, errmsg);
 }
 
 /// Creates an error response to the current command (unless suppressed).
 static void gr_reporterror_frame(ImageFrame *frame, const char *format, ...) {
 	char errmsg[MAX_GRAPHICS_RESPONSE_LEN];
 	graphics_command_result.error = 1;
 	va_list args;
 	va_start(args, format);
 	vsnprintf(errmsg, MAX_GRAPHICS_RESPONSE_LEN, format, args);
 	va_end(args);
 
 	if (!frame) {
 		fprintf(stderr, "%s\n", errmsg);
 		gr_createresponse(0, 0, 0, errmsg);
 	} else {
 		uint32_t id = frame->image->query_id ? frame->image->query_id
 						     : frame->image->image_id;
 		fprintf(stderr, "%s  id=%u\n", errmsg, id);
 		if (frame->quiet < 2)
 			gr_createresponse(id, frame->image->image_number,
 					  frame->image->initial_placement_id,
 					  errmsg);
 	}
 }
 
 /// Loads an image and creates a success/failure response. Returns `frame`, or
 /// NULL if it's a query action and the image was deleted.
 static ImageFrame *gr_loadimage_and_report(ImageFrame *frame) {
 	gr_load_imlib_object(frame);
 	if (!frame->imlib_object) {
 		gr_reporterror_frame(frame, "EBADF: could not load image");
 	} else {
 		gr_reportsuccess_frame(frame);
 	}
 	// If it was a query action, discard the image.
 	if (frame->image->query_id) {
 		gr_delete_image(frame->image);
 		return NULL;
 	}
 	return frame;
 }
 
 /// Creates an appropriate uploading failure response to the current command.
 static void gr_reportuploaderror(ImageFrame *frame) {
 	switch (frame->uploading_failure) {
 	case 0:
 		return;
 	case ERROR_CANNOT_OPEN_CACHED_FILE:
 		gr_reporterror_frame(frame,
 				   "EIO: could not create a file for image");
 		break;
 	case ERROR_OVER_SIZE_LIMIT:
 		gr_reporterror_frame(
 			frame,
 			"EFBIG: the size of the uploaded image exceeded "
 			"the image size limit %u",
 			graphics_max_single_image_file_size);
 		break;
 	case ERROR_UNEXPECTED_SIZE:
 		gr_reporterror_frame(frame,
 				   "EINVAL: the size of the uploaded image %u "
 				   "doesn't match the expected size %u",
 				   frame->disk_size, frame->expected_size);
 		break;
 	};
 }
 
 /// Displays a non-virtual placement. This functions records the information in
 /// `graphics_command_result`, the placeholder itself is created by the terminal
 /// after handling the current command in the graphics module.
 static void gr_display_nonvirtual_placement(ImagePlacement *placement) {
 	if (placement->virtual)
 		return;
 	if (placement->image->first_frame.status < STATUS_RAM_LOADING_SUCCESS)
 		return;
 	// Infer the placement size if needed.
 	gr_infer_placement_size_maybe(placement);
 	// Populate the information about the placeholder which will be created
 	// by the terminal.
 	graphics_command_result.create_placeholder = 1;
 	graphics_command_result.placeholder.image_id = placement->image->image_id;
 	graphics_command_result.placeholder.placement_id = placement->placement_id;
 	graphics_command_result.placeholder.columns = placement->cols;
 	graphics_command_result.placeholder.rows = placement->rows;
 	graphics_command_result.placeholder.do_not_move_cursor =
 		placement->do_not_move_cursor;
 	GR_LOG("Creating a placeholder for %u/%u  %d x %d\n",
 	       placement->image->image_id, placement->placement_id,
 	       placement->cols, placement->rows);
 }
 
 /// Marks the rows that are occupied by the image as dirty.
 static void gr_schedule_image_redraw(Image *img) {
 	if (!img)
 		return;
 	gr_schedule_image_redraw_by_id(img->image_id);
 }
 
 /// Appends data from `payload` to the frame `frame` when using direct
 /// transmission. Note that we report errors only for the final command
 /// (`!more`) to avoid spamming the client. If the frame is not specified, use
 /// the image id and frame index we are currently uploading.
 static void gr_append_data(ImageFrame *frame, const char *payload, int more) {
 	if (!frame) {
 		Image *img = gr_find_image(current_upload_image_id);
 		frame = gr_get_frame(img, current_upload_frame_index);
 		GR_LOG("Appending data to image %u frame %d\n",
 		       current_upload_image_id, current_upload_frame_index);
 		if (!img)
 			GR_LOG("ERROR: this image doesn't exist\n");
 		if (!frame)
 			GR_LOG("ERROR: this frame doesn't exist\n");
 	}
 	if (!more) {
 		current_upload_image_id = 0;
 		current_upload_frame_index = 0;
 	}
 	if (!frame) {
 		if (!more)
 			gr_reporterror_frame(NULL, "ENOENT: could not find the "
 						   "image to append data to");
 		return;
 	}
 	if (frame->status != STATUS_UPLOADING) {
 		if (!more)
 			gr_reportuploaderror(frame);
 		return;
 	}
 
 	// Decode the data.
 	size_t data_size = 0;
 	char *data = gr_base64dec(payload, &data_size);
 
 	GR_LOG("appending %u + %zu = %zu bytes\n", frame->disk_size, data_size,
 	       frame->disk_size + data_size);
 
 	// Do not append this data if the image exceeds the size limit.
 	if (frame->disk_size + data_size >
 		    graphics_max_single_image_file_size ||
 	    frame->expected_size > graphics_max_single_image_file_size) {
 		free(data);
 		gr_delete_imagefile(frame);
 		frame->uploading_failure = ERROR_OVER_SIZE_LIMIT;
 		if (!more)
 			gr_reportuploaderror(frame);
 		return;
 	}
 
 	// If there is no open file corresponding to the image, create it.
 	if (!frame->open_file) {
 		gr_make_sure_tmpdir_exists();
 		char filename[MAX_FILENAME_SIZE];
 		gr_get_frame_filename(frame, filename, MAX_FILENAME_SIZE);
 		FILE *file = fopen(filename, frame->disk_size ? "a" : "w");
 		if (!file) {
 			frame->status = STATUS_UPLOADING_ERROR;
 			frame->uploading_failure = ERROR_CANNOT_OPEN_CACHED_FILE;
 			if (!more)
 				gr_reportuploaderror(frame);
 			return;
 		}
 		frame->open_file = file;
 	}
 
 	// Write data to the file and update disk size variables.
 	fwrite(data, 1, data_size, frame->open_file);
 	free(data);
 	frame->disk_size += data_size;
 	frame->image->total_disk_size += data_size;
 	images_disk_size += data_size;
 	gr_touch_frame(frame);
 
 	if (more) {
 		current_upload_image_id = frame->image->image_id;
 		current_upload_frame_index = frame->index;
 	} else {
 		current_upload_image_id = 0;
 		current_upload_frame_index = 0;
 		// Close the file.
 		if (frame->open_file) {
 			fclose(frame->open_file);
 			frame->open_file = NULL;
 		}
 		frame->status = STATUS_UPLOADING_SUCCESS;
 		uint32_t placement_id = frame->image->default_placement;
 		if (frame->expected_size &&
 		    frame->expected_size != frame->disk_size) {
 			// Report failure if the uploaded image size doesn't
 			// match the expected size.
 			frame->status = STATUS_UPLOADING_ERROR;
 			frame->uploading_failure = ERROR_UNEXPECTED_SIZE;
 			gr_reportuploaderror(frame);
 		} else {
 			// Make sure to redraw all existing image instances.
 			gr_schedule_image_redraw(frame->image);
 			// Try to load the image into ram and report the result.
 			frame = gr_loadimage_and_report(frame);
 			// If there is a non-virtual image placement, we may
 			// need to display it.
 			if (frame && frame->index == 1) {
 				Image *img = frame->image;
 				ImagePlacement *placement = NULL;
 				kh_foreach_value(img->placements, placement, {
 					gr_display_nonvirtual_placement(placement);
 				});
 			}
 		}
 	}
 
 	// Check whether we need to delete old images.
 	gr_check_limits();
 }
 
 /// Finds the image either by id or by number specified in the command and sets
 /// the image_id of `cmd` if the image was found.
 static Image *gr_find_image_for_command(GraphicsCommand *cmd) {
 	if (cmd->image_id)
 		return gr_find_image(cmd->image_id);
 	Image *img = NULL;
 	// If the image number is not specified, we can't find the image, unless
 	// it's a put command, in which case we will try the last image.
 	if (cmd->image_number == 0 && cmd->action == 'p')
 		img = gr_find_image(last_image_id);
 	else
 		img = gr_find_image_by_number(cmd->image_number);
 	if (img)
 		cmd->image_id = img->image_id;
 	return img;
 }
 
 /// Creates a new image or a new frame in an existing image (depending on the
 /// command's action) and initializes its parameters from the command.
 static ImageFrame *gr_new_image_or_frame_from_command(GraphicsCommand *cmd) {
 	if (cmd->format != 0 && cmd->format != 32 && cmd->format != 24 &&
 	    cmd->compression != 0) {
 		gr_reporterror_cmd(cmd, "EINVAL: compression is supported only "
 					"for raw pixel data (f=32 or f=24)");
 		// Even though we report an error, we still create an image.
 	}
 
 	Image *img = NULL;
 	if (cmd->action == 'f') {
 		// If it's a frame transmission action, there must be an
 		// existing image.
 		img = gr_find_image_for_command(cmd);
 		if (!img) {
 			gr_reporterror_cmd(cmd, "ENOENT: image not found");
 			return NULL;
 		}
 	} else {
 		// Otherwise create a new image object. If the action is `q`,
 		// we'll use random id instead of the one specified in the
 		// command.
 		uint32_t image_id = cmd->action == 'q' ? 0 : cmd->image_id;
 		img = gr_new_image(image_id);
 		if (!img)
 			return NULL;
 		if (cmd->action == 'q')
 			img->query_id = cmd->image_id;
 		else if (!cmd->image_id)
 			cmd->image_id = img->image_id;
 		// Set the image number.
 		img->image_number = cmd->image_number;
 	}
 
 	ImageFrame *frame = gr_append_new_frame(img);
 	// Initialize the frame.
 	frame->expected_size = cmd->size;
 	frame->format = cmd->format;
 	frame->compression = cmd->compression;
 	frame->background_color = cmd->background_color;
 	frame->background_frame_index = cmd->background_frame;
 	frame->gap = cmd->gap;
 	img->total_duration += frame->gap;
 	frame->blend = !cmd->replace_instead_of_blending;
 	frame->data_pix_width = cmd->frame_pix_width;
 	frame->data_pix_height = cmd->frame_pix_height;
 	if (cmd->action == 'f') {
 		frame->x = cmd->frame_dst_pix_x;
 		frame->y = cmd->frame_dst_pix_y;
 	}
 	// We save the quietness information in the frame because for direct
 	// transmission subsequent transmission command won't contain this info.
 	frame->quiet = cmd->quiet;
 	return frame;
 }
 
 /// Removes a file if it actually looks like a temporary file.
 static void gr_delete_tmp_file(const char *filename) {
 	if (strstr(filename, "tty-graphics-protocol") == NULL)
 		return;
 	if (strstr(filename, "/tmp/") != filename) {
 		const char *tmpdir = getenv("TMPDIR");
 		if (!tmpdir || !tmpdir[0] ||
 		    strstr(filename, tmpdir) != filename)
 			return;
 	}
 	unlink(filename);
 }
 
 /// Handles a data transmission command.
 static ImageFrame *gr_handle_transmit_command(GraphicsCommand *cmd) {
 	// The default is direct transmission.
 	if (!cmd->transmission_medium)
 		cmd->transmission_medium = 'd';
 
 	// If neither id, nor image number is specified, and the transmission
 	// medium is 'd' (or unspecified), and there is an active direct upload,
 	// this is a continuation of the upload.
 	if (current_upload_image_id != 0 && cmd->image_id == 0 &&
 	    cmd->image_number == 0 && cmd->transmission_medium == 'd') {
 		cmd->image_id = current_upload_image_id;
 		GR_LOG("No images id is specified, continuing uploading %u\n",
 		       cmd->image_id);
 	}
 
 	ImageFrame *frame = NULL;
 	if (cmd->transmission_medium == 'f' ||
 	    cmd->transmission_medium == 't') {
 		// File transmission.
 		// Create a new image or a new frame of an existing image.
 		frame = gr_new_image_or_frame_from_command(cmd);
 		if (!frame)
 			return NULL;
 		last_image_id = frame->image->image_id;
 		// Decode the filename.
 		char *original_filename = gr_base64dec(cmd->payload, NULL);
 		GR_LOG("Copying image %s\n",
 		       sanitized_filename(original_filename));
 		// Stat the file and check that it's a regular file and not too
 		// big.
 		struct stat st;
 		int stat_res = stat(original_filename, &st);
 		const char *stat_error = NULL;
 		if (stat_res)
 			stat_error = strerror(errno);
 		else if (!S_ISREG(st.st_mode))
 			stat_error = "Not a regular file";
 		else if (st.st_size == 0)
 			stat_error = "The size of the file is zero";
 		else if (st.st_size > graphics_max_single_image_file_size)
 			stat_error = "The file is too large";
 		if (stat_error) {
 			gr_reporterror_cmd(cmd,
 					   "EBADF: %s", stat_error);
 			fprintf(stderr, "Could not load the file %s\n",
 				sanitized_filename(original_filename));
 			frame->status = STATUS_UPLOADING_ERROR;
 			frame->uploading_failure = ERROR_CANNOT_COPY_FILE;
 		} else {
 			gr_make_sure_tmpdir_exists();
 			// Build the filename for the cached copy of the file.
 			char cache_filename[MAX_FILENAME_SIZE];
 			gr_get_frame_filename(frame, cache_filename,
 					      MAX_FILENAME_SIZE);
 			// We will create a symlink to the original file, and
 			// then copy the file to the temporary cache dir. We do
 			// this symlink trick mostly to be able to use cp for
 			// copying, and avoid escaping file name characters when
 			// calling system at the same time.
 			char tmp_filename_symlink[MAX_FILENAME_SIZE + 4] = {0};
 			strcat(tmp_filename_symlink, cache_filename);
 			strcat(tmp_filename_symlink, ".sym");
 			char command[MAX_FILENAME_SIZE + 256];
 			size_t len =
 				snprintf(command, MAX_FILENAME_SIZE + 255,
 					 "cp '%s' '%s'", tmp_filename_symlink,
 					 cache_filename);
 			if (len > MAX_FILENAME_SIZE + 255 ||
 			    symlink(original_filename, tmp_filename_symlink) ||
 			    system(command) != 0) {
 				gr_reporterror_cmd(cmd,
 						   "EBADF: could not copy the "
 						   "image to the cache dir");
 				fprintf(stderr,
 					"Could not copy the image "
 					"%s (symlink %s) to %s",
 					sanitized_filename(original_filename),
 					tmp_filename_symlink, cache_filename);
 				frame->status = STATUS_UPLOADING_ERROR;
 				frame->uploading_failure = ERROR_CANNOT_COPY_FILE;
 			} else {
 				// Get the file size of the copied file.
 				frame->status = STATUS_UPLOADING_SUCCESS;
 				frame->disk_size = st.st_size;
 				frame->image->total_disk_size += st.st_size;
 				images_disk_size += frame->disk_size;
 				if (frame->expected_size &&
 				    frame->expected_size != frame->disk_size) {
 					// The file has unexpected size.
 					frame->status = STATUS_UPLOADING_ERROR;
 					frame->uploading_failure =
 						ERROR_UNEXPECTED_SIZE;
 					gr_reportuploaderror(frame);
 				} else {
 					// Everything seems fine, try to load
 					// and redraw existing instances.
 					gr_schedule_image_redraw(frame->image);
 					frame = gr_loadimage_and_report(frame);
 				}
 			}
 			// Delete the symlink.
 			unlink(tmp_filename_symlink);
 			// Delete the original file if it's temporary.
 			if (cmd->transmission_medium == 't')
 				gr_delete_tmp_file(original_filename);
 		}
 		free(original_filename);
 		gr_check_limits();
 	} else if (cmd->transmission_medium == 'd') {
 		// Direct transmission (default if 't' is not specified).
 		frame = gr_get_last_frame(gr_find_image_for_command(cmd));
 		if (frame && frame->status == STATUS_UPLOADING) {
 			// This is a continuation of the previous transmission.
 			cmd->is_direct_transmission_continuation = 1;
 			gr_append_data(frame, cmd->payload, cmd->more);
 			return frame;
 		}
 		// If no action is specified, it's not the first transmission
 		// command. If we couldn't find the image, something went wrong
 		// and we should just drop this command.
 		if (cmd->action == 0)
 			return NULL;
 		// Otherwise create a new image or frame structure.
 		frame = gr_new_image_or_frame_from_command(cmd);
 		if (!frame)
 			return NULL;
 		last_image_id = frame->image->image_id;
 		frame->status = STATUS_UPLOADING;
 		// Start appending data.
 		gr_append_data(frame, cmd->payload, cmd->more);
 	} else {
 		gr_reporterror_cmd(
 			cmd,
 			"EINVAL: transmission medium '%c' is not supported",
 			cmd->transmission_medium);
 		return NULL;
 	}
 
 	return frame;
 }
 
 /// Handles the 'put' command by creating a placement.
 static void gr_handle_put_command(GraphicsCommand *cmd) {
 	if (cmd->image_id == 0 && cmd->image_number == 0) {
 		gr_reporterror_cmd(cmd,
 				   "EINVAL: neither image id nor image number "
 				   "are specified or both are zero");
 		return;
 	}
 
 	// Find the image with the id or number.
 	Image *img = gr_find_image_for_command(cmd);
 	if (!img) {
 		gr_reporterror_cmd(cmd, "ENOENT: image not found");
 		return;
 	}
 
 	// Create a placement. If a placement with the same id already exists,
 	// it will be deleted. If the id is zero, a random id will be generated.
 	ImagePlacement *placement = gr_new_placement(img, cmd->placement_id);
 	placement->virtual = cmd->virtual;
 	placement->src_pix_x = cmd->src_pix_x;
 	placement->src_pix_y = cmd->src_pix_y;
 	placement->src_pix_width = cmd->src_pix_width;
 	placement->src_pix_height = cmd->src_pix_height;
 	placement->cols = cmd->columns;
 	placement->rows = cmd->rows;
 	placement->do_not_move_cursor = cmd->do_not_move_cursor;
 
 	if (placement->virtual) {
 		placement->scale_mode = SCALE_MODE_CONTAIN;
 	} else if (placement->cols && placement->rows) {
 		// For classic placements the default is to stretch the image if
 		// both cols and rows are specified.
 		placement->scale_mode = SCALE_MODE_FILL;
 	} else if (placement->cols || placement->rows) {
 		// But if only one of them is specified, the default is to
 		// contain.
 		placement->scale_mode = SCALE_MODE_CONTAIN;
 	} else {
 		// If none of them are specified, the default is to use the
 		// original size.
 		placement->scale_mode = SCALE_MODE_NONE;
 	}
 
 	// Display the placement unless it's virtual.
 	gr_display_nonvirtual_placement(placement);
 
 	// Report success.
 	gr_reportsuccess_cmd(cmd);
 }
 
 /// Information about what to delete.
 typedef struct DeletionData {
 	uint32_t image_id;
 	uint32_t placement_id;
 	/// If true, delete the image object if there are no more placements.
 	char delete_image_if_no_ref;
 } DeletionData;
 
 /// The callback called for each cell to perform deletion.
 static int gr_deletion_callback(void *data, uint32_t image_id,
 					    uint32_t placement_id, int col,
 					    int row, char is_classic) {
 	DeletionData *del_data = data;
 	// Leave unicode placeholders alone.
 	if (!is_classic)
 		return 0;
 	if (del_data->image_id && del_data->image_id != image_id)
 		return 0;
 	if (del_data->placement_id && del_data->placement_id != placement_id)
 		return 0;
 	Image *img = gr_find_image(image_id);
 	// If the image is already deleted, just erase the placeholder.
 	if (!img)
 		return 1;
 	// Delete the placement.
 	if (placement_id)
 		gr_delete_placement(gr_find_placement(img, placement_id));
 	// Delete the image if image deletion is requested (uppercase delete
 	// specifier) and there are no more placements.
 	if (del_data->delete_image_if_no_ref && kh_size(img->placements) == 0)
 		gr_delete_image(img);
 	return 1;
 }
 
 /// Handles the delete command.
 static void gr_handle_delete_command(GraphicsCommand *cmd) {
 	DeletionData del_data = {0};
 	del_data.delete_image_if_no_ref = isupper(cmd->delete_specifier) != 0;
 	char d = tolower(cmd->delete_specifier);
 
 	if (d == 'n') {
 		d = 'i';
 		Image *img = gr_find_image_by_number(cmd->image_number);
 		if (!img)
 			return;
 		del_data.image_id = img->image_id;
 	}
 
 	if (!d || d == 'a') {
 		// Delete all visible placements.
 		gr_for_each_image_cell(gr_deletion_callback, &del_data);
 	} else if (d == 'i') {
 		// Delete the specified image by image id and maybe placement
 		// id.
 		if (!del_data.image_id)
 			del_data.image_id = cmd->image_id;
 		if (!del_data.image_id) {
 			fprintf(stderr,
 				"ERROR: image id is not specified in the "
 				"delete command\n");
 			return;
 		}
 		del_data.placement_id = cmd->placement_id;
 		// NOTE: It's not very clear whether we should delete the image
 		// even if there are no _visible_ placements to delete. We do
 		// this because otherwise there is no way to delete an image
 		// with virtual placements in one command.
 		if (!del_data.placement_id && del_data.delete_image_if_no_ref)
 			gr_delete_image(gr_find_image(cmd->image_id));
 		gr_for_each_image_cell(gr_deletion_callback, &del_data);
 	} else {
 		fprintf(stderr,
 			"WARNING: unsupported value of the d key: '%c'. The "
 			"command is ignored.\n",
 			cmd->delete_specifier);
 	}
 }
 
 static void gr_handle_animation_control_command(GraphicsCommand *cmd) {
 	if (cmd->image_id == 0 && cmd->image_number == 0) {
 		gr_reporterror_cmd(cmd,
 				   "EINVAL: neither image id nor image number "
 				   "are specified or both are zero");
 		return;
 	}
 
 	// Find the image with the id or number.
 	Image *img = gr_find_image_for_command(cmd);
 	if (!img) {
 		gr_reporterror_cmd(cmd, "ENOENT: image not found");
 		return;
 	}
 
 	// Find the frame to edit, if requested.
 	ImageFrame *frame = NULL;
 	if (cmd->edit_frame)
 		frame = gr_get_frame(img, cmd->edit_frame);
 	if (cmd->edit_frame || cmd->gap) {
 		if (!frame) {
 			gr_reporterror_cmd(cmd, "ENOENT: frame %d not found",
 					   cmd->edit_frame);
 			return;
 		}
 		if (cmd->gap) {
 			img->total_duration -= frame->gap;
 			frame->gap = cmd->gap;
 			img->total_duration += frame->gap;
 		}
 	}
 
 	// Set animation-related parameters of the image.
 	if (cmd->current_frame)
 		img->current_frame = cmd->current_frame;
 	if (cmd->animation_state) {
 		if (cmd->animation_state == 1) {
 			img->animation_state = ANIMATION_STATE_STOPPED;
 		} else if (cmd->animation_state == 2) {
 			img->animation_state = ANIMATION_STATE_LOADING;
 		} else if (cmd->animation_state == 3) {
 			img->animation_state = ANIMATION_STATE_LOOPING;
 		} else {
 			gr_reporterror_cmd(
 				cmd, "EINVAL: invalid animation state: %d",
 				cmd->animation_state);
 		}
 	}
 	// TODO: Set the number of loops to cmd->loops
 
 	// Make sure we redraw all instances of the image.
 	gr_schedule_image_redraw(img);
 }
 
 /// Handles a command.
 static void gr_handle_command(GraphicsCommand *cmd) {
 	if (!cmd->image_id && !cmd->image_number) {
 		// If there is no image id or image number, nobody expects a
 		// response, so set quiet to 2.
 		cmd->quiet = 2;
 	}
 	ImageFrame *frame = NULL;
 	switch (cmd->action) {
 	case 0:
 		// If no action is specified, it may be a data transmission
 		// command if 'm=' is specified.
 		if (cmd->is_data_transmission) {
 			gr_handle_transmit_command(cmd);
 			break;
 		}
 		gr_reporterror_cmd(cmd, "EINVAL: no action specified");
 		break;
 	case 't':
 	case 'q':
 	case 'f':
 		// Transmit data. 'q' means query, which is basically the same
 		// as transmit, but the image is discarded, and the id is fake.
 		// 'f' appends a frame to an existing image.
 		gr_handle_transmit_command(cmd);
 		break;
 	case 'p':
 		// Display (put) the image.
 		gr_handle_put_command(cmd);
 		break;
 	case 'T':
 		// Transmit and display.
 		frame = gr_handle_transmit_command(cmd);
 		if (frame && !cmd->is_direct_transmission_continuation) {
 			gr_handle_put_command(cmd);
 			if (cmd->placement_id)
 				frame->image->initial_placement_id =
 					cmd->placement_id;
 		}
 		break;
 	case 'd':
 		gr_handle_delete_command(cmd);
 		break;
 	case 'a':
 		gr_handle_animation_control_command(cmd);
 		break;
 	default:
 		gr_reporterror_cmd(cmd, "EINVAL: unsupported action: %c",
 				   cmd->action);
 		return;
 	}
 }
 
 /// A partially parsed key-value pair.
 typedef struct KeyAndValue {
 	char *key_start;
 	char *val_start;
 	unsigned key_len, val_len;
 } KeyAndValue;
 
 /// Parses the value of a key and assigns it to the appropriate field of `cmd`.
 static void gr_set_keyvalue(GraphicsCommand *cmd, KeyAndValue *kv) {
 	char *key_start = kv->key_start;
 	char *key_end = key_start + kv->key_len;
 	char *value_start = kv->val_start;
 	char *value_end = value_start + kv->val_len;
 	// Currently all keys are one-character.
 	if (key_end - key_start != 1) {
 		gr_reporterror_cmd(cmd, "EINVAL: unknown key of length %ld: %s",
 				   key_end - key_start, key_start);
 		return;
 	}
 	long num = 0;
 	if (*key_start == 'a' || *key_start == 't' || *key_start == 'd' ||
 	    *key_start == 'o') {
 		// Some keys have one-character values.
 		if (value_end - value_start != 1) {
 			gr_reporterror_cmd(
 				cmd,
 				"EINVAL: value of 'a', 't' or 'd' must be a "
 				"single char: %s",
 				key_start);
 			return;
 		}
 	} else {
 		// All the other keys have integer values.
 		char *num_end = NULL;
 		num = strtol(value_start, &num_end, 10);
 		if (num_end != value_end) {
 			gr_reporterror_cmd(
 				cmd, "EINVAL: could not parse number value: %s",
 				key_start);
 			return;
 		}
 	}
 	switch (*key_start) {
 	case 'a':
 		cmd->action = *value_start;
 		break;
 	case 't':
 		cmd->transmission_medium = *value_start;
 		break;
 	case 'd':
 		cmd->delete_specifier = *value_start;
 		break;
 	case 'q':
 		cmd->quiet = num;
 		break;
 	case 'f':
 		cmd->format = num;
 		if (num != 0 && num != 24 && num != 32 && num != 100) {
 			gr_reporterror_cmd(
 				cmd,
 				"EINVAL: unsupported format specification: %s",
 				key_start);
 		}
 		break;
 	case 'o':
 		cmd->compression = *value_start;
 		if (cmd->compression != 'z') {
 			gr_reporterror_cmd(cmd,
 					   "EINVAL: unsupported compression "
 					   "specification: %s",
 					   key_start);
 		}
 		break;
 	case 's':
 		if (cmd->action == 'a')
 			cmd->animation_state = num;
 		else
 			cmd->frame_pix_width = num;
 		break;
 	case 'v':
 		if (cmd->action == 'a')
 			cmd->loops = num;
 		else
 			cmd->frame_pix_height = num;
 		break;
 	case 'i':
 		cmd->image_id = num;
 		break;
 	case 'I':
 		cmd->image_number = num;
 		break;
 	case 'p':
 		cmd->placement_id = num;
 		break;
 	case 'x':
 		cmd->src_pix_x = num;
 		cmd->frame_dst_pix_x = num;
 		break;
 	case 'y':
 		if (cmd->action == 'f')
 			cmd->frame_dst_pix_y = num;
 		else
 			cmd->src_pix_y = num;
 		break;
 	case 'w':
 		cmd->src_pix_width = num;
 		break;
 	case 'h':
 		cmd->src_pix_height = num;
 		break;
 	case 'c':
 		if (cmd->action == 'f')
 			cmd->background_frame = num;
 		else if (cmd->action == 'a')
 			cmd->current_frame = num;
 		else
 			cmd->columns = num;
 		break;
 	case 'r':
 		if (cmd->action == 'f' || cmd->action == 'a')
 			cmd->edit_frame = num;
 		else
 			cmd->rows = num;
 		break;
 	case 'm':
 		cmd->is_data_transmission = 1;
 		cmd->more = num;
 		break;
 	case 'S':
 		cmd->size = num;
 		break;
 	case 'U':
 		cmd->virtual = num;
 		break;
 	case 'X':
 		if (cmd->action == 'f')
 			cmd->replace_instead_of_blending = num;
 		else
 			break; /*ignore*/
 		break;
 	case 'Y':
 		if (cmd->action == 'f')
 			cmd->background_color = num;
 		else
 			break; /*ignore*/
 		break;
 	case 'z':
 		if (cmd->action == 'f' || cmd->action == 'a')
 			cmd->gap = num;
 		else
 			break; /*ignore*/
 		break;
 	case 'C':
 		cmd->do_not_move_cursor = num;
 		break;
 	default:
 		gr_reporterror_cmd(cmd, "EINVAL: unsupported key: %s",
 				   key_start);
 		return;
 	}
 }
 
 /// Parse and execute a graphics command. `buf` must start with 'G' and contain
 /// at least `len + 1` characters. Returns 1 on success.
 int gr_parse_command(char *buf, size_t len) {
 	if (buf[0] != 'G')
 		return 0;
 
 	memset(&graphics_command_result, 0, sizeof(GraphicsCommandResult));
 
 	global_command_counter++;
 	GR_LOG("### Command %lu: %.80s\n", global_command_counter, buf);
 
 	// Eat the 'G'.
 	++buf;
 	--len;
 
 	GraphicsCommand cmd = {.command = buf};
 	// The state of parsing. 'k' to parse key, 'v' to parse value, 'p' to
 	// parse the payload.
 	char state = 'k';
 	// An array of partially parsed key-value pairs.
 	KeyAndValue key_vals[32];
 	unsigned key_vals_count = 0;
 	char *key_start = buf;
 	char *key_end = NULL;
 	char *val_start = NULL;
 	char *val_end = NULL;
 	char *c = buf;
 	while (c - buf < len + 1) {
 		if (state == 'k') {
 			switch (*c) {
 			case ',':
 			case ';':
 			case '\0':
 				state = *c == ',' ? 'k' : 'p';
 				key_end = c;
 				gr_reporterror_cmd(
 					&cmd, "EINVAL: key without value: %s ",
 					key_start);
 				break;
 			case '=':
 				key_end = c;
 				state = 'v';
 				val_start = c + 1;
 				break;
 			default:
 				break;
 			}
 		} else if (state == 'v') {
 			switch (*c) {
 			case ',':
 			case ';':
 			case '\0':
 				state = *c == ',' ? 'k' : 'p';
 				val_end = c;
 				if (key_vals_count >=
 				    sizeof(key_vals) / sizeof(*key_vals)) {
 					gr_reporterror_cmd(&cmd,
 							   "EINVAL: too many "
 							   "key-value pairs");
 					break;
 				}
 				key_vals[key_vals_count].key_start = key_start;
 				key_vals[key_vals_count].val_start = val_start;
 				key_vals[key_vals_count].key_len =
 					key_end - key_start;
 				key_vals[key_vals_count].val_len =
 					val_end - val_start;
 				++key_vals_count;
 				key_start = c + 1;
 				break;
 			default:
 				break;
 			}
 		} else if (state == 'p') {
 			cmd.payload = c;
 			// break out of the loop, we don't check the payload
 			break;
 		}
 		++c;
 	}
 
 	// Set the action key ('a=') first because we need it to disambiguate
 	// some keys. Also set 'i=' and 'I=' for better error reporting.
 	for (unsigned i = 0; i < key_vals_count; ++i) {
 		if (key_vals[i].key_len == 1) {
 			char *start = key_vals[i].key_start;
 			if (*start == 'a' || *start == 'i' || *start == 'I') {
 				gr_set_keyvalue(&cmd, &key_vals[i]);
 				break;
 			}
 		}
 	}
 	// Set the rest of the keys.
 	for (unsigned i = 0; i < key_vals_count; ++i)
 		gr_set_keyvalue(&cmd, &key_vals[i]);
 
 	if (!cmd.payload)
 		cmd.payload = buf + len;
 
 	if (cmd.payload && cmd.payload[0])
 		GR_LOG("    payload size: %ld\n", strlen(cmd.payload));
 
 	if (!graphics_command_result.error)
 		gr_handle_command(&cmd);
 
 	if (graphics_debug_mode) {
 		fprintf(stderr, "Response: ");
 		for (const char *resp = graphics_command_result.response;
 		     *resp != '\0'; ++resp) {
 			if (isprint(*resp))
 				fprintf(stderr, "%c", *resp);
 			else
 				fprintf(stderr, "(0x%x)", *resp);
 		}
 		fprintf(stderr, "\n");
 	}
 
 	// Make sure that we suppress response if needed. Usually cmd.quiet is
 	// taken into account when creating the response, but it's not very
 	// reliable in the current implementation.
 	if (cmd.quiet) {
 		if (!graphics_command_result.error || cmd.quiet >= 2)
 			graphics_command_result.response[0] = '\0';
 	}
 
 	return 1;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // base64 decoding part is basically copied from st.c
 ////////////////////////////////////////////////////////////////////////////////
 
 static const char gr_base64_digits[] = {
 	0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 	0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 	0,  0,  0,  0,  0,  0,  0,  0,  0,  62, 0,  0,  0,  63, 52, 53, 54,
 	55, 56, 57, 58, 59, 60, 61, 0,  0,  0,  -1, 0,  0,  0,  0,  1,  2,
 	3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
 	20, 21, 22, 23, 24, 25, 0,  0,  0,  0,  0,  0,  26, 27, 28, 29, 30,
 	31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
 	48, 49, 50, 51, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 	0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 	0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 	0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 	0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 	0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 	0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 	0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0};
 
 static char gr_base64_getc(const char **src) {
 	while (**src && !isprint(**src))
 		(*src)++;
 	return **src ? *((*src)++) : '='; /* emulate padding if string ends */
 }
 
 char *gr_base64dec(const char *src, size_t *size) {
 	size_t in_len = strlen(src);
 	char *result, *dst;
 
 	result = dst = malloc((in_len + 3) / 4 * 3 + 1);
 	while (*src) {
 		int a = gr_base64_digits[(unsigned char)gr_base64_getc(&src)];
 		int b = gr_base64_digits[(unsigned char)gr_base64_getc(&src)];
 		int c = gr_base64_digits[(unsigned char)gr_base64_getc(&src)];
 		int d = gr_base64_digits[(unsigned char)gr_base64_getc(&src)];
 
 		if (a == -1 || b == -1)
 			break;
 
 		*dst++ = (a << 2) | ((b & 0x30) >> 4);
 		if (c == -1)
 			break;
 		*dst++ = ((b & 0x0f) << 4) | ((c & 0x3c) >> 2);
 		if (d == -1)
 			break;
 		*dst++ = ((c & 0x03) << 6) | d;
 	}
 	*dst = '\0';
 	if (size) {
 		*size = dst - result;
 	}
 	return result;
 }