vtskit 0.1.0__tar.gz → 0.2.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vtskit
-Version: 0.1.0
+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
@@ -85,18 +85,22 @@ play the discs vtskit writes.
 ## Installing
 
 vtskit is one package of plain Python (3.11 or later), with nothing else
-to install. Until it is on PyPI:
+to install:
 
 ```
-pip install git+https://github.com/kajisho5/vtskit
+pip install vtskit
 ```
 
-A tag `v*` on this repository builds the package, attaches it to a GitHub
-release and publishes it to PyPI (`.github/workflows/release.yml`); the
-first PyPI release needs the project registered there with this
-repository as its trusted publisher. oncemore does not install vtskit: it
-carries a copy of `vtskit/` as `oncemore/_vendor/vtskit`, updated with its
-`tools/vendor_vtskit.py`.
+A release is made by the version: when the version in `pyproject.toml`
+(and `vtskit/__init__.py`) reaches `main` without a tag of its own,
+`.github/workflows/release.yml` runs the tests, builds the package, makes
+the GitHub release with its tag and publishes to PyPI. Merging the version
+bump is the whole act; a tag `v*` pushed by hand releases the same way.
+PyPI knows this repository and workflow as the project's trusted
+publisher. oncemore does not install vtskit: it
+carries a copy of each release as `oncemore/_vendor/vtskit`, taken from
+PyPI with its `tools/vendor.py vtskit --pypi <version>` (a pull request
+does it there each day a newer release is out).
 
 ## What is here now
 
@@ -129,9 +133,23 @@ oncemore writing its discs with vtskit.
   libdvdnav a title whose post commands run out plays on into its next
   program chain; dvdauthor writes none of these. A title may be
   several parts in a row, streams and `Angles` blocks of 2 to 9 streams: an
-  angle block is interleaved on the disc, its navigation packs point from
-  each unit to every angle's next, and its cells are marked as an angle
-  block.
+  angle block is interleaved on the disc and its cells are marked as an
+  angle block. A seamless block (the default) is switched at the end of an
+  interleaved unit: its navigation packs point from each unit to every
+  angle's next (SML_AGLI) and its cells say "seamless angle"; a block
+  switched with a break (`seamless=False`) points instead at every angle's
+  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. 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.
@@ -172,13 +190,18 @@ 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
 switches angles under libdvdnav, every pointer of its navigation packs
-landing on the unit it names (dvdauthor writes no angles, so a set-top
-player is the check still owed)
+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); 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.0 → vtskit-0.2.0}/README.md

@@ -68,18 +68,22 @@ play the discs vtskit writes.
 ## Installing
 
 vtskit is one package of plain Python (3.11 or later), with nothing else
-to install. Until it is on PyPI:
+to install:
 
 ```
-pip install git+https://github.com/kajisho5/vtskit
+pip install vtskit
 ```
 
-A tag `v*` on this repository builds the package, attaches it to a GitHub
-release and publishes it to PyPI (`.github/workflows/release.yml`); the
-first PyPI release needs the project registered there with this
-repository as its trusted publisher. oncemore does not install vtskit: it
-carries a copy of `vtskit/` as `oncemore/_vendor/vtskit`, updated with its
-`tools/vendor_vtskit.py`.
+A release is made by the version: when the version in `pyproject.toml`
+(and `vtskit/__init__.py`) reaches `main` without a tag of its own,
+`.github/workflows/release.yml` runs the tests, builds the package, makes
+the GitHub release with its tag and publishes to PyPI. Merging the version
+bump is the whole act; a tag `v*` pushed by hand releases the same way.
+PyPI knows this repository and workflow as the project's trusted
+publisher. oncemore does not install vtskit: it
+carries a copy of each release as `oncemore/_vendor/vtskit`, taken from
+PyPI with its `tools/vendor.py vtskit --pypi <version>` (a pull request
+does it there each day a newer release is out).
 
 ## What is here now
 
@@ -112,9 +116,23 @@ oncemore writing its discs with vtskit.
   libdvdnav a title whose post commands run out plays on into its next
   program chain; dvdauthor writes none of these. A title may be
   several parts in a row, streams and `Angles` blocks of 2 to 9 streams: an
-  angle block is interleaved on the disc, its navigation packs point from
-  each unit to every angle's next, and its cells are marked as an angle
-  block.
+  angle block is interleaved on the disc and its cells are marked as an
+  angle block. A seamless block (the default) is switched at the end of an
+  interleaved unit: its navigation packs point from each unit to every
+  angle's next (SML_AGLI) and its cells say "seamless angle"; a block
+  switched with a break (`seamless=False`) points instead at every angle's
+  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. 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.
@@ -155,13 +173,18 @@ 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
 switches angles under libdvdnav, every pointer of its navigation packs
-landing on the unit it names (dvdauthor writes no angles, so a set-top
-player is the check still owed)
+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); 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.0 → vtskit-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vtskit"
-version = "0.1.0"
+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.1.0 → vtskit-0.2.0}/tests/test_angles.py

@@ -1,7 +1,7 @@
 """Angle blocks (vtskit.titleset.Angles): the interleaved layout, every
 pointer of the navigation packs landing where the descriptions say, the
-cells and tables of the IFO, and libdvdnav playing and switching the
-angles. dvdauthor writes no angles, so there is nothing of its to compare
+cells and tables of the IFO, libdvdnav playing and switching the angles,
+and the pictures it hands a player decoded, through a switch. dvdauthor writes no angles, so there is nothing of its to compare
 with; the structure is checked against itself and the descriptions."""
 
 import os
@@ -23,17 +23,61 @@ except Exception:  # pragma: no cover
 TOOLS_OK = bool(shutil.which("ffmpeg"))
 
 
-def encode(path, seconds, colour, gop=15):
+def encode(path, seconds, colour, gop=15, extra=()):
     """A stream like oncemore's, a coloured frame around the test picture;
     the same arguments give angles the same GOPs and VOBUs."""
     subprocess.run(["ffmpeg", "-hide_banner", "-v", "error", "-y",
                     "-f", "lavfi", "-i", f"testsrc2=s=720x480:r=30000/1001:d={seconds}",
                     "-f", "lavfi", "-i", f"sine=f=440:d={seconds}",
                     "-vf", f"drawbox=c={colour}:t=40", "-target", "ntsc-dvd", "-aspect", "4:3",
-                    "-b:v", "3000k", "-g", str(gop), "-sc_threshold", "1000000000",
+                    "-b:v", "3000k", "-g", str(gop), "-sc_threshold", "1000000000", *extra,
                     "-c:a", "ac3", "-ac", "2", path], check=True)
 
 
+def border(path, frames=None):
+    """The colour of each picture's frame (the drawbox), as (Y, Cb, Cr)."""
+    raw = subprocess.run(["ffmpeg", "-v", "error", "-i", path] +
+                         (["-frames:v", str(frames)] if frames else []) +
+                         ["-vf", "crop=20:20:5:5,scale=1:1:flags=area,format=yuv444p",
+                          "-f", "rawvideo", "-"], capture_output=True, check=True).stdout
+    return [tuple(raw[i:i + 3]) for i in range(0, len(raw), 3)]
+
+
+def play(disc, switch=None):
+    """What libdvdnav hands a player, title domain only, as one program
+    stream (the VOBUs as delivered, navigation packs included), and the
+    angle switches made: `switch` = (after that many navigation packs, to
+    angle n)."""
+    blocks, done = [], []
+    with dvdnav_sim.DvdSim(disc, LIBDVDNAV) as d:
+        d.wait_title()
+        navs = 0
+        for _ in range(2_000_000):
+            e = d.step()
+            if e in (dvdnav_sim.EV_BLOCK_OK, dvdnav_sim.EV_NAV_PACKET) and d.domain() == "title":
+                blocks.append(bytes(d.buf.raw[:2048]))
+            if e == dvdnav_sim.EV_NAV_PACKET and d.domain() == "title":
+                navs += 1
+                if switch and not done and navs == switch[0]:
+                    done.append(d.change_angle(switch[1]))
+            if d.stopped:
+                break
+    return b"".join(blocks), done
+
+
+def runs(colours, names):
+    """The colours as [(name, pictures in a row)], each picture named after
+    the nearest of `names` ({name: (Y, Cb, Cr)})."""
+    out = []
+    for c in colours:
+        n = min(names, key=lambda k: sum((a - b) ** 2 for a, b in zip(names[k], c)))
+        if out and out[-1][0] == n:
+            out[-1][1] += 1
+        else:
+            out.append([n, 1])
+    return [tuple(x) for x in out]
+
+
 def u32(b, o):
     return struct.unpack_from(">I", b, o)[0]
 
@@ -109,7 +153,10 @@ class TestAngleBlock(unittest.TestCase):
         # block, interleaved, the first stretch with STC discontinuity, the
         # second seamless and "seamless angle linked in DSI"
         self.assertEqual(cats[0], 0x02)
-        self.assertEqual(cats[1:4], [0x40 | 0x10 | 0x04 | 0x02, 0x80 | 0x10 | 0x04 | 0x02, 0xC0 | 0x10 | 0x04 | 0x02])
+        # (every cell of a seamless block is "seamless angle linked in DSI",
+        # the first stretch's too: libdvdnav switches it at a unit's end)
+        self.assertEqual(cats[1:4], [0x40 | 0x10 | 0x04 | 0x02 | 0x01, 0x80 | 0x10 | 0x04 | 0x02 | 0x01,
+                                     0xC0 | 0x10 | 0x04 | 0x02 | 0x01])
         self.assertEqual(cats[4:7], [0x40 | 0x10 | 0x08 | 0x04 | 0x01, 0x80 | 0x10 | 0x08 | 0x04 | 0x01,
                                      0xC0 | 0x10 | 0x08 | 0x04 | 0x01])
         self.assertEqual(cats[7], 0x02)
@@ -200,17 +247,8 @@ class TestAngleBlock(unittest.TestCase):
                     self.assertTrue(u16(tdsi, 0x20) & 0x2000)
                     self.assertEqual(size, u32(tdsi, 0x22) + 1)
                     self.assertGreater(target, unit_end)
-            # NSML_AGLI: every angle's VOBU of the same moment
-            for b in range(9):
-                dsta = u32(pci, 0x3C + 4 * b)
-                if b >= 3:
-                    self.assertEqual(dsta, 0)
-                    continue
-                target = s + (dsta & 0x7FFFFFFF) * (-1 if dsta & 0x80000000 else 1)
-                tpci, tdsi = self.navs[target]
-                self.assertEqual(u16(tdsi, 0x18), 2 + b)
-                self.assertEqual(tpci[0x18:0x1C], pci[0x18:0x1C], "the same cell elapsed time")
-                self.assertEqual(tdsi[0x1B], dsi[0x1B], "the same cell")
+            # NSML_AGLI is left empty in a seamless block (TestBreak fills it)
+            self.assertEqual(pci[0x3C:0x60], bytes(36))
         # the VOB start and end times of every angle VOBU are its own VOB's
         for s in block:
             dsi = self.navs[s][1]
@@ -236,6 +274,28 @@ class TestAngleBlock(unittest.TestCase):
                     self.assertIn(target, self.navs, f"VOBU at {s}, pointer {k}")
                     self.assertEqual(u16(self.navs[target][1], 0x18), vob, f"VOBU at {s}, pointer {k}")
 
+    @unittest.skipUnless(LIBDVDNAV, "needs libdvdnav")
+    def test_what_the_player_shows(self):
+        # the pictures libdvdnav hands a player through a switch from angle 1
+        # to 2, decoded: every picture once, in order (as many as the sources
+        # have), the switch at the end of an interleaved unit
+        stream, done = play(self.disc, switch=(9, 2))
+        self.assertEqual(done, [True])
+        path = os.path.join(self.tmp, "played.mpg")
+        with open(path, "wb") as f:
+            f.write(stream)
+        sources = [os.path.join(self.tmp, n) for n in ("intro.mpg", "outro.mpg", "plain.mpg")] + \
+            self.angles
+        names = dict(zip(("white", "black", "gray", "red", "green", "blue"),
+                         (border(p, 1)[0] for p in sources)))
+        seen = runs(border(path), names)
+        self.assertEqual([n for n, _ in seen], ["white", "red", "green", "black", "gray"], seen)
+        counts = dict(seen)
+        self.assertEqual((counts["white"], counts["black"], counts["gray"]), (90, 60, 60))
+        self.assertEqual(counts["red"] + counts["green"], 180)      # nothing twice, nothing lost
+        self.assertEqual(counts["red"] % 30, 0)                     # at a unit's end (a second)
+        self.assertGreater(counts["red"], 15 * 3)                   # (after the 9th VOBU played)
+
     @unittest.skipUnless(LIBDVDNAV, "needs libdvdnav")
     def test_libdvdnav_switches_angles(self):
         played = []
@@ -268,6 +328,18 @@ class TestAngleBlock(unittest.TestCase):
         self.assertEqual([c for i, c in enumerate(chapters) if i == 0 or chapters[i - 1] != c],
                          [(1, 1), (1, 2), (1, 3), (1, 4), (2, 1)])
 
+    def test_open_groups_refused(self):
+        # B-pictures shown before a unit's I-picture lean on the group before
+        # (another angle's after a switch) unless the group is closed
+        a, b = (os.path.join(self.tmp, f"open{k}.mpg") for k in (1, 2))
+        for path, colour in ((a, "red"), (b, "green")):
+            encode(path, 4, colour, extra=("-bf", "2"))
+        with self.assertRaisesRegex(VtsError, "closed groups"):
+            titleset.write(os.path.join(self.tmp, "open"), 1, [Title(parts=(Angles((a, b)),))])
+        for path, colour in ((a, "red"), (b, "green")):
+            encode(path, 4, colour, extra=("-bf", "2", "-flags", "+cgop"))
+        titleset.write(os.path.join(self.tmp, "closed"), 1, [Title(parts=(Angles((a, b)),))])
+
     def test_refused(self):
         short = os.path.join(self.tmp, "short.mpg")
         encode(short, 4, "red")
@@ -279,5 +351,67 @@ class TestAngleBlock(unittest.TestCase):
             titleset.write(os.path.join(self.tmp, "x"), 1, [Title(self.angles[0], parts=(self.angles[1],))])
 
 
+@unittest.skipUnless(TOOLS_OK, "needs ffmpeg")
+class TestBreak(unittest.TestCase):
+    """A title that is one angle block, switched with a break (not
+    seamless), as a title of oncemore's angles is laid out: NSML_AGLI
+    filled, SML_AGLI empty, cells not marked seamless."""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.tmp = tempfile.mkdtemp(prefix="vtskit-angles-break-")
+        cls.angles = [os.path.join(cls.tmp, f"angle{k}.mpg") for k in range(2)]
+        for path, colour in zip(cls.angles, ("red", "green")):
+            encode(path, 4, colour)
+        cls.disc = os.path.join(cls.tmp, "disc")
+        cls.ts = titleset.write(cls.disc, 1, [Title(parts=(Angles(tuple(cls.angles), seamless=False),),
+                                                    chapters=(0, 2))])
+        vmg.write(cls.disc, [cls.ts])
+        cls.ifo = open(os.path.join(cls.disc, "VTS_01_0.IFO"), "rb").read()
+        cls.vob = b"".join(open(os.path.join(cls.disc, n), "rb").read()
+                           for n in sorted(cls.ts.files) if n.endswith(".VOB"))
+        cls.navs = nav_packs(cls.vob)
+
+    @classmethod
+    def tearDownClass(cls):
+        shutil.rmtree(cls.tmp, ignore_errors=True)
+
+    def test_cells(self):
+        cells, program_map = pgc_cells(self.ifo)
+        self.assertEqual(program_map, [1, 3])
+        self.assertEqual([c[0][0] for c in cells],
+                         [0x40 | 0x10 | 0x04 | 0x02, 0xC0 | 0x10 | 0x04 | 0x02,
+                          0x40 | 0x10 | 0x04, 0xC0 | 0x10 | 0x04])
+
+    def test_pointers(self):
+        for s, (pci, dsi) in self.navs.items():
+            self.assertTrue(u16(dsi, 0x20) & 0x4000, "ILVU flag")
+            self.assertEqual(dsi[0xB4:0xB4 + 54], bytes(54), "SML_AGLI empty")
+            for b in range(9):
+                dsta = u32(pci, 0x3C + 4 * b)
+                if b >= 2:
+                    self.assertEqual(dsta, 0)
+                    continue
+                target = s + (dsta & 0x7FFFFFFF) * (-1 if dsta & 0x80000000 else 1)
+                tpci, tdsi = self.navs[target]
+                self.assertEqual(u16(tdsi, 0x18), 1 + b)
+                self.assertEqual(tpci[0x18:0x1C], pci[0x18:0x1C], "the same cell elapsed time")
+                self.assertEqual(tdsi[0x1B], dsi[0x1B], "the same cell")
+
+    @unittest.skipUnless(LIBDVDNAV, "needs libdvdnav")
+    def test_switches(self):
+        stream, done = play(self.disc, switch=(3, 2))
+        self.assertEqual(done, [True])
+        path = os.path.join(self.tmp, "played.mpg")
+        with open(path, "wb") as f:
+            f.write(stream)
+        names = {"red": border(self.angles[0], 1)[0], "green": border(self.angles[1], 1)[0]}
+        seen = runs(border(path), names)
+        # angle 1, then angle 2 to the end (from the moment it was at: a
+        # VOBU may come again, as a break)
+        self.assertEqual([n for n, _ in seen], ["red", "green"], seen)
+        self.assertGreaterEqual(sum(n for _, n in seen), 120)
+
+
 if __name__ == "__main__":
     unittest.main()

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.0 → 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.0"
+__version__ = "0.2.0"
 __all__ = ["VtsError"]

{vtskit-0.1.0 → 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.0 → 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.0 → vtskit-0.2.0}/vtskit/ps.py

@@ -198,13 +198,14 @@ class Mapped:
 
 
 class Picture:
-    __slots__ = ("type", "start", "end", "pts", "fields", "order")
+    __slots__ = ("type", "start", "end", "pts", "fields", "order", "closed")
 
     def __init__(self, type_, start, pts, order):
         self.type, self.start, self.pts = type_, start, pts
         self.end = None          # sector of the picture's last byte
         self.fields = 2
         self.order = order       # temporal_reference: its place in its group's display order
+        self.closed = None       # the first picture of a group: its header's closed_gop (13818-2)
 
 
 class _Video:
@@ -221,6 +222,7 @@ class _Video:
         self.before = None           # the sector of the byte before the tail
         self.pending_pts = None      # the PTS of the packet the tail's first start code is in
         self.last_sector = None
+        self.gop_closed = None       # the closed_gop of the group header just read
 
     def feed(self, chunk, sector, pts):
         buf = self.tail + chunk
@@ -253,6 +255,7 @@ class _Video:
                                  buf[k + 7] >> 4, buf[k + 7] & 0x0F)
             elif code == _GOP:
                 self.groups.append([])
+                self.gop_closed = bool(buf[k + 7] & 0x40)    # (after the 25-bit time code)
             elif code == _PICTURE:
                 t = "?IPB"[(buf[k + 5] >> 3) & 7]
                 # a packet's PTS belongs to the first picture that starts in it
@@ -263,6 +266,7 @@ class _Video:
                 else:
                     own = None
                 picture = Picture(t, sector_of(k), own, buf[k + 4] << 2 | buf[k + 5] >> 6)
+                picture.closed, self.gop_closed = self.gop_closed, None
                 if not self.groups or t == "I" and self.groups[-1]:
                     self.groups.append([])           # (a group without its header)
                 self.groups[-1].append(picture)

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

@@ -41,12 +41,15 @@ or an Angles block of 2 to 9 streams the viewer switches between. An angle
 block is interleaved (dvdinfo dsi_pkt.html, pgc.html): each angle's VOBUs
 are cut into interleaved units (ILVUs) of the same number of VOBUs, and the
 units take turns on the disc, angle 1's first, then angle 2's, ... then
-angle 1's second; every VOBU's DSI says where its unit ends, where its
-angle's next unit is, and where every angle's next unit is (SML_AGLI);
-every PCI where every angle's VOBU of the same moment is (NSML_AGLI); the
-three VOBUs before a block carry the PREU flags; the block's cells are one
-an angle, marked first, middle and last of an angle block, interleaved,
-and seamless when asked. dvdauthor writes no angles, so none of this is
+angle 1's second; every VOBU's DSI says where its unit ends and where its
+angle's next unit is. A seamless block (the default) is switched at the
+end of a unit: every DSI says where every angle's next unit is (SML_AGLI)
+and every cell is marked "seamless angle linked in DSI"; a block switched
+with a break says instead, in every PCI, where every angle's VOBU of the
+same moment is (NSML_AGLI). Only one of the two is filled: libdvdnav takes
+NSML_AGLI whenever it is there. The three VOBUs before a block carry the
+PREU flags; the block's cells are one an angle, marked first, middle and
+last of an angle block, and interleaved. dvdauthor writes no angles, so none of this is
 checked against it: the structure is checked against the descriptions and
 libdvdnav plays and switches the angles (tests/test_angles.py); a set-top
 player is the check still owed.
@@ -114,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 = ()
@@ -129,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
@@ -150,6 +158,7 @@ class Cell:
     stc_discontinuity: bool = True   # the first cell of its VOB
     seamless: bool = False  # continues the previous cell without a break
     interleaved: bool = False
+    seamless_angle: bool = False    # an angle block switched at its interleaved units (SML_AGLI)
     last_of_program: bool = True
     segment: tuple = (0, 1)     # (part, stretch of it) the cell plays
 
@@ -161,7 +170,7 @@ class Cell:
             kind = 0x40 if self.angle == 1 else 0xC0 if self.angle == self.angles else 0x80
             kind |= 0x10
         return kind | (0x08 if self.seamless else 0) | (0x04 if self.interleaved else 0) \
-            | (0x02 if self.stc_discontinuity else 0) | (0x01 if self.seamless and self.angle else 0)
+            | (0x02 if self.stc_discontinuity else 0) | (0x01 if self.seamless_angle and self.angle else 0)
 
 
 @dataclass
@@ -509,21 +518,63 @@ def _aligned(loaded, where):
                        f"{len(fs.pictures)} and {len(os_.pictures)} pictures)")
 
 
+def _clean_starts(where, stream, vs, starts):
+    """An angle is switched to at the start of an interleaved unit: the
+    pictures there must not lean on the group before, which is another
+    angle's after the switch. B-pictures coded after the unit's first
+    I-picture but shown before it are predicted from the previous group
+    unless its header says closed_gop (ISO 13818-2); such a stream is
+    refused (ffmpeg's -flags +cgop, or no B-pictures, makes groups that
+    stand alone; oncemore's have no B-pictures)."""
+    pictures = stream.pictures
+    firsts = [p.start for p in pictures]
+    for i in starts:
+        k = bisect.bisect_left(firsts, vs[i].start)
+        if k >= len(pictures) or pictures[k].type != "I":
+            continue
+        head = pictures[k]
+        leading = []
+        for p in pictures[k + 1:]:
+            if p.type != "B":
+                break
+            if p.order < head.order:
+                leading.append(p)
+        if leading and not head.closed:
+            raise VtsError(f"{where}: the group of pictures that starts an interleaved unit "
+                           f"(VOBU {i + 1}) is open: {len(leading)} B-pictures shown before its "
+                           "I-picture lean on the group before, which is another angle's after a "
+                           "switch. Encode the angles with closed groups (ffmpeg -flags +cgop) "
+                           "or without B-pictures")
+
+
 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:
@@ -597,6 +648,9 @@ def _title(number, title, offset, vob_id):
                 if unit < 1:
                     raise VtsError("an interleaved unit holds at least one VOBU")
                 groups = [range(g, min(g + unit, i1)) for g in range(i0, i1, unit)]
+                for a in range(n_angles):
+                    _clean_starts(f"title {number}, part {k + 1}, angle {a + 1}", part[a][0],
+                                  part[a][1], [rng[0] for rng in groups[1:]])
                 # the three VOBUs before the block: PREU (the first of them
                 # Unit_Start, the last Unit_End), when they are not interleaved
                 before = [p for p in preceding[-3:] if not isinstance(parts[p[0]], Angles)]
@@ -631,9 +685,16 @@ def _title(number, title, offset, vob_id):
                                 nxt_sa, nxt_sz = 0xFFFFFFFF, 0xFFFF
                             else:
                                 nxt_sa, nxt_sz = unit_start[(a, g + 1)] - lay[i], unit_size[(a, g + 1)]
+                            # a seamless block says where every angle's next unit
+                            # is (SML_AGLI) and leaves NSML_AGLI empty; a block
+                            # switched with a break, the other way round. Players
+                            # take the pointers that are there: libdvdnav follows
+                            # NSML_AGLI whenever it is filled, replaying the moment
+                            # it was at, and SML_AGLI otherwise, going on at the
+                            # next unit (tests/test_angles.py)
                             agli = []
                             for b in range(9):
-                                if b >= n_angles:
+                                if b >= n_angles or not block.seamless:
                                     agli.append((0, 0))
                                 elif last_group:
                                     agli.append((0x7FFFFFFF, 0))
@@ -642,7 +703,7 @@ def _title(number, title, offset, vob_id):
                             ilvu_info[(k, a)][i] = (flags, unit_end - lay[i], nxt_sa, nxt_sz, agli)
                             nsml = []
                             for b in range(9):
-                                if b >= n_angles:
+                                if b >= n_angles or block.seamless:
                                     nsml.append(0)
                                 else:
                                     d = layouts[(k, b)][i] - lay[i]
@@ -655,17 +716,19 @@ def _title(number, title, offset, vob_id):
                                       lay[i1 - 1], lay[i1 - 1] + vs[i1 - 1].end - vs[i1 - 1].start,
                                       vs[i0].s_ptm, e, len(programs), a + 1, n_angles,
                                       stc_discontinuity=seg == 1, seamless=block.seamless and seg > 1,
-                                      interleaved=True, segment=(k, seg)))
+                                      interleaved=True, seamless_angle=block.seamless,
+                                      segment=(k, seg)))
         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)))
@@ -685,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.0 → vtskit-0.2.0/vtskit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vtskit
-Version: 0.1.0
+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
@@ -85,18 +85,22 @@ play the discs vtskit writes.
 ## Installing
 
 vtskit is one package of plain Python (3.11 or later), with nothing else
-to install. Until it is on PyPI:
+to install:
 
 ```
-pip install git+https://github.com/kajisho5/vtskit
+pip install vtskit
 ```
 
-A tag `v*` on this repository builds the package, attaches it to a GitHub
-release and publishes it to PyPI (`.github/workflows/release.yml`); the
-first PyPI release needs the project registered there with this
-repository as its trusted publisher. oncemore does not install vtskit: it
-carries a copy of `vtskit/` as `oncemore/_vendor/vtskit`, updated with its
-`tools/vendor_vtskit.py`.
+A release is made by the version: when the version in `pyproject.toml`
+(and `vtskit/__init__.py`) reaches `main` without a tag of its own,
+`.github/workflows/release.yml` runs the tests, builds the package, makes
+the GitHub release with its tag and publishes to PyPI. Merging the version
+bump is the whole act; a tag `v*` pushed by hand releases the same way.
+PyPI knows this repository and workflow as the project's trusted
+publisher. oncemore does not install vtskit: it
+carries a copy of each release as `oncemore/_vendor/vtskit`, taken from
+PyPI with its `tools/vendor.py vtskit --pypi <version>` (a pull request
+does it there each day a newer release is out).
 
 ## What is here now
 
@@ -129,9 +133,23 @@ oncemore writing its discs with vtskit.
   libdvdnav a title whose post commands run out plays on into its next
   program chain; dvdauthor writes none of these. A title may be
   several parts in a row, streams and `Angles` blocks of 2 to 9 streams: an
-  angle block is interleaved on the disc, its navigation packs point from
-  each unit to every angle's next, and its cells are marked as an angle
-  block.
+  angle block is interleaved on the disc and its cells are marked as an
+  angle block. A seamless block (the default) is switched at the end of an
+  interleaved unit: its navigation packs point from each unit to every
+  angle's next (SML_AGLI) and its cells say "seamless angle"; a block
+  switched with a break (`seamless=False`) points instead at every angle's
+  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. 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.
@@ -172,13 +190,18 @@ 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
 switches angles under libdvdnav, every pointer of its navigation packs
-landing on the unit it names (dvdauthor writes no angles, so a set-top
-player is the check still owed)
+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); 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.0 → 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