prosolis
f1007a0dbc
ROADMAP K2. DLXP1: a 49,664 B record that is 97 sectors exactly, no index and no length word, because a packed record's length is geometry rather than content. 582.0 KB/s, which is what FINDINGS 61.9 predicted to the tenth, and it encodes in 3.3 s because there is no k-means in it. px68k's own x68k/gvram.c renders the container's bytes index-exact with the harness computing no interleave -- the only test that can catch an encoder whose byte order is wrong, since a container round-trips against its own inverse either way. Both negative controls fail as they must. The picture is re-derived against this project's builder rather than PIL's (34.05 dB against 61.9's 34.08) and the GGGGGRRRRRBBBBBI word is charged for the first time in this tree: 0.53 dB, on every row, so it moves no comparison. What the control found is the finding. A packed container on a SCENE palette lands exactly on the codec's ceiling, so the whole +2.31 dB is the per-frame palette and nothing else -- and 231 of 256 entries change every frame, which makes a mismatched paint 12.8 dB worse than the correct pairing, on screen for roughly half of every frame slot if buffer mode does not blank. So B2 now decides which packed CONTAINER ships, not only which player. The fallback is already a flag: --scene-palette --no-palette is 30.79 dB, zero churn, 576.0 KB/s and still +2.07 dB on the shipping codec. 62.5 is priced and is a wash: palette first 20.32 dB, palette last 20.33. Claude-Session: https://claude.ai/code/session_01194oWYW8DQXK1SZ2DnChW6
88 lines
3.5 KiB
Python
88 lines
3.5 KiB
Python
#!/usr/bin/env python3
|
|
"""The PACKED CONTAINER's own bytes, through px68k's real GVRAM code.
|
|
|
|
python3 tools/bench/gvpack/verify_dlxp.py [packed.dlxp] [frame] [--controls]
|
|
|
|
`verify_gvpack.py` checks the LAYOUT: it hands the harness a picture and lets
|
|
the harness compute the interleave, so what it proves is that FINDINGS 47.2's
|
|
scheme renders. This checks the CONTAINER: it writes a DLXP1 record's bytes
|
|
into GVRAM VERBATIM -- no interleave computed anywhere in the harness -- and
|
|
asks px68k what they display as. That is the only way to test a format whose
|
|
whole design is that nothing parses it (dlxp.py): if the encoder's byte order
|
|
were wrong, every check upstream of the display would still pass, because the
|
|
container round-trips against its own inverse.
|
|
|
|
It is the same second-emulator argument tools/bench/c68k makes for cycles: the
|
|
address decode, the R20 bit-11 write path, the page-byte selection, the scroll
|
|
wrap and the index-0 transparency test are px68k's own `x68k/gvram.c`.
|
|
|
|
Two negative controls, because a test that cannot fail proves nothing, and both
|
|
are mechanisms this container depends on rather than decoration:
|
|
--nobuffer R20 bit 11 CLEAR -- the high byte of every word is masked away,
|
|
so page 1 (columns 128..255) never gets written
|
|
--noscroll page 1 unscrolled -- its storage sits under the wrong columns
|
|
"""
|
|
import os, struct, subprocess, sys
|
|
sys.path.insert(0, "tools/encoder")
|
|
import numpy as np
|
|
from dlxp import DLXP
|
|
|
|
args = [x for x in sys.argv[1:] if not x.startswith("--")]
|
|
path = args[0] if args else "tmp/packed_singe.dlxp"
|
|
frame = int(args[1]) if len(args) > 1 else 0
|
|
controls = "--controls" in sys.argv
|
|
|
|
d = DLXP(path)
|
|
_, pic = d._split(frame)
|
|
blob = b"DLXQ" + struct.pack(">HH", d.W, d.H) + b"\0" * 768 + pic
|
|
open("tmp/dlxp_gvpack.bin", "wb").write(blob)
|
|
|
|
BIN = "tools/bench/gvpack/gvpack"
|
|
if not os.path.exists(BIN):
|
|
sys.exit(f"{BIN} not built -- make -C tools/bench/gvpack PX68K=...")
|
|
|
|
|
|
def run(extra=None):
|
|
cmd = [BIN, "tmp/dlxp_gvpack.bin", "tmp/dlxp_gvpack.raw", "--packed", "0x02"]
|
|
if extra:
|
|
cmd.append(extra)
|
|
subprocess.run(cmd, check=True, stderr=subprocess.DEVNULL)
|
|
g = np.frombuffer(open("tmp/dlxp_gvpack.raw", "rb").read(), np.uint8)
|
|
return g.reshape(256, 256)
|
|
|
|
|
|
want = d.indices(frame)
|
|
yoff = (256 - d.H) // 2
|
|
g = run()
|
|
act = g[yoff:yoff + d.H]
|
|
|
|
fail = []
|
|
if not np.array_equal(act, want):
|
|
bad = act != want
|
|
fail.append(f"{bad.sum()} px differ (left half {bad[:, :128].sum()}, "
|
|
f"right half {bad[:, 128:].sum()})")
|
|
bars = np.concatenate([g[:yoff], g[yoff + d.H:]])
|
|
if bars.size and (bars != 255).any():
|
|
fail.append(f"letterbox is not index 255: {(bars != 255).sum()} px")
|
|
if (act == 0).any():
|
|
fail.append(f"index 0 reached the screen: {(act == 0).sum()} px")
|
|
|
|
if controls and not fail:
|
|
for flag, why in (("--nobuffer", "R20 bit 11 clear"),
|
|
("--noscroll", "page 1 unscrolled")):
|
|
c = run(flag)[yoff:yoff + d.H]
|
|
n = int((c != want).sum())
|
|
print(f" control {flag:<11s} ({why}): {n:,} px differ"
|
|
+ ("" if n else " <-- IT DID NOT FAIL"))
|
|
if not n:
|
|
fail.append(f"control {flag} passed -- the test cannot fail on it")
|
|
|
|
for x in fail:
|
|
print("FAIL " + x)
|
|
if fail:
|
|
sys.exit(1)
|
|
print(f"OK {os.path.basename(path)} frame {frame}: px68k's own gvram.c renders "
|
|
f"the container's {d.pic_bytes:,} bytes index-exact over {d.W}x{d.H},")
|
|
print(f" letterbox on the reserved black, and the transparency key never "
|
|
f"reaches the screen. The harness computed no interleave.")
|