/* image.c: pictures as a pardes addon (.png .jpg .gif .bmp .ppm .pgm .tga). * A pane keeps its file's bytes (its record in a dump) and decodes them on * a job with stb_image, at most MAX_DIM pixels a side; the core shows the * RGBA fitted to the pane (or as glyph art, its Petscii word). */ #include #include "pardes_addon.h" #define MAX_DIM 1280u /* the longest side kept */ #define MAX_PIXELS (64ull * 1024 * 1024) /* refused before decoding */ static const pa_api *api; /* stb's memory: the job's on a worker (freed after its job_done), else * the pane's arena (a header read at open). Both are freed whole. */ static _Thread_local pa_out *job; static void *mem(size_t n) { return job ? job->alloc(job, n) : api->alloc(n); } static void *remem(void *p, size_t old, size_t n) { void *q = mem(n); if (q && p) memcpy(q, p, old < n ? old : n); return q; } #define STBI_MALLOC(n) mem(n) #define STBI_REALLOC_SIZED(p, old, n) remem(p, old, n) #define STBI_FREE(p) ((void)(p)) #define STBIR_MALLOC(n, c) ((void)(c), mem(n)) #define STBIR_FREE(p, c) ((void)(p), (void)(c)) #define STBI_NO_STDIO #define STBI_NO_HDR #define STB_IMAGE_IMPLEMENTATION #define STB_IMAGE_RESIZE_IMPLEMENTATION #define STB_IMAGE_STATIC #define STB_IMAGE_RESIZE_STATIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-function" #include "stb_image.h" #include "stb_image_resize.h" #pragma GCC diagnostic pop typedef struct image { const uint8_t *raw; /* the file's bytes */ uint32_t len, w, h; const uint8_t *rgba; /* w x h, once its job is done */ } image; static int init(const pa_api *a) { api = a; return PA_OK; } /* The bytes kept, and decoded on a job. */ static void keep(image *im, const uint8_t *bytes, uint32_t len) { uint8_t *copy = api->alloc(len); if (!copy) return; memcpy(copy, bytes, len); im->raw = copy, im->len = len; if (len > 0) api->job(copy, len); } static void *open(const char *path, const uint8_t *bytes, uint64_t len) { (void)path; image *im = api->alloc(sizeof *im); if (!im || !bytes) return im; int w, h, c; /* One it cannot read (corrupt, truncated, not what its name says) is * refused, rather than shown as a blank pane. */ if (len == 0 || len > INT_MAX || !stbi_info_from_memory(bytes, (int)len, &w, &h, &c)) { static const char why[] = "not an image pardes can read"; api->say(why, sizeof why - 1, 1); } else keep(im, bytes, (uint32_t)len); return im; } static void paint(void *st, const pa_window *win, pa_paint *out) { const image *im = st; memcpy(out->prefix, "img", 3); /* the core follows it with its art words and the path */ out->prefix_len = 3; if (!im || !im->rgba) return; out->placements[0] = (pa_placement){ .rgba = im->rgba, .w = im->w, .h = im->h, .src = { 0, 0, im->w, im->h }, .dst = { 0, 0, win->cols, win->rows } }; out->n = 1; } static void put32(uint8_t *at, uint32_t v) { for (int i = 0; i < 4; i++) at[i] = (uint8_t)(v >> (8 * i)); } /* On a worker: width and height (little endian), then the RGBA. */ static uint32_t decode(const uint8_t *in, uint32_t n) { int w, h, c; if (n == 0 || n > INT_MAX || !stbi_info_from_memory(in, (int)n, &w, &h, &c) || (uint64_t)w * (uint64_t)h > MAX_PIXELS) return 0; uint8_t *px = stbi_load_from_memory(in, (int)n, &w, &h, &c, 4); if (!px) return 0; uint32_t longest = (uint32_t)(w > h ? w : h), nw = (uint32_t)w, nh = (uint32_t)h; if (longest > MAX_DIM) { nw = (uint32_t)((uint64_t)w * MAX_DIM / longest), nh = (uint32_t)((uint64_t)h * MAX_DIM / longest); nw += !nw, nh += !nh; uint8_t *small = mem((size_t)nw * nh * 4); if (!small || !stbir_resize_uint8(px, w, h, 0, small, (int)nw, (int)nh, 0, 4)) return 0; px = small; } size_t len = 8 + (size_t)nw * nh * 4; uint8_t *a = job->alloc(job, len); /* the last: the answer */ if (!a) return 0; put32(a, nw), put32(a + 4, nh); memcpy(a + 8, px, len - 8); return (uint32_t)len; } static uint32_t job_run(const uint8_t *in, uint32_t n, pa_out *out) { job = out; uint32_t got = decode(in, n); job = 0; return got; } static void job_done(void *st, uint32_t token, const uint8_t *out, uint32_t n) { image *im = st; (void)token; if (!im || n < 8) return; uint32_t w = out[0] | out[1] << 8 | out[2] << 16 | (uint32_t)out[3] << 24; uint32_t h = out[4] | out[5] << 8 | out[6] << 16 | (uint32_t)out[7] << 24; if ((uint64_t)w * h * 4 != n - 8) return; uint8_t *rgba = api->alloc(n - 8); if (!rgba) return; memcpy(rgba, out + 8, n - 8); im->rgba = rgba, im->w = w, im->h = h; } /* The record is the file's bytes. */ static uint32_t dump(void *st, uint8_t *buf, uint32_t n) { const image *im = st; if (!im) return 0; if (im->len <= n) memcpy(buf, im->raw, im->len); return im->len; } static int load(void *st, const uint8_t *buf, uint32_t n, uint32_t version) { (void)version; if (!st) return 1; keep(st, buf, n); return PA_OK; } const pa_ops pardes_addon = { .head = PA_ADDON("image", 1, ".png .jpg .jpeg .gif .bmp .ppm .pgm .tga", 0, 0), .init = init, .open = open, .paint = paint, .job_run = job_run, .job_done = job_done, .dump = dump, .load = load, };