135 lines
4.8 KiB
Python
135 lines
4.8 KiB
Python
"""Read an image's pixel dimensions from its header, with no image library.
|
|
|
|
A level's `mapwidth`/`mapheight` are the coordinate space every marker on it is
|
|
expressed in, so getting them wrong moves every marker relative to the drawing.
|
|
Reading them off the uploaded file removes the most likely way to get them
|
|
wrong, which is somebody typing what they remember.
|
|
|
|
Pillow would do this in one line and is not a dependency. Adding it would mean a
|
|
new cp314 win_amd64 wheel in the offline installer's hash-pinned wheelhouse -
|
|
built on Windows, verified against bundle-lock.json, shipped in a 240 MB
|
|
installer - to read two integers out of a header. This is the cheaper trade.
|
|
|
|
Returns (width, height), or (None, None) when the format is not one of these or
|
|
the header is truncated. A caller must treat None as "ask the operator" and
|
|
never as a default.
|
|
"""
|
|
|
|
import re
|
|
import struct
|
|
|
|
|
|
def png_size(data):
|
|
# An IHDR chunk always follows the 8-byte signature, and its first two
|
|
# fields are width and height as big-endian 32-bit integers.
|
|
if len(data) < 24 or data[:8] != b'\x89PNG\r\n\x1a\n':
|
|
return None, None
|
|
if data[12:16] != b'IHDR':
|
|
return None, None
|
|
width, height = struct.unpack('>II', data[16:24])
|
|
return width, height
|
|
|
|
|
|
def gif_size(data):
|
|
if len(data) < 10 or data[:6] not in (b'GIF87a', b'GIF89a'):
|
|
return None, None
|
|
width, height = struct.unpack('<HH', data[6:10])
|
|
return width, height
|
|
|
|
|
|
def webp_size(data):
|
|
if len(data) < 30 or data[:4] != b'RIFF' or data[8:12] != b'WEBP':
|
|
return None, None
|
|
kind = data[12:16]
|
|
if kind == b'VP8 ':
|
|
width, height = struct.unpack('<HH', data[26:30])
|
|
return width & 0x3FFF, height & 0x3FFF
|
|
if kind == b'VP8L':
|
|
bits = struct.unpack('<I', data[21:25])[0]
|
|
return (bits & 0x3FFF) + 1, ((bits >> 14) & 0x3FFF) + 1
|
|
if kind == b'VP8X':
|
|
width = int.from_bytes(data[24:27], 'little') + 1
|
|
height = int.from_bytes(data[27:30], 'little') + 1
|
|
return width, height
|
|
return None, None
|
|
|
|
|
|
def jpeg_size(data):
|
|
"""Walk the marker segments to the start-of-frame, which carries the size.
|
|
|
|
JPEG has no fixed header offset - the dimensions live in whichever SOF
|
|
marker the encoder used, after any number of application and comment
|
|
segments of varying length. So this walks rather than indexes.
|
|
"""
|
|
if len(data) < 4 or data[:2] != b'\xff\xd8':
|
|
return None, None
|
|
index = 2
|
|
end = len(data)
|
|
while index < end - 9:
|
|
if data[index] != 0xFF:
|
|
index += 1
|
|
continue
|
|
marker = data[index + 1]
|
|
# SOF0 through SOF15, excluding the DHT/JPG/DAC markers interleaved
|
|
# in that range, all carry height then width at the same offset.
|
|
if marker in (0xC0, 0xC1, 0xC2, 0xC3, 0xC5, 0xC6, 0xC7,
|
|
0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF):
|
|
height, width = struct.unpack('>HH', data[index + 5:index + 9])
|
|
return width, height
|
|
if marker in (0xD8, 0x01) or 0xD0 <= marker <= 0xD9:
|
|
index += 2
|
|
continue
|
|
segment = struct.unpack('>H', data[index + 2:index + 4])[0]
|
|
index += 2 + segment
|
|
return None, None
|
|
|
|
|
|
def svg_size(data):
|
|
"""SVG states a size in attributes, or implies one through viewBox.
|
|
|
|
Width and height may carry units (mm, in, pt) or be percentages, and a
|
|
percentage says nothing about pixels - so a unit that is not px falls back to
|
|
the viewBox, which is unitless user space and is what a renderer scales to.
|
|
"""
|
|
try:
|
|
head = data[:4096].decode('utf-8', errors='replace')
|
|
except Exception:
|
|
return None, None
|
|
if '<svg' not in head:
|
|
return None, None
|
|
|
|
def attribute(name):
|
|
found = re.search(r'\b%s\s*=\s*["\']([^"\']+)["\']' % name, head)
|
|
return found.group(1).strip() if found else None
|
|
|
|
def pixels(value):
|
|
if not value:
|
|
return None
|
|
match = re.match(r'^([0-9.]+)\s*(px)?$', value)
|
|
return int(round(float(match.group(1)))) if match else None
|
|
|
|
width = pixels(attribute('width'))
|
|
height = pixels(attribute('height'))
|
|
if width and height:
|
|
return width, height
|
|
|
|
viewbox = attribute('viewBox')
|
|
if viewbox:
|
|
parts = re.split(r'[\s,]+', viewbox.strip())
|
|
if len(parts) == 4:
|
|
try:
|
|
return (int(round(float(parts[2]))),
|
|
int(round(float(parts[3]))))
|
|
except ValueError:
|
|
return None, None
|
|
return None, None
|
|
|
|
|
|
def image_size(data):
|
|
"""Dimensions of PNG, JPEG, GIF, WEBP or SVG data. (None, None) otherwise."""
|
|
for reader in (png_size, jpeg_size, gif_size, webp_size, svg_size):
|
|
width, height = reader(data)
|
|
if width and height:
|
|
return width, height
|
|
return None, None
|