vtskit 0.1.0__py3-none-any.whl

vtskit/menu.py

@@ -0,0 +1,171 @@
+"""Menus: a program chain of a menu domain with its buttons.
+
+A menu is a VOB like a title's, with a subpicture overlay (vtskit.spu)
+drawn where the buttons light up, and the highlight information (HLI) of
+every navigation pack's PCI (https://dvdnav.mplayerhq.hu/dvdinfo/pci_pkt.html)
+saying where each button is, which button each arrow key leads to, and the
+command a button runs. The colours come from the program chain's palette:
+entry 0 is the highlight (a button selected), entry 1 the selection (a
+button activated), as dvdauthor and spumux arrange them; the overlay is
+invisible until a button is selected. A menu may instead show its buttons
+in a `normal` colour all the time (spumux's `image`): then the palette is
+normal, highlight, selection, and the overlay draws palette 0.
+
+A menu without a stream is a program chain of commands alone (its `pre`
+runs and leaves), as dvdauthor writes a `<pgc>` without a `<vob>`.
+
+From dvdauthor's output: the HLI is repeated whole in every VOBU
+(HLI_SS 1), its start time is the menu's first picture, its end times are
+0xFFFFFFFF (never), the buttons form one group of the normal kind, every
+button uses colour table 1, and in that table only the pattern code (1) is
+coloured: palette 0 and opaque when selected, palette 1 and opaque when
+activated.
+"""
+
+import struct
+from dataclasses import dataclass, field
+
+from . import spu
+from .errors import VtsError
+
+YELLOW, RED = (0xD2, 0x92, 0x10), (0x52, 0xF0, 0x5A)      # Y, Cr, Cb
+
+
+@dataclass
+class Button:
+    """A button: its rectangle (x0, y0, x1, y1 in the picture, x1 and y1 the
+    last column and line + 1), the command it runs (8 bytes), the buttons
+    (numbers, from 1) the arrow keys lead to (default: itself), and whether
+    it runs as soon as it is selected (`auto`)."""
+    rect: tuple
+    command: bytes
+    up: int = 0
+    down: int = 0
+    left: int = 0
+    right: int = 0
+    auto: bool = False
+
+
+@dataclass
+class Menu:
+    """A menu: its program stream (ffmpeg -f dvd, no subpictures), its
+    buttons, the overlay of pixel codes lighting up the buttons (code 1
+    where a button shows when selected; by default the buttons' rectangles),
+    the highlight and selection colours (Y, Cr, Cb, and a contrast 0-15,
+    15 if left out), the colour the buttons show in otherwise (None: they
+    show nothing), where its cells start (seconds, as a title's chapters; a
+    loop point), its commands, and which remote key it answers (`entry`:
+    "title" in the VMG; "root", "subpicture", "audio", "angle" or "ptt" in
+    a titleset; None for a menu reached by commands). `stream` None: a
+    program chain of commands only, without pictures or buttons."""
+    stream: str | None
+    buttons: list = field(default_factory=list)
+    overlay: object = None
+    highlight: tuple = YELLOW
+    select: tuple = RED
+    normal: tuple | None = None
+    cells: tuple = (0.0,)
+    pre: tuple = ()
+    post: tuple = ()                # none: Exit, as dvdauthor writes a menu without post commands
+    entry: str | None = None
+    first_button: int = 0          # the button selected when the menu shows (0: the player's choice)
+    button_offset: int = 0         # added to a number key's digit to pick a button
+    uops: int = 0                  # user operations the menu forbids (bit n: vtskit.vm.UOP_*)
+
+
+ENTRY_TYPES = {"title": 2, "root": 3, "subpicture": 4, "audio": 5, "angle": 6, "ptt": 7}
+ENTRY_FLAGS = {"title": 0x80, "root": 0x80, "subpicture": 0x40, "audio": 0x20, "angle": 0x10, "ptt": 0x08}
+
+
+def _colour(c, what):
+    """(Y, Cr, Cb), contrast of a colour given as 3 or 4 numbers."""
+    if len(c) not in (3, 4) or not all(isinstance(v, int) for v in c):
+        raise VtsError(f"the {what} colour is (Y, Cr, Cb) or (Y, Cr, Cb, contrast)")
+    contrast = c[3] if len(c) == 4 else 15
+    if not 0 <= contrast <= 15:
+        raise VtsError(f"the {what} colour's contrast is 0 to 15")
+    return tuple(c[:3]), contrast
+
+
+def check(menu, width, height):
+    if menu.stream is None and menu.buttons:
+        raise VtsError("a menu without a stream has no buttons")
+    if len(menu.buttons) > 36:
+        raise VtsError(f"{len(menu.buttons)} buttons (a menu has at most 36)")
+    _colour(menu.highlight, "highlight")
+    _colour(menu.select, "selection")
+    if menu.normal is not None:
+        _colour(menu.normal, "normal")
+    if menu.entry is not None and menu.entry not in ENTRY_TYPES:
+        raise VtsError(f"{menu.entry!r} is not a menu entry kind")
+    for n, b in enumerate(menu.buttons, 1):
+        x0, y0, x1, y1 = b.rect
+        if not (0 <= x0 < x1 <= width and 0 <= y0 < y1 <= height):
+            raise VtsError(f"button {n}: {b.rect} is not inside {width}x{height}")
+        if len(b.command) != 8:
+            raise VtsError(f"button {n}: a command is 8 bytes")
+        for k in (b.up, b.down, b.left, b.right):
+            if not 0 <= k <= len(menu.buttons):
+                raise VtsError(f"button {n} points at button {k}, which the menu has not")
+    if not 0 <= menu.first_button <= len(menu.buttons):
+        raise VtsError(f"first button {menu.first_button}: the menu has {len(menu.buttons)}")
+    if not 0 <= menu.button_offset <= 255:
+        raise VtsError("the button offset is 0 to 255")
+
+
+def overlay(menu, width, height):
+    """The menu's overlay: as given, or its buttons' rectangles."""
+    if menu.overlay is not None:
+        if (menu.overlay.width, menu.overlay.height) != (width, height):
+            raise VtsError("the overlay is not the picture's size")
+        return menu.overlay
+    return spu.Overlay.from_rects(width, height, [b.rect for b in menu.buttons])
+
+
+def palette(menu):
+    """The program chain's colours: the normal colour if any, then the
+    highlight and the selection; none for a menu without buttons."""
+    if not menu.buttons:
+        return ()
+    colours = [_colour(menu.highlight, "highlight")[0], _colour(menu.select, "selection")[0]]
+    if menu.normal is not None:
+        colours.insert(0, _colour(menu.normal, "normal")[0])
+    return tuple(colours)
+
+
+def unit(menu, width, height):
+    """The menu's subpicture unit: the overlay, shown in the normal colour
+    (palette 0, its contrast) or not at all."""
+    o = overlay(menu, width, height)
+    if menu.normal is None:
+        return spu.encode(o)
+    return spu.encode(o, colours=(0, 0, 0, 0), contrasts=(0, _colour(menu.normal, "normal")[1], 0, 0))
+
+
+def hli(menu, s_ptm):
+    """The highlight information of the menu's navigation packs (the PCI
+    from 0x60 to 0x316), shown from `s_ptm`, the menu's first picture."""
+    buttons = menu.buttons
+    out = bytearray(0x316 - 0x60)
+    if not buttons:
+        return bytes(out)
+    struct.pack_into(">HIIIHBBBBBB", out, 0, 1, s_ptm, 0xFFFFFFFF, 0xFFFFFFFF, 0x1000,
+                     menu.button_offset, len(buttons), len(buttons), 0, menu.first_button, 0)
+    # colour table 1: the pattern code, the highlight's palette entry and
+    # contrast when selected, the selection's when activated; the other
+    # codes stay as they are
+    first = 1 if menu.normal is not None else 0
+    out[0x16:0x1E] = bytes((0x00, first << 4, 0x00, _colour(menu.highlight, "highlight")[1] << 4,
+                            0x00, (first + 1) << 4, 0x00, _colour(menu.select, "selection")[1] << 4))
+    for n, b in enumerate(buttons):
+        x0, y0, x1, y1 = b.rect
+        e = 0x2E + 18 * n
+        out[e] = 1 << 6 | x0 >> 4
+        out[e + 1] = (x0 & 0xF) << 4 | x1 >> 8
+        out[e + 2] = x1 & 0xFF
+        out[e + 3] = (0x40 if b.auto else 0) | y0 >> 4      # auto action mode 01
+        out[e + 4] = (y0 & 0xF) << 4 | y1 >> 8
+        out[e + 5] = y1 & 0xFF
+        out[e + 6:e + 10] = bytes(k or n + 1 for k in (b.up, b.down, b.left, b.right))
+        out[e + 10:e + 18] = b.command
+    return bytes(out)

vtskit/nav.py

@@ -0,0 +1,256 @@
+"""Fill the navigation packs of a VOB.
+
+Every VOBU starts with a navigation pack: a PCI packet (presentation:
+times, and a menu's buttons) and a DSI packet (search: where this VOBU
+ends, where its reference pictures end, where the VOBUs 0.5 s to 120 s
+away start, where its sound starts). ffmpeg's `-f dvd` leaves both empty;
+`fill` writes them, and no pack moves.
+
+The fields are those described at https://dvdnav.mplayerhq.hu/dvdinfo/
+(pci_pkt.html, dsi_pkt.html). Where the description leaves a choice open,
+the choice is the one dvdauthor makes, found by comparing its output
+bytes (see tests/test_nav.py).
+"""
+
+import bisect
+import struct
+
+from . import ps
+from .errors import VtsError
+
+PCI = 0x2D                 # the PCI data, in the navigation pack
+DSI = 0x407                # the DSI data
+
+# the search spans of VOBU_SRI, in half seconds: forward from the farthest,
+# backward from the nearest
+SPANS = (240, 120, 60, 20, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
+
+COARSE = (20, 60, 120, 240)
+NONE = 0x3FFFFFFF          # no VOBU for this span (or no next / previous VOBU)
+NO_VIDEO = 0xBFFFFFFF      # no next / previous VOBU with video
+VALID = 0x80000000
+BETWEEN = 0x40000000       # VOBUs lie between this one and the nearer span's
+
+
+class Vobu:
+    """One VOBU of a stream: its sectors (nav pack first, last), times and
+    what the DSI points at."""
+    __slots__ = ("start", "end", "scr", "s_ptm", "e_ptm", "video", "refs", "cell")
+
+    def __init__(self, start, end, scr):
+        self.start, self.end, self.scr = start, end, scr
+        self.s_ptm = self.e_ptm = None
+        self.video = False
+        self.refs = []
+        self.cell = None           # (vob id, cell id, index of its first VOBU, of its last)
+
+
+def vobus(stream):
+    """The VOBUs of a scanned stream (`ps.scan`), with their times and
+    reference pictures."""
+    if not stream.navs or stream.navs[0][0] != 0:
+        raise VtsError("the stream does not start with a navigation pack")
+    starts = [s for s, _ in stream.navs]
+    out = [Vobu(s, e - 1, scr) for (s, scr), e in zip(stream.navs, starts[1:] + [stream.sectors])]
+    k = 0
+    for p in stream.pictures:
+        while k + 1 < len(out) and p.start >= out[k + 1].start:
+            k += 1
+        v = out[k]
+        v.video = True
+        if p.pts is not None and (v.s_ptm is None or p.pts < v.s_ptm):
+            v.s_ptm = p.pts
+        if p.type in "IP" and len(v.refs) < 3:
+            v.refs.append(p.end - v.start)
+    if any(v.s_ptm is None for v in out):
+        raise VtsError("a VOBU without video: a stream of sound alone is not a DVD title (dvdauthor "
+                       "refuses it too; a still is one picture, with the sound after it)")
+    for a, b in zip(out, out[1:]):
+        a.e_ptm = b.s_ptm
+    out[-1].e_ptm = stream.end
+    return out
+
+
+def _bcd(n):
+    return (n // 10) << 4 | n % 10
+
+
+def elapsed(ticks, frame):
+    """A time as the PGC and navigation packs give it: BCD hh:mm:ss:ff, the
+    top two bits of ff saying 30 (11) or 25 (01) frames a second."""
+    fps, flag = (25, 0x40) if frame == 3600 else (30, 0xC0)
+    frames = int(round(ticks / frame))
+    s, f = divmod(frames, fps)
+    m, s = divmod(s, 60)
+    h, m = divmod(m, 60)
+    return bytes((_bcd(h), _bcd(m), _bcd(s), _bcd(f) | flag))
+
+
+def _search(vs, times, i, first, last, pos):
+    """VOBU_SRI of VOBU i, its cell being VOBUs first..last (`times`: the
+    start of each VOBU, `pos`: the sector of each VOBU on the disc)."""
+    v = vs[i]
+    end = vs[last].e_ptm
+
+    def find(t):
+        if t < times[first] or t >= end:
+            return None
+        return bisect.bisect_right(times, t, first, last + 1) - 1
+
+    def entries(sign):
+        # (the coarse spans, 10 s and up, also say whether VOBUs lie between
+        # their target and the nearer span's, or past it when they have none)
+        out, nearer = [], i
+        for span in sorted(SPANS):
+            j = find(v.s_ptm + sign * span * 45000)
+            coarse = span in COARSE and nearer is not None
+            if j is None:
+                beyond = first <= nearer + sign <= last if coarse else False
+                out.append(NONE | (BETWEEN if beyond else 0))
+            else:
+                val = VALID | abs(pos[j] - pos[i])
+                if coarse and abs(j - nearer) > 1:
+                    val |= BETWEEN
+                out.append(val)
+            nearer = j
+        return out                           # nearest first
+
+    fwd = entries(1)[::-1]
+    bwd = entries(-1)
+    nxt = VALID | (pos[i + 1] - pos[i]) if i < last else NONE
+    prv = VALID | (pos[i] - pos[i - 1]) if i > first else NONE
+    nvwv = next((VALID | (pos[j] - pos[i]) for j in range(i + 1, last + 1) if vs[j].video),
+                NO_VIDEO)
+    pvwv = next((VALID | (pos[i] - pos[j]) for j in range(i - 1, first - 1, -1)
+                 if vs[j].video), NO_VIDEO)
+    return [nvwv] + fwd + [nxt, prv] + bwd + [pvwv]
+
+
+def _audio_sync(stream, vs, pos, final):
+    """a_synca of each VOBU: per sound stream (numbered in the order the
+    streams first appear), the offset to the stream's last packet stamped
+    at or before the VOBU's start (or its first, if none is)."""
+    if len(stream.audio) > 8:
+        raise VtsError(f"{len(stream.audio)} sound streams (a DVD title has at most 8)")
+    out = [[0] * 8 for _ in vs]
+    for n, packets in enumerate(stream.audio.values()):
+        stamped = [(s, p) for s, p, _ in packets if p is not None]
+        if not stamped:
+            continue
+        k = 0
+        for i, (row, v) in enumerate(zip(out, vs)):
+            while k + 1 < len(stamped) and stamped[k + 1][1] <= v.s_ptm:
+                k += 1
+            off = final(stamped[k][0]) - pos[i]
+            row[n] = off if off >= 0 else 0x8000 | -off
+    return out
+
+
+def _subpicture_sync(stream, vs, pos, covered):
+    """sp_synca of each VOBU: per subpicture stream (0-31), where the unit
+    on screen during the VOBU is: in this VOBU, or nothing on screen
+    (7fffffff), or the offset to the VOBU it starts in. The unit on screen
+    is the last one shown before the VOBU ends and not gone before it
+    starts; a unit from before the VOBU's cell is not pointed at (a
+    player entering the cell has not read it), as dvdauthor writes them."""
+    starts = [v.start for v in vs]
+    cell_start = {}
+    for i, cell in enumerate(covered):
+        cell_start.setdefault(cell, vs[i].start)
+    out = [[0] * 32 for _ in vs]
+    for sub, units in stream.subpictures.items():
+        n = sub - 0x20
+        for i, (row, v) in enumerate(zip(out, vs)):
+            val = 0x7FFFFFFF
+            for sector, shown, until in reversed(units):
+                if sector < cell_start[covered[i]]:
+                    break
+                if shown < v.e_ptm and (until is None or until > v.s_ptm):
+                    home = pos[bisect.bisect_right(starts, sector) - 1]
+                    if home > pos[i]:
+                        val = home - pos[i]
+                    elif home < pos[i]:
+                        val = 0x80000000 | (pos[i] - home)
+                    break
+            row[n] = val
+    return out
+
+
+HLI = 0x60                 # the highlight information in the PCI data, to 0x316
+
+
+def fill(data, cells, lbn=0, uops=0, stream=None, hli=None, layout=None, ilvu=None, nsml=None):
+    """Fill the navigation packs of a VOB in place (a bytearray or a
+    writable mmap).
+
+    `cells`: [(vob id, cell id, first VOBU index, last VOBU index)], every
+    VOBU in one cell. `lbn`: the sector of the stream's first pack in the
+    titleset's VOBs, when the VOB lies whole there; `layout`: the sector of
+    each VOBU on the disc instead, when the VOB is interleaved with others.
+    `stream`: the stream already scanned, if it is. `hli`: {vob id: the
+    highlight information (buttons) of its menu, 0x2B6 bytes}, written into
+    every navigation pack of that VOB. `ilvu`: {VOBU index: (flags, end,
+    next start, next size, [(angle's next unit, size)] * 9)}, the SML_PBI
+    and SML_AGLI of a VOBU in or before an interleaved block. `nsml`: {VOBU
+    index: [angle's VOBU] * 9}, the PCI's NSML_AGLI. Returns the VOBUs."""
+    stream = stream or ps.scan(data)
+    vs = vobus(stream)
+    pos = list(layout) if layout is not None else [lbn + v.start for v in vs]
+    if len(pos) != len(vs):
+        raise VtsError("the layout does not give every VOBU a sector")
+    starts = [v.start for v in vs]
+
+    def final(sector):
+        k = bisect.bisect_right(starts, sector) - 1
+        return pos[k] + sector - vs[k].start
+    ilvu = ilvu or {}
+    nsml = nsml or {}
+    covered = [None] * len(vs)
+    for cell in cells:
+        vob_id, cell_id, first, last = cell
+        for j in range(first, last + 1):
+            covered[j] = cell
+    if None in covered:
+        raise VtsError("a VOBU is in no cell")
+    vob_s, vob_e = {}, {}
+    for v, cell in zip(vs, covered):
+        v.cell = cell
+        vob_s.setdefault(cell[0], v.s_ptm)
+        vob_e[cell[0]] = v.e_ptm
+    times = [v.s_ptm for v in vs]
+    sync = _audio_sync(stream, vs, pos, final)
+    spu = _subpicture_sync(stream, vs, pos, covered)
+    for i, v in enumerate(vs):
+        vob_id, cell_id, first, last = v.cell
+        base = v.start * ps.SECTOR
+        if data[base + 0x26:base + 0x2D] != b"\x00\x00\x01\xbf\x03\xd4\x00" or \
+                data[base + 0x400:base + 0x407] != b"\x00\x00\x01\xbf\x03\xfa\x01":
+            raise VtsError(f"sector {v.start}: not a navigation pack of PCI and DSI")
+        eltm = elapsed(v.s_ptm - vs[first].s_ptm, stream.frame)
+        pci = bytearray(0x3D4 - 1)
+        struct.pack_into(">IIIIIII", pci, 0, pos[i], 0, uops,
+                         v.s_ptm, v.e_ptm, 0, int.from_bytes(eltm, "big"))
+        if i in nsml:
+            struct.pack_into(">9I", pci, 0x3C, *nsml[i])
+        if hli and vob_id in hli:
+            if len(hli[vob_id]) != 0x316 - HLI:
+                raise VtsError("the highlight information is 0x2B6 bytes")
+            pci[HLI:0x316] = hli[vob_id]
+        dsi = bytearray(0x3FA - 1)
+        # (fewer than three reference pictures: the last one's end again,
+        # as dvdauthor writes it)
+        refs = v.refs + [v.refs[-1] if v.refs else 0] * (3 - len(v.refs))
+        struct.pack_into(">IIIIIIHxB4s", dsi, 0, v.scr & 0xFFFFFFFF, pos[i],
+                         v.end - v.start, *refs, vob_id, cell_id, eltm)
+        if i in ilvu:
+            flags, ea, sa, sz, agli = ilvu[i]
+            struct.pack_into(">HIIH", dsi, 0x20, flags, ea, sa, sz)
+            for n, (dsta, size) in enumerate(agli):
+                struct.pack_into(">IH", dsi, 0xB4 + 6 * n, dsta, size)
+        struct.pack_into(">II", dsi, 0x2C, vob_s[vob_id], vob_e[vob_id])
+        struct.pack_into(">42I", dsi, 0xEA, *_search(vs, times, i, first, last, pos))
+        struct.pack_into(">8H", dsi, 0x192, *sync[i])
+        struct.pack_into(">32I", dsi, 0x1A2, *spu[i])
+        data[base + PCI:base + PCI + len(pci)] = pci
+        data[base + DSI:base + DSI + len(dsi)] = dsi
+    return vs