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
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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
/* 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 <limits.h>
#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;
}
/* On a state with no picture (a Restore's), the record's; one open made
* from the file as it is now (it changed on disk) keeps that one. */
static int load(void *st, const uint8_t *buf, uint32_t n, uint32_t version) {
(void)version;
if (!st) return 1;
if (!((image *)st)->raw) 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,
};
|