feat: storing thumbnails on disk

meson.build

@@ -186,6 +186,7 @@ sources = [
   'src/memdata.c',
   'src/pixmap.c',
   'src/sway.c',
+  'src/thumbnail.c',
   'src/ui.c',
   'src/viewer.c',
   'src/formats/bmp.c',

src/config.c

@@ -194,13 +194,7 @@ static struct config* get_section(struct config* cfg, const char* name)
     return NULL;
 }
 
-/**
- * Expand path from environment variable.
- * @param prefix_env path prefix (var name)
- * @param postfix constant postfix
- * @return allocated buffer with path, caller should free it after use
- */
-static char* expand_path(const char* prefix_env, const char* postfix)
+char* expand_path(const char* prefix_env, const char* postfix)
 {
     char* path;
     const char* prefix;

src/config.h

@@ -114,3 +114,11 @@ void config_error_key(const char* section, const char* key);
  * @param value configuration parameters
  */
 void config_error_val(const char* section, const char* value);
+
+/**
+ * Expand path from environment variable.
+ * @param prefix_env path prefix (var name)
+ * @param postfix constant postfix
+ * @return allocated buffer with path, caller should free it after use
+ */
+char* expand_path(const char* prefix_env, const char* postfix);

src/gallery.c

@@ -8,6 +8,7 @@
 #include "imagelist.h"
 #include "info.h"
 #include "loader.h"
+#include "thumbnail.h"
 #include "ui.h"
 
 #include <stdlib.h>
@@ -72,13 +73,28 @@ static struct gallery ctx;
 static void add_thumbnail(struct image* image)
 {
     struct thumbnail* entry = malloc(sizeof(*entry));
+    struct pixmap thumb;
+    struct thumbnail_params params;
+
+    /* TODO: move to config */
+    bool thumbnails_disk_cache = false;
+
     if (!entry) {
         image_free(image);
     } else {
         entry->width = image->frames[0].pm.width;
         entry->height = image->frames[0].pm.height;
         entry->image = image;
-        image_thumbnail(image, ctx.thumb_size, ctx.thumb_fill, ctx.thumb_aa);
+        thumbnail_params(&params, image, ctx.thumb_size, ctx.thumb_fill,
+                         ctx.thumb_aa);
+        if (!thumbnails_disk_cache ||
+            !thumbnail_load(&thumb, image->source, &params)) {
+            thumbnail_create(&thumb, image, &params);
+            if (thumbnails_disk_cache) {
+                thumbnail_save(&thumb, image->source, &params);
+            }
+        }
+        image_thumbnail(image, &thumb);
         ctx.thumbs = list_append(ctx.thumbs, entry);
     }
 }

src/image.c

@@ -51,47 +51,14 @@ void image_rotate(struct image* ctx, size_t angle)
     }
 }
 
-void image_thumbnail(struct image* image, size_t size, bool fill,
-                     bool antialias)
+void image_thumbnail(struct image* image, struct pixmap* thumbnail)
 {
-    struct pixmap thumb;
     struct image_frame* frame;
-    const struct pixmap* full = &image->frames[0].pm;
-    const float scale_width = 1.0 / ((float)full->width / size);
-    const float scale_height = 1.0 / ((float)full->height / size);
-    const float scale =
-        fill ? max(scale_width, scale_height) : min(scale_width, scale_height);
-    size_t thumb_width = scale * full->width;
-    size_t thumb_height = scale * full->height;
-    ssize_t offset_x, offset_y;
-    enum pixmap_scale scaler;
-
-    if (antialias) {
-        scaler = (scale > 1.0) ? pixmap_bicubic : pixmap_average;
-    } else {
-        scaler = pixmap_nearest;
-    }
-
-    if (fill) {
-        offset_x = size / 2 - thumb_width / 2;
-        offset_y = size / 2 - thumb_height / 2;
-        thumb_width = size;
-        thumb_height = size;
-    } else {
-        offset_x = 0;
-        offset_y = 0;
-    }
-
-    // create thumbnail
-    if (!pixmap_create(&thumb, thumb_width, thumb_height)) {
-        return;
-    }
-    pixmap_scale(scaler, full, &thumb, offset_x, offset_y, scale, image->alpha);
 
     image_free_frames(image);
     frame = image_create_frames(image, 1);
     if (frame) {
-        frame->pm = thumb;
+        frame->pm = *thumbnail;
     }
 }
 

src/image.h

@@ -76,12 +76,9 @@ void image_rotate(struct image* ctx, size_t angle);
 /**
  * Create thumbnail from full size image.
  * @param image original image
- * @param size thumbnail size in pixels
- * @param fill thumbnail scale mode (fill/fit)
- * @param antialias use antialiasing
+ * @param thumbnail pixmap with thumbnail of the image
  */
-void image_thumbnail(struct image* image, size_t size, bool fill,
-                     bool antialias);
+void image_thumbnail(struct image* image, struct pixmap *thumbnail);
 
 /**
  * Set image format description.

src/thumbnail.c

@@ -0,0 +1,238 @@
+// SPDX-License-Identifier: MIT
+// Image instance: pixel data and meta info.
+// Copyright (C) 2021 Artem Senichev <[email protected]>
+// Copyright (C) 2024 Rentib <[email protected]>
+
+#include "thumbnail.h"
+
+#include "config.h"
+#include "image.h"
+#include "memdata.h"
+#include "pixmap.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <time.h>
+#include <unistd.h>
+
+/**
+ * Makes directories like `mkdir -p`.
+ * @param path absolute path to the directory to be created, should not be null
+ * or empty
+ * @return true if successful
+ */
+static bool make_directories(const char* path)
+{
+    char* path_copy = str_dup(path, NULL); // maybe use [PATH_MAX] buffer
+    char* slash = path_copy;
+
+    while (true) {
+        slash = strchr(slash + 1, '/');
+        if (!slash) {
+            break;
+        }
+        *slash = '\0';
+        if (mkdir(path_copy, 0755) && errno != EEXIST) {
+            free(path_copy);
+            return false;
+        }
+        *slash = '/';
+    }
+
+    free(path_copy);
+    return true;
+}
+
+static bool get_thumb_path(char** path, const char* source)
+{
+    const char* prefix = "XDG_CACHE_HOME";
+    const char* postfix = "/swayimg";
+    const char* prefix_fallback = "HOME";
+    const char* postfix_fallback = "/.cache/swayimg";
+    if ((!(*path = expand_path(prefix, postfix)) &&
+         !(*path = expand_path(prefix_fallback, postfix_fallback))) ||
+        !(*path = str_append(source, 0, path))) {
+        return false;
+    }
+    return true;
+}
+
+void thumbnail_params(struct thumbnail_params* params,
+                      const struct image* image, size_t size, bool fill,
+                      bool antialias)
+{
+    const struct pixmap* full = &image->frames[0].pm;
+    const float scale_width = 1.0 / ((float)full->width / size);
+    const float scale_height = 1.0 / ((float)full->height / size);
+    const float scale =
+        fill ? max(scale_width, scale_height) : min(scale_width, scale_height);
+    size_t thumb_width = scale * full->width;
+    size_t thumb_height = scale * full->height;
+    ssize_t offset_x, offset_y;
+
+    if (fill) {
+        offset_x = size / 2 - thumb_width / 2;
+        offset_y = size / 2 - thumb_height / 2;
+        thumb_width = size;
+        thumb_height = size;
+    } else {
+        offset_x = 0;
+        offset_y = 0;
+    }
+
+    *params = (struct thumbnail_params) {
+        .thumb_width = thumb_width,
+        .thumb_height = thumb_height,
+        .offset_x = offset_x,
+        .offset_y = offset_y,
+        .fill = fill,
+        .antialias = antialias,
+        .scale = scale,
+    };
+}
+
+bool thumbnail_save(const struct pixmap* thumb, const char* source,
+                    const struct thumbnail_params* params)
+{
+    FILE* fp = NULL;
+    uint32_t i;
+    char* path = NULL;
+
+    if (!get_thumb_path(&path, source)) {
+        goto fail;
+    }
+
+    if (!make_directories(path)) {
+        goto fail;
+    }
+
+    if (!(fp = fopen(path, "wb"))) {
+        goto fail;
+    }
+
+    if (fprintf(fp, "P6\n%zu %zu\n255\n", thumb->width, thumb->height) < 0) {
+        goto fail;
+    }
+
+    /* comment to store params */
+    if (fputc('#', fp) == EOF ||
+        fwrite(params, sizeof(struct thumbnail_params), 1, fp) != 1 ||
+        fputc('\n', fp) == EOF) {
+        goto fail;
+    }
+
+    // TODO: add alpha channel
+    for (i = 0; i < thumb->width * thumb->height; ++i) {
+        uint8_t color[] = { (((thumb->data[i] >> (8 * 2)) & 0xff)),
+                            (((thumb->data[i] >> (8 * 1)) & 0xff)),
+                            (((thumb->data[i] >> (8 * 0)) & 0xff)) };
+        fwrite(color, 3, 1, fp);
+    }
+
+    free(path);
+    fclose(fp);
+    return true;
+
+fail:
+    free(path);
+    if (fp) {
+        fclose(fp);
+    }
+    return false;
+}
+
+/**
+ * Allocate/reallocate pixel map.
+ * @param thumb pixmap context
+ * @param path path to load from
+ * @return true pixmap was loaded
+ */
+bool thumbnail_load(struct pixmap* thumb, const char* source,
+                    const struct thumbnail_params* params)
+{
+    FILE* fp = NULL;
+    char* path = NULL;
+    uint32_t i;
+    struct stat attr_img, attr_thumb;
+    struct thumbnail_params saved_params;
+
+    if (!get_thumb_path(&path, source) || stat(source, &attr_img) ||
+        stat(path, &attr_thumb) ||
+        difftime(attr_img.st_ctime, attr_thumb.st_ctime) > 0) {
+        goto fail;
+    }
+
+    if (!(fp = fopen(path, "rb"))) {
+        goto fail;
+    }
+
+    char header[3];
+    if (fscanf(fp, "%2s\n%zu %zu\n255\n", header, &thumb->width,
+               &thumb->height) != 3) {
+        goto fail;
+    }
+
+    if (strcmp(header, "P6")) {
+        goto fail;
+    }
+
+    /* comment with stored params */
+    if (fgetc(fp) != '#' ||
+        fread(&saved_params, sizeof(struct thumbnail_params), 1, fp) != 1 ||
+        fgetc(fp) != '\n') {
+        goto fail;
+    }
+
+    if (memcmp(params, &saved_params, sizeof(struct thumbnail_params))) {
+        goto fail;
+    }
+
+    if (!pixmap_create(thumb, thumb->width, thumb->height)) {
+        goto fail;
+    }
+
+    for (i = 0; i < thumb->width * thumb->height; ++i) {
+        uint8_t color[3];
+        if (fread(color, 3, 1, fp) != 1) {
+            pixmap_free(thumb);
+            goto fail;
+        }
+        thumb->data[i] = ARGB(0xff, color[0], color[1], color[2]);
+    }
+
+    free(path);
+    fclose(fp);
+    return true;
+
+fail:
+    free(path);
+    if (fp) {
+        fclose(fp);
+    }
+    return false;
+}
+
+bool thumbnail_create(struct pixmap* thumb, const struct image* image,
+                      const struct thumbnail_params* params)
+{
+    const struct pixmap* full = &image->frames[0].pm;
+    enum pixmap_scale scaler;
+
+    if (params->antialias) {
+        scaler = (params->scale > 1.0) ? pixmap_bicubic : pixmap_average;
+    } else {
+        scaler = pixmap_nearest;
+    }
+
+    // create thumbnail
+    if (!pixmap_create(thumb, params->thumb_width, params->thumb_height)) {
+        return false;
+    }
+    pixmap_scale(scaler, full, thumb, params->offset_x, params->offset_y,
+                 params->scale, image->alpha);
+
+    return true;
+}