nnnotes 0.1.0__py3-none-any.whl

nnnotes/atoms/sniff.py

@@ -0,0 +1,198 @@
+"""Atom `sniff`: what a byte string is, from its content.
+
+`sniff(data, hint)` returns the format, the file extension and the media type. Binary formats are recognized by
+their magic numbers (the table below); then JSON (strictly: UTF-8 text that parses as JSON, a Spine skeleton when it
+has a `skeleton.spine` version), UTF-8 text, and otherwise `binary`. `hint`, a file name, only chooses among
+equivalent answers: a text extension it ends with (`.csv`, `.atlas`, ...; a trailing `.bytes` is skipped) for text,
+`.acf` for a CRI table. Magic numbers take precedence over the hint.
+"""
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+
+from . import estimate
+from .. import contract
+
+
+@dataclass(frozen=True)
+class Sniffed:
+    format: str
+    ext: str
+    media_type: str
+
+
+# (offset, magic, format, extension, media type); the first match wins
+MAGIC: tuple = (
+    (0, b"\x89PNG\r\n\x1a\n", "png", "png", "image/png"),
+    (0, b"\xff\xd8\xff", "jpeg", "jpg", "image/jpeg"),
+    (0, b"GIF87a", "gif", "gif", "image/gif"),
+    (0, b"GIF89a", "gif", "gif", "image/gif"),
+    (0, b"\x13\xab\xa1\x5c", "astc", "astc", "image/astc"),
+    (0, b"DDS ", "dds", "dds", "image/vnd-ms.dds"),
+    (0, b"\xabKTX 11\xbb\r\n\x1a\n", "ktx", "ktx", "image/ktx"),
+    (0, b"\xabKTX 20\xbb\r\n\x1a\n", "ktx2", "ktx2", "image/ktx2"),
+    (0, b"OTTO", "otf", "otf", "font/otf"),
+    (0, b"\x00\x01\x00\x00", "ttf", "ttf", "font/ttf"),
+    (0, b"true", "ttf", "ttf", "font/ttf"),
+    (0, b"ttcf", "ttc", "ttc", "font/collection"),
+    (0, b"wOFF", "woff", "woff", "font/woff"),
+    (0, b"wOF2", "woff2", "woff2", "font/woff2"),
+    (0, b"@UTF", "cri-utf", "acb", "application/octet-stream"),
+    (0, b"AFS2", "afs2", "awb", "application/octet-stream"),
+    (0, b"CRID", "usm", "usm", "application/octet-stream"),
+    (0, b"HCA\x00", "hca", "hca", "application/octet-stream"),
+    (0, b"\xc8\xc3\xc1\x00", "hca", "hca", "application/octet-stream"),       # HCA with masked chunk names
+    (0, b"UnityFS\x00", "unityfs", "bundle", "application/octet-stream"),
+    (0, b"UnityWeb\x00", "unityweb", "bundle", "application/octet-stream"),
+    (0, b"UnityRaw\x00", "unityraw", "bundle", "application/octet-stream"),
+    (0, b"UnityArchive", "unityarchive", "bundle", "application/octet-stream"),
+    (0, b"MOC3", "moc3", "moc3", "application/octet-stream"),
+    (0, b"glTF", "glb", "glb", "model/gltf-binary"),
+    (0, b"OggS", "ogg", "ogg", "audio/ogg"),
+    (0, b"fLaC", "flac", "flac", "audio/flac"),
+    (0, b"ID3", "mp3", "mp3", "audio/mpeg"),
+    (0, b"MThd", "midi", "mid", "audio/midi"),
+    (0, b"DKIF", "ivf", "ivf", "video/x-ivf"),
+    (0, b"\x1a\x45\xdf\xa3", "matroska", "mkv", "video/x-matroska"),
+    (4, b"ftyp", "mp4", "mp4", "video/mp4"),
+    (0, b"%PDF-", "pdf", "pdf", "application/pdf"),
+    (0, b"\x1f\x8b", "gzip", "gz", "application/gzip"),
+    (0, b"PK\x03\x04", "zip", "zip", "application/zip"),
+    (0, b"PK\x05\x06", "zip", "zip", "application/zip"),
+    (0, b"7z\xbc\xaf\x27\x1c", "7z", "7z", "application/x-7z-compressed"),
+    (0, b"\xfd7zXZ\x00", "xz", "xz", "application/x-xz"),
+    (0, b"\x28\xb5\x2f\xfd", "zstd", "zst", "application/zstd"),
+    (0, b"\x04\x22\x4d\x18", "lz4", "lz4", "application/octet-stream"),
+)
+# RIFF containers by form type
+RIFF = {b"WAVE": ("wav", "wav", "audio/wav"), b"WEBP": ("webp", "webp", "image/webp"),
+        b"AVI ": ("avi", "avi", "video/x-msvideo")}
+TEXT_EXTS = frozenset({"txt", "csv", "tsv", "xml", "yaml", "yml", "ini", "md", "html", "css", "js", "lua", "atlas",
+                       "srt", "vtt", "svg", "plist"})
+_CONTROL = re.compile(r"[\x00-\x08\x0b\x0e-\x1f\x7f]")      # not in text: C0 controls except \t \n \f \r, DEL
+_SPINE_VERSION = re.compile(r"[34]\.\d+(\.\d+)*")
+
+
+def _media(ext: str, fallback: str = "application/octet-stream") -> str:
+    m = contract.media_type(ext)
+    return fallback if m == "application/octet-stream" else m
+
+
+def _hint_ext(hint: str | None) -> str:
+    if not hint:
+        return ""
+    parts = re.split(r"[\\/]", hint)[-1].lower().split(".")[1:]
+    if parts and parts[-1] == "bytes":
+        parts.pop()
+    return parts[-1] if parts else ""
+
+
+def _varint(data: bytes, pos: int) -> tuple[int, int]:
+    """Spine's variable-length unsigned int (7 bits per byte, least significant first, at most 5 bytes)."""
+    value = shift = 0
+    for i in range(5):
+        if pos + i >= len(data):
+            raise ValueError
+        b = data[pos + i]
+        value |= (b & 0x7F) << shift
+        if not b & 0x80:
+            return value, pos + i + 1
+        shift += 7
+    raise ValueError
+
+
+def _spine_string(data: bytes, pos: int) -> tuple[str, int]:
+    n, pos = _varint(data, pos)
+    if n == 0 or pos + n - 1 > len(data):
+        raise ValueError
+    return data[pos:pos + n - 1].decode("ascii"), pos + n - 1
+
+
+def spine_binary_version(data: bytes) -> str | None:
+    """The Spine version a binary skeleton (.skel) states, None if `data` is not one: 4.x files start with an
+    8-byte hash then the version string, 3.x files with the hash string then the version string."""
+    for start in (8, None):
+        try:
+            pos = start if start is not None else _spine_string(data, 0)[1]
+            version = _spine_string(data, pos)[0]
+        except (ValueError, UnicodeDecodeError):
+            continue
+        if _SPINE_VERSION.fullmatch(version) and version[0] == ("4" if start is not None else "3"):
+            return version
+    return None
+
+
+def _sfnt(data: bytes) -> bool:
+    """An OpenType / TrueType table directory: a table count and the search range that goes with it."""
+    if len(data) < 12:
+        return False
+    n, search = int.from_bytes(data[4:6], "big"), int.from_bytes(data[6:8], "big")
+    return 0 < n <= 512 and len(data) >= 12 + 16 * n and search == 16 << (n.bit_length() - 1)
+
+
+# checks beyond the magic, for magics short or common enough to begin other data
+VALIDATE = {
+    "ttf": _sfnt, "otf": _sfnt,
+    "gzip": lambda d: d[2:3] == b"\x08",
+    "midi": lambda d: d[4:8] == b"\x00\x00\x00\x06",
+    "glb": lambda d: d[4:8] in (b"\x01\x00\x00\x00", b"\x02\x00\x00\x00"),
+}
+
+
+def _adx(data: bytes) -> bool:
+    if len(data) < 6 or data[:2] != b"\x80\x00":
+        return False
+    off = int.from_bytes(data[2:4], "big")
+    return data[off - 2:off + 4] == b"(c)CRI"
+
+
+def sniff(data: bytes, hint: str | None = None) -> Sniffed:
+    data = bytes(data)
+    if not data:
+        return Sniffed("empty", "bin", "application/octet-stream")
+    head = data[:16]
+    for off, magic, fmt, ext, media in MAGIC:
+        if head[off:off + len(magic)] == magic and VALIDATE.get(fmt, bool)(data):
+            if fmt == "cri-utf" and _hint_ext(hint) == "acf":
+                ext = "acf"
+            return Sniffed(fmt, ext, media)
+    if head[:4] == b"RIFF" and head[8:12] in RIFF:
+        return Sniffed(*RIFF[head[8:12]])
+    if _adx(data):
+        return Sniffed("adx", "adx", "audio/x-adx")
+    version = spine_binary_version(data)
+    if version is not None:
+        return Sniffed("spine-skel", "skel", "application/octet-stream")
+    try:
+        text = data.decode("utf-8")
+    except UnicodeDecodeError:
+        return Sniffed("binary", "bin", "application/octet-stream")
+    if text.startswith(""):
+        text = text[1:]
+    if _CONTROL.search(text):
+        return Sniffed("binary", "bin", "application/octet-stream")
+    stripped = text.lstrip(" \t\r\n")
+    if stripped[:1] in ("{", "["):
+        try:
+            doc = json.loads(text)
+        except ValueError:
+            doc = None
+        else:
+            skeleton = doc.get("skeleton") if isinstance(doc, dict) else None
+            if isinstance(skeleton, dict) and isinstance(skeleton.get("spine"), str):
+                return Sniffed("spine-json", "json", "application/json")
+            return Sniffed("json", "json", "application/json")
+    ext = _hint_ext(hint)
+    if stripped.startswith("<?xml") and ext not in TEXT_EXTS:
+        ext = "xml"
+    if ext not in TEXT_EXTS:
+        ext = "txt"
+    return Sniffed("text", ext, _media(ext, "text/plain"))
+
+
+def cost(facts: dict) -> dict:
+    """facts: size."""
+    n = int(facts.get("size", 0))
+    return estimate(1e-5 + n * 2e-9, n * 3)

nnnotes/atoms/sprite.py

@@ -0,0 +1,236 @@
+"""Atom `sprite.crop`: a Sprite's image from its texture's decoded image.
+
+A port of UnityPy's `SpriteHelper.get_image_from_sprite` (MIT) that works on values instead of objects: the texture
+rect is cut out of the texture (merged with the alpha texture's first channel when there is one), a packed sprite's
+packing rotation or flip is undone, and a tightly packed sprite is masked with its mesh (or, when its mesh has
+texture coordinates, drawn from them triangle by triangle); the result is top row first. The output equals UnityPy's
+for the same sprite (tests compare the two).
+
+The texture image is the one `texture.decode` returns (top row first); the rect is cut from it directly, so an atlas
+texture is not copied once per sprite.
+
+`canvas` places the result on the sprite's full rect (Sprite.m_Rect size, transparent elsewhere) at its
+textureRectOffset -- where a tightly packed or trimmed sprite sits in its original bounds; a sprite drawn from its
+mesh is placed by its mesh bounds and the pivot. Sizes are rounded; when rounding fractional rects leaves the canvas
+one pixel narrower or lower than the cut, the canvas takes that pixel.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from . import Unsupported, estimate
+
+TIGHT, RECTANGLE = 0, 1
+ROTATIONS = {0: "none", 1: "flipHorizontal", 2: "flipVertical", 3: "rotate180", 4: "rotate90"}
+
+
+@dataclass(frozen=True)
+class Settings:
+    packed: bool
+    packing_mode: int            # 0 tight, 1 rectangle
+    packing_rotation: int        # 0 none, 1 flip horizontal, 2 flip vertical, 3 rotate 180, 4 rotate 90
+    mesh_type: int               # 0 full rect, 1 tight
+
+
+def settings(raw: int) -> Settings:
+    """SpriteSettings bits of `settingsRaw`."""
+    raw = int(raw)
+    return Settings(bool(raw & 1), (raw >> 1) & 1, (raw >> 2) & 0xF, (raw >> 6) & 1)
+
+
+def mesh_values(mesh) -> dict:
+    """The part of a sprite's MeshArrays sprite.crop reads, as plain values (for a document that carries a sprite
+    to a task without its bundle): positions, triangles per submesh, texture coordinates (or None). Floats are the
+    stored float32 values, so they read back exactly."""
+    uv = mesh.channels.get("uv0")
+    return {"positions": mesh.channels["position"].data.astype(float).tolist(),
+            "submeshes": [p.indices.tolist() for p in mesh.primitives
+                          if p.topology == "triangles" and p.indices is not None],
+            "uv0": None if uv is None else uv.data.astype(float).tolist()}
+
+
+def mesh_from_values(values: dict):
+    """The MeshArrays of mesh_values(...)."""
+    import numpy as np
+    from .mesh import Channel, MeshArrays, Primitive
+    pos = np.asarray(values["positions"], np.float32).reshape(-1, 3)
+    channels = {"position": Channel(pos)}
+    if values.get("uv0") is not None:
+        channels["uv0"] = Channel(np.asarray(values["uv0"], np.float32).reshape(len(pos), -1))
+    prims = [Primitive("triangles", np.asarray(t, np.int64).reshape(-1, 3), i)
+             for i, t in enumerate(values.get("submeshes") or [])]
+    return MeshArrays("", len(pos), channels, prims)
+
+
+def _cut(image, rect: dict):
+    """The texture rect of a top-row-first image as UnityPy cuts it from the bottom-row-first image (Pillow's crop
+    rounds the box and pads outside the image with zeros), still bottom row first."""
+    from PIL.Image import Transpose
+    x, y, w, h = rect["x"], rect["y"], rect["width"], rect["height"]
+    if x + w < x or y + h < y:
+        raise ValueError(f"texture rect {rect}: negative size")
+    x0, y0, x1, y1 = (int(round(v)) for v in (x, y, x + w, y + h))
+    top = image.height
+    return image.crop((x0, top - y1, x1, top - y0)).transpose(Transpose.FLIP_TOP_BOTTOM)
+
+
+def _merge(rgb, alpha):
+    from PIL import Image
+    return Image.merge("RGBA", (*rgb.split()[:3], alpha.split()[0]))
+
+
+def _positions(mesh) -> list:
+    ch = mesh.channels.get("position")
+    if ch is None or ch.data.shape[1] != 3 or not len(ch.data):
+        shape = None if ch is None else ch.data.shape
+        raise Unsupported("unsupported.sprite.tight_mask", f"sprite mesh positions {shape}")
+    return [tuple(v) for v in ch.data.tolist()]
+
+
+def _triangles(mesh) -> list[list[tuple]]:
+    return [[tuple(t) for t in p.indices.tolist()] for p in mesh.primitives
+            if p.topology == "triangles" and p.indices is not None]
+
+
+def _mask(mesh, image, ppu: float):
+    from PIL import Image, ImageDraw
+    positions = _positions(mesh)
+    mask = Image.new("1", image.size, color=0)
+    draw = ImageDraw.ImageDraw(mask)
+    min_x = min(x for x, _y, _z in positions)
+    min_y = min(y for _x, y, _z in positions)
+    flat = [((x - min_x) * ppu, (y - min_y) * ppu) for x, y, _z in positions]
+    for tris in _triangles(mesh):
+        for a, b, c in tris:
+            draw.polygon((flat[a], flat[b], flat[c]), fill=1)
+    if image.mode == "RGBA":
+        return Image.composite(image, Image.new(image.mode, image.size, color=0), mask)
+    image = image.copy()
+    image.putalpha(mask)
+    return image
+
+
+def _copy_triangle(src, src_tri, dst, dst_tri) -> None:
+    import numpy as np
+    from PIL import Image, ImageDraw
+    from PIL.Image import Transform
+    src_off = ((src_tri[1][0] - src_tri[0][0], src_tri[1][1] - src_tri[0][1]),
+               (src_tri[2][0] - src_tri[0][0], src_tri[2][1] - src_tri[0][1]))
+    dst_off = ((dst_tri[1][0] - dst_tri[0][0], dst_tri[1][1] - dst_tri[0][1]),
+               (dst_tri[2][0] - dst_tri[0][0], dst_tri[2][1] - dst_tri[0][1]))
+    if src_off == dst_off:                   # same shape: copy the triangle's box through a triangle mask
+        upper_left = (min(p[0] for p in src_tri), min(p[1] for p in src_tri))
+        lower_right = (max(p[0] for p in src_tri), max(p[1] for p in src_tri))
+        part = src.crop((*upper_left, *lower_right))
+        mask = Image.new("1", part.size)
+        ImageDraw.Draw(mask).polygon([(x - upper_left[0], y - upper_left[1]) for x, y in src_tri], fill=255)
+        dst.paste(part, (int(min(p[0] for p in dst_tri)), int(min(p[1] for p in dst_tri))), mask=mask)
+        return
+    (x11, x12), (x21, x22), (x31, x32) = src_tri   # the affine map from destination to source coordinates
+    (y11, y12), (y21, y22), (y31, y32) = dst_tri
+    m = [[y11, y12, 1, 0, 0, 0], [y21, y22, 1, 0, 0, 0], [y31, y32, 1, 0, 0, 0],
+         [0, 0, 0, y11, y12, 1], [0, 0, 0, y21, y22, 1], [0, 0, 0, y31, y32, 1]]
+    coeffs = np.linalg.solve(m, [x11, x21, x31, x12, x22, x32])
+    moved = src.transform(dst.size, Transform.AFFINE, coeffs)
+    mask = Image.new("1", dst.size)
+    ImageDraw.Draw(mask).polygon(dst_tri, fill=255)
+    dst.paste(moved, mask=mask)
+
+
+def _render(mesh, texture, ppu: float):
+    """The sprite drawn from its first submesh's triangles through their texture coordinates (bottom row first),
+    and its mesh bounds' minimum corner in units."""
+    from PIL import Image
+    tris = _triangles(mesh)
+    positions = _positions(mesh)
+    uv = mesh.channels["uv0"].data
+    if not tris:
+        raise Unsupported("unsupported.sprite.tight_mask", "sprite mesh without triangles")
+    if uv.shape[1] != 2:
+        raise Unsupported("unsupported.sprite.tight_mask", f"sprite texture coordinates with {uv.shape[1]} components")
+    axes = [[p[i] for p in positions] for i in range(3)]
+    for i in range(2, -1, -1):
+        if len(set(axes[i])) == 1:
+            break
+    else:
+        raise Unsupported("unsupported.sprite.tight_mask", "sprite mesh is not flat")
+    axes = axes[:i] + axes[i + 1:]
+    x_min, y_min, x_max, y_max = min(axes[0]), min(axes[1]), max(axes[0]), max(axes[1])
+    pos = [(round((x - x_min) * ppu), round((y - y_min) * ppu)) for x, y in zip(*axes)]
+    width, height = texture.size
+    uv_abs = [(round(u * width), round(v * height)) for u, v in uv.tolist()]
+    sprite = Image.new(texture.mode, (round((x_max - x_min) * ppu), round((y_max - y_min) * ppu)))
+    for tri in tris[0]:
+        _copy_triangle(texture, tuple(uv_abs[k] for k in tri), sprite, tuple(pos[k] for k in tri))
+    return sprite, (x_min, y_min)
+
+
+def crop(image, texture_rect: dict, settings_raw: int, mesh=None, pixels_to_units: float = 100.0, alpha=None, *,
+         downscale: float = 1.0, canvas: dict | None = None):
+    """The sprite's PIL image, top row first.
+
+    image / alpha: the decoded texture and alpha texture (texture.decode); texture_rect: {x, y, width, height} in
+    texels from the bottom-left; mesh: the MeshArrays of the sprite's own render data (tight packing);
+    pixels_to_units: Sprite.m_PixelsToUnits; downscale: the atlas' downscaleMultiplier (only 1 is supported);
+    canvas: {rect: {width, height}, offset: textureRectOffset {x, y}, pivot: m_Pivot {x, y}}."""
+    from PIL.Image import Transpose
+    if downscale != 1.0:
+        raise Unsupported("unsupported.sprite.downscale", f"downscaleMultiplier {downscale}")
+    if alpha is not None and alpha.size != image.size:
+        raise ValueError(f"alpha texture {alpha.size} for texture {image.size}")
+    img = _cut(image, texture_rect)
+    if alpha is not None:
+        img = _merge(img, _cut(alpha, texture_rect))
+    s = settings(settings_raw)
+    if s.packed:
+        turn = {1: Transpose.FLIP_LEFT_RIGHT, 2: Transpose.FLIP_TOP_BOTTOM, 3: Transpose.ROTATE_180,
+                4: Transpose.ROTATE_270}.get(s.packing_rotation)
+        if turn is not None:
+            img = img.transpose(turn)
+    corner = None
+    if s.packing_mode == TIGHT:
+        if mesh is None:
+            raise ValueError("tightly packed sprite without its mesh")
+        uv = mesh.channels.get("uv0")
+        if uv is not None and len(uv.data) and bool((uv.data[:, :2] != 0).any()):
+            texture = image if alpha is None else _merge(image, alpha)
+            img, corner = _render(mesh, texture.transpose(Transpose.FLIP_TOP_BOTTOM), pixels_to_units)
+        else:
+            img = _mask(mesh, img, pixels_to_units)
+    img = img.transpose(Transpose.FLIP_TOP_BOTTOM)
+    if canvas is None:
+        return img
+    cut_rounded = any(float(texture_rect[k]) % 1 for k in ("x", "y", "width", "height"))
+    return _place(img, canvas, corner, pixels_to_units, cut_rounded)
+
+
+def _place(img, canvas: dict, corner, ppu: float, cut_rounded: bool = False):
+    from PIL import Image
+    rect, pivot = canvas["rect"], canvas.get("pivot") or {"x": 0.5, "y": 0.5}
+    w, h = int(round(rect["width"])), int(round(rect["height"]))
+    if corner is None:
+        ox, oy = canvas["offset"]["x"], canvas["offset"]["y"]
+    else:
+        ox, oy = corner[0] * ppu + pivot["x"] * rect["width"], corner[1] * ppu + pivot["y"] * rect["height"]
+    x, y = int(round(ox)), int(round(oy))
+    # fractional values: the texture rect is cut at its rounded edges and the canvas has the rounded size, so the cut
+    # can be one pixel wider or higher than the canvas; the canvas grows by that pixel
+    if cut_rounded or rect["width"] % 1 or ox % 1:
+        w = w + 1 if x + img.width == w + 1 else w
+    if cut_rounded or rect["height"] % 1 or oy % 1:
+        h = h + 1 if y + img.height == h + 1 else h
+    if x < 0 or y < 0 or x + img.width > w or y + img.height > h:
+        raise Unsupported("unsupported.sprite.canvas", f"{img.width}x{img.height} image at ({x}, {y}) outside the "
+                                                       f"{w}x{h} rect")
+    if "A" not in img.getbands():
+        img = img.convert("RGBA")
+    out = Image.new(img.mode, (w, h))
+    out.paste(img, (x, h - y - img.height))
+    return out
+
+
+def cost(facts: dict) -> dict:
+    """facts: width, height (texture rect), textureWidth, textureHeight, tight (bool)."""
+    px = int(facts.get("width", 0)) * int(facts.get("height", 0))
+    tex = int(facts.get("textureWidth", 0)) * int(facts.get("textureHeight", 0))
+    return estimate(5e-5 + px * 1.5e-8 + (tex * 4e-9 if facts.get("tight") else 0), px * 8 + tex * 4)

nnnotes/atoms/texture.py

@@ -0,0 +1,80 @@
+"""Atom `texture.decode`: the image of a Texture2D's first mip level from its stored bytes.
+
+The reference implementation is UnityPy's `Texture2DConverter.parse_image_data` with the arguments UnityPy's
+`Texture2D.image` passes (top row first), so the image, and its PNG encoding, equal the ones the other commands
+write. HDR ASTC formats are refused: the decoder turns their blocks into its error colour (they are exported as
+.astc, see `astc.container`).
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from . import Unsupported, estimate
+
+HDR_ASTC = frozenset(range(66, 72))                       # TextureFormat ASTC_HDR_4x4 .. ASTC_HDR_12x12
+# TextureFormat -> ASTC block size (width, height)
+ASTC_BLOCKS = {
+    **{48 + i: b for i, b in enumerate(((4, 4), (5, 5), (6, 6), (8, 8), (10, 10), (12, 12)))},   # ASTC_RGB_*
+    **{54 + i: b for i, b in enumerate(((4, 4), (5, 5), (6, 6), (8, 8), (10, 10), (12, 12)))},   # ASTC_RGBA_*
+    **{66 + i: b for i, b in enumerate(((4, 4), (5, 5), (6, 6), (8, 8), (10, 10), (12, 12)))},   # ASTC_HDR_*
+}
+# formats stored uncompressed (bytes per texel is all their decode needs)
+_RAW = frozenset({*range(1, 10), *range(13, 21), 62, 63, *range(72, 83)})
+
+
+@dataclass(frozen=True)
+class TextureInput:
+    """What a Texture2D's image depends on: the stored image data (every mip level, as `get_image_data` returns
+    it), size, TextureFormat, the serialized file's Unity version and build target, and the platform blob."""
+    data: bytes
+    width: int
+    height: int
+    format: int
+    version: tuple = (0, 0, 0, 0)
+    platform: int = 0
+    platform_blob: bytes | None = None
+
+    def key(self) -> tuple:
+        """The decode inputs as one tuple (the order export._decode_inputs uses)."""
+        return (self.data, self.width, self.height, self.format, tuple(self.version), self.platform,
+                self.platform_blob)
+
+
+def is_hdr_astc(fmt: int) -> bool:
+    return int(fmt) in HDR_ASTC
+
+
+def format_name(fmt: int) -> str:
+    from UnityPy.enums import TextureFormat
+    try:
+        return TextureFormat(int(fmt)).name
+    except ValueError:
+        return str(int(fmt))
+
+
+def decode(inp: TextureInput):
+    """PIL image of the first mip level, top row first. Unsupported: `empty.texture` for a texture without pixels
+    (0 wide or high), `unsupported.texture.format` for HDR ASTC and for formats the decoder does not implement."""
+    from UnityPy.export.Texture2DConverter import parse_image_data
+    fmt = int(inp.format)
+    if not inp.width or not inp.height:
+        raise Unsupported("empty.texture", f"{inp.width}x{inp.height} texture")
+    if fmt in HDR_ASTC:
+        raise Unsupported("unsupported.texture.format",
+                          f"{format_name(fmt)} (HDR ASTC): the decoder returns its error colour for these blocks")
+    try:
+        return parse_image_data(inp.data, inp.width, inp.height, fmt, tuple(inp.version), inp.platform,
+                                inp.platform_blob, True)
+    except NotImplementedError as e:
+        raise Unsupported("unsupported.texture.format", str(e)) from None
+    except ValueError as e:
+        if "is not a valid TextureFormat" in str(e):
+            raise Unsupported("unsupported.texture.format", f"texture format {fmt}") from None
+        raise
+
+
+def cost(facts: dict) -> dict:
+    """facts: width, height, format."""
+    px = int(facts.get("width", 0)) * int(facts.get("height", 0))
+    per_px = 4e-9 if int(facts.get("format", 4)) in _RAW else 2.5e-8
+    return estimate(1e-4 + px * per_px, px * 4 * 3)