vtskit 0.1.1__tar.gz → 0.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vtskit
-Version: 0.1.1
+Version: 0.3.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,18 @@ 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 (where two stretches meet inside a VOBU, the one covering more
+  of it), 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. As
+  dvdauthor does, a title with buttons starts with its first button
+  highlighted (SetHL_BTNN 1 before its own pre commands).
 * `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.
@@ -149,8 +160,8 @@ oncemore writing its discs with vtskit.
   `if (g5 != 0) { button = g5; }`, `call menu entry root;`) for the domain
   a text runs in, to the same commands dvdauthor writes for it: a tool
   that already speaks the language, as oncemore does, keeps its text. A
-  button of several commands runs them from the menu's post through a
-  dispatcher, and a jump to a chapter of another titleset goes through pad
+  button of several commands, a menu's or a title's, runs them from the
+  program chain's post through a dispatcher, and a jump to a chapter of another titleset goes through pad
   program chains, as dvdauthor's "jumppads" do.
 * `vtskit.vmg` writes the video manager: VIDEO_TS.IFO and its BUP, with
   the first-play commands, the table of titles and the titlesets'
@@ -182,7 +193,9 @@ 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 (one of them of
+several commands) is dvdauthor's VOB and IFO byte for byte, but for the
+palette. 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 +203,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.3.0}/README.md

@@ -124,7 +124,18 @@ 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 (where two stretches meet inside a VOBU, the one covering more
+  of it), 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. As
+  dvdauthor does, a title with buttons starts with its first button
+  highlighted (SetHL_BTNN 1 before its own pre commands).
 * `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.
@@ -132,8 +143,8 @@ oncemore writing its discs with vtskit.
   `if (g5 != 0) { button = g5; }`, `call menu entry root;`) for the domain
   a text runs in, to the same commands dvdauthor writes for it: a tool
   that already speaks the language, as oncemore does, keeps its text. A
-  button of several commands runs them from the menu's post through a
-  dispatcher, and a jump to a chapter of another titleset goes through pad
+  button of several commands, a menu's or a title's, runs them from the
+  program chain's post through a dispatcher, and a jump to a chapter of another titleset goes through pad
   program chains, as dvdauthor's "jumppads" do.
 * `vtskit.vmg` writes the video manager: VIDEO_TS.IFO and its BUP, with
   the first-play commands, the table of titles and the titlesets'
@@ -165,7 +176,9 @@ 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 (one of them of
+several commands) is dvdauthor's VOB and IFO byte for byte, but for the
+palette. 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 +186,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.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vtskit"
-version = "0.1.1"
+version = "0.3.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.1.1 → vtskit-0.3.0}/tests/test_lang.py

@@ -138,6 +138,17 @@ class TestForms(unittest.TestCase):
         self.assertEqual(hexes(self.d.compile("g1 = 0; exit;", "vts", 1)), ["7100000100000000", "3001000000000000"])
         self.assertEqual(hexes(self.d.compile("call menu entry root resume 3;", "vts", 1)), ["3008000003830000"])
 
+    def test_title_buttons(self):
+        # dvdauthor's bytes for the same buttons in a title's <pgc>, with
+        # <post>jump title 2;</post>: the same dispatcher as a menu's
+        buttons, post = self.d.menu(["g1 = 2; g2 = 3; jump title 2 chapter 1;", "g3 = 4; g4 = 5; jump title 2;"],
+                                    "jump title 2;", "vts", 1)
+        self.assertEqual(hexes(buttons), ["7101000f0001000d", "7101000f0002000d"])
+        self.assertEqual(hexes(post), ["6100000e000f0000", "7100000f00000000", "00a1000e00010006",
+                                       "00a1000e00020009", "3003000000020000", "7100000100020000",
+                                       "7100000200030000", "3005000100020000", "7100000300040000",
+                                       "7100000400050000", "3003000000020000"])
+
     def test_dead_code_after_a_jump(self):
         self.assertEqual(hexes(self.d.compile("g1 = 0; resume; g1 = 0; jump title 1 chapter 2; "
                                               "subtitle = 65; audio = 1;", "vtsm", 1)),
@@ -191,7 +202,7 @@ class TestForms(unittest.TestCase):
         with self.assertRaises(VtsError):
             self.d.menu(["g1 = 1; g2 = 2;"], "g3 = 3;", "vtsm", 1)   # post that does not leave
         with self.assertRaises(VtsError):
-            self.d.menu(["exit;"], "exit;", "vts", 1)
+            self.d.menu(["exit;"], "exit;", "fp")                   # no buttons in the first play
 
 
 def author(folder, menu_n, menu_h, a, b):

vtskit-0.3.0/tests/test_title_buttons.py

@@ -0,0 +1,247 @@
+"""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, lang, 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) and IFO
+        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)
+        texts = ["g1 = 2; g2 = 3; jump title 2 chapter 1;", "exit;"]
+        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">{texts[0]}</button>'
+                    f'<button name="b2">{texts[1]}</button><post>jump title 2;</post></pgc>'
+                    f'<pgc><vob file="{self.short}"/></pgc></titles></titleset></dvdauthor>')
+        subprocess.run(["dvdauthor", "-x", f"{t}/dvd.xml"], check=True, capture_output=True, env=ENV)
+        # vtskit: the same buttons compiled with vtskit.lang (a button of
+        # several commands runs them from the post, through a dispatcher)
+        disc = lang.Disc({(1, 1): 1, (1, 2): 2}, titlesets={1: lang.Menus()})
+        commands, post = disc.menu(texts, "jump title 2;", "vts", 1)
+        tb = buttons(0, None)
+        for b, c in zip(tb.buttons, commands):
+            b.command = c
+        mine = f"{t}/mine-whole"
+        titleset.write(mine, 1, [Title(sp, audio=(Audio("en", 2),), post=tuple(post), buttons=(tb,)),
+                                 Title(self.short, audio=(Audio("en", 2),))])
+        theirs = f"{t}/dvd/VIDEO_TS"
+        a, b = read(f"{mine}/VTS_01_1.VOB"), read(f"{theirs}/VTS_01_1.VOB")
+        self.assertEqual([n[2] for n in navs(a)], [n[2] for n in navs(b)])
+        self.assertEqual(a, b)
+        # the IFO: the same, the title's pre (SetHL_BTNN 1) and post
+        # included, but for the palette (spumux's colours)
+        a, b = read(f"{mine}/VTS_01_0.IFO"), read(f"{theirs}/VTS_01_0.IFO")
+        self.assertEqual(len(a), len(b))
+        pgc = struct.unpack_from(">I", a, 0xCC)[0] * 2048 + 16
+        self.assertEqual(a[:pgc + 0xA4], b[:pgc + 0xA4])
+        self.assertEqual(a[pgc + 0xE4:], b[pgc + 0xE4:])
+
+    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, 3.0), buttons(3.05, 3.2), buttons(3.25, 5))   # in the VOBU from 3.0 s
+        with self.assertRaisesRegex(VtsError, "after the title ends"):
+            write(buttons(30, 40))
+
+    def test_stretches_meeting_in_a_vobu(self):
+        # the VOBUs start every 0.6006 s; where two stretches meet inside a
+        # VOBU, it carries the one covering more of it
+        def starts(*tbs):
+            """{VOBU start (s, rounded): its HLI's start from the title's start}"""
+            out = os.path.join(self.tmp, "meeting")
+            titleset.write(out, 1, [Title(self.plain, audio=(Audio("en", 2),), buttons=tbs)])
+            packs = navs(read(f"{out}/VTS_01_1.VOB"))
+            s0 = packs[0][1]
+            return {round((s - s0) / 90000, 1): struct.unpack_from(">I", h, 2)[0] - s0 if h[1] else None
+                    for _, s, h in packs}
+        got = starts(buttons(1, 2.8), buttons(2.9, 5))
+        self.assertEqual((got[1.8], got[2.4], got[3.0]), (90000, 90000, 261000))
+        # buttons that change a frame before or after a VOBU's start (as a
+        # film title's frames fall): each VOBU still carries its own
+        for edge in (3.003 - 3003 / 90000, 3.003 + 3003 / 90000):
+            got = starts(buttons(1, edge), buttons(edge, 5))
+            self.assertEqual((got[2.4], got[3.0]), (90000, int(round(edge * 90000))), edge)
+
+    @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.3.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.3.0"
 __all__ = ["VtsError"]

{vtskit-0.1.1 → vtskit-0.3.0}/vtskit/lang.py

@@ -25,10 +25,10 @@ authored):
 * `audio = 1; subtitle = 65;` next to each other are one SetSTN; `g1 = 0;
   jump menu 2;` is one command (vtskit.vm folds a Set and a Link), and
   what follows an unconditional jump in a block is left out;
-* a menu's button runs one command: a button whose text compiles to more
-  sets GPRM 15 to its number and links to the end of the program chain,
-  whose post commands start with a dispatcher (`g14 = g15; g15 = 0;` and a
-  Goto per such button) and end with each button's code;
+* a menu's or a title's button runs one command: a button whose text
+  compiles to more sets GPRM 15 to its number and links to the end of the
+  program chain, whose post commands start with a dispatcher (`g14 = g15;
+  g15 = 0;` and a Goto per such button) and end with each button's code;
 * a jump into another titleset (dvdauthor's "jumppad") cannot be one
   command: from the video manager a jump to a chapter sets GPRM 15 to a
   code naming the title and chapter and jumps to the titleset's chapter
@@ -572,10 +572,12 @@ class Disc:
     def menu(self, buttons, post, domain="vtsm", vts=0):
         """A menu's buttons and post commands: ([one command a button],
         post commands). A button whose text takes several commands runs
-        them from the post, through a dispatcher, as dvdauthor arranges."""
+        them from the post, through a dispatcher, as dvdauthor arranges.
+        A title's buttons (domain "vts") are compiled the same way, as
+        dvdauthor compiles them."""
         self._check_domain(domain)
-        if domain not in ("vtsm", "vmgm"):
-            raise VtsError("buttons belong to menus")
+        if domain not in ("vtsm", "vmgm", "vts"):
+            raise VtsError("buttons belong to menus and titles")
         commands, deferred = [], []
         for n, text in enumerate(buttons, 1):
             items = self.instructions(text, domain, vts)

{vtskit-0.1.1 → vtskit-0.3.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.3.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.3.0}/vtskit/titleset.py

@@ -63,7 +63,7 @@ import os
 import struct
 from dataclasses import dataclass, field
 
-from . import menu as menus_, nav, ps, spu
+from . import menu as menus_, nav, ps, spu, vm
 from .errors import VtsError
 
 SECTOR = ps.SECTOR
@@ -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,71 @@ def _title(number, title, offset, vob_id):
     return w, sector, vob_id
 
 
+def _pre(title):
+    """A title's pre commands: with buttons, first the first button
+    highlighted (SetHL_BTNN 1), as dvdauthor writes it for a title with
+    buttons (tests/test_title_buttons.py)."""
+    if not title.buttons:
+        return tuple(title.pre)
+    return (vm.set_hl_btnn(1 << 10).encode(),) + tuple(title.pre)
+
+
+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). Where two
+    stretches meet inside a VOBU, it carries the one that covers more of
+    it: buttons that change between VOBUs (oncemore starts a VOBU there)
+    are not lost to a picture's difference between a time and the VOBU's
+    start, as in a film title with pulldown."""
+    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 = {}
+    touched, used = set(), 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 i, v in enumerate(vs):
+                t0 = part_start[k] + v.s_ptm - base
+                t1 = part_start[k] + v.e_ptm - base
+                # (two stretches in a VOBU: the one covering more of it, the
+                # later on a tie; a VOBU carries one set of buttons)
+                best = None
+                for s, e, tb, what in stretches:
+                    cover = min(t1, e if e is not None else t1) - max(t0, s)
+                    if cover > 0:
+                        touched.add(what)
+                        if best is None or cover >= best[0]:
+                            best = (cover, s, e, tb, what)
+                if best is None:
+                    continue
+                _, s, e, tb, what = best
+                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 touched:
+            raise VtsError(f"{what} start after the title ends")
+        if what not in used:
+            raise VtsError(f"{what} are shown for less of each VOBU they fall in than the buttons "
+                           "beside them: a VOBU carries one set of buttons")
+    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
@@ -893,7 +977,7 @@ def _write(folder, vts, titles, written, menus, language, pan_scan, letterbox, c
         for name in ("next_pgc", "prev_pgc", "up_pgc"):
             if not 0 <= getattr(t, name) <= len(titles):
                 raise VtsError(f"title {n}: {name} {getattr(t, name)}: the titleset has {len(titles)} program chains")
-    pgcs = [_pgc((t.pre, t.post, t.cell_commands), w, frame, sorted(w.stream.subpictures), t.palette,
+    pgcs = [_pgc((_pre(t), t.post, t.cell_commands), w, frame, sorted(w.stream.subpictures), t.palette,
                  stills=t.stills, uops=t.uops, video=video, links=(t.next_pgc, t.prev_pgc, t.up_pgc))
             for t, w in zip(titles, written)]
     pgci = struct.pack(">HHI", len(pgcs), 0, 0)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vtskit
-Version: 0.1.1
+Version: 0.3.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,18 @@ 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 (where two stretches meet inside a VOBU, the one covering more
+  of it), 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. As
+  dvdauthor does, a title with buttons starts with its first button
+  highlighted (SetHL_BTNN 1 before its own pre commands).
 * `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.
@@ -149,8 +160,8 @@ oncemore writing its discs with vtskit.
   `if (g5 != 0) { button = g5; }`, `call menu entry root;`) for the domain
   a text runs in, to the same commands dvdauthor writes for it: a tool
   that already speaks the language, as oncemore does, keeps its text. A
-  button of several commands runs them from the menu's post through a
-  dispatcher, and a jump to a chapter of another titleset goes through pad
+  button of several commands, a menu's or a title's, runs them from the
+  program chain's post through a dispatcher, and a jump to a chapter of another titleset goes through pad
   program chains, as dvdauthor's "jumppads" do.
 * `vtskit.vmg` writes the video manager: VIDEO_TS.IFO and its BUP, with
   the first-play commands, the table of titles and the titlesets'
@@ -182,7 +193,9 @@ 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 (one of them of
+several commands) is dvdauthor's VOB and IFO byte for byte, but for the
+palette. 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 +203,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.3.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