diff options
Diffstat (limited to 'files/config/suckless/st/graphics.c')
| -rw-r--r-- | files/config/suckless/st/graphics.c | 3812 |
1 files changed, 0 insertions, 3812 deletions
diff --git a/files/config/suckless/st/graphics.c b/files/config/suckless/st/graphics.c deleted file mode 100644 index 64e6fe0..0000000 --- a/files/config/suckless/st/graphics.c +++ /dev/null @@ -1,3812 +0,0 @@ -/* 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; -} |