First public commit.
This commit is contained in:
The Dust Council
parent
2a48f52979
commit
4bac9d83ed
288 changed files with 18417 additions and 1076 deletions
|
|
@ -14,9 +14,9 @@ import numpy as np
|
|||
|
||||
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||||
|
||||
from c64view import imageprep, palette as pal # noqa: E402
|
||||
from c64view.convert import fli, hires, ifli, multicolor # noqa: E402
|
||||
from c64view.viewer.assemble import SOURCES, build_viewer_prg, have_xa # noqa: E402
|
||||
from lenser import imageprep, palette as pal # noqa: E402
|
||||
from lenser.convert import fli, hires, ifli, multicolor # noqa: E402
|
||||
from lenser.viewer.assemble import SOURCES, build_viewer_prg, have_xa # noqa: E402
|
||||
|
||||
|
||||
def _gradient(w, h):
|
||||
|
|
@ -94,12 +94,449 @@ def test_interlace_blend_better():
|
|||
assert len(ifli.convert(img).data) == 25577
|
||||
|
||||
|
||||
def test_vic20_multicolor_roundtrip():
|
||||
from lenser.vic20.convert import multicolor as vmc
|
||||
img = imageprep.prepare(_imgobj(vmc.WIDTH, vmc.HEIGHT), vmc.WIDTH, vmc.HEIGHT,
|
||||
vmc.PIXEL_ASPECT, imageprep.PrepOptions())
|
||||
c = vmc.convert(img)
|
||||
d = c.data
|
||||
chardata, screen, color = d["chardata"], d["screen"], d["color"]
|
||||
bg, border, aux = d["bg"], d["border"], d["aux"]
|
||||
dec = np.zeros((vmc.HEIGHT, vmc.WIDTH), np.uint8)
|
||||
for cr in range(vmc.N_ROWS):
|
||||
for cc in range(vmc.N_COLS):
|
||||
ci = cr * vmc.N_COLS + cc
|
||||
f = color[ci] & 0x07
|
||||
lut = [bg, border, f, aux]
|
||||
ch = int(screen[ci])
|
||||
for r in range(8):
|
||||
byte = chardata[ch * 8 + r]
|
||||
for x in range(4):
|
||||
code = (byte >> (6 - 2 * x)) & 3
|
||||
dec[cr * 8 + r, cc * 4 + x] = lut[code]
|
||||
assert np.array_equal(dec, c.index_image)
|
||||
# colour RAM must flag multicolour (bit 3) and keep fg within 0-7
|
||||
assert np.all((color & 0x08) == 0x08)
|
||||
assert np.all((color & 0x07) <= 7)
|
||||
|
||||
|
||||
def test_vic20_hires_roundtrip():
|
||||
from lenser.vic20.convert import hires as vhi
|
||||
img = imageprep.prepare(_imgobj(vhi.WIDTH, vhi.HEIGHT), vhi.WIDTH, vhi.HEIGHT,
|
||||
vhi.PIXEL_ASPECT, imageprep.PrepOptions())
|
||||
c = vhi.convert(img)
|
||||
d = c.data
|
||||
chardata, screen, color = d["chardata"], d["screen"], d["color"]
|
||||
bg = d["bg"]
|
||||
dec = np.zeros((vhi.HEIGHT, vhi.WIDTH), np.uint8)
|
||||
for cr in range(vhi.N_ROWS):
|
||||
for cc in range(vhi.N_COLS):
|
||||
ci = cr * vhi.N_COLS + cc
|
||||
f = color[ci] & 0x07
|
||||
ch = int(screen[ci])
|
||||
for r in range(8):
|
||||
byte = chardata[ch * 8 + r]
|
||||
for x in range(8):
|
||||
dec[cr * 8 + r, cc * 8 + x] = f if (byte >> (7 - x)) & 1 else bg
|
||||
assert np.array_equal(dec, c.index_image)
|
||||
|
||||
|
||||
def test_spectrum_roundtrip():
|
||||
from lenser.spectrum.convert import hires as zh
|
||||
from lenser.spectrum import palette as zpal
|
||||
img = imageprep.prepare(_imgobj(zh.WIDTH, zh.HEIGHT), zh.WIDTH, zh.HEIGHT,
|
||||
zh.PIXEL_ASPECT, imageprep.PrepOptions())
|
||||
c = zh.convert(img)
|
||||
scr = c.data
|
||||
assert len(scr) == 6912
|
||||
dec = np.zeros((zh.HEIGHT, zh.WIDTH), np.uint8)
|
||||
for cy in range(zh.N_ROWS):
|
||||
for cx in range(zh.N_COLS):
|
||||
attr = scr[6144 + cy * 32 + cx]
|
||||
bright = (attr >> 6) & 1
|
||||
ink = (bright << 3) | (attr & 7)
|
||||
paper = (bright << 3) | ((attr >> 3) & 7)
|
||||
for r in range(8):
|
||||
y = cy * 8 + r
|
||||
byte = scr[zh._bitmap_offset(y, cx)]
|
||||
for px in range(8):
|
||||
bit = (byte >> (7 - px)) & 1
|
||||
dec[y, cx * 8 + px] = ink if bit else paper
|
||||
assert np.array_equal(dec, c.index_image)
|
||||
# every cell's two colours must share the BRIGHT bit (no normal/bright mix)
|
||||
for cy in range(zh.N_ROWS):
|
||||
for cx in range(zh.N_COLS):
|
||||
attr = scr[6144 + cy * 32 + cx]
|
||||
assert (attr & 0x80) == 0 # FLASH never set
|
||||
|
||||
|
||||
def test_mono_modes_available_and_convert():
|
||||
"""EVERY platform offers a monochrome mode that converts to a luminance-
|
||||
matched image (indices restricted to its grey ramp)."""
|
||||
from lenser import platforms
|
||||
for p in platforms.PLATFORMS:
|
||||
assert "mono" in platforms.modes(p), f"{p} missing mono mode"
|
||||
# the mono mode actually converts (greyscale) on every platform
|
||||
prep0 = imageprep.PrepOptions()
|
||||
src = _imgobj(320, 200)
|
||||
for p in platforms.PLATFORMS:
|
||||
c = platforms.convert(p, src, "mono", platforms.palettes(p)[0],
|
||||
"floyd", False, prep0, "grayscale")
|
||||
assert c.mode == "mono", f"{p} mono did not report mode 'mono'"
|
||||
prep = imageprep.PrepOptions()
|
||||
img = _imgobj(256, 192)
|
||||
# ti99 + spectrum mono decode exactly like their gm2 / hires colour formats
|
||||
from lenser.ti99.convert import convert_image as ti
|
||||
c = ti(img, mode="mono", dither_mode="atkinson")
|
||||
assert len(c.data) == 6912 and c.mode == "mono"
|
||||
from lenser.spectrum.convert import convert_image as zx
|
||||
c = zx(img, mode="mono", dither_mode="atkinson")
|
||||
assert len(c.data) == 6912
|
||||
# dictionary platforms: mono produces the same data dict their viewer expects
|
||||
from lenser.vic20.convert import convert_image as v
|
||||
d = v(img, mode="mono", dither_mode="floyd").data
|
||||
assert d["bg"] == 0 and len(d["chardata"]) == 2048 and d["color"].max() <= 7
|
||||
from lenser.intv.convert import convert_image as iv
|
||||
d = iv(img, mode="mono", dither_mode="none").data
|
||||
assert len(d["gram"]) == 64 * 8 and len(d["cards"]) == 240
|
||||
|
||||
|
||||
def test_a5200_cart():
|
||||
"""Atari 5200 reuses the Atari GTIA encoders and packs a 32K cartridge whose
|
||||
display list + bitmap ANTIC reads straight from ROM."""
|
||||
from lenser.a5200.convert import convert_image
|
||||
from lenser.a5200.viewer.assemble import build_cart, have_xa, BITMAP_ADDR
|
||||
img = _imgobj(160, 192)
|
||||
for mode in ("gr15", "gr8", "gr9"):
|
||||
c = convert_image(img, mode=mode, dither_mode="floyd")
|
||||
assert c.mode == mode
|
||||
if not have_xa():
|
||||
continue
|
||||
# all three display durations assemble + pack to 32K
|
||||
for disp, secs in (("forever", 0), ("key", 0), ("seconds", 10)):
|
||||
rom = build_cart(c.mode, bytes(c.data), display=disp, seconds=secs)
|
||||
assert len(rom) == 0x8000 # 32K
|
||||
# start vector at $BFFE-F points into the cart
|
||||
start = rom[0xBFFE - 0x4000] | (rom[0xBFFF - 0x4000] << 8)
|
||||
assert start == 0x4000
|
||||
# bitmap landed at $6000 (so the 4K split maps to $6000/$7000)
|
||||
assert rom[BITMAP_ADDR - 0x4000:BITMAP_ADDR - 0x4000 + 8] == c.data[:8]
|
||||
|
||||
|
||||
def test_a7800_cart():
|
||||
"""Atari 7800 (MARIA) packs a 48K .a78 with the bitmap + display lists + DLL
|
||||
that MARIA DMAs from ROM."""
|
||||
from lenser.a7800.convert import convert_image
|
||||
from lenser.a7800.viewer.assemble import (build_cart, have_xa, BITMAP_ADDR,
|
||||
DLL_ADDR, LINES, N_SEG)
|
||||
img = _imgobj(160, 192)
|
||||
for mode in ("c160", "mono"):
|
||||
c = convert_image(img, mode=mode, dither_mode="floyd")
|
||||
assert c.mode == mode
|
||||
# data = bitmap(7680) + seg_palettes(192*4) + colours(25)
|
||||
assert len(c.data) == 7680 + LINES * N_SEG + 25
|
||||
assert all(p < 8 for p in c.data[7680:7680 + LINES * N_SEG]) # palette 0-7
|
||||
if not have_xa():
|
||||
continue
|
||||
rom = build_cart(bytes(c.data), title="t")
|
||||
assert len(rom) == 128 + 0xC000 # header + 48K
|
||||
assert rom[1:1 + 9] == b"ATARI7800" # .a78 signature
|
||||
body = rom[128:]
|
||||
# reset vector points at the viewer entry ($4000)
|
||||
assert body[0xFFFC - 0x4000] | (body[0xFFFD - 0x4000] << 8) == 0x4000
|
||||
# bitmap landed at $8000
|
||||
assert body[BITMAP_ADDR - 0x4000:BITMAP_ADDR - 0x4000 + 8] == c.data[:8]
|
||||
|
||||
|
||||
def test_spectrum_sna():
|
||||
from lenser.spectrum.convert import hires as zh
|
||||
from lenser.spectrum import snapshot
|
||||
img = imageprep.prepare(_imgobj(zh.WIDTH, zh.HEIGHT), zh.WIDTH, zh.HEIGHT,
|
||||
zh.PIXEL_ASPECT, imageprep.PrepOptions())
|
||||
sna = snapshot.build_sna(zh.convert(img).data, border=0)
|
||||
assert len(sna) == 27 + 49152 # header + 48K RAM
|
||||
ram = sna[27:]
|
||||
assert ram[0x8000 - 0x4000:0x8000 - 0x4000 + 3] == bytes([0xF3, 0x18, 0xFE])
|
||||
# SP (header offset 0x17) points at the stub return address
|
||||
sp = sna[0x17] | (sna[0x18] << 8)
|
||||
lo = ram[sp - 0x4000]; hi = ram[sp - 0x4000 + 1]
|
||||
assert (lo | (hi << 8)) == 0x8000
|
||||
|
||||
|
||||
def test_vic20_cart_builds():
|
||||
from lenser.vic20.viewer.assemble import build_cart, have_xa
|
||||
if not have_xa():
|
||||
return # xa not installed; skip
|
||||
from lenser.vic20.convert import multicolor as vmc
|
||||
img = imageprep.prepare(_imgobj(vmc.WIDTH, vmc.HEIGHT), vmc.WIDTH, vmc.HEIGHT,
|
||||
vmc.PIXEL_ASPECT, imageprep.PrepOptions())
|
||||
rom = build_cart(vmc.convert(img).data)
|
||||
assert len(rom) == 0x2000 # full 8K cart
|
||||
assert rom[4:9] == bytes([0x41, 0x30, 0xC3, 0xC2, 0xCD]) # "A0CBM" signature
|
||||
|
||||
|
||||
def test_c128_mono_prg():
|
||||
# mono is high-res greyscale via the custom-charset (font) path, like hicolor
|
||||
from lenser.c128.convert import mono as c128mono, hicolor as hc
|
||||
from lenser.c128.viewer.assemble import (build_prg_hicolor, have_xa,
|
||||
BASIC_START, DATA_ORG, _STUB)
|
||||
img = imageprep.prepare(_imgobj(c128mono.WIDTH, c128mono.HEIGHT),
|
||||
c128mono.WIDTH, c128mono.HEIGHT,
|
||||
c128mono.PIXEL_ASPECT, imageprep.PrepOptions())
|
||||
conv = c128mono.convert(img)
|
||||
assert conv.mode == "mono"
|
||||
assert len(conv.data) == hc.VDC_LEN # full VDC RAM image
|
||||
assert conv.meta["vdc_mode"] == "hicolor" # uses the font-mode viewer
|
||||
# mono only uses the four greys, so every cell's ink is one of them
|
||||
greys = set(c128mono.GREYS)
|
||||
attrs = conv.data[hc.ATTR_ADDR:hc.ATTR_ADDR + hc.ROWS * hc.COLS]
|
||||
assert all((b & 0x0F) in greys for b in attrs)
|
||||
if not have_xa():
|
||||
return # xa not installed; skip the assembly half
|
||||
prg = build_prg_hicolor(bytes(conv.data), conv.meta["fgbg"])
|
||||
assert prg[:2] == bytes([BASIC_START & 0xFF, BASIC_START >> 8]) # load $1C01
|
||||
assert prg[2:2 + len(_STUB)] == _STUB # BASIC 10 SYS7200 stub
|
||||
assert bytes(prg[-hc.VDC_LEN:]) == bytes(conv.data)
|
||||
assert len(prg) == 2 + (DATA_ORG - BASIC_START) + hc.VDC_LEN
|
||||
|
||||
|
||||
def test_c128_color_prg():
|
||||
from lenser.c128.convert import color as c128color
|
||||
from lenser.c128.viewer.assemble import (build_prg_color, have_xa,
|
||||
BASIC_START, DATA_ORG)
|
||||
img = imageprep.prepare(_imgobj(c128color.WIDTH, c128color.HEIGHT),
|
||||
c128color.WIDTH, c128color.HEIGHT,
|
||||
c128color.PIXEL_ASPECT, imageprep.PrepOptions())
|
||||
conv = c128color.convert(img)
|
||||
assert len(conv.data) == 8000 # 80x100 attribute bytes
|
||||
assert conv.meta["vdc_mode"] == "color"
|
||||
# colour lives in the high nibble; low nibble (bg) is 0
|
||||
assert all((b & 0x0F) == 0 for b in conv.data)
|
||||
if not have_xa():
|
||||
return
|
||||
prg = build_prg_color(bytes(conv.data), conv.meta["fgbg"])
|
||||
assert prg[:2] == bytes([BASIC_START & 0xFF, BASIC_START >> 8])
|
||||
assert bytes(prg[-8000:]) == bytes(conv.data) # attributes land at $2000
|
||||
assert len(prg) == 2 + (DATA_ORG - BASIC_START) + 8000
|
||||
|
||||
|
||||
def test_c128_hicolor_prg():
|
||||
from lenser.c128.convert import hicolor as hc
|
||||
from lenser.c128.viewer.assemble import (build_prg_hicolor, have_xa,
|
||||
BASIC_START, DATA_ORG)
|
||||
img = imageprep.prepare(_imgobj(hc.WIDTH, hc.HEIGHT), hc.WIDTH, hc.HEIGHT,
|
||||
hc.PIXEL_ASPECT, imageprep.PrepOptions())
|
||||
conv = hc.convert(img)
|
||||
assert len(conv.data) == hc.VDC_LEN # full 16K VDC RAM image
|
||||
assert conv.meta["vdc_mode"] == "hicolor"
|
||||
# ink in the low nibble, bit 7 may select bank 1; blink/underline/reverse off
|
||||
attrs = conv.data[hc.ATTR_ADDR:hc.ATTR_ADDR + hc.ROWS * hc.COLS]
|
||||
assert all((b & 0x70) == 0 for b in attrs)
|
||||
if not have_xa():
|
||||
return
|
||||
prg = build_prg_hicolor(bytes(conv.data), conv.meta["fgbg"])
|
||||
assert prg[:2] == bytes([BASIC_START & 0xFF, BASIC_START >> 8])
|
||||
assert bytes(prg[-hc.VDC_LEN:]) == bytes(conv.data)
|
||||
assert len(prg) == 2 + (DATA_ORG - BASIC_START) + hc.VDC_LEN
|
||||
|
||||
|
||||
def test_c16_hires_prg():
|
||||
from lenser.c16.convert import hires as c16h
|
||||
from lenser.c16.viewer.assemble import (build_prg, have_xa, BASIC_START,
|
||||
BITMAP_ORG, _STUB)
|
||||
img = imageprep.prepare(_imgobj(c16h.WIDTH, c16h.HEIGHT), c16h.WIDTH,
|
||||
c16h.HEIGHT, c16h.PIXEL_ASPECT, imageprep.PrepOptions())
|
||||
conv = c16h.convert(img)
|
||||
assert conv.mode == "hires"
|
||||
assert len(conv.data) == 10000 # bitmap 8000 + attr 1000 + ch 1000
|
||||
if not have_xa():
|
||||
return
|
||||
prg = build_prg(bytes(conv.data))
|
||||
assert prg[:2] == bytes([BASIC_START & 0xFF, BASIC_START >> 8]) # load $1001
|
||||
assert prg[2:2 + len(_STUB)] == _STUB # 10 SYS4128
|
||||
# the 8000-byte bitmap lands at $2000
|
||||
off = 2 + (BITMAP_ORG - BASIC_START)
|
||||
assert bytes(prg[off:off + 8000]) == bytes(conv.data[:8000])
|
||||
|
||||
|
||||
def test_plus4_reuses_c16():
|
||||
# Plus/4 uses the same TED + BASIC 3.5 as the C16, so its encoder, modes and
|
||||
# .prg are identical -- the plus4 package re-exports the C16 implementation.
|
||||
from lenser.plus4.convert import MODES, convert_image
|
||||
from lenser.c16.convert import MODES as C16_MODES, convert_image as c16_convert
|
||||
from lenser.plus4.exporter import export_prg
|
||||
from lenser.c16.exporter import export_prg as c16_export_prg
|
||||
assert MODES == C16_MODES
|
||||
assert convert_image is c16_convert and export_prg is c16_export_prg
|
||||
img = _imgobj(320, 200)
|
||||
conv = convert_image(img, mode="hires", dither_mode="floyd")
|
||||
assert conv.mode == "hires" and len(conv.data) == 10000
|
||||
|
||||
|
||||
def test_cpc_sna():
|
||||
from lenser.cpc.convert import convert_image, MODES
|
||||
from lenser.cpc.exporter import export_sna
|
||||
from lenser.cpc import snapshot
|
||||
import tempfile, os
|
||||
img = _imgobj(320, 200)
|
||||
assert MODES == ["mode0", "mode1", "mono"]
|
||||
for m, ncol in (("mode0", 16), ("mode1", 4), ("mono", 2)):
|
||||
conv = convert_image(img, mode=m, dither_mode="floyd")
|
||||
assert len(conv.data) == 0x4000 # 16K screen at &C000
|
||||
assert conv.data_addr == 0xC000
|
||||
assert 1 <= len(conv.meta["inks"]) <= ncol
|
||||
with tempfile.TemporaryDirectory() as td:
|
||||
p = export_sna(conv, os.path.join(td, "x.sna"))
|
||||
sna = open(p, "rb").read()
|
||||
assert sna[:8] == b"MV - SNA" # CPC snapshot signature
|
||||
assert len(sna) == 0x100 + 0x10000 # 256 header + 64K RAM
|
||||
assert (sna[0x40] & 0x03) == conv.meta["cpc_mode"] # mode in RMR
|
||||
|
||||
|
||||
def test_coco3_cart():
|
||||
from lenser.coco3.convert import convert_image, MODES
|
||||
from lenser.coco3.exporter import export_ccc
|
||||
import tempfile, os
|
||||
img = _imgobj(320, 192)
|
||||
assert MODES == ["gr16", "gr4", "mono"]
|
||||
for m, ncol in (("gr16", 16), ("gr4", 4), ("mono", 2)):
|
||||
conv = convert_image(img, mode=m, dither_mode="floyd")
|
||||
assert len(conv.data) == 15360 # 80 bytes/row * 192, linear
|
||||
assert conv.data_addr == 0x4000
|
||||
assert 1 <= len(conv.meta["inks"]) <= ncol
|
||||
assert all(0 <= c < 64 for c in conv.meta["inks"]) # 6-bit GIME colours
|
||||
with tempfile.TemporaryDirectory() as td:
|
||||
p = export_ccc(conv, os.path.join(td, "x.ccc"))
|
||||
rom = open(p, "rb").read()
|
||||
assert len(rom) == 0x4000 # 16K cartridge
|
||||
assert rom[:2] == bytes([0x1A, 0x50]) # viewer starts: ORCC #$50
|
||||
|
||||
|
||||
def test_nes_cart():
|
||||
from lenser.nes.convert import convert_image, MODES
|
||||
from lenser.nes.exporter import export_nes
|
||||
from lenser.nes.cartridge import have_xa
|
||||
import tempfile, os
|
||||
img = _imgobj(256, 240)
|
||||
assert MODES == ["bg", "mono"]
|
||||
for m in MODES:
|
||||
conv = convert_image(img, mode=m, dither_mode="floyd")
|
||||
d = conv.data
|
||||
assert len(d["palette"]) == 32
|
||||
assert len(d["nametable"]) == 1024 # 960 names + 64 attribute
|
||||
assert len(d["chr"]) == 8192 # 8K CHR-ROM (256 bg tiles)
|
||||
assert all(0 <= b < 64 for b in d["palette"]) # 6-bit NES colours
|
||||
if not have_xa():
|
||||
continue
|
||||
with tempfile.TemporaryDirectory() as td:
|
||||
p = export_nes(conv, os.path.join(td, "x.nes"))
|
||||
rom = open(p, "rb").read()
|
||||
assert rom[:4] == b"NES\x1a" # iNES signature
|
||||
assert rom[4] == 1 and rom[5] == 1 # 16K PRG + 8K CHR (NROM)
|
||||
assert len(rom) == 16 + 0x4000 + 0x2000
|
||||
# reset vector ($FFFC) -> $C000 (viewer start)
|
||||
assert rom[16 + 0x3FFC] == 0x00 and rom[16 + 0x3FFD] == 0xC0
|
||||
|
||||
|
||||
def test_iigs_dsk():
|
||||
from lenser.iigs.convert import convert_image, MODES
|
||||
from lenser.iigs.viewer.assemble import assemble_boot, have_xa
|
||||
from lenser.iigs.exporter import export_dsk
|
||||
import tempfile, os
|
||||
img = _imgobj(320, 200)
|
||||
assert MODES == ["shr", "mono"]
|
||||
for m in MODES:
|
||||
conv = convert_image(img, mode=m, dither_mode="floyd")
|
||||
assert len(conv.data) == 0x8000 # 32K SHR block ($2000-$9FFF)
|
||||
assert conv.data_addr == 0x2000
|
||||
if not have_xa():
|
||||
return
|
||||
boot = assemble_boot()
|
||||
assert len(boot) <= 256 # fits one boot sector
|
||||
assert boot[1] == 0xAD # entry: LDA dpage (abs)
|
||||
with tempfile.TemporaryDirectory() as td:
|
||||
conv = convert_image(img, mode="shr", dither_mode="floyd")
|
||||
p = export_dsk(conv, os.path.join(td, "x.dsk"))
|
||||
dsk = open(p, "rb").read()
|
||||
assert len(dsk) == 143360 # 140K 5.25" disk
|
||||
assert dsk[:len(boot)] == boot # boot sector at track 0 sector 0
|
||||
|
||||
|
||||
def test_pet_prg():
|
||||
from lenser.pet.convert import convert_image
|
||||
from lenser.pet import palette as petpal
|
||||
from lenser.pet.viewer.assemble import build_prg, have_xa, BASIC_START, _STUB
|
||||
# all 16 quadrant codes distinct -> a real one-to-one block mapping
|
||||
assert len(set(petpal.QUAD)) == 16
|
||||
for cols, scr in ((40, 1000), (80, 2000)):
|
||||
conv = convert_image(_imgobj(320, 200), cols=cols, dither_mode="floyd")
|
||||
assert conv.mode == "mono"
|
||||
assert len(conv.data) == scr # screen-RAM bytes
|
||||
assert conv.data_addr == 0x8000
|
||||
assert all(b in petpal.QUAD for b in conv.data) # only quadrant codes
|
||||
if not have_xa():
|
||||
continue
|
||||
prg = build_prg(bytes(conv.data))
|
||||
assert prg[:2] == bytes([BASIC_START & 0xFF, BASIC_START >> 8]) # $0401
|
||||
assert prg[2:2 + len(_STUB)] == _STUB # 10 SYS1056
|
||||
|
||||
|
||||
def test_sms_cart():
|
||||
from lenser.sms.convert import convert_image, MODES
|
||||
from lenser.sms.exporter import export_sms
|
||||
from lenser.sms import viewer as smsv
|
||||
import tempfile, os
|
||||
img = _imgobj(256, 192)
|
||||
assert MODES == ["bg", "mono"]
|
||||
for m in MODES:
|
||||
conv = convert_image(img, mode=m, dither_mode="floyd")
|
||||
d = conv.data
|
||||
assert len(d["patterns"]) == 448 * 32 # <=448 tiles, no name-table clash
|
||||
assert len(d["nametable"]) == 32 * 24 * 2
|
||||
assert len(d["palette"]) == 32 # 2 x 16 colours
|
||||
assert all(0 <= b < 64 for b in d["palette"])
|
||||
with tempfile.TemporaryDirectory() as td:
|
||||
p = export_sms(conv, os.path.join(td, "x.sms"))
|
||||
rom = open(p, "rb").read()
|
||||
assert len(rom) == 0x8000 # 32K cartridge
|
||||
assert rom[:1] == bytes([0xF3]) # Z80 viewer starts with DI
|
||||
assert rom[0x7FF0:0x7FF8] == b"TMR SEGA" # SMS header signature
|
||||
|
||||
|
||||
def test_amiga_adf():
|
||||
from lenser.amiga.convert import convert_image, MODES
|
||||
from lenser.amiga.exporter import export_adf
|
||||
import tempfile, os, struct
|
||||
img = _imgobj(320, 200)
|
||||
assert MODES == ["lowres", "mono"]
|
||||
for m, nplanes in (("lowres", 5), ("mono", 4)):
|
||||
conv = convert_image(img, mode=m, dither_mode="floyd")
|
||||
d = conv.data
|
||||
assert d["nplanes"] == nplanes and d["ham"] is False
|
||||
assert len(d["planes"]) == nplanes * 40 * 200 # contiguous bitplanes
|
||||
assert all(0 <= c < 4096 for c in d["colors"]) # 12-bit colours
|
||||
with tempfile.TemporaryDirectory() as td:
|
||||
p = export_adf(conv, os.path.join(td, "x.adf"))
|
||||
adf = open(p, "rb").read()
|
||||
assert len(adf) == 901120 # 880K floppy
|
||||
assert adf[0:4] == b"DOS\x00" # boot block id
|
||||
# boot block longword checksum must total $FFFFFFFF (else not bootable)
|
||||
s = 0
|
||||
for i in range(0, 1024, 4):
|
||||
s += struct.unpack(">I", adf[i:i + 4])[0]
|
||||
if s > 0xFFFFFFFF:
|
||||
s = (s + 1) & 0xFFFFFFFF
|
||||
assert s == 0xFFFFFFFF
|
||||
|
||||
|
||||
def test_viewers_assemble_and_fit():
|
||||
if not have_xa():
|
||||
return # xa not installed; skip
|
||||
sizes = {"hires": 9000, "multicolor": 10001, "fli": 17385,
|
||||
"fli_ntsc": 17385, "interlace": 25577}
|
||||
for key in SOURCES:
|
||||
if key not in sizes:
|
||||
continue # e.g. "slideshow" is code-only (own builder/test)
|
||||
prg = build_viewer_prg(key, bytes(sizes[key]),
|
||||
0x4000 if key.startswith("fli") else 0x2000)
|
||||
assert prg[:2] == bytes([0x01, 0x08]) # PRG load address $0801
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue