vtskit 0.1.1__tar.gz → 0.2.0__tar.gz

{vtskit-0.1.1/vtskit.egg-info → vtskit-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vtskit
-Version: 0.1.1
+Version: 0.2.0
 Summary: DVD-Video titlesets in pure Python: VOBs, navigation packs and IFO files
 Author: kajisho5
 License-Expression: LGPL-3.0-or-later
@@ -141,7 +141,15 @@ oncemore writing its discs with vtskit.
   VOBU of the same moment (NSML_AGLI). Only one of the two is filled, as
   players take NSML_AGLI whenever it is there. A stream whose interleaved
   units start with open groups of pictures (B-pictures leaning on the group
-  before, another angle's after a switch) is refused.
+  before, another angle's after a switch) is refused. A title may carry
+  buttons over stretches of it (`vtskit.menu.TitleButtons`: from a start
+  to an end, the buttons, the palette entries that draw them): their
+  overlay is a forced subpicture added with `vtskit.subtitles`, and the
+  highlight information goes only into the VOBUs that play during the
+  stretch, with the stretch's start and end as its start time, end time
+  and the end of the selection (dvdinfo's hli_s_ptm, hli_e_ptm,
+  btn_sl_e_ptm). dvdauthor gives a title's buttons the whole title (every
+  VOBU, never ending), which is what buttons without an end write.
 * `vtskit.subtitles` adds subtitles to a title's program stream, as spumux
   does: each cue a picture of up to four colours placed on the screen and
   shown for a while, as subpicture packs a little before their time.
@@ -182,7 +190,8 @@ dvdauthor's (its buttons made with spumux), and a menu's overlay in a
 normal colour is spumux's unit byte for byte; subtitles muxed by vtskit are
 spumux's units, placed where spumux places them, and the title written
 from that stream (4:3, and 16:9 with and without pan-scan or letterbox) is
-dvdauthor's. A VIDEO_TS written by vtskit alone plays
+dvdauthor's; a title with buttons over the whole of it is dvdauthor's
+VOB byte for byte. A VIDEO_TS written by vtskit alone plays
 its titles and chapters in order under libdvdnav, its commands jumping
 between titles, its menus' buttons lead where they say, and its jumps into
 another titleset's chapters land; a title with an angle block plays and
@@ -190,7 +199,9 @@ switches angles under libdvdnav, every pointer of its navigation packs
 landing on the unit it names, and the pictures libdvdnav hands a player
 through a switch, decoded with ffmpeg, are every picture once, in order,
 the new angle from the end of a unit (dvdauthor writes no angles, so a
-set-top player is the check still owed)
+set-top player is the check still owed); a title's buttons over a stretch
+are offered by libdvdnav in that stretch's VOBUs alone, and run their
+commands
 (`python -m unittest discover -s tests -t .`; a test is skipped when a tool
 it needs is missing). oncemore's switch to vtskit (step 4) is merged:
 [oncemore#90](https://github.com/kajisho5/oncemore/pull/90) and

{vtskit-0.1.1 → vtskit-0.2.0}/README.md

@@ -124,7 +124,15 @@ oncemore writing its discs with vtskit.
   VOBU of the same moment (NSML_AGLI). Only one of the two is filled, as
   players take NSML_AGLI whenever it is there. A stream whose interleaved
   units start with open groups of pictures (B-pictures leaning on the group
-  before, another angle's after a switch) is refused.
+  before, another angle's after a switch) is refused. A title may carry
+  buttons over stretches of it (`vtskit.menu.TitleButtons`: from a start
+  to an end, the buttons, the palette entries that draw them): their
+  overlay is a forced subpicture added with `vtskit.subtitles`, and the
+  highlight information goes only into the VOBUs that play during the
+  stretch, with the stretch's start and end as its start time, end time
+  and the end of the selection (dvdinfo's hli_s_ptm, hli_e_ptm,
+  btn_sl_e_ptm). dvdauthor gives a title's buttons the whole title (every
+  VOBU, never ending), which is what buttons without an end write.
 * `vtskit.subtitles` adds subtitles to a title's program stream, as spumux
   does: each cue a picture of up to four colours placed on the screen and
   shown for a while, as subpicture packs a little before their time.
@@ -165,7 +173,8 @@ dvdauthor's (its buttons made with spumux), and a menu's overlay in a
 normal colour is spumux's unit byte for byte; subtitles muxed by vtskit are
 spumux's units, placed where spumux places them, and the title written
 from that stream (4:3, and 16:9 with and without pan-scan or letterbox) is
-dvdauthor's. A VIDEO_TS written by vtskit alone plays
+dvdauthor's; a title with buttons over the whole of it is dvdauthor's
+VOB byte for byte. A VIDEO_TS written by vtskit alone plays
 its titles and chapters in order under libdvdnav, its commands jumping
 between titles, its menus' buttons lead where they say, and its jumps into
 another titleset's chapters land; a title with an angle block plays and
@@ -173,7 +182,9 @@ switches angles under libdvdnav, every pointer of its navigation packs
 landing on the unit it names, and the pictures libdvdnav hands a player
 through a switch, decoded with ffmpeg, are every picture once, in order,
 the new angle from the end of a unit (dvdauthor writes no angles, so a
-set-top player is the check still owed)
+set-top player is the check still owed); a title's buttons over a stretch
+are offered by libdvdnav in that stretch's VOBUs alone, and run their
+commands
 (`python -m unittest discover -s tests -t .`; a test is skipped when a tool
 it needs is missing). oncemore's switch to vtskit (step 4) is merged:
 [oncemore#90](https://github.com/kajisho5/oncemore/pull/90) and

{vtskit-0.1.1 → vtskit-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vtskit"
-version = "0.1.1"
+version = "0.2.0"
 description = "DVD-Video titlesets in pure Python: VOBs, navigation packs and IFO files"
 readme = "README.md"
 license = "LGPL-3.0-or-later"

vtskit-0.2.0/tests/test_title_buttons.py

@@ -0,0 +1,210 @@
+"""Buttons over a stretch of a title (vtskit.menu.TitleButtons): the VOB
+checked byte for byte against dvdauthor's for buttons over the whole
+title, the highlight information only in the VOBUs of a stretch, and
+libdvdnav offering the buttons during the stretch alone and running their
+commands."""
+
+import ctypes
+import os
+import shutil
+import struct
+import subprocess
+import sys
+import tempfile
+import unittest
+
+from vtskit import VtsError, menu, ps, spu, subtitles, titleset, vm, vmg
+from vtskit.menu import Button, TitleButtons
+from vtskit.titleset import Audio, Title
+
+from .test_menu import RECTS, png
+from .test_titleset import encode
+
+try:
+    from . import dvdnav_sim
+    LIBDVDNAV = dvdnav_sim.load_library()
+except Exception:  # pragma: no cover
+    LIBDVDNAV = None
+
+TOOLS_OK = bool(shutil.which("ffmpeg") and shutil.which("dvdauthor") and shutil.which("spumux"))
+ENV = {**os.environ, "VIDEO_FORMAT": "NTSC"}
+YELLOW, RED = (0xD2, 0x92, 0x10), (0x52, 0xF0, 0x5A)
+
+
+def read(path):
+    with open(path, "rb") as f:
+        return f.read()
+
+
+def buttons(start, end, first=(vm.jump_vts_ptt(1, 1), vm.exit())):
+    return TitleButtons(start, end, [Button(RECTS[0], first[0].encode(), up=2, down=2),
+                                     Button(RECTS[1], first[1].encode(), up=1, down=1)],
+                        highlight=(0, 15), select=(1, 15))
+
+
+def navs(vob):
+    """(sector, VOBU s_ptm, the PCI's highlight information) of every navigation pack."""
+    out = []
+    for pk in ps.iter_packs(vob):
+        if pk.nav:
+            o = pk.sector * ps.SECTOR + 0x2D
+            out.append((pk.sector, struct.unpack_from(">I", vob, o + 0x0C)[0], vob[o + 0x60:o + 0x316]))
+    return out
+
+
+class TestFields(unittest.TestCase):
+    def test_hli(self):
+        h = buttons(1.0, 2.0).hli(1000, 2000)
+        self.assertEqual(struct.unpack_from(">HIIIHBBBBBB", h, 0),
+                         (1, 1000, 2000, 2000, 0x1000, 0, 2, 2, 0, 0, 0))
+        self.assertEqual(h[0x16:0x1E].hex(), "000000f0001000f0")       # dvdauthor's for a title
+        self.assertEqual(h[0x2E:0x34].hex(), "46412c06408c")      # colour table 1
+
+    def test_cue(self):
+        c = buttons(1.0, 3.5).cue(720, 480)
+        self.assertEqual((c.start, c.end, c.x, c.y, c.forced), (1.0, 3.5, 100, 100, True))
+        self.assertEqual((c.picture.width, c.picture.height), (200, 140))
+        self.assertEqual((c.colours, c.contrasts), ((0, 0, 0, 0), (0, 0, 0, 0)))
+        area, pixels, cmds = spu.decode(subtitles.unit(c))
+        self.assertEqual(area, (100, 299, 100, 239))
+        self.assertEqual(cmds[0], 0x00)                                # forced start
+        self.assertEqual(sum(1 for v in pixels.values() if v == 1), 2 * 200 * 40)
+        shown = TitleButtons(0, None, buttons(0, 1).buttons, (0, 15), (1, 15), normal=(2, 9))
+        c = shown.cue(720, 480, length=8)
+        self.assertEqual((c.end, c.colours, c.contrasts), (8, (0, 2, 0, 0), (0, 9, 0, 0)))
+        with self.assertRaisesRegex(VtsError, "length"):
+            shown.cue(720, 480)
+
+    def test_refused(self):
+        bad = [TitleButtons(2.0, 1.0, buttons(0, 1).buttons, (0, 15), (1, 15)),
+               TitleButtons(0, 1, buttons(0, 1).buttons, (16, 15), (1, 15)),
+               TitleButtons(0, 1, buttons(0, 1).buttons, (0, 15), (1,)),
+               TitleButtons(0, 1, [], (0, 15), (1, 15)),
+               TitleButtons(0, 1, [Button((0, 0, 800, 10), bytes(8))], (0, 15), (1, 15)),
+               TitleButtons(0, 1, buttons(0, 1).buttons, (0, 15), (1, 15), first_button=3)]
+        for tb in bad:
+            with self.assertRaises(VtsError, msg=tb):
+                menu.check_title_buttons(tb, 720, 480, "t")
+
+
+@unittest.skipUnless(TOOLS_OK, "needs ffmpeg, spumux and dvdauthor")
+class TestTitleButtons(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.tmp = t = tempfile.mkdtemp(prefix="vtskit-tbtn-")
+        cls.plain = os.path.join(t, "plain.mpg")
+        encode(cls.plain, seconds=10)
+        cls.short = os.path.join(t, "short.mpg")
+        encode(cls.short, seconds=2)
+
+    @classmethod
+    def tearDownClass(cls):
+        shutil.rmtree(cls.tmp, ignore_errors=True)
+
+    def test_whole_title_as_dvdauthor(self):
+        # spumux's buttons over the whole title, then dvdauthor; vtskit
+        # given the same stream and buttons without an end writes the same
+        # VOB (dvdauthor writes the HLI in every VOBU, never ending)
+        t = self.tmp
+        png(f"{t}/hl.png", 720, 480, RECTS, (255, 255, 0))
+        png(f"{t}/sel.png", 720, 480, RECTS, (255, 0, 0))
+        with open(f"{t}/spu.xml", "w") as f:
+            f.write('<subpictures format="NTSC"><stream><spu start="00:00:00.00" end="00:00:10.00" '
+                    f'highlight="{t}/hl.png" select="{t}/sel.png">'
+                    '<button name="b1" x0="100" y0="100" x1="300" y1="140" up="b2" down="b2"/>'
+                    '<button name="b2" x0="100" y0="200" x1="300" y1="240" up="b1" down="b1"/>'
+                    '</spu></stream></subpictures>')
+        sp = f"{t}/buttons.mpg"
+        with open(self.plain, "rb") as src, open(sp, "wb") as dst:
+            subprocess.run(["spumux", "-s", "0", f"{t}/spu.xml"], stdin=src, stdout=dst, check=True,
+                           stderr=subprocess.DEVNULL, env=ENV)
+        with open(f"{t}/dvd.xml", "w") as f:
+            f.write(f'<dvdauthor dest="{t}/dvd"><vmgm/><titleset><titles>'
+                    '<video format="ntsc" aspect="4:3"/><audio format="ac3" channels="2" lang="en"/>'
+                    f'<pgc><vob file="{sp}"/><button name="b1">jump title 1 chapter 1;</button>'
+                    '<button name="b2">exit;</button></pgc></titles></titleset></dvdauthor>')
+        subprocess.run(["dvdauthor", "-x", f"{t}/dvd.xml"], check=True, capture_output=True, env=ENV)
+        mine = f"{t}/mine-whole"
+        titleset.write(mine, 1, [Title(sp, audio=(Audio("en", 2),), buttons=(buttons(0, None),))])
+        a, b = read(f"{mine}/VTS_01_1.VOB"), read(f"{t}/dvd/VIDEO_TS/VTS_01_1.VOB")
+        self.assertEqual([n[2] for n in navs(a)], [n[2] for n in navs(b)])
+        self.assertEqual(a, b)
+
+    def stretch_disc(self, start, end):
+        """Title 1 (10 s) with buttons from `start` to `end` (button 1:
+        title 2, button 2: exit), title 2 short."""
+        t = self.tmp
+        tb = buttons(start, end, (vm.jump_vts_tt(2), vm.exit()))
+        mpg = f"{t}/stretch-{start}-{end}.mpg"
+        with open(mpg, "wb") as f:
+            f.write(subtitles.mux(read(self.plain), {0: [tb.cue(720, 480)]}))
+        out = f"{t}/disc-{start}-{end}"
+        ts = titleset.write(out, 1, [Title(mpg, audio=(Audio("en", 2),), palette=(YELLOW, RED),
+                                           buttons=(tb,)),
+                                     Title(self.short, audio=(Audio("en", 2),))])
+        vmg.write(out, [ts])
+        return out
+
+    def test_hli_in_the_stretch_only(self):
+        out = self.stretch_disc(3.0, 6.0)
+        packs = navs(read(f"{out}/VTS_01_1.VOB"))
+        packs = packs[:next(k for k in range(1, len(packs)) if packs[k][1] < packs[k - 1][1])]  # title 1's
+        s0 = packs[0][1]
+        ends = [p[1] for p in packs[1:]] + [None]
+        lit = 0
+        for (sector, s_ptm, h), e_ptm in zip(packs, ends):
+            during = (e_ptm is None or e_ptm > s0 + 270000) and s_ptm < s0 + 540000
+            if during:
+                lit += 1
+                self.assertEqual(struct.unpack_from(">HIII", h, 0),
+                                 (1, s0 + 270000, s0 + 540000, s0 + 540000), sector)
+                self.assertEqual(h[17], 2)                             # btn_ns
+            else:
+                self.assertEqual(h, bytes(len(h)), sector)            # hli_ss 0, nothing
+        self.assertGreater(lit, 4)
+        self.assertLess(lit, len(packs) - 4)
+
+    def test_refused_in_a_title(self):
+        def write(*tbs, stream=None):
+            titleset.write(os.path.join(self.tmp, "refused"), 1,
+                           [Title(stream or self.plain, audio=(Audio("en", 2),), buttons=tbs)])
+        with self.assertRaisesRegex(VtsError, "overlap"):
+            write(buttons(1, 4), buttons(3, 5))
+        with self.assertRaisesRegex(VtsError, "overlap"):
+            write(buttons(1, None), buttons(3, 5))
+        with self.assertRaisesRegex(VtsError, "one set of buttons"):
+            write(buttons(1, 2.8), buttons(2.9, 5))                   # in the VOBU from 2.4 s to 3.0 s
+        with self.assertRaisesRegex(VtsError, "after the title ends"):
+            write(buttons(30, 40))
+
+    @unittest.skipUnless(LIBDVDNAV, "needs libdvdnav")
+    def test_under_libdvdnav(self):
+        out = self.stretch_disc(3.0, 6.0)
+        with dvdnav_sim.DvdSim(out, LIBDVDNAV) as d:
+            self.assertEqual(d.wait_title(), (1, 1))
+            seen = []                                # (VOBU start, buttons) through title 1
+            e = dvdnav_sim.EV_NAV_PACKET
+            while not d.stopped:                     # (title 1 ends with Exit)
+                if e == dvdnav_sim.EV_NAV_PACKET and d.domain() == "title":
+                    self.assertEqual(d.title_part()[0], 1)
+                    raw = ctypes.string_at(LIBDVDNAV.dvdnav_get_current_nav_pci(d.h), 16)
+                    seen.append((int.from_bytes(raw[12:16], sys.byteorder), d.button_count()))
+                e = d.step()
+        s0 = seen[0][0]
+        starts = [s for s, _ in seen]
+        ends = starts[1:] + [None]
+        expect = [2 if (e is None or e > s0 + 270000) and s < s0 + 540000 else 0
+                  for s, e in zip(starts, ends)]
+        self.assertEqual([n for _, n in seen], expect)
+        self.assertIn(0, expect[:2])
+        # the first button, pressed while the buttons are there: title 2
+        with dvdnav_sim.DvdSim(out, LIBDVDNAV) as d:
+            d.wait_title()
+            d.run_until(lambda e: e == dvdnav_sim.EV_NAV_PACKET and d.button_count() > 0)
+            self.assertEqual(d.title_part(), (1, 1))
+            d.activate(1)
+            self.assertEqual(d.wait_title(), (2, 1))
+
+
+if __name__ == "__main__":
+    unittest.main()

{vtskit-0.1.1 → vtskit-0.2.0}/vtskit/__init__.py

@@ -21,5 +21,5 @@ subtitles and angles, and dvdauthor's command language:
 
 from .errors import VtsError
 
-__version__ = "0.1.1"
+__version__ = "0.2.0"
 __all__ = ["VtsError"]

{vtskit-0.1.1 → vtskit-0.2.0}/vtskit/menu.py

@@ -14,6 +14,17 @@ 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>`.
 
+A title may carry buttons too, over a stretch of it (TitleButtons): their
+overlay is a forced subpicture shown for the stretch (`TitleButtons.cue`,
+added to the title's stream with vtskit.subtitles.mux), and the HLI is in
+the navigation packs of the VOBUs that play during the stretch, with the
+stretch's start and end as its start time (hli_s_ptm), end time (hli_e_ptm)
+and the end of the user's selection (btn_sl_e_ptm: "ignore user after
+this", dvdinfo); the other VOBUs have none (hli_ss 0: "no highlight
+information for this VOBU"). dvdauthor gives a title's buttons the whole
+title instead: the HLI in every VOBU, from the first picture, never ending,
+which is what a stretch without an end writes.
+
 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
@@ -25,7 +36,7 @@ activated.
 import struct
 from dataclasses import dataclass, field
 
-from . import spu
+from . import spu, subtitles
 from .errors import VtsError
 
 YELLOW, RED = (0xD2, 0x92, 0x10), (0x52, 0xF0, 0x5A)      # Y, Cr, Cb
@@ -73,6 +84,69 @@ class Menu:
     uops: int = 0                  # user operations the menu forbids (bit n: vtskit.vm.UOP_*)
 
 
+@dataclass
+class TitleButtons:
+    """Buttons over a stretch of a title: from `start` to `end` (seconds
+    from the title's first picture; `end` None: to the end, the buttons
+    never taken off), the buttons, the entries of the title's palette
+    (0-15) and contrasts (0-15) drawing a button selected (`highlight`) and
+    activated (`select`) as (entry, contrast), the entry and contrast the
+    buttons show in otherwise (`normal`; None: nothing), the overlay (code
+    1 where a button lights up; by default the buttons' rectangles), the
+    button selected when they show (0: the player's choice) and the number
+    added to a number key's digit."""
+    start: float
+    end: float | None
+    buttons: list
+    highlight: tuple
+    select: tuple
+    normal: tuple | None = None
+    overlay: object = None
+    first_button: int = 0
+    button_offset: int = 0
+
+    def cue(self, width, height, length=None):
+        """The overlay as a subtitle cue for vtskit.subtitles.mux: forced
+        (shown with subtitles off), from `start` to `end` (or `length`
+        seconds, the title's, for buttons without an end), transparent or
+        in the normal colour."""
+        end = self.end if self.end is not None else length
+        if end is None:
+            raise VtsError("buttons without an end: give the title's length")
+        o = self.overlay if self.overlay is not None else \
+            spu.Overlay.from_rects(width, height, [b.rect for b in self.buttons])
+        if (o.width, o.height) != (width, height):
+            raise VtsError("the overlay is not the picture's size")
+        box = o.bounds()
+        if box is None:
+            raise VtsError("the overlay is blank")
+        x0, y0, x1, y1 = box
+        crop = b"".join(o.pixels[y * width + x0:y * width + x1 + 1] for y in range(y0, y1 + 1))
+        entry, contrast = self.normal if self.normal is not None else (0, 0)
+        return subtitles.Cue(self.start, end, spu.Overlay(x1 - x0 + 1, y1 - y0 + 1, crop), x0, y0,
+                             colours=(0, entry, 0, 0), contrasts=(0, contrast, 0, 0), forced=True)
+
+    def hli(self, s_ptm, e_ptm):
+        """The highlight information shown from `s_ptm` to `e_ptm` (the
+        stretch's start and end in the VOB's time)."""
+        return _hli(self.buttons, s_ptm, e_ptm, self.button_offset, self.first_button,
+                    self.highlight + self.select)
+
+
+def check_title_buttons(tb, width, height, what):
+    """Refuse buttons a title cannot carry."""
+    for name, pair in (("highlight", tb.highlight), ("selection", tb.select), ("normal", tb.normal)):
+        if pair is None and name == "normal":
+            continue
+        if len(pair) != 2 or not all(isinstance(v, int) and 0 <= v <= 15 for v in pair):
+            raise VtsError(f"{what}: the {name} is (palette entry 0-15, contrast 0-15)")
+    if tb.start < 0 or tb.end is not None and tb.end <= tb.start:
+        raise VtsError(f"{what}: buttons from {tb.start} to {tb.end} s")
+    if not tb.buttons:
+        raise VtsError(f"{what}: no buttons")
+    _check_buttons(tb.buttons, tb.first_button, tb.button_offset, width, height)
+
+
 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}
 
@@ -98,18 +172,24 @@ def check(menu, width, height):
         _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):
+    _check_buttons(menu.buttons, menu.first_button, menu.button_offset, width, height)
+
+
+def _check_buttons(buttons, first_button, button_offset, width, height):
+    if len(buttons) > 36:
+        raise VtsError(f"{len(buttons)} buttons (at most 36)")
+    for n, b in enumerate(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:
+            if not 0 <= k <= len(buttons):
+                raise VtsError(f"button {n} points at button {k}, which is not there")
+    if not 0 <= first_button <= len(buttons):
+        raise VtsError(f"first button {first_button}: there are {len(buttons)}")
+    if not 0 <= button_offset <= 255:
         raise VtsError("the button offset is 0 to 255")
 
 
@@ -145,18 +225,28 @@ def unit(menu, width, height):
 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
+    first = 1 if menu.normal is not None else 0
+    return _hli(menu.buttons, s_ptm, 0xFFFFFFFF, menu.button_offset, menu.first_button,
+                (first, _colour(menu.highlight, "highlight")[1],
+                 first + 1, _colour(menu.select, "selection")[1]))
+
+
+def _hli(buttons, s_ptm, e_ptm, button_offset, first_button, colours):
+    """The highlight information (PCI 0x60 to 0x316): the buttons, shown
+    from `s_ptm` to `e_ptm` (hli_s_ptm, hli_e_ptm; the user's selection
+    ends with them, btn_sl_e_ptm), drawn selected and activated with the
+    palette entries and contrasts `colours` (entry, contrast, entry,
+    contrast)."""
     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)
+    struct.pack_into(">HIIIHBBBBBB", out, 0, 1, s_ptm, e_ptm, e_ptm, 0x1000,
+                     button_offset, len(buttons), len(buttons), 0, 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))
+    hl, hl_c, sel, sel_c = colours
+    out[0x16:0x1E] = bytes((0x00, hl << 4, 0x00, hl_c << 4, 0x00, sel << 4, 0x00, sel_c << 4))
     for n, b in enumerate(buttons):
         x0, y0, x1, y1 = b.rect
         e = 0x2E + 18 * n

{vtskit-0.1.1 → vtskit-0.2.0}/vtskit/nav.py

@@ -179,7 +179,8 @@ def _subpicture_sync(stream, vs, pos, covered):
 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):
+def fill(data, cells, lbn=0, uops=0, stream=None, hli=None, layout=None, ilvu=None, nsml=None,
+         highlights=None):
     """Fill the navigation packs of a VOB in place (a bytearray or a
     writable mmap).
 
@@ -192,7 +193,9 @@ def fill(data, cells, lbn=0, uops=0, stream=None, hli=None, layout=None, ilvu=No
     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."""
+    index: [angle's VOBU] * 9}, the PCI's NSML_AGLI. `highlights`: {VOBU
+    index: highlight information}, buttons in some VOBUs only (a title's).
+    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]
@@ -232,10 +235,13 @@ def fill(data, cells, lbn=0, uops=0, stream=None, hli=None, layout=None, ilvu=No
                          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:
+        h = highlights.get(i) if highlights else None
+        if h is None and hli and vob_id in hli:
+            h = hli[vob_id]
+        if h is not None:
+            if len(h) != 0x316 - HLI:
                 raise VtsError("the highlight information is 0x2B6 bytes")
-            pci[HLI:0x316] = hli[vob_id]
+            pci[HLI:0x316] = h
         dsi = bytearray(0x3FA - 1)
         # (fewer than three reference pictures: the last one's end again,
         # as dvdauthor writes it)

{vtskit-0.1.1 → vtskit-0.2.0}/vtskit/titleset.py

@@ -117,7 +117,11 @@ class Title:
     writes none (titles are chained with commands instead). Under
     libdvdnav, a title whose post commands run out plays on into its next
     program chain, and one without a next stops (tests/test_titleset.py);
-    what players make of them is otherwise not described."""
+    what players make of them is otherwise not described.
+
+    `buttons`: vtskit.menu.TitleButtons, buttons over stretches of the
+    title that do not overlap; their overlays must be in the stream
+    already (TitleButtons.cue, vtskit.subtitles.mux)."""
     stream: str | None = None
     chapters: tuple = (0.0,)
     audio: tuple = ()
@@ -132,6 +136,7 @@ class Title:
     next_pgc: int = 0
     prev_pgc: int = 0
     up_pgc: int = 0
+    buttons: tuple = ()     # vtskit.menu.TitleButtons over stretches of the title
 
 
 @dataclass
@@ -545,18 +550,31 @@ def _clean_starts(where, stream, vs, starts):
 def _title(number, title, offset, vob_id):
     """Read a title's parts, place its chapters, lay its VOBUs on the disc
     (interleaving the angle blocks) and fill their navigation packs:
-    (WrittenTitle, the next free sector, the next VOB id)."""
+    (WrittenTitle, the next free sector, the next VOB id). The streams
+    read are closed again if the title is refused."""
+    loaded = []                 # a part: [(stream, vobus, bytes)] one an angle
+    try:
+        return _lay_title(number, title, offset, vob_id, loaded)
+    except BaseException:
+        for part in loaded:
+            for _, _, buffer in part:
+                _close(buffer)
+        raise
+
+
+def _lay_title(number, title, offset, vob_id, loaded):
     parts = title.parts or (title.stream,)
     if not parts or title.stream and title.parts:
         raise VtsError(f"title {number}: give a stream or parts, not both")
-    loaded = []                 # a part: [(stream, vobus, bytes)] one an angle
     for k, part in enumerate(parts, 1):
         if isinstance(part, Angles):
             if not 2 <= len(part.streams) <= 9:
                 raise VtsError(f"title {number}, part {k}: 2 to 9 angles")
-            angles = [_load(p) for p in part.streams]
-            _aligned(angles, f"title {number}, part {k}")
+            angles = []
             loaded.append(angles)
+            for p in part.streams:
+                angles.append(_load(p))
+            _aligned(angles, f"title {number}, part {k}")
         elif isinstance(part, str):
             loaded.append([_load(part)])
         else:
@@ -703,13 +721,14 @@ def _title(number, title, offset, vob_id):
         for a in range(n_angles):
             jobs.append((k, a, vob_id + a))
         vob_id += n_angles
+    highlights = _title_buttons(number, title, loaded, part_start)
     # fill every VOB now that every sector, and every flag of the VOBUs
     # before an angle block, is known
     for k, a, vid in jobs:
         st, vs, vob = loaded[k][a]
         vob_cells = [(vid, c.cell_id, c.first_vobu, c.last_vobu) for c in cells if c.vob_id == vid]
         nav.fill(vob, vob_cells, stream=st, layout=layouts[(k, a)], ilvu=ilvu_info[(k, a)],
-                 nsml=nsml_info[(k, a)])
+                 nsml=nsml_info[(k, a)], highlights=highlights.get((k, a)))
         lay = layouts[(k, a)]
         if len(loaded[k]) == 1:
             chunks.append((lay[0], vob, 0, len(vob)))
@@ -729,6 +748,49 @@ def _title(number, title, offset, vob_id):
     return w, sector, vob_id
 
 
+def _title_buttons(number, title, loaded, part_start):
+    """The HLI of the title's buttons: {(part, angle): {VOBU: HLI}}, in the
+    VOBUs that play during each stretch (every angle's), shown from the
+    stretch's start to its end in the VOB's time (a stretch that began in
+    an earlier part from the VOB's start; one that goes on into a later
+    part to the VOB's end; one without an end never ending)."""
+    if not title.buttons:
+        return {}
+    width, height = loaded[0][0][0].sequence[:2]
+    stretches = []
+    for n, tb in enumerate(title.buttons, 1):
+        what = f"title {number}, buttons {n}"
+        menus_.check_title_buttons(tb, width, height, what)
+        end = None if tb.end is None else int(round(tb.end * 90000))
+        stretches.append((int(round(tb.start * 90000)), end, tb, what))
+    stretches.sort(key=lambda x: x[0])
+    for (_, e1, _, w1), (s2, _, _, w2) in zip(stretches, stretches[1:]):
+        if e1 is None or e1 > s2:
+            raise VtsError(f"{w1} and {w2} overlap in time")
+    out = {}
+    used = set()
+    for k, part in enumerate(loaded):
+        for a, (_, vs, _) in enumerate(part):
+            base, vob_end = vs[0].s_ptm, vs[-1].e_ptm
+            table = out[(k, a)] = {}
+            for s, e, tb, what in stretches:
+                for i, v in enumerate(vs):
+                    t0 = part_start[k] + v.s_ptm - base
+                    t1 = part_start[k] + v.e_ptm - base
+                    if t1 <= s or e is not None and t0 >= e:
+                        continue
+                    if i in table:
+                        raise VtsError(f"{what} start in the VOBU (part {k + 1}, VOBU {i + 1}) where "
+                                       "the buttons before end: a VOBU carries one set of buttons")
+                    he = 0xFFFFFFFF if e is None else min(base + e - part_start[k], vob_end)
+                    table[i] = tb.hli(base + max(s - part_start[k], 0), he)
+                    used.add(what)
+    for _, _, _, what in stretches:
+        if what not in used:
+            raise VtsError(f"{what} start after the title ends")
+    return out
+
+
 def _attributes(written, pan_scan, letterbox, audio, subpictures, what, captions=(False, False)):
     """(video attr, audio count, audio attrs, subpicture count, subpicture
     attrs, sub-streams) of the VOBs: the picture the same in every one, the

{vtskit-0.1.1 → vtskit-0.2.0/vtskit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vtskit
-Version: 0.1.1
+Version: 0.2.0
 Summary: DVD-Video titlesets in pure Python: VOBs, navigation packs and IFO files
 Author: kajisho5
 License-Expression: LGPL-3.0-or-later
@@ -141,7 +141,15 @@ oncemore writing its discs with vtskit.
   VOBU of the same moment (NSML_AGLI). Only one of the two is filled, as
   players take NSML_AGLI whenever it is there. A stream whose interleaved
   units start with open groups of pictures (B-pictures leaning on the group
-  before, another angle's after a switch) is refused.
+  before, another angle's after a switch) is refused. A title may carry
+  buttons over stretches of it (`vtskit.menu.TitleButtons`: from a start
+  to an end, the buttons, the palette entries that draw them): their
+  overlay is a forced subpicture added with `vtskit.subtitles`, and the
+  highlight information goes only into the VOBUs that play during the
+  stretch, with the stretch's start and end as its start time, end time
+  and the end of the selection (dvdinfo's hli_s_ptm, hli_e_ptm,
+  btn_sl_e_ptm). dvdauthor gives a title's buttons the whole title (every
+  VOBU, never ending), which is what buttons without an end write.
 * `vtskit.subtitles` adds subtitles to a title's program stream, as spumux
   does: each cue a picture of up to four colours placed on the screen and
   shown for a while, as subpicture packs a little before their time.
@@ -182,7 +190,8 @@ dvdauthor's (its buttons made with spumux), and a menu's overlay in a
 normal colour is spumux's unit byte for byte; subtitles muxed by vtskit are
 spumux's units, placed where spumux places them, and the title written
 from that stream (4:3, and 16:9 with and without pan-scan or letterbox) is
-dvdauthor's. A VIDEO_TS written by vtskit alone plays
+dvdauthor's; a title with buttons over the whole of it is dvdauthor's
+VOB byte for byte. A VIDEO_TS written by vtskit alone plays
 its titles and chapters in order under libdvdnav, its commands jumping
 between titles, its menus' buttons lead where they say, and its jumps into
 another titleset's chapters land; a title with an angle block plays and
@@ -190,7 +199,9 @@ switches angles under libdvdnav, every pointer of its navigation packs
 landing on the unit it names, and the pictures libdvdnav hands a player
 through a switch, decoded with ffmpeg, are every picture once, in order,
 the new angle from the end of a unit (dvdauthor writes no angles, so a
-set-top player is the check still owed)
+set-top player is the check still owed); a title's buttons over a stretch
+are offered by libdvdnav in that stretch's VOBUs alone, and run their
+commands
 (`python -m unittest discover -s tests -t .`; a test is skipped when a tool
 it needs is missing). oncemore's switch to vtskit (step 4) is merged:
 [oncemore#90](https://github.com/kajisho5/oncemore/pull/90) and

{vtskit-0.1.1 → vtskit-0.2.0}/vtskit.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ tests/test_lang.py
 tests/test_menu.py
 tests/test_nav.py
 tests/test_subtitles.py
+tests/test_title_buttons.py
 tests/test_titleset.py
 tests/test_vm.py
 tests/test_vmg.py