mirror of
https://github.com/irmen/prog8.git
synced 2026-11-22 19:24:41 +00:00
286 lines
13 KiB
Python
Executable File
286 lines
13 KiB
Python
Executable File
#!/usr/bin/env python
|
|
# package requirements: pillow
|
|
|
|
import argparse
|
|
import struct
|
|
from PIL import Image
|
|
from typing import List
|
|
|
|
if __package__:
|
|
from .cx16images import (
|
|
BitmapImage,
|
|
BAYER_4X4,
|
|
BAYER_8X8,
|
|
apply_ordered_dither,
|
|
)
|
|
else:
|
|
from cx16images import (
|
|
BitmapImage,
|
|
BAYER_4X4,
|
|
BAYER_8X8,
|
|
apply_ordered_dither,
|
|
)
|
|
|
|
|
|
class Bmx:
|
|
header_fmt = "<3sBBBHHBBHbB"
|
|
VERSION = 1
|
|
|
|
class BmxError(RuntimeError):
|
|
pass
|
|
|
|
def __init__(self):
|
|
assert struct.calcsize(Bmx.header_fmt) == 16
|
|
self.magic = b"BMX"
|
|
self.version = Bmx.VERSION
|
|
self.bpp = 0
|
|
self.vera_color_depth = 0
|
|
self.width = 0
|
|
self.height = 0
|
|
self.pal_used = 0
|
|
self.pal_start = 0
|
|
self.data_start = 0
|
|
self.compressed = 0
|
|
self.border = 0
|
|
self.palette_data = b""
|
|
self.bitmap_data = b""
|
|
|
|
def __str__(self) -> str:
|
|
cmpr = "compressed" if self.compressed else "uncompressed"
|
|
return f"[BMX image {self.width}*{self.height}, {self.bpp} bpp, {self.pal_used} colors, {cmpr}]"
|
|
|
|
def read(self, filename: str):
|
|
data = open(filename, "rb").read()
|
|
self.__parse_header(data)
|
|
self.palette_data = data[32: 32 + self.pal_used * 2]
|
|
self.bitmap_data = data[32 + self.pal_used * 2:]
|
|
if self.bpp not in (1, 2, 4, 8):
|
|
raise self.BmxError("invalid bpp")
|
|
bytes_per_row = (self.width * self.bpp + 7) // 8
|
|
expected_bitmap_data_size = bytes_per_row * self.height
|
|
if len(self.bitmap_data) > expected_bitmap_data_size:
|
|
print(f"warning: invalid bitmap data size, got {len(self.bitmap_data)} expected {expected_bitmap_data_size}. Truncated.")
|
|
self.bitmap_data = self.bitmap_data[:expected_bitmap_data_size]
|
|
elif len(self.bitmap_data) < expected_bitmap_data_size:
|
|
print(f"warning: invalid bitmap data size, got {len(self.bitmap_data)} expected {expected_bitmap_data_size}.")
|
|
|
|
def write(self, filename: str) -> None:
|
|
header_pal_used = self.pal_used if self.pal_used < 256 else 0
|
|
header = struct.pack(Bmx.header_fmt, self.magic, self.version, self.bpp, self.vera_color_depth, self.width,
|
|
self.height, header_pal_used, self.pal_start, self.data_start, self.compressed,
|
|
self.border) + bytes(16)
|
|
with open(filename, "wb") as out:
|
|
out.write(header)
|
|
out.write(self.palette_data)
|
|
out.write(self.bitmap_data)
|
|
|
|
def as_image(self) -> Image:
|
|
"""Convert to a 8bpp pillow image that can easily be saved, shown, etc"""
|
|
self.__decompress_if_compressed()
|
|
if self.bpp == 8:
|
|
img = Image.frombytes("P", (self.width, self.height), self.bitmap_data)
|
|
elif self.bpp in (1, 2, 4):
|
|
bytes_per_row = (self.width * self.bpp + 7) // 8
|
|
pixel_mask = (1 << self.bpp) - 1
|
|
pixels = bytearray(self.width * self.height)
|
|
for y in range(self.height):
|
|
row_offset = y * bytes_per_row
|
|
for x in range(self.width):
|
|
bit_offset = x * self.bpp
|
|
byte = self.bitmap_data[row_offset + bit_offset // 8]
|
|
shift = 8 - self.bpp - bit_offset % 8
|
|
pixels[y * self.width + x] = (byte >> shift) & pixel_mask
|
|
img = Image.frombytes("P", (self.width, self.height), bytes(pixels))
|
|
else:
|
|
raise self.BmxError(f"no support for converting bpp {self.bpp} to an image")
|
|
palette = []
|
|
for rgb in self.__get_palette_rgb32():
|
|
palette.append(rgb[0])
|
|
palette.append(rgb[1])
|
|
palette.append(rgb[2])
|
|
img.putpalette(palette)
|
|
return img
|
|
|
|
def from_image(self, image: Image, max_width: int = 320, max_height: int = 240, preserve_first_16_colors=False, dither: str = "none", bpp: int = 8) -> None:
|
|
"""Create a BMX image from the given Pillow image."""
|
|
if bpp not in (1, 2, 4, 8):
|
|
raise ValueError("bpp must be 1, 2, 4, or 8")
|
|
if preserve_first_16_colors and bpp not in (4, 8):
|
|
raise ValueError("preserving the default 16 colors requires 4 or 8 bpp")
|
|
if dither not in ("none", "fs", "ordered4", "ordered8"):
|
|
raise ValueError("dither must be none, fs, ordered4, or ordered8")
|
|
palette_limit = 1 << bpp
|
|
bitmap_image = BitmapImage("", image)
|
|
if bitmap_image.width > max_width or bitmap_image.height > max_height:
|
|
print(f"Scaling image to fit within {max_width}x{max_height}, preserving aspect ratio")
|
|
bitmap_image.constrain_size(max_width=max_width, max_height=max_height)
|
|
if bitmap_image.width > 640 or bitmap_image.height > 480:
|
|
raise self.BmxError("image exceeds the X16's 640x480 resolution limit")
|
|
pixels_per_byte = 8 // bpp
|
|
aligned_width = bitmap_image.width - bitmap_image.width % pixels_per_byte
|
|
if aligned_width == 0:
|
|
raise self.BmxError(f"image width {bitmap_image.width} is too small for {bpp}bpp byte alignment")
|
|
if aligned_width != bitmap_image.width:
|
|
print(f"Warning: cropping {bitmap_image.width - aligned_width} right-edge pixels for {bpp}bpp byte alignment")
|
|
bitmap_image = bitmap_image.crop(0, 0, aligned_width, bitmap_image.height)
|
|
|
|
preserve_palette = bitmap_image.has_palette() and bpp == 8 and not preserve_first_16_colors and dither == "none"
|
|
if not preserve_palette:
|
|
if dither in ("ordered4", "ordered8"):
|
|
source_image = bitmap_image.get_image().convert("RGB")
|
|
palette_image = BitmapImage("", source_image.copy())
|
|
palette_image.quantize(bpp, preserve_first_16_colors=preserve_first_16_colors, dither=Image.Dither.NONE)
|
|
matrix = BAYER_4X4 if dither == "ordered4" else BAYER_8X8
|
|
ordered = apply_ordered_dither(source_image, palette_image.get_image(), matrix)
|
|
bitmap_image = BitmapImage("", ordered)
|
|
else:
|
|
dither_mode = Image.Dither.FLOYDSTEINBERG if dither == "fs" else Image.Dither.NONE
|
|
bitmap_image.quantize(bpp, preserve_first_16_colors=preserve_first_16_colors, dither=dither_mode)
|
|
|
|
self.width, self.height = bitmap_image.size
|
|
self.set_bpp(bpp)
|
|
palette = bitmap_image.get_palette()
|
|
if not palette or len(palette) > 1 << bpp:
|
|
raise self.BmxError("invalid palette size for bitmap depth")
|
|
self.pal_used = len(palette)
|
|
x16_palette = []
|
|
for r, g, b in palette:
|
|
x16_palette.append(self.__to4bit(g) << 4 | self.__to4bit(b))
|
|
x16_palette.append(self.__to4bit(r))
|
|
self.data_start = 32 + 2 * self.pal_used
|
|
self.palette_data = bytes(x16_palette)
|
|
pixels = bitmap_image.get_all_pixels_8bpp()
|
|
if bpp == 8:
|
|
self.bitmap_data = bytes(pixels)
|
|
else:
|
|
bytes_per_row = (self.width * bpp + 7) // 8
|
|
packed = bytearray(bytes_per_row * self.height)
|
|
pixel_mask = palette_limit - 1
|
|
for y in range(self.height):
|
|
row_offset = y * bytes_per_row
|
|
for x in range(self.width):
|
|
bit_offset = x * bpp
|
|
byte_offset = row_offset + bit_offset // 8
|
|
shift = 8 - bpp - bit_offset % 8
|
|
packed[byte_offset] |= (pixels[y * self.width + x] & pixel_mask) << shift
|
|
self.bitmap_data = bytes(packed)
|
|
vram_required = len(self.bitmap_data) + len(self.palette_data)
|
|
if vram_required > 128 * 1024:
|
|
raise self.BmxError(f"image and palette need {vram_required} bytes, exceeding the X16's 128 KiB of VERA VRAM")
|
|
|
|
def set_bpp(self, bpp: int) -> None:
|
|
self.bpp = bpp
|
|
if bpp == 1:
|
|
self.vera_color_depth = 0
|
|
elif bpp == 2:
|
|
self.vera_color_depth = 1
|
|
elif bpp == 4:
|
|
self.vera_color_depth = 2
|
|
elif bpp == 8:
|
|
self.vera_color_depth = 3
|
|
else:
|
|
raise ValueError("bpp must be 1,2,4,8")
|
|
|
|
def set_vera_colordepth(self, depth: int) -> None:
|
|
self.vera_color_depth = depth
|
|
self.bpp = 2 ** depth
|
|
if depth < 0 or depth > 3:
|
|
raise ValueError("depth must be 0,1,2,3")
|
|
|
|
def __parse_header(self, bmxdata: bytes) -> None:
|
|
if bmxdata[0:3] != b"BMX":
|
|
raise self.BmxError("not a BMX file")
|
|
self.magic, self.version, self.bpp, self.vera_color_depth, self.width, self.height, self.pal_used, self.pal_start, self.data_start, self.compressed, self.border = struct.unpack(
|
|
Bmx.header_fmt, bmxdata[:16])
|
|
if self.magic != b"BMX":
|
|
raise self.BmxError("not a BMX file")
|
|
if self.version != Bmx.VERSION:
|
|
raise self.BmxError("invalid BMX version, only supports " + str(Bmx.VERSION))
|
|
if self.pal_used == 0:
|
|
self.pal_used = 256
|
|
if self.data_start != 32 + 2 * self.pal_used:
|
|
print("Warning: data start offset mismatch:", self.data_start, "expected:", 32 + 2 * self.pal_used)
|
|
|
|
def __get_palette_rgb32(self) -> List[tuple]:
|
|
rgb = []
|
|
for i in range(0, self.pal_used * 2, 2):
|
|
G4 = self.palette_data[i] >> 4
|
|
B4 = self.palette_data[i] & 15
|
|
R4 = self.palette_data[i + 1] & 15
|
|
rgb.append((R4 << 4 | R4, G4 << 4 | G4, B4 << 4 | B4))
|
|
return rgb
|
|
|
|
def __to4bit(self, color: int) -> int:
|
|
# more accurate colorspace reduction, see https://threadlocalmutex.com/?p=48
|
|
return (color * 15 + 135) >> 8
|
|
|
|
def __decompress_if_compressed(self) -> None:
|
|
if self.compressed:
|
|
raise self.BmxError("doesn't support compressed images (spec not finalized and not implemented here)")
|
|
# TODO decompress compressed BMX (spec not finalized for this yet)...
|
|
self.compressed = False
|
|
|
|
|
|
def bmx_show(filename: str) -> None:
|
|
bmx = Bmx()
|
|
bmx.read(filename)
|
|
print(f"showing: {bmx}")
|
|
img = bmx.as_image()
|
|
img.show()
|
|
|
|
|
|
def bmx_info(filename: str) -> None:
|
|
bmx = Bmx()
|
|
bmx.read(filename)
|
|
print(f"{filename}: {bmx}")
|
|
|
|
|
|
def bmx_create(filename: str, outputfile: str, preserve16: bool, dither: str, bpp: int, hires: bool = False) -> None:
|
|
img = Image.open(filename)
|
|
max_width, max_height = (640, 480) if hires else (320, 240)
|
|
bmx = Bmx()
|
|
bmx.from_image(img, max_width=max_width, max_height=max_height, preserve_first_16_colors=preserve16, dither=dither, bpp=bpp)
|
|
bmx.write(outputfile)
|
|
print(f"wrote {filename} as {outputfile} {bmx}")
|
|
|
|
|
|
def bmx_convert(filename: str, outputfile: str) -> None:
|
|
bmx = Bmx()
|
|
bmx.read(filename)
|
|
img = bmx.as_image()
|
|
img.save(outputfile)
|
|
print(f"wrote {filename} {bmx} as {outputfile}")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
parser = argparse.ArgumentParser(description="Commander-X16 'BMX' image format converter")
|
|
parser.add_argument("--preserve16", action="store_true", default=False, help="preserve first 16 default Vera color palette entries (in 8bpp/256 colors mode)")
|
|
parser.add_argument("--bpp", default=8, type=int, help="bits per pixel of the output bmx image (default: 8)", choices=[1, 2, 4, 8])
|
|
parser.add_argument("--hires", action="store_true", help="scale to fit within 640x480 instead of 320x240")
|
|
parser.add_argument("-d", "--dither", nargs="?", const="fs", default="none", choices=("none", "fs", "ordered4", "ordered8"), metavar="MODE", help="dithering when quantizing: none, fs (Floyd-Steinberg), ordered4 (4x4 Bayer), ordered8 (8x8 Bayer). Bare --dither means fs. (default: none)")
|
|
parser.add_argument("action", help="the action to perform", type=str, choices=["show", "info", "tobmx", "topng"])
|
|
parser.add_argument("filename", help="the file to process", type=str)
|
|
parser.add_argument("output", nargs="?", help="output path (required for tobmx and topng)")
|
|
args = parser.parse_args()
|
|
if args.action == "show":
|
|
if args.output is not None:
|
|
parser.error("show does not take an output path")
|
|
bmx_show(args.filename)
|
|
elif args.action == "info":
|
|
if args.output is not None:
|
|
parser.error("info does not take an output path")
|
|
bmx_info(args.filename)
|
|
elif args.action == "tobmx":
|
|
if args.output is None:
|
|
parser.error("tobmx requires an output path")
|
|
if args.preserve16 and args.bpp not in (4, 8):
|
|
parser.error("--preserve16 requires 4 or 8 bpp output")
|
|
try:
|
|
bmx_create(args.filename, args.output, args.preserve16, args.dither, args.bpp, args.hires)
|
|
except Bmx.BmxError as error:
|
|
parser.error(str(error))
|
|
elif args.action == "topng":
|
|
if args.output is None:
|
|
parser.error("topng requires an output path")
|
|
bmx_convert(args.filename, args.output)
|