tools: group scripts by what runs them
tools/windows/ .ps1 (pwsh, so usable from Linux and macOS too)
tools/posix/ .sh
tools/python/ .py
tools/ .c and .pl
The .c and .pl files stay at the top level because they are not
host-specific: the build compiles or invokes them on every platform.
Call sites updated in the Makefile, ports/mk/port.mk, docs and the
project memory. The one thing that does not survive a move on its own is
a script deriving the repo root from its own location -- all nine
PowerShell tools used Split-Path $PSScriptRoot -Parent, and memory-sync.sh
used dirname/.., both of which quietly become tools/ one level deeper.
Two levels now.
Two pre-existing Windows failures surfaced while verifying, both real and
neither caused by the move:
- schfs_fsck.c did not compile under mingw at all: --extract uses
POSIX mkdir(path,mode), symlink() and link(), none of which mingw
has. That took the whole tool with it, and `make schfs-check` with
it. mkdir maps to _mkdir; symlink and link fail loudly rather than
writing a regular file in their place, because an extracted tree
that differs from the image while reporting success defeats the
point of --extract.
- the round-trip test then failed at `ln -s`, since Git Bash cannot
create symlinks without developer mode. It skips with a message now.
Not a fudge: mkschfs's mingw build cannot see a symlink either, so
the test would have compared a tree with none against an image with
none and called it a pass -- coverage reporting itself as present
while being absent.
Verified on Windows: build clean, all seven bootcheck suites green,
make schfs-check passes.
This commit is contained in:
Nexoniarz
parent
531ef120ef
commit
754d96ebc5
26 changed files with 127 additions and 39 deletions
184
tools/mklogo.py
184
tools/mklogo.py
|
|
@ -1,184 +0,0 @@
|
|||
#!/usr/bin/env python3
|
||||
"""Turn Assets/*.png into a C header the kernel can draw.
|
||||
|
||||
Why this exists rather than a PNG decoder in the kernel: the boot logo is one
|
||||
fixed image that changes about never, so decoding it at runtime would mean
|
||||
carrying an inflate implementation in the kernel forever to answer a question
|
||||
that is already known at build time. Precedent is include/font.h, which is the
|
||||
same trade for the same reason.
|
||||
|
||||
Output is an 8-bit coverage mask, not colour. The logo is a single-colour
|
||||
silhouette (a monogram in a ring), so what matters is *how much* of each pixel
|
||||
is ink -- which lets the kernel composite it in whatever the theme's accent
|
||||
happens to be, anti-aliased, at one byte per pixel. Storing RGB would be four
|
||||
times the size and would hardcode a colour into the kernel image.
|
||||
|
||||
python3 tools/mklogo.py "Assets/SchOS Small Logo.png" include/logo.h 128
|
||||
"""
|
||||
|
||||
import sys, zlib, struct
|
||||
|
||||
|
||||
def read_png(path):
|
||||
d = open(path, 'rb').read()
|
||||
if d[:8] != b'\x89PNG\r\n\x1a\n':
|
||||
raise SystemExit(f'{path}: not a PNG')
|
||||
pos, idat, w, h, bd, ct = 8, b'', 0, 0, 0, 0
|
||||
while pos < len(d):
|
||||
ln, typ = struct.unpack('>I4s', d[pos:pos + 8])
|
||||
body = d[pos + 8:pos + 8 + ln]
|
||||
if typ == b'IHDR':
|
||||
w, h, bd, ct = struct.unpack('>IIBB', body[:10])
|
||||
elif typ == b'IDAT':
|
||||
idat += body
|
||||
elif typ == b'IEND':
|
||||
break
|
||||
pos += 12 + ln
|
||||
if bd != 8 or ct not in (2, 6):
|
||||
raise SystemExit(f'{path}: need 8-bit RGB or RGBA, got depth={bd} type={ct}')
|
||||
nch = 4 if ct == 6 else 3
|
||||
raw = zlib.decompress(idat)
|
||||
|
||||
# Undo PNG's per-scanline filters. Each row is prefixed with a filter byte
|
||||
# and predicted from the row above and the pixel to the left; without this
|
||||
# step the data is not an image at all.
|
||||
stride = w * nch
|
||||
out = bytearray(h * stride)
|
||||
prev = bytearray(stride)
|
||||
p = 0
|
||||
for y in range(h):
|
||||
f = raw[p]; p += 1
|
||||
cur = bytearray(raw[p:p + stride]); p += stride
|
||||
if f == 1:
|
||||
for i in range(nch, stride):
|
||||
cur[i] = (cur[i] + cur[i - nch]) & 0xFF
|
||||
elif f == 2:
|
||||
for i in range(stride):
|
||||
cur[i] = (cur[i] + prev[i]) & 0xFF
|
||||
elif f == 3:
|
||||
for i in range(stride):
|
||||
a = cur[i - nch] if i >= nch else 0
|
||||
cur[i] = (cur[i] + ((a + prev[i]) >> 1)) & 0xFF
|
||||
elif f == 4:
|
||||
for i in range(stride):
|
||||
a = cur[i - nch] if i >= nch else 0
|
||||
b = prev[i]
|
||||
c = prev[i - nch] if i >= nch else 0
|
||||
pa, pb, pc = abs(b - c), abs(a - c), abs(a + b - 2 * c)
|
||||
pr = a if (pa <= pb and pa <= pc) else (b if pb <= pc else c)
|
||||
cur[i] = (cur[i] + pr) & 0xFF
|
||||
elif f != 0:
|
||||
raise SystemExit(f'unknown PNG filter {f}')
|
||||
out[y * stride:(y + 1) * stride] = cur
|
||||
prev = cur
|
||||
return w, h, nch, out
|
||||
|
||||
|
||||
def ink(px, nch, x, y, w):
|
||||
"""How much ink is at (x, y), 0..255.
|
||||
|
||||
The source is a dark mark on white with an alpha channel. Ink is therefore
|
||||
'opaque and not white': darkness weighted by alpha. Using luminance alone
|
||||
would make the transparent margin count as black.
|
||||
"""
|
||||
i = (y * w + x) * nch
|
||||
r, g, b = px[i], px[i + 1], px[i + 2]
|
||||
a = px[i + 3] if nch == 4 else 255
|
||||
lum = (r * 299 + g * 587 + b * 114) // 1000
|
||||
return ((255 - lum) * a) // 255
|
||||
|
||||
|
||||
def main():
|
||||
if len(sys.argv) < 3:
|
||||
raise SystemExit(__doc__)
|
||||
src, dst = sys.argv[1], sys.argv[2]
|
||||
size = int(sys.argv[3]) if len(sys.argv) > 3 else 128
|
||||
|
||||
w, h, nch, px = read_png(src)
|
||||
|
||||
# Crop to the mark. These files are 1920x1080 with the logo floating in a
|
||||
# large empty field; scaling that whole canvas down would waste most of the
|
||||
# output on margin and leave the mark tiny.
|
||||
x0, y0, x1, y1 = w, h, -1, -1
|
||||
for y in range(h):
|
||||
for x in range(w):
|
||||
if ink(px, nch, x, y, w) > 24:
|
||||
if x < x0: x0 = x
|
||||
if y < y0: y0 = y
|
||||
if x > x1: x1 = x
|
||||
if y > y1: y1 = y
|
||||
if x1 < 0:
|
||||
raise SystemExit(f'{src}: no non-white pixels found')
|
||||
|
||||
# Square the crop so the aspect ratio survives the scale.
|
||||
cw, ch = x1 - x0 + 1, y1 - y0 + 1
|
||||
side = max(cw, ch)
|
||||
x0 -= (side - cw) // 2
|
||||
y0 -= (side - ch) // 2
|
||||
|
||||
# Box filter. Averaging every source pixel that lands in an output cell is
|
||||
# what keeps the ring's edge smooth; nearest-neighbour at this reduction
|
||||
# ratio (roughly 8:1) would break it into dashes.
|
||||
mask = bytearray(size * size)
|
||||
for oy in range(size):
|
||||
sy0 = y0 + oy * side // size
|
||||
sy1 = max(sy0 + 1, y0 + (oy + 1) * side // size)
|
||||
for ox in range(size):
|
||||
sx0 = x0 + ox * side // size
|
||||
sx1 = max(sx0 + 1, x0 + (ox + 1) * side // size)
|
||||
tot = n = 0
|
||||
for sy in range(sy0, sy1):
|
||||
if sy < 0 or sy >= h: continue
|
||||
for sx in range(sx0, sx1):
|
||||
if sx < 0 or sx >= w: continue
|
||||
tot += ink(px, nch, sx, sy, w); n += 1
|
||||
mask[oy * size + ox] = tot // n if n else 0
|
||||
|
||||
# Normalise to full strength. The source art is a mid-grey gradient on
|
||||
# white, so its darkest pixel is only about 60% "ink" -- composited as-is
|
||||
# against a near-black background the mark comes out muddy. Scaling by the
|
||||
# peak keeps the gradient's internal shape (the relative values are
|
||||
# unchanged) while letting the brightest part of the logo actually reach the
|
||||
# accent colour.
|
||||
peak = max(mask)
|
||||
if peak:
|
||||
for i, v in enumerate(mask):
|
||||
mask[i] = min(255, v * 255 // peak)
|
||||
|
||||
# Pack two pixels per byte. This header is included by the *bootloader* as
|
||||
# well as the kernel, and stage2 has to fit between 0x7E00 and the 0x10000
|
||||
# kernel-search buffer -- so the mask's size is a boot-time constraint, not
|
||||
# just a matter of taste. 16 grey levels is visually indistinguishable from
|
||||
# 256 for a single-colour mark, and halves the cost.
|
||||
packed = bytearray(len(mask) // 2)
|
||||
for i in range(0, len(mask), 2):
|
||||
packed[i // 2] = ((mask[i] // 17) << 4) | (mask[i + 1] // 17)
|
||||
|
||||
with open(dst, 'w', newline='\n') as f:
|
||||
f.write('#pragma once\n\n')
|
||||
f.write('// GENERATED by tools/mklogo.py -- do not edit. Run `make logo`.\n')
|
||||
f.write(f'// source: {src}\n')
|
||||
f.write('//\n')
|
||||
f.write('// An ink-coverage mask, not colour: 0 is background and full scale is\n')
|
||||
f.write('// solid logo. Whoever draws it picks the colour, so the palette stays in\n')
|
||||
f.write('// include/theme.h and can change without regenerating anything.\n')
|
||||
f.write('//\n')
|
||||
f.write('// Two pixels per byte, high nibble first. Included by boot/stage2main.c\n')
|
||||
f.write('// as well as kernel/dev/vga.c, and stage2 must fit below the 0x10000\n')
|
||||
f.write('// kernel-search buffer -- hence 4 bits rather than 8.\n\n')
|
||||
f.write(f'#define LOGO_W {size}\n#define LOGO_H {size}\n\n')
|
||||
f.write('// Ink at linear pixel index i, 0..255.\n')
|
||||
f.write('#define LOGO_INK(i) ((unsigned char)((((i) & 1) '
|
||||
'? (logo_mask[(i) >> 1] & 0xF) \\\n')
|
||||
f.write(' : (logo_mask[(i) >> 1] >> 4)) * 17))\n\n')
|
||||
f.write('static const unsigned char logo_mask[LOGO_W * LOGO_H / 2] = {\n')
|
||||
for i in range(0, len(packed), 16):
|
||||
f.write(' ' + ','.join('0x%02x' % b for b in packed[i:i + 16]) + ',\n')
|
||||
f.write('};\n')
|
||||
|
||||
nz = sum(1 for b in mask if b)
|
||||
print(f'{dst}: {size}x{size}, cropped from {cw}x{ch} at ({x0},{y0}), '
|
||||
f'{nz} inked pixels, {len(packed)} bytes packed (4bpp)')
|
||||
|
||||
|
||||
main()
|
||||
Loading…
Reference in a new issue