@weft-framework/server 0.0.0-stage → 0.0.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +4 -2
- package/dist/account.d.ts +124 -0
- package/dist/account.js +344 -0
- package/dist/action.d.ts +43 -0
- package/dist/action.js +135 -0
- package/dist/admin.d.ts +99 -0
- package/dist/admin.js +431 -0
- package/dist/api.d.ts +21 -0
- package/dist/api.js +72 -0
- package/dist/app.d.ts +202 -0
- package/dist/app.js +3692 -0
- package/dist/assets.d.ts +4 -0
- package/dist/assets.js +91 -0
- package/dist/auth.d.ts +150 -0
- package/dist/auth.js +215 -0
- package/dist/backup.d.ts +46 -0
- package/dist/backup.js +345 -0
- package/dist/build.d.ts +33 -0
- package/dist/build.js +274 -0
- package/dist/bun.d.ts +30 -0
- package/dist/bun.js +53 -0
- package/dist/calendar.d.ts +161 -0
- package/dist/calendar.js +690 -0
- package/dist/compiler.d.ts +13 -0
- package/dist/compiler.js +58 -0
- package/dist/compress.d.ts +6 -0
- package/dist/compress.js +78 -0
- package/dist/config.d.ts +26 -0
- package/dist/config.js +317 -0
- package/dist/context.d.ts +9 -0
- package/dist/context.js +1 -0
- package/dist/contract.d.ts +18 -0
- package/dist/contract.js +171 -0
- package/dist/datamap.d.ts +24 -0
- package/dist/datamap.js +365 -0
- package/dist/db-backup.d.ts +27 -0
- package/dist/db-backup.js +115 -0
- package/dist/dev-events.d.ts +14 -0
- package/dist/dev-events.js +135 -0
- package/dist/dev.d.ts +1 -0
- package/dist/dev.js +240 -0
- package/dist/devtools-client.d.ts +1 -0
- package/dist/devtools-client.js +362 -0
- package/dist/devtools.d.ts +87 -0
- package/dist/devtools.js +68 -0
- package/dist/edge.d.ts +3 -0
- package/dist/edge.js +7 -0
- package/dist/email-signin.d.ts +92 -0
- package/dist/email-signin.js +259 -0
- package/dist/env.d.ts +1 -0
- package/dist/env.js +15 -0
- package/dist/explain.d.ts +12 -0
- package/dist/explain.js +217 -0
- package/dist/files.d.ts +6 -0
- package/dist/files.js +170 -0
- package/dist/grants.d.ts +69 -0
- package/dist/grants.js +206 -0
- package/dist/image/bitmap.d.ts +11 -0
- package/dist/image/bitmap.js +172 -0
- package/dist/image/jpeg.d.ts +10 -0
- package/dist/image/jpeg.js +697 -0
- package/dist/image/png.d.ts +8 -0
- package/dist/image/png.js +282 -0
- package/dist/image/transform.d.ts +20 -0
- package/dist/image/transform.js +52 -0
- package/dist/image/worker.d.ts +1 -0
- package/dist/image/worker.js +11 -0
- package/dist/images.d.ts +39 -0
- package/dist/images.js +283 -0
- package/dist/index.d.ts +64 -0
- package/dist/index.js +31 -0
- package/dist/inspect-hub.d.ts +42 -0
- package/dist/inspect-hub.js +14 -0
- package/dist/inspector.d.ts +51 -0
- package/dist/inspector.js +193 -0
- package/dist/job-admin.d.ts +55 -0
- package/dist/job-admin.js +89 -0
- package/dist/jobs.d.ts +222 -0
- package/dist/jobs.js +789 -0
- package/dist/live.d.ts +72 -0
- package/dist/live.js +481 -0
- package/dist/load-config.d.ts +2 -0
- package/dist/load-config.js +41 -0
- package/dist/log.d.ts +20 -0
- package/dist/log.js +143 -0
- package/dist/mail.d.ts +189 -0
- package/dist/mail.js +999 -0
- package/dist/media.d.ts +129 -0
- package/dist/media.js +470 -0
- package/dist/meta.d.ts +54 -0
- package/dist/meta.js +146 -0
- package/dist/middleware.d.ts +20 -0
- package/dist/middleware.js +101 -0
- package/dist/migrate.d.ts +12 -0
- package/dist/migrate.js +88 -0
- package/dist/node.d.ts +26 -0
- package/dist/node.js +96 -0
- package/dist/notice.d.ts +21 -0
- package/dist/notice.js +48 -0
- package/dist/npm.d.ts +16 -0
- package/dist/npm.js +347 -0
- package/dist/oauth.d.ts +76 -0
- package/dist/oauth.js +408 -0
- package/dist/otel.d.ts +57 -0
- package/dist/otel.js +293 -0
- package/dist/passkey.d.ts +99 -0
- package/dist/passkey.js +572 -0
- package/dist/password.d.ts +8 -0
- package/dist/password.js +65 -0
- package/dist/pdf.d.ts +46 -0
- package/dist/pdf.js +332 -0
- package/dist/personal-data.d.ts +22 -0
- package/dist/personal-data.js +148 -0
- package/dist/pointers.d.ts +9 -0
- package/dist/pointers.js +148 -0
- package/dist/postcss.d.ts +3 -0
- package/dist/postcss.js +89 -0
- package/dist/presence.d.ts +27 -0
- package/dist/presence.js +161 -0
- package/dist/preview.d.ts +25 -0
- package/dist/preview.js +353 -0
- package/dist/production.d.ts +16 -0
- package/dist/production.js +119 -0
- package/dist/project.d.ts +23 -0
- package/dist/project.js +536 -0
- package/dist/regions.d.ts +47 -0
- package/dist/regions.js +511 -0
- package/dist/replay.d.ts +44 -0
- package/dist/replay.js +259 -0
- package/dist/router.d.ts +29 -0
- package/dist/router.js +146 -0
- package/dist/rules-diff.d.ts +18 -0
- package/dist/rules-diff.js +165 -0
- package/dist/rules-test.d.ts +17 -0
- package/dist/rules-test.js +108 -0
- package/dist/saml.d.ts +160 -0
- package/dist/saml.js +959 -0
- package/dist/seal.d.ts +35 -0
- package/dist/seal.js +107 -0
- package/dist/secret.d.ts +14 -0
- package/dist/secret.js +110 -0
- package/dist/security.d.ts +53 -0
- package/dist/security.js +250 -0
- package/dist/seed.d.ts +16 -0
- package/dist/seed.js +94 -0
- package/dist/seo.d.ts +42 -0
- package/dist/seo.js +175 -0
- package/dist/settings.d.ts +79 -0
- package/dist/settings.js +212 -0
- package/dist/shared.d.ts +15 -0
- package/dist/shared.js +283 -0
- package/dist/shell.d.ts +12 -0
- package/dist/shell.js +118 -0
- package/dist/storage.d.ts +13 -0
- package/dist/storage.js +55 -0
- package/dist/support.d.ts +83 -0
- package/dist/support.js +236 -0
- package/dist/sync.d.ts +35 -0
- package/dist/sync.js +167 -0
- package/dist/tailwind.d.ts +14 -0
- package/dist/tailwind.js +117 -0
- package/dist/two-factor.d.ts +103 -0
- package/dist/two-factor.js +435 -0
- package/dist/uploads.d.ts +185 -0
- package/dist/uploads.js +991 -0
- package/dist/webhooks.d.ts +169 -0
- package/dist/webhooks.js +758 -0
- package/dist/webpush.d.ts +97 -0
- package/dist/webpush.js +372 -0
- package/dist/wizard.d.ts +141 -0
- package/dist/wizard.js +410 -0
- package/dist/workflows.d.ts +134 -0
- package/dist/workflows.js +511 -0
- package/package.json +186 -4
|
@@ -0,0 +1,697 @@
|
|
|
1
|
+
import { ImageError } from "./bitmap.js";
|
|
2
|
+
const ZIGZAG = new Uint8Array([
|
|
3
|
+
0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, 35, 42, 49, 56, 57,
|
|
4
|
+
50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63,
|
|
5
|
+
]);
|
|
6
|
+
export function isJpeg(b) {
|
|
7
|
+
return b.length > 3 && b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff;
|
|
8
|
+
}
|
|
9
|
+
function buildHuffman(counts, values) {
|
|
10
|
+
const maxcode = new Int32Array(18).fill(-1);
|
|
11
|
+
const valptr = new Int32Array(17);
|
|
12
|
+
const mincode = new Int32Array(17);
|
|
13
|
+
let code = 0;
|
|
14
|
+
let k = 0;
|
|
15
|
+
for (let l = 1; l <= 16; l++) {
|
|
16
|
+
valptr[l] = k;
|
|
17
|
+
mincode[l] = code;
|
|
18
|
+
code += counts[l - 1];
|
|
19
|
+
k += counts[l - 1];
|
|
20
|
+
maxcode[l] = counts[l - 1] ? code - 1 : -1;
|
|
21
|
+
code <<= 1;
|
|
22
|
+
}
|
|
23
|
+
maxcode[17] = 0x7fffffff;
|
|
24
|
+
return { maxcode, valptr, mincode, values };
|
|
25
|
+
}
|
|
26
|
+
export function jpegSize(b) {
|
|
27
|
+
let at = 2;
|
|
28
|
+
while (at + 4 <= b.length) {
|
|
29
|
+
if (b[at] !== 0xff)
|
|
30
|
+
throw new ImageError("JPEG is damaged");
|
|
31
|
+
const m = b[at + 1];
|
|
32
|
+
if (m === 0xff) {
|
|
33
|
+
at++;
|
|
34
|
+
continue;
|
|
35
|
+
}
|
|
36
|
+
const len = (b[at + 2] << 8) | b[at + 3];
|
|
37
|
+
if (m >= 0xc0 && m <= 0xcf && m !== 0xc4 && m !== 0xc8 && m !== 0xcc) {
|
|
38
|
+
return { height: (b[at + 5] << 8) | b[at + 6], width: (b[at + 7] << 8) | b[at + 8] };
|
|
39
|
+
}
|
|
40
|
+
at += 2 + len;
|
|
41
|
+
}
|
|
42
|
+
throw new ImageError("JPEG has no frame");
|
|
43
|
+
}
|
|
44
|
+
export function decodeJpeg(b, maxPixels) {
|
|
45
|
+
if (!isJpeg(b))
|
|
46
|
+
throw new ImageError("not a JPEG");
|
|
47
|
+
const qt = [];
|
|
48
|
+
const dcTables = [];
|
|
49
|
+
const acTables = [];
|
|
50
|
+
let frame = null;
|
|
51
|
+
let restart = 0;
|
|
52
|
+
let adobe = -1;
|
|
53
|
+
let orientation = 1;
|
|
54
|
+
let jfif = false;
|
|
55
|
+
let at = 2;
|
|
56
|
+
const u16 = (i) => (b[i] << 8) | b[i + 1];
|
|
57
|
+
for (;;) {
|
|
58
|
+
if (at + 4 > b.length)
|
|
59
|
+
break;
|
|
60
|
+
if (b[at] !== 0xff) {
|
|
61
|
+
at++;
|
|
62
|
+
continue;
|
|
63
|
+
}
|
|
64
|
+
const m = b[at + 1];
|
|
65
|
+
if (m === 0xff || m === 0x00 || (m >= 0xd0 && m <= 0xd7) || m === 0x01) {
|
|
66
|
+
at += m === 0xff ? 1 : 2;
|
|
67
|
+
continue;
|
|
68
|
+
}
|
|
69
|
+
if (m === 0xd9)
|
|
70
|
+
break;
|
|
71
|
+
const len = u16(at + 2);
|
|
72
|
+
const seg = b.subarray(at + 4, at + 2 + len);
|
|
73
|
+
if (seg.length !== len - 2)
|
|
74
|
+
throw new ImageError("JPEG is cut short");
|
|
75
|
+
at += 2 + len;
|
|
76
|
+
if (m === 0xe0 && seg[0] === 0x4a && seg[1] === 0x46 && seg[2] === 0x49 && seg[3] === 0x46)
|
|
77
|
+
jfif = true;
|
|
78
|
+
else if (m === 0xe1)
|
|
79
|
+
orientation = exifOrientation(seg) ?? orientation;
|
|
80
|
+
else if (m === 0xee && seg[0] === 0x41 && seg[1] === 0x64 && seg[2] === 0x6f && seg[3] === 0x62 && seg[4] === 0x65)
|
|
81
|
+
adobe = seg[11] ?? 0;
|
|
82
|
+
else if (m === 0xdb) {
|
|
83
|
+
for (let i = 0; i < seg.length;) {
|
|
84
|
+
const pq = seg[i] >> 4;
|
|
85
|
+
const tq = seg[i] & 15;
|
|
86
|
+
i++;
|
|
87
|
+
const t = new Int32Array(64);
|
|
88
|
+
for (let k = 0; k < 64; k++) {
|
|
89
|
+
t[ZIGZAG[k]] = pq ? (seg[i + k * 2] << 8) | seg[i + k * 2 + 1] : seg[i + k];
|
|
90
|
+
}
|
|
91
|
+
i += pq ? 128 : 64;
|
|
92
|
+
qt[tq & 3] = t;
|
|
93
|
+
}
|
|
94
|
+
}
|
|
95
|
+
else if (m === 0xc4) {
|
|
96
|
+
for (let i = 0; i < seg.length;) {
|
|
97
|
+
const tc = seg[i] >> 4;
|
|
98
|
+
const th = seg[i] & 3;
|
|
99
|
+
const counts = seg.subarray(i + 1, i + 17);
|
|
100
|
+
const total = counts.reduce((n, c) => n + c, 0);
|
|
101
|
+
const values = seg.slice(i + 17, i + 17 + total);
|
|
102
|
+
i += 17 + total;
|
|
103
|
+
(tc === 0 ? dcTables : acTables)[th] = buildHuffman(counts, values);
|
|
104
|
+
}
|
|
105
|
+
}
|
|
106
|
+
else if (m === 0xdd)
|
|
107
|
+
restart = (seg[0] << 8) | seg[1];
|
|
108
|
+
else if (m === 0xc0 || m === 0xc1 || m === 0xc2) {
|
|
109
|
+
if (seg[0] !== 8)
|
|
110
|
+
throw new ImageError("only 8-bit JPEGs are supported");
|
|
111
|
+
const height = (seg[1] << 8) | seg[2];
|
|
112
|
+
const width = (seg[3] << 8) | seg[4];
|
|
113
|
+
if (!width || !height)
|
|
114
|
+
throw new ImageError("JPEG without a height (DNL) is not supported");
|
|
115
|
+
if (width * height > maxPixels)
|
|
116
|
+
throw new ImageError("image too large");
|
|
117
|
+
const n = seg[5];
|
|
118
|
+
if (n !== 1 && n !== 3 && n !== 4)
|
|
119
|
+
throw new ImageError("unsupported JPEG component count");
|
|
120
|
+
const comps = [];
|
|
121
|
+
for (let i = 0; i < n; i++) {
|
|
122
|
+
const o = 6 + i * 3;
|
|
123
|
+
const h = seg[o + 1] >> 4;
|
|
124
|
+
const v = seg[o + 1] & 15;
|
|
125
|
+
if (h < 1 || h > 4 || v < 1 || v > 4)
|
|
126
|
+
throw new ImageError("JPEG sampling is invalid");
|
|
127
|
+
comps.push({ id: seg[o], h, v, tq: seg[o + 2] & 3, bpl: 0, bpc: 0, bplMcu: 0, bpcMcu: 0, coef: new Int16Array(0), pred: 0 });
|
|
128
|
+
}
|
|
129
|
+
const maxH = Math.max(...comps.map((c) => c.h));
|
|
130
|
+
const maxV = Math.max(...comps.map((c) => c.v));
|
|
131
|
+
const mpl = Math.ceil(width / (8 * maxH));
|
|
132
|
+
const mpc = Math.ceil(height / (8 * maxV));
|
|
133
|
+
for (const c of comps) {
|
|
134
|
+
c.bpl = Math.ceil(Math.ceil((width * c.h) / maxH) / 8);
|
|
135
|
+
c.bpc = Math.ceil(Math.ceil((height * c.v) / maxV) / 8);
|
|
136
|
+
c.bplMcu = mpl * c.h;
|
|
137
|
+
c.bpcMcu = mpc * c.v;
|
|
138
|
+
c.coef = new Int16Array(c.bplMcu * c.bpcMcu * 64);
|
|
139
|
+
}
|
|
140
|
+
frame = { width, height, progressive: m === 0xc2, comps, maxH, maxV, mpl, mpc };
|
|
141
|
+
}
|
|
142
|
+
else if (m >= 0xc3 && m <= 0xcf && m !== 0xc4 && m !== 0xc8 && m !== 0xcc) {
|
|
143
|
+
throw new ImageError("lossless, hierarchical and arithmetic-coded JPEGs are not supported");
|
|
144
|
+
}
|
|
145
|
+
else if (m === 0xda) {
|
|
146
|
+
if (!frame)
|
|
147
|
+
throw new ImageError("JPEG scan before its frame");
|
|
148
|
+
const ns = seg[0];
|
|
149
|
+
const comps = [];
|
|
150
|
+
for (let i = 0; i < ns; i++) {
|
|
151
|
+
const c = frame.comps.find((x) => x.id === seg[1 + i * 2]);
|
|
152
|
+
if (!c)
|
|
153
|
+
throw new ImageError("JPEG scan names an unknown component");
|
|
154
|
+
const t = seg[2 + i * 2];
|
|
155
|
+
c.dc = dcTables[t >> 4];
|
|
156
|
+
c.ac = acTables[t & 15];
|
|
157
|
+
comps.push(c);
|
|
158
|
+
}
|
|
159
|
+
const o = 1 + ns * 2;
|
|
160
|
+
at = decodeScan(b, at, frame, comps, restart, seg[o], seg[o + 1], seg[o + 2] >> 4, seg[o + 2] & 15);
|
|
161
|
+
}
|
|
162
|
+
}
|
|
163
|
+
if (!frame)
|
|
164
|
+
throw new ImageError("JPEG has no frame");
|
|
165
|
+
const planes = frame.comps.map((c) => {
|
|
166
|
+
const q = qt[c.tq];
|
|
167
|
+
if (!q)
|
|
168
|
+
throw new ImageError("JPEG quantisation table missing");
|
|
169
|
+
const w = c.bplMcu * 8;
|
|
170
|
+
const plane = new Uint8Array(w * c.bpcMcu * 8);
|
|
171
|
+
const block = new Float32Array(64);
|
|
172
|
+
for (let by = 0; by < c.bpcMcu; by++) {
|
|
173
|
+
for (let bx = 0; bx < c.bplMcu; bx++) {
|
|
174
|
+
const off = (by * c.bplMcu + bx) * 64;
|
|
175
|
+
for (let i = 0; i < 64; i++)
|
|
176
|
+
block[i] = c.coef[off + i] * q[i];
|
|
177
|
+
idct(block);
|
|
178
|
+
for (let y = 0; y < 8; y++) {
|
|
179
|
+
for (let x = 0; x < 8; x++) {
|
|
180
|
+
const v = block[y * 8 + x] + 128;
|
|
181
|
+
plane[(by * 8 + y) * w + bx * 8 + x] = v < 0 ? 0 : v > 255 ? 255 : Math.round(v);
|
|
182
|
+
}
|
|
183
|
+
}
|
|
184
|
+
}
|
|
185
|
+
}
|
|
186
|
+
return { plane, w, c };
|
|
187
|
+
});
|
|
188
|
+
const { width, height, maxH, maxV } = frame;
|
|
189
|
+
const out = new Uint8Array(width * height * 4);
|
|
190
|
+
const n = planes.length;
|
|
191
|
+
const ids = frame.comps.map((c) => c.id);
|
|
192
|
+
const rgb = n === 3 && (adobe === 0 || (!jfif && ids[0] === 0x52 && ids[1] === 0x47 && ids[2] === 0x42));
|
|
193
|
+
const axis = (full, f, max) => {
|
|
194
|
+
const n = Math.ceil((full * f) / max);
|
|
195
|
+
const i0 = new Int32Array(full);
|
|
196
|
+
const i1 = new Int32Array(full);
|
|
197
|
+
const w = new Float32Array(full);
|
|
198
|
+
for (let x = 0; x < full; x++) {
|
|
199
|
+
const s = Math.min(n - 1, Math.max(0, ((x + 0.5) * f) / max - 0.5));
|
|
200
|
+
i0[x] = Math.floor(s);
|
|
201
|
+
i1[x] = Math.min(n - 1, i0[x] + 1);
|
|
202
|
+
w[x] = s - i0[x];
|
|
203
|
+
}
|
|
204
|
+
return { i0, i1, w };
|
|
205
|
+
};
|
|
206
|
+
const sample = planes.map(({ plane, w: pw, c }) => {
|
|
207
|
+
if (c.h === maxH && c.v === maxV)
|
|
208
|
+
return (x, y) => plane[y * pw + x];
|
|
209
|
+
const ax = axis(width, c.h, maxH);
|
|
210
|
+
const ay = axis(height, c.v, maxV);
|
|
211
|
+
return (x, y) => {
|
|
212
|
+
const r0 = ay.i0[y] * pw;
|
|
213
|
+
const r1 = ay.i1[y] * pw;
|
|
214
|
+
const a = ax.i0[x];
|
|
215
|
+
const b = ax.i1[x];
|
|
216
|
+
const wx = ax.w[x];
|
|
217
|
+
const top = plane[r0 + a] + (plane[r0 + b] - plane[r0 + a]) * wx;
|
|
218
|
+
const bottom = plane[r1 + a] + (plane[r1 + b] - plane[r1 + a]) * wx;
|
|
219
|
+
return top + (bottom - top) * ay.w[y];
|
|
220
|
+
};
|
|
221
|
+
});
|
|
222
|
+
const clamp = (v) => (v < 0 ? 0 : v > 255 ? 255 : Math.round(v));
|
|
223
|
+
for (let y = 0; y < height; y++) {
|
|
224
|
+
for (let x = 0; x < width; x++) {
|
|
225
|
+
const d = (y * width + x) * 4;
|
|
226
|
+
if (n === 1) {
|
|
227
|
+
out[d] = out[d + 1] = out[d + 2] = clamp(sample[0](x, y));
|
|
228
|
+
}
|
|
229
|
+
else {
|
|
230
|
+
let c0 = sample[0](x, y);
|
|
231
|
+
let c1 = sample[1](x, y);
|
|
232
|
+
let c2 = sample[2](x, y);
|
|
233
|
+
if (!(n === 3 && rgb) && !(n === 4 && adobe === 0)) {
|
|
234
|
+
const yy = c0;
|
|
235
|
+
const cb = c1 - 128;
|
|
236
|
+
const cr = c2 - 128;
|
|
237
|
+
c0 = clamp(yy + 1.402 * cr);
|
|
238
|
+
c1 = clamp(yy - 0.344136 * cb - 0.714136 * cr);
|
|
239
|
+
c2 = clamp(yy + 1.772 * cb);
|
|
240
|
+
}
|
|
241
|
+
if (n === 4) {
|
|
242
|
+
const k = sample[3](x, y);
|
|
243
|
+
c0 = clamp((c0 * k) / 255);
|
|
244
|
+
c1 = clamp((c1 * k) / 255);
|
|
245
|
+
c2 = clamp((c2 * k) / 255);
|
|
246
|
+
}
|
|
247
|
+
out[d] = clamp(c0);
|
|
248
|
+
out[d + 1] = clamp(c1);
|
|
249
|
+
out[d + 2] = clamp(c2);
|
|
250
|
+
}
|
|
251
|
+
out[d + 3] = 255;
|
|
252
|
+
}
|
|
253
|
+
}
|
|
254
|
+
return { width, height, data: out, orientation };
|
|
255
|
+
}
|
|
256
|
+
function decodeScan(b, start, frame, comps, restart, ss, se, ah, al) {
|
|
257
|
+
let pos = start;
|
|
258
|
+
let bits = 0;
|
|
259
|
+
let nbits = 0;
|
|
260
|
+
let marker = false;
|
|
261
|
+
const bit = () => {
|
|
262
|
+
if (nbits === 0) {
|
|
263
|
+
if (marker || pos >= b.length)
|
|
264
|
+
return 0;
|
|
265
|
+
const byte = b[pos];
|
|
266
|
+
if (byte === 0xff) {
|
|
267
|
+
const next = b[pos + 1];
|
|
268
|
+
if (next === 0x00)
|
|
269
|
+
pos += 2;
|
|
270
|
+
else {
|
|
271
|
+
marker = true;
|
|
272
|
+
return 0;
|
|
273
|
+
}
|
|
274
|
+
}
|
|
275
|
+
else
|
|
276
|
+
pos++;
|
|
277
|
+
bits = byte;
|
|
278
|
+
nbits = 8;
|
|
279
|
+
}
|
|
280
|
+
nbits--;
|
|
281
|
+
return (bits >> nbits) & 1;
|
|
282
|
+
};
|
|
283
|
+
const receive = (n) => {
|
|
284
|
+
let v = 0;
|
|
285
|
+
while (n-- > 0)
|
|
286
|
+
v = (v << 1) | bit();
|
|
287
|
+
return v;
|
|
288
|
+
};
|
|
289
|
+
const extend = (n) => {
|
|
290
|
+
if (n === 0)
|
|
291
|
+
return 0;
|
|
292
|
+
if (n > 16)
|
|
293
|
+
throw new ImageError("JPEG data is damaged");
|
|
294
|
+
const v = receive(n);
|
|
295
|
+
return v < 1 << (n - 1) ? v - (1 << n) + 1 : v;
|
|
296
|
+
};
|
|
297
|
+
const decode = (h) => {
|
|
298
|
+
if (!h)
|
|
299
|
+
throw new ImageError("JPEG Huffman table missing");
|
|
300
|
+
let code = 0;
|
|
301
|
+
for (let l = 1; l <= 16; l++) {
|
|
302
|
+
code = (code << 1) | bit();
|
|
303
|
+
if (code <= h.maxcode[l])
|
|
304
|
+
return h.values[h.valptr[l] + code - h.mincode[l]];
|
|
305
|
+
}
|
|
306
|
+
throw new ImageError("JPEG data is damaged");
|
|
307
|
+
};
|
|
308
|
+
let eobrun = 0;
|
|
309
|
+
let acState = 0;
|
|
310
|
+
let acNext = 0;
|
|
311
|
+
let acRun = 0;
|
|
312
|
+
const baseline = (c, off) => {
|
|
313
|
+
const t = decode(c.dc);
|
|
314
|
+
c.pred += extend(t);
|
|
315
|
+
c.coef[off] = c.pred;
|
|
316
|
+
for (let k = 1; k < 64;) {
|
|
317
|
+
const rs = decode(c.ac);
|
|
318
|
+
const s = rs & 15;
|
|
319
|
+
const r = rs >> 4;
|
|
320
|
+
if (s === 0) {
|
|
321
|
+
if (r < 15)
|
|
322
|
+
break;
|
|
323
|
+
k += 16;
|
|
324
|
+
continue;
|
|
325
|
+
}
|
|
326
|
+
k += r;
|
|
327
|
+
if (k > 63)
|
|
328
|
+
break;
|
|
329
|
+
c.coef[off + ZIGZAG[k]] = extend(s);
|
|
330
|
+
k++;
|
|
331
|
+
}
|
|
332
|
+
};
|
|
333
|
+
const dcFirst = (c, off) => {
|
|
334
|
+
const t = decode(c.dc);
|
|
335
|
+
c.pred += extend(t) * (1 << al);
|
|
336
|
+
c.coef[off] = c.pred;
|
|
337
|
+
};
|
|
338
|
+
const dcRefine = (c, off) => {
|
|
339
|
+
if (bit())
|
|
340
|
+
c.coef[off] |= 1 << al;
|
|
341
|
+
};
|
|
342
|
+
const acFirst = (c, off) => {
|
|
343
|
+
if (eobrun > 0) {
|
|
344
|
+
eobrun--;
|
|
345
|
+
return;
|
|
346
|
+
}
|
|
347
|
+
for (let k = ss; k <= se;) {
|
|
348
|
+
const rs = decode(c.ac);
|
|
349
|
+
const s = rs & 15;
|
|
350
|
+
const r = rs >> 4;
|
|
351
|
+
if (s === 0) {
|
|
352
|
+
if (r < 15) {
|
|
353
|
+
eobrun = receive(r) + (1 << r) - 1;
|
|
354
|
+
break;
|
|
355
|
+
}
|
|
356
|
+
k += 16;
|
|
357
|
+
continue;
|
|
358
|
+
}
|
|
359
|
+
k += r;
|
|
360
|
+
if (k > 63)
|
|
361
|
+
break;
|
|
362
|
+
c.coef[off + ZIGZAG[k]] = extend(s) * (1 << al);
|
|
363
|
+
k++;
|
|
364
|
+
}
|
|
365
|
+
};
|
|
366
|
+
const acRefine = (c, off) => {
|
|
367
|
+
for (let k = ss; k <= se; k++) {
|
|
368
|
+
const z = off + ZIGZAG[k];
|
|
369
|
+
const sign = c.coef[z] < 0 ? -1 : 1;
|
|
370
|
+
switch (acState) {
|
|
371
|
+
case 0: {
|
|
372
|
+
const rs = decode(c.ac);
|
|
373
|
+
const s = rs & 15;
|
|
374
|
+
acRun = rs >> 4;
|
|
375
|
+
if (s === 0) {
|
|
376
|
+
if (acRun < 15) {
|
|
377
|
+
eobrun = receive(acRun) + (1 << acRun);
|
|
378
|
+
acState = 4;
|
|
379
|
+
}
|
|
380
|
+
else {
|
|
381
|
+
acRun = 16;
|
|
382
|
+
acState = 1;
|
|
383
|
+
}
|
|
384
|
+
}
|
|
385
|
+
else {
|
|
386
|
+
if (s !== 1)
|
|
387
|
+
throw new ImageError("JPEG data is damaged");
|
|
388
|
+
acNext = extend(s);
|
|
389
|
+
acState = acRun ? 2 : 3;
|
|
390
|
+
}
|
|
391
|
+
k--;
|
|
392
|
+
continue;
|
|
393
|
+
}
|
|
394
|
+
case 1:
|
|
395
|
+
case 2:
|
|
396
|
+
if (c.coef[z])
|
|
397
|
+
c.coef[z] += sign * (bit() << al);
|
|
398
|
+
else if (--acRun === 0)
|
|
399
|
+
acState = acState === 2 ? 3 : 0;
|
|
400
|
+
break;
|
|
401
|
+
case 3:
|
|
402
|
+
if (c.coef[z])
|
|
403
|
+
c.coef[z] += sign * (bit() << al);
|
|
404
|
+
else {
|
|
405
|
+
c.coef[z] = acNext * (1 << al);
|
|
406
|
+
acState = 0;
|
|
407
|
+
}
|
|
408
|
+
break;
|
|
409
|
+
case 4:
|
|
410
|
+
if (c.coef[z])
|
|
411
|
+
c.coef[z] += sign * (bit() << al);
|
|
412
|
+
break;
|
|
413
|
+
}
|
|
414
|
+
}
|
|
415
|
+
if (acState === 4 && --eobrun === 0)
|
|
416
|
+
acState = 0;
|
|
417
|
+
};
|
|
418
|
+
const fn = !frame.progressive ? baseline : ss === 0 ? (ah === 0 ? dcFirst : dcRefine) : ah === 0 ? acFirst : acRefine;
|
|
419
|
+
if (frame.progressive && ss !== 0 && comps.length !== 1)
|
|
420
|
+
throw new ImageError("JPEG AC scan with several components");
|
|
421
|
+
const single = comps.length === 1;
|
|
422
|
+
const total = single ? comps[0].bpl * comps[0].bpc : frame.mpl * frame.mpc;
|
|
423
|
+
const interval = restart || total;
|
|
424
|
+
for (let n = 0; n < total;) {
|
|
425
|
+
for (const c of comps)
|
|
426
|
+
c.pred = 0;
|
|
427
|
+
eobrun = 0;
|
|
428
|
+
acState = 0;
|
|
429
|
+
const end = Math.min(total, n + interval);
|
|
430
|
+
for (; n < end; n++) {
|
|
431
|
+
if (single) {
|
|
432
|
+
const c = comps[0];
|
|
433
|
+
const row = Math.floor(n / c.bpl);
|
|
434
|
+
const col = n % c.bpl;
|
|
435
|
+
fn(c, (row * c.bplMcu + col) * 64);
|
|
436
|
+
}
|
|
437
|
+
else {
|
|
438
|
+
const mrow = Math.floor(n / frame.mpl);
|
|
439
|
+
const mcol = n % frame.mpl;
|
|
440
|
+
for (const c of comps) {
|
|
441
|
+
for (let v = 0; v < c.v; v++) {
|
|
442
|
+
for (let h = 0; h < c.h; h++) {
|
|
443
|
+
fn(c, ((mrow * c.v + v) * c.bplMcu + mcol * c.h + h) * 64);
|
|
444
|
+
}
|
|
445
|
+
}
|
|
446
|
+
}
|
|
447
|
+
}
|
|
448
|
+
}
|
|
449
|
+
nbits = 0;
|
|
450
|
+
marker = false;
|
|
451
|
+
while (pos + 1 < b.length && !(b[pos] === 0xff && b[pos + 1] !== 0x00 && b[pos + 1] !== 0xff))
|
|
452
|
+
pos++;
|
|
453
|
+
if (n < total && b[pos + 1] >= 0xd0 && b[pos + 1] <= 0xd7)
|
|
454
|
+
pos += 2;
|
|
455
|
+
else if (n < total)
|
|
456
|
+
break;
|
|
457
|
+
}
|
|
458
|
+
return pos;
|
|
459
|
+
}
|
|
460
|
+
const COS = (() => {
|
|
461
|
+
const t = new Float32Array(64);
|
|
462
|
+
for (let x = 0; x < 8; x++) {
|
|
463
|
+
for (let u = 0; u < 8; u++)
|
|
464
|
+
t[x * 8 + u] = (u === 0 ? Math.SQRT1_2 : 1) * Math.cos(((2 * x + 1) * u * Math.PI) / 16);
|
|
465
|
+
}
|
|
466
|
+
return t;
|
|
467
|
+
})();
|
|
468
|
+
function idct(blk) {
|
|
469
|
+
const tmp = new Float32Array(64);
|
|
470
|
+
for (let v = 0; v < 8; v++) {
|
|
471
|
+
for (let x = 0; x < 8; x++) {
|
|
472
|
+
let s = 0;
|
|
473
|
+
for (let u = 0; u < 8; u++)
|
|
474
|
+
s += COS[x * 8 + u] * blk[v * 8 + u];
|
|
475
|
+
tmp[v * 8 + x] = s / 2;
|
|
476
|
+
}
|
|
477
|
+
}
|
|
478
|
+
for (let x = 0; x < 8; x++) {
|
|
479
|
+
for (let y = 0; y < 8; y++) {
|
|
480
|
+
let s = 0;
|
|
481
|
+
for (let v = 0; v < 8; v++)
|
|
482
|
+
s += COS[y * 8 + v] * tmp[v * 8 + x];
|
|
483
|
+
blk[y * 8 + x] = s / 2;
|
|
484
|
+
}
|
|
485
|
+
}
|
|
486
|
+
}
|
|
487
|
+
function fdct(blk) {
|
|
488
|
+
const tmp = new Float32Array(64);
|
|
489
|
+
for (let y = 0; y < 8; y++) {
|
|
490
|
+
for (let u = 0; u < 8; u++) {
|
|
491
|
+
let s = 0;
|
|
492
|
+
for (let x = 0; x < 8; x++)
|
|
493
|
+
s += COS[x * 8 + u] * blk[y * 8 + x];
|
|
494
|
+
tmp[y * 8 + u] = s / 2;
|
|
495
|
+
}
|
|
496
|
+
}
|
|
497
|
+
for (let u = 0; u < 8; u++) {
|
|
498
|
+
for (let v = 0; v < 8; v++) {
|
|
499
|
+
let s = 0;
|
|
500
|
+
for (let y = 0; y < 8; y++)
|
|
501
|
+
s += COS[y * 8 + v] * tmp[y * 8 + u];
|
|
502
|
+
blk[v * 8 + u] = s / 2;
|
|
503
|
+
}
|
|
504
|
+
}
|
|
505
|
+
}
|
|
506
|
+
function exifOrientation(seg) {
|
|
507
|
+
if (seg.length < 14 || String.fromCharCode(...seg.subarray(0, 4)) !== "Exif")
|
|
508
|
+
return null;
|
|
509
|
+
const t = seg.subarray(6);
|
|
510
|
+
const le = t[0] === 0x49 && t[1] === 0x49;
|
|
511
|
+
if (!le && !(t[0] === 0x4d && t[1] === 0x4d))
|
|
512
|
+
return null;
|
|
513
|
+
const r16 = (i) => (le ? t[i] | (t[i + 1] << 8) : (t[i] << 8) | t[i + 1]);
|
|
514
|
+
const r32 = (i) => (le ? (r16(i) | (r16(i + 2) << 16)) >>> 0 : ((r16(i) << 16) | r16(i + 2)) >>> 0);
|
|
515
|
+
const ifd = r32(4);
|
|
516
|
+
if (ifd + 2 > t.length)
|
|
517
|
+
return null;
|
|
518
|
+
const count = r16(ifd);
|
|
519
|
+
for (let i = 0; i < count; i++) {
|
|
520
|
+
const e = ifd + 2 + i * 12;
|
|
521
|
+
if (e + 12 > t.length)
|
|
522
|
+
return null;
|
|
523
|
+
if (r16(e) === 0x0112) {
|
|
524
|
+
const v = r16(e + 8);
|
|
525
|
+
return v >= 1 && v <= 8 ? v : null;
|
|
526
|
+
}
|
|
527
|
+
}
|
|
528
|
+
return null;
|
|
529
|
+
}
|
|
530
|
+
const STD_LUMA = [
|
|
531
|
+
16, 11, 10, 16, 24, 40, 51, 61, 12, 12, 14, 19, 26, 58, 60, 55, 14, 13, 16, 24, 40, 57, 69, 56, 14, 17, 22, 29, 51, 87, 80, 62, 18, 22, 37, 56,
|
|
532
|
+
68, 109, 103, 77, 24, 35, 55, 64, 81, 104, 113, 92, 49, 64, 78, 87, 103, 121, 120, 101, 72, 92, 95, 98, 112, 100, 103, 99,
|
|
533
|
+
];
|
|
534
|
+
const STD_CHROMA = [
|
|
535
|
+
17, 18, 24, 47, 99, 99, 99, 99, 18, 21, 26, 66, 99, 99, 99, 99, 24, 26, 56, 99, 99, 99, 99, 99, 47, 66, 99, 99, 99, 99, 99, 99,
|
|
536
|
+
...new Array(32).fill(99),
|
|
537
|
+
];
|
|
538
|
+
const DC_LUMA_BITS = [0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0];
|
|
539
|
+
const DC_CHROMA_BITS = [0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0];
|
|
540
|
+
const DC_VALS = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
|
|
541
|
+
const AC_LUMA_BITS = [0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d];
|
|
542
|
+
const AC_LUMA_VALS = hex("01020300041105122131410613516107227114328191a1082342b1c11552d1f02433627282090a161718191a25262728292a3435363738393a434445464748494a535455565758595a636465666768696a737475767778797a838485868788898a92939495969798999aa2a3a4a5a6a7a8a9aab2b3b4b5b6b7b8b9bac2c3c4c5c6c7c8c9cad2d3d4d5d6d7d8d9dae1e2e3e4e5e6e7e8e9eaf1f2f3f4f5f6f7f8f9fa");
|
|
543
|
+
const AC_CHROMA_BITS = [0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77];
|
|
544
|
+
const AC_CHROMA_VALS = hex("000102031104052131061241510761711322328108144291a1b1c109233352f0156272d10a162434e125f11718191a262728292a35363738393a434445464748494a535455565758595a636465666768696a737475767778797a82838485868788898a92939495969798999aa2a3a4a5a6a7a8a9aab2b3b4b5b6b7b8b9bac2c3c4c5c6c7c8c9cad2d3d4d5d6d7d8d9dae2e3e4e5e6e7e8e9eaf2f3f4f5f6f7f8f9fa");
|
|
545
|
+
function hex(s) {
|
|
546
|
+
const out = [];
|
|
547
|
+
for (let i = 0; i < s.length; i += 2)
|
|
548
|
+
out.push(parseInt(s.slice(i, i + 2), 16));
|
|
549
|
+
return out;
|
|
550
|
+
}
|
|
551
|
+
function codes(bits, vals) {
|
|
552
|
+
const code = new Uint16Array(256);
|
|
553
|
+
const size = new Uint8Array(256);
|
|
554
|
+
let c = 0;
|
|
555
|
+
let k = 0;
|
|
556
|
+
for (let l = 1; l <= 16; l++) {
|
|
557
|
+
for (let i = 0; i < bits[l - 1]; i++) {
|
|
558
|
+
code[vals[k]] = c++;
|
|
559
|
+
size[vals[k]] = l;
|
|
560
|
+
k++;
|
|
561
|
+
}
|
|
562
|
+
c <<= 1;
|
|
563
|
+
}
|
|
564
|
+
return { code, size };
|
|
565
|
+
}
|
|
566
|
+
const DC_LUMA = codes(DC_LUMA_BITS, DC_VALS);
|
|
567
|
+
const DC_CHROMA = codes(DC_CHROMA_BITS, DC_VALS);
|
|
568
|
+
const AC_LUMA = codes(AC_LUMA_BITS, AC_LUMA_VALS);
|
|
569
|
+
const AC_CHROMA = codes(AC_CHROMA_BITS, AC_CHROMA_VALS);
|
|
570
|
+
function scaled(table, quality) {
|
|
571
|
+
const q = Math.max(1, Math.min(100, Math.round(quality)));
|
|
572
|
+
const s = q < 50 ? 5000 / q : 200 - q * 2;
|
|
573
|
+
return Int32Array.from(table, (v) => Math.max(1, Math.min(255, Math.floor((v * s + 50) / 100))));
|
|
574
|
+
}
|
|
575
|
+
export function encodeJpeg(img, quality = 82) {
|
|
576
|
+
const { width, height, data } = img;
|
|
577
|
+
if (width > 65535 || height > 65535)
|
|
578
|
+
throw new ImageError("image too large for JPEG");
|
|
579
|
+
const lq = scaled(STD_LUMA, quality);
|
|
580
|
+
const cq = scaled(STD_CHROMA, quality);
|
|
581
|
+
const sub = quality < 90 ? 2 : 1;
|
|
582
|
+
const out = [];
|
|
583
|
+
const w16 = (v) => out.push((v >> 8) & 255, v & 255);
|
|
584
|
+
const marker = (m, body) => {
|
|
585
|
+
out.push(0xff, m);
|
|
586
|
+
w16(body.length + 2);
|
|
587
|
+
for (const v of body)
|
|
588
|
+
out.push(v);
|
|
589
|
+
};
|
|
590
|
+
out.push(0xff, 0xd8);
|
|
591
|
+
marker(0xe0, [0x4a, 0x46, 0x49, 0x46, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0]);
|
|
592
|
+
marker(0xdb, [0, ...Array.from(ZIGZAG, (z) => lq[z]), 1, ...Array.from(ZIGZAG, (z) => cq[z])]);
|
|
593
|
+
marker(0xc0, [8, height >> 8, height & 255, width >> 8, width & 255, 3, 1, (sub << 4) | sub, 0, 2, 0x11, 1, 3, 0x11, 1]);
|
|
594
|
+
marker(0xc4, [
|
|
595
|
+
0x00, ...DC_LUMA_BITS, ...DC_VALS,
|
|
596
|
+
0x10, ...AC_LUMA_BITS, ...AC_LUMA_VALS,
|
|
597
|
+
0x01, ...DC_CHROMA_BITS, ...DC_VALS,
|
|
598
|
+
0x11, ...AC_CHROMA_BITS, ...AC_CHROMA_VALS,
|
|
599
|
+
]);
|
|
600
|
+
marker(0xda, [3, 1, 0x00, 2, 0x11, 3, 0x11, 0, 63, 0]);
|
|
601
|
+
let acc = 0;
|
|
602
|
+
let nacc = 0;
|
|
603
|
+
const put = (code, size) => {
|
|
604
|
+
acc = (acc << size) | (code & ((1 << size) - 1));
|
|
605
|
+
nacc += size;
|
|
606
|
+
while (nacc >= 8) {
|
|
607
|
+
const byte = (acc >> (nacc - 8)) & 255;
|
|
608
|
+
out.push(byte);
|
|
609
|
+
if (byte === 0xff)
|
|
610
|
+
out.push(0);
|
|
611
|
+
nacc -= 8;
|
|
612
|
+
acc &= (1 << nacc) - 1;
|
|
613
|
+
}
|
|
614
|
+
};
|
|
615
|
+
const category = (v) => {
|
|
616
|
+
let a = Math.abs(v);
|
|
617
|
+
let n = 0;
|
|
618
|
+
while (a) {
|
|
619
|
+
n++;
|
|
620
|
+
a >>= 1;
|
|
621
|
+
}
|
|
622
|
+
return n;
|
|
623
|
+
};
|
|
624
|
+
const bitsOf = (v, n) => (v < 0 ? v + (1 << n) - 1 : v);
|
|
625
|
+
const preds = [0, 0, 0];
|
|
626
|
+
const blk = new Float32Array(64);
|
|
627
|
+
const block = (plane, sample, q) => {
|
|
628
|
+
for (let y = 0; y < 8; y++)
|
|
629
|
+
for (let x = 0; x < 8; x++)
|
|
630
|
+
blk[y * 8 + x] = sample(x, y) - 128;
|
|
631
|
+
fdct(blk);
|
|
632
|
+
const dc = DC_LUMA_OR(plane);
|
|
633
|
+
const ac = plane === 0 ? AC_LUMA : AC_CHROMA;
|
|
634
|
+
const zz = new Int32Array(64);
|
|
635
|
+
for (let k = 0; k < 64; k++)
|
|
636
|
+
zz[k] = Math.round(blk[ZIGZAG[k]] / q[ZIGZAG[k]]);
|
|
637
|
+
const diff = zz[0] - preds[plane];
|
|
638
|
+
preds[plane] = zz[0];
|
|
639
|
+
const c = category(diff);
|
|
640
|
+
put(dc.code[c], dc.size[c]);
|
|
641
|
+
if (c)
|
|
642
|
+
put(bitsOf(diff, c), c);
|
|
643
|
+
let run = 0;
|
|
644
|
+
for (let k = 1; k < 64; k++) {
|
|
645
|
+
const v = zz[k];
|
|
646
|
+
if (v === 0) {
|
|
647
|
+
run++;
|
|
648
|
+
continue;
|
|
649
|
+
}
|
|
650
|
+
while (run > 15) {
|
|
651
|
+
put(ac.code[0xf0], ac.size[0xf0]);
|
|
652
|
+
run -= 16;
|
|
653
|
+
}
|
|
654
|
+
const s = category(v);
|
|
655
|
+
const sym = (run << 4) | s;
|
|
656
|
+
put(ac.code[sym], ac.size[sym]);
|
|
657
|
+
put(bitsOf(v, s), s);
|
|
658
|
+
run = 0;
|
|
659
|
+
}
|
|
660
|
+
if (run)
|
|
661
|
+
put(ac.code[0], ac.size[0]);
|
|
662
|
+
};
|
|
663
|
+
const DC_LUMA_OR = (plane) => (plane === 0 ? DC_LUMA : DC_CHROMA);
|
|
664
|
+
const px = (x, y) => ((Math.min(height - 1, y) * width + Math.min(width - 1, x)) * 4);
|
|
665
|
+
const Y = (x, y) => {
|
|
666
|
+
const i = px(x, y);
|
|
667
|
+
return 0.299 * data[i] + 0.587 * data[i + 1] + 0.114 * data[i + 2];
|
|
668
|
+
};
|
|
669
|
+
const C = (x, y, which) => {
|
|
670
|
+
let s = 0;
|
|
671
|
+
for (let dy = 0; dy < sub; dy++) {
|
|
672
|
+
for (let dx = 0; dx < sub; dx++) {
|
|
673
|
+
const i = px(x * sub + dx, y * sub + dy);
|
|
674
|
+
const r = data[i];
|
|
675
|
+
const g = data[i + 1];
|
|
676
|
+
const b = data[i + 2];
|
|
677
|
+
s += which === 1 ? -0.168736 * r - 0.331264 * g + 0.5 * b + 128 : 0.5 * r - 0.418688 * g - 0.081312 * b + 128;
|
|
678
|
+
}
|
|
679
|
+
}
|
|
680
|
+
return s / (sub * sub);
|
|
681
|
+
};
|
|
682
|
+
const mcu = 8 * sub;
|
|
683
|
+
for (let my = 0; my < height; my += mcu) {
|
|
684
|
+
for (let mx = 0; mx < width; mx += mcu) {
|
|
685
|
+
for (let by = 0; by < sub; by++) {
|
|
686
|
+
for (let bx = 0; bx < sub; bx++)
|
|
687
|
+
block(0, (x, y) => Y(mx + bx * 8 + x, my + by * 8 + y), lq);
|
|
688
|
+
}
|
|
689
|
+
block(1, (x, y) => C(mx / sub + x, my / sub + y, 1), cq);
|
|
690
|
+
block(2, (x, y) => C(mx / sub + x, my / sub + y, 2), cq);
|
|
691
|
+
}
|
|
692
|
+
}
|
|
693
|
+
if (nacc)
|
|
694
|
+
put(0x7f, 8 - nacc);
|
|
695
|
+
out.push(0xff, 0xd9);
|
|
696
|
+
return Uint8Array.from(out);
|
|
697
|
+
}
|
|
@@ -0,0 +1,8 @@
|
|
|
1
|
+
import { type Bitmap } from "./bitmap.js";
|
|
2
|
+
export declare function isPng(b: Uint8Array): boolean;
|
|
3
|
+
export declare function pngSize(b: Uint8Array): {
|
|
4
|
+
width: number;
|
|
5
|
+
height: number;
|
|
6
|
+
};
|
|
7
|
+
export declare function decodePng(b: Uint8Array, maxPixels: number): Bitmap;
|
|
8
|
+
export declare function encodePng(img: Bitmap): Uint8Array;
|