bdmvkit 0.3.0__tar.gz → 0.5.0__tar.gz

{bdmvkit-0.3.0/bdmvkit.egg-info → bdmvkit-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bdmvkit
-Version: 0.3.0
+Version: 0.5.0
 Summary: Blu-ray (BDMV) authoring in pure Python: playlists, clip information, HDMV navigation, PGS subtitles
 Author: kajisho5
 License-Expression: LGPL-3.0-or-later
@@ -35,14 +35,14 @@ only to encode.
 
 日本語の説明は [README.ja.md](README.ja.md) にあります。
 
-**Status: 0.3.** Titles with chapters, sound and subtitle tracks;
+**Status: 0.5.** Titles with chapters, sound and subtitle tracks;
 playlists (in order, at random or shuffled) and play all; menus whose
 buttons start titles, chapters, playlists and other menus, switch sound and
 subtitle tracks, or open a menu on a chosen button; loop counts, end-action
 overrides, link transitions, remote keys a title turns off, and 720p. This
 navigation is the one [oncemore](https://github.com/kajisho5/oncemore)
-writes, byte for byte. Encoding pop-up menus and menus with motion or music
-comes next.
+writes, byte for byte. 0.4 adds pop-up menus over a playing title, 0.5
+menus with motion or music.
 
 ## Why
 
@@ -132,6 +132,28 @@ disc.add_menu("main", "menu.png", [
 ], loop=3, end="playall", seconds=10)
 ```
 
+A menu's background may be a video, and a menu may have music. Such a menu
+plays again when it ends, from `loop_point` (seconds) the second time
+round; it lasts as long as its video, else its music, unless `seconds`
+says:
+
+```python
+disc.add_menu("main", "loop.mp4", buttons, music="theme.wav", loop_point=2.0)
+```
+
+A title can have a pop-up menu: buttons over its picture, opened with the
+remote's Pop-up Menu key. Their pictures are placed on the 1920 x 1080 frame
+as a menu's are; a button that only switches the sound or subtitle track
+closes the menu.
+
+```python
+disc.add_popup(a, [
+    MenuButton("scenes", 160, 900, "scenes.png", "scenes-on.png", "scenes-off.png",
+               action="menu:main"),
+    MenuButton("ja", 560, 900, "ja.png", normal="ja-off.png", action="audio:2"),
+])
+```
+
 Underneath, `bdmvkit.program` describes a disc made of encoded clips
 (titles, playlists, menu clips that carry their buttons, transitions) and
 `bdmvkit.nav.write_program` writes it; `nav.Navigation` gives the commands a
@@ -196,6 +218,10 @@ The tests encode real clips, write a disc, and read it back with
   the titles, chapters, playlists and menus they link to, that a shuffled
   playlist plays each item once, and that a menu with a loop count goes on
   by itself;
+* that a menu with a video and music plays again from its loop point, and
+  that one with a loop count goes on by itself after playing that often;
+* that a pop-up menu opens over a playing title with the Pop-up Menu key and
+  its buttons start another title or a chapter;
 * the commands every kind of action, title, playlist and menu turns into.
 
 The files' fixed bytes are checked as well.

{bdmvkit-0.3.0 → bdmvkit-0.5.0}/README.md

@@ -18,14 +18,14 @@ only to encode.
 
 日本語の説明は [README.ja.md](README.ja.md) にあります。
 
-**Status: 0.3.** Titles with chapters, sound and subtitle tracks;
+**Status: 0.5.** Titles with chapters, sound and subtitle tracks;
 playlists (in order, at random or shuffled) and play all; menus whose
 buttons start titles, chapters, playlists and other menus, switch sound and
 subtitle tracks, or open a menu on a chosen button; loop counts, end-action
 overrides, link transitions, remote keys a title turns off, and 720p. This
 navigation is the one [oncemore](https://github.com/kajisho5/oncemore)
-writes, byte for byte. Encoding pop-up menus and menus with motion or music
-comes next.
+writes, byte for byte. 0.4 adds pop-up menus over a playing title, 0.5
+menus with motion or music.
 
 ## Why
 
@@ -115,6 +115,28 @@ disc.add_menu("main", "menu.png", [
 ], loop=3, end="playall", seconds=10)
 ```
 
+A menu's background may be a video, and a menu may have music. Such a menu
+plays again when it ends, from `loop_point` (seconds) the second time
+round; it lasts as long as its video, else its music, unless `seconds`
+says:
+
+```python
+disc.add_menu("main", "loop.mp4", buttons, music="theme.wav", loop_point=2.0)
+```
+
+A title can have a pop-up menu: buttons over its picture, opened with the
+remote's Pop-up Menu key. Their pictures are placed on the 1920 x 1080 frame
+as a menu's are; a button that only switches the sound or subtitle track
+closes the menu.
+
+```python
+disc.add_popup(a, [
+    MenuButton("scenes", 160, 900, "scenes.png", "scenes-on.png", "scenes-off.png",
+               action="menu:main"),
+    MenuButton("ja", 560, 900, "ja.png", normal="ja-off.png", action="audio:2"),
+])
+```
+
 Underneath, `bdmvkit.program` describes a disc made of encoded clips
 (titles, playlists, menu clips that carry their buttons, transitions) and
 `bdmvkit.nav.write_program` writes it; `nav.Navigation` gives the commands a
@@ -179,6 +201,10 @@ The tests encode real clips, write a disc, and read it back with
   the titles, chapters, playlists and menus they link to, that a shuffled
   playlist plays each item once, and that a menu with a loop count goes on
   by itself;
+* that a menu with a video and music plays again from its loop point, and
+  that one with a loop count goes on by itself after playing that often;
+* that a pop-up menu opens over a playing title with the Pop-up Menu key and
+  its buttons start another title or a chapter;
 * the commands every kind of action, title, playlist and menu turns into.
 
 The files' fixed bytes are checked as well.

{bdmvkit-0.3.0 → bdmvkit-0.5.0}/bdmvkit/__init__.py

@@ -1,7 +1,8 @@
 """bdmvkit: Blu-ray (BDMV) authoring in pure Python.
 
 * `bdmvkit.Disc`: a BDMV folder from encoded clips (titles, chapters, sound
-  and subtitle tracks), playlists and menus (`MenuButton`).
+  and subtitle tracks), playlists, menus (still, or with motion or music)
+  and pop-up menus (`MenuButton`).
 * `bdmvkit.program` and `bdmvkit.nav`: the model underneath (titles,
   playlists, menu clips, transitions, actions) and its writer,
   `nav.write_program`, with the navigation commands (`nav.Navigation`).
@@ -15,5 +16,5 @@
 from .disc import Disc, MenuButton
 from .errors import BdmvError
 
-__version__ = "0.3.0"
+__version__ = "0.5.0"
 __all__ = ["Disc", "MenuButton", "BdmvError"]

{bdmvkit-0.3.0 → bdmvkit-0.5.0}/bdmvkit/__main__.py

@@ -10,8 +10,10 @@ DISC.json: {"titles": [{"clip": "a.m2ts", "fps": "24000/1001",
 "action": "title:1"}]}], "play_all": true}; paths are relative to the JSON
 file. A button may also have "activated" and "normal" pictures, "nav"
 ({"up": id, ...}), "auto", "audio", "subtitle" and "override"; a menu
-"default" (a button id), "fps", "loop", "end", "seconds" and "prohibit"; a
-title "default_audio", "default_subtitle" and "prohibit". The disc may have
+"default" (a button id), "fps", "loop", "end", "seconds", "prohibit",
+"music" (a sound file) and "loop_point" (its "background" may be a video); a
+title "default_audio", "default_subtitle", "prohibit" and "popup" ({"buttons":
+[...], "default"}: its pop-up menu, buttons as a menu's). The disc may have
 "playlists" ([{"id", "items": [n or [n, first, last]], "order", "end"}]),
 "first_play" and "title_key".
 """
@@ -75,15 +77,21 @@ def main(argv=None):
         def file(name):
             return os.path.join(base, name) if name else None
 
+        def buttons(spec_buttons):
+            return [MenuButton(b["id"], int(b["x"]), int(b["y"]), file(b["selected"]),
+                               file(b.get("activated")), file(b.get("normal")), b.get("action"),
+                               dict(b.get("nav", {})), bool(b.get("auto")), b.get("audio"),
+                               b.get("subtitle"), b.get("override")) for b in spec_buttons]
+
+        for n, t in enumerate(spec.get("titles", []), 1):
+            if t.get("popup"):
+                disc.add_popup(n, buttons(t["popup"]["buttons"]), t["popup"].get("default"))
         for m in spec.get("menus", []):
-            disc.add_menu(m["id"], file(m["background"]), [
-                MenuButton(b["id"], int(b["x"]), int(b["y"]), file(b["selected"]),
-                           file(b.get("activated")), file(b.get("normal")), b.get("action"),
-                           dict(b.get("nav", {})), bool(b.get("auto")), b.get("audio"),
-                           b.get("subtitle"), b.get("override"))
-                for b in m["buttons"]], fps=_fps(m.get("fps", "24000/1001")),
-                default=m.get("default"), loop=m.get("loop"), end=m.get("end"),
-                prohibit=m.get("prohibit", []), seconds=float(m.get("seconds", 1.0)))
+            disc.add_menu(m["id"], file(m["background"]), buttons(m["buttons"]),
+                          fps=_fps(m.get("fps", "24000/1001")), default=m.get("default"),
+                          loop=m.get("loop"), end=m.get("end"), prohibit=m.get("prohibit", []),
+                          seconds=m.get("seconds"), music=file(m.get("music")),
+                          loop_point=m.get("loop_point"))
         res = disc.write(args.out, play_all=spec.get("play_all", True), fast=args.fast)
     except (BdmvError, OSError, KeyError, ValueError) as e:
         print(f"bdmvkit: {getattr(e, 'message', e)}", file=sys.stderr)

{bdmvkit-0.3.0 → bdmvkit-0.5.0}/bdmvkit/disc.py

@@ -34,10 +34,11 @@ import dataclasses
 import os
 import tempfile
 
-from . import encode, igs, program
+from . import encode, hdmv, igs, program
 from .errors import BdmvError
 from .formats import AUDIO_PID, CODECS, FORMATS, HEIGHT, PG_PID, WIDTH, lang3
 from .m2ts import stream_pids
+from .program import parse_action
 from .nav import DIRS, Navigation, _write, chapter_marks, write_program  # noqa: F401
 
 
@@ -73,14 +74,16 @@ class MenuButton:
 @dataclasses.dataclass
 class Menu:
     id: str
-    background: str              # picture file, fitted into the HD frame
+    background: str              # picture (or video) file, fitted into the HD frame
     buttons: list
     fps: tuple = (24000, 1001)
     default: str = None          # the button selected first (default: the first)
     loop: int = None             # held this many times its length, then `end`
     end: str = None
     prohibit: list = dataclasses.field(default_factory=list)
-    seconds: float = 1.0         # its clip's length
+    seconds: float = None        # its clip's length (default: 1, or the video's or music's)
+    music: str = None            # sound file played with it
+    loop_point: float = None     # where it plays again from (seconds), with motion or music
 
 
 def _check_streams(n, title):
@@ -103,6 +106,7 @@ class Disc:
         self.titles = []
         self.menus = []
         self.playlists = []
+        self.popups = {}                 # title number -> (buttons, default)
         self.first_play = first_play
         self.title_key = title_key
 
@@ -148,23 +152,42 @@ class Disc:
         self.playlists.append(program.Playlist(playlist_id, out, order, end))
 
     def add_menu(self, menu_id, background, buttons, fps=(24000, 1001), default=None, loop=None,
-                 end=None, prohibit=(), seconds=1.0):
-        """Add a menu: `background` a picture, `buttons` MenuButtons. The
-        menu's clip (`seconds` long) is made when the disc is written
-        (ffmpeg). It holds its last picture; with `loop`, only for `loop`
-        times its length, then it does `end`."""
+                 end=None, prohibit=(), seconds=None, music=None, loop_point=None):
+        """Add a menu: `background` a picture or a video, `buttons`
+        MenuButtons, `music` a sound file. The menu's clip (`seconds` long:
+        by default 1, or as long as the video, else the music) is made when
+        the disc is written (ffmpeg). A still menu holds its last picture;
+        one with a video or music plays again, from `loop_point` (seconds)
+        the second time round. With `loop`, it does so `loop` times (a
+        still one holds its picture for its length each time), then `end`."""
         if tuple(fps) not in FORMATS:
             raise BdmvError(f"{fps[0]}/{fps[1]} fps has no Blu-ray format")
         if any(m.id == menu_id for m in self.menus):
             raise BdmvError(f"there is a menu {menu_id!r} already")
         if not buttons:
             raise BdmvError(f"menu {menu_id!r} needs at least one button")
+        if loop_point is not None and loop_point < 0:
+            raise BdmvError(f"menu {menu_id!r}: loop point {loop_point} before the start")
         self.menus.append(Menu(menu_id, background, list(buttons), tuple(fps), default, loop,
-                               end, list(prohibit), seconds))
+                               end, list(prohibit), seconds, music, loop_point))
 
-    def program(self, play_all=True):
+    def add_popup(self, title, buttons, default=None):
+        """Give title `title` (its number) a pop-up menu: `buttons`
+        (MenuButtons, their pictures placed on the 1920 x 1080 picture over
+        the playing title) shown by the remote's Pop-up Menu key. A button
+        that switches the sound or subtitle track closes the menu; one that
+        goes elsewhere goes there. The menu's IG stream is muxed into the
+        title's clip when the disc is written."""
+        if not 1 <= title <= len(self.titles):
+            raise BdmvError(f"there is no title {title}")
+        if not buttons:
+            raise BdmvError(f"title {title}: a pop-up menu needs at least one button")
+        self.popups[title] = (list(buttons), default)
+
+    def program(self, play_all=True, probe=False):
         """The disc as a program.Program (titles "1", "2" ...; menus with no
-        clip yet: write makes them)."""
+        clip yet: write makes them). With `probe`, menu backgrounds are read
+        to tell videos from pictures (else they count as pictures)."""
         n_titles = len(self.titles)
         titles = []
         for n, t in enumerate(self.titles, 1):
@@ -174,14 +197,18 @@ class Disc:
                 [program.Audio(CODECS[c], ch, _lang(lang), k == t.default_audio)
                  for k, (c, ch, lang) in enumerate(t.audio, 1)],
                 [program.Subtitle(_lang(lang), k == t.default_subtitle)
-                 for k, lang in enumerate(t.subtitles, 1)], end, list(t.prohibit)))
-        menus = [program.Menu(m.id, None,
-                              [program.Button(b.id, b.action, b.audio, b.subtitle,
-                                              override=b.override) for b in m.buttons],
-                              fps=m.fps, default=m.default, loop=m.loop, end=m.end,
-                              still_time=max(1, round(m.seconds)) if m.loop is not None
-                              else None,
-                              prohibit=list(m.prohibit)) for m in self.menus]
+                 for k, lang in enumerate(t.subtitles, 1)], end, list(t.prohibit),
+                popup=n in self.popups,
+                popup_buttons=[_button(b) for b in self.popups.get(n, ((), None))[0]]))
+        menus = []
+        for m in self.menus:
+            still = not (m.music or (probe and _motion(m)))
+            menus.append(program.Menu(
+                m.id, None, [_button(b) for b in m.buttons], fps=m.fps, default=m.default,
+                still=still,
+                still_time=max(1, round(_seconds(m))) if still and m.loop is not None else None,
+                loop_point=m.loop_point if not still else None, loop=m.loop, end=m.end,
+                music=bool(m.music), prohibit=list(m.prohibit)))
         first_menu = f"menu:{self.menus[0].id}" if self.menus else None
         return program.Program(titles, list(self.playlists), menus,
                                first_play=self.first_play or first_menu,
@@ -194,8 +221,8 @@ class Disc:
         "chapters"}."""
         if not self.titles:
             raise BdmvError("a disc needs at least one title")
-        prog = self.program(play_all)
-        prog.check()                     # (the menus' clips are made below)
+        self.program(play_all).check()   # (before any file is read)
+        prog = self.program(play_all, probe=True)
         for n, t in enumerate(self.titles, 1):
             _check_streams(n, t)
         nav = Navigation(prog)
@@ -203,6 +230,10 @@ class Disc:
         for k, (m, pm) in enumerate(zip(self.menus, prog.menus), len(self.titles) + 1):
             pm.clip = os.path.join(out_dir, "BDMV", "STREAM", f"{k:05d}.m2ts")
             self._encode_menu(m, pm, nav, fast)
+        for n, (buttons, default) in sorted(self.popups.items()):
+            pt = prog.titles[n - 1]
+            pt.clip = os.path.join(out_dir, "BDMV", "STREAM", f"{n:05d}.m2ts")
+            self._add_popup(self.titles[n - 1], buttons, default, pt, nav)
         out = write_program(prog, out_dir, move=move)
         return {"titles": len(self.titles), "menus": len(self.menus),
                 "playlists": out["playlists"], "chapters": out["chapters"]}
@@ -210,23 +241,67 @@ class Disc:
     def _encode_menu(self, m, pm, nav, fast):
         """Menu `m`'s clip (pm.clip): its buttons' pictures read, the IG
         stream made with their commands and encoded with its picture."""
-        buttons = []
-        for b, pb in zip(m.buttons, pm.buttons):
-            w, h, sel = encode.picture(b.selected)
-            if b.x < 0 or b.y < 0 or b.x + w > WIDTH or b.y + h > HEIGHT:
-                raise BdmvError(f"menu {m.id!r}: button {b.id!r} ({w} x {h} at {b.x}, {b.y}) "
-                                f"is not inside the {WIDTH} x {HEIGHT} frame")
-            act = encode.picture(b.activated, (w, h))[2] if b.activated else None
-            nor = encode.picture(b.normal, (w, h))[2] if b.normal else None
-            buttons.append(igs.Button(b.id, b.x, b.y, w, h, sel, act, nor,
-                                      nav.button(pb) if b.action else [], dict(b.nav), b.auto))
+        buttons = _ig_buttons(f"menu {m.id!r}", m.buttons, pm.buttons, nav)
         _, frame_rate = FORMATS[m.fps]
         with tempfile.TemporaryDirectory(prefix="bdmvkit-") as work:
             sup = os.path.join(work, "menu.sup")
             with open(sup, "wb") as f:
                 f.write(igs.ig_stream(buttons, frame_rate, default=m.default,
                                       follow_selection=nav.follows_selection(m.id)))
-            encode.encode_menu(m.background, sup, pm.clip, m.fps, seconds=m.seconds, fast=fast)
+            encode.encode_menu(m.background, sup, pm.clip, m.fps, seconds=_seconds(m), fast=fast,
+                               motion=_motion(m), music=m.music,
+                               keys=[m.loop_point] if m.loop_point else [])
+
+
+    def _add_popup(self, t, buttons, default, pt, nav):
+        """The title's clip with its pop-up menu's IG stream, as pt.clip."""
+        _, frame_rate = FORMATS[t.fps]
+        ig = _ig_buttons(f"title {pt.id}'s pop-up menu", buttons, pt.popup_buttons, nav,
+                         popup=True)
+        with tempfile.TemporaryDirectory(prefix="bdmvkit-") as work:
+            sup = os.path.join(work, "popup.sup")
+            with open(sup, "wb") as f:
+                f.write(igs.ig_stream(ig, frame_rate, default=default, popup=True))
+            encode.add_ig_stream(t.clip, sup, pt.clip)
+
+
+def _motion(m):
+    """Whether menu m's background is a video (asked once)."""
+    if not hasattr(m, "_motion"):
+        m._motion = encode.is_video(m.background)
+    return m._motion
+
+
+def _seconds(m):
+    if m.seconds is not None:
+        return m.seconds
+    if _motion(m):
+        return encode.media_seconds(m.background)
+    return encode.media_seconds(m.music) if m.music else 1.0
+
+
+def _button(b):
+    return program.Button(b.id, b.action, b.audio, b.subtitle, override=b.override)
+
+
+def _ig_buttons(where, buttons, program_buttons, nav, popup=False):
+    """MenuButtons as igs.Buttons: their pictures read, their commands the
+    navigation's (in a pop-up menu, a button that only switches streams
+    closes the menu too)."""
+    out = []
+    for b, pb in zip(buttons, program_buttons):
+        w, h, sel = encode.picture(b.selected)
+        if b.x < 0 or b.y < 0 or b.x + w > WIDTH or b.y + h > HEIGHT:
+            raise BdmvError(f"{where}: button {b.id!r} ({w} x {h} at {b.x}, {b.y}) "
+                            f"is not inside the {WIDTH} x {HEIGHT} frame")
+        act = encode.picture(b.activated, (w, h))[2] if b.activated else None
+        nor = encode.picture(b.normal, (w, h))[2] if b.normal else None
+        commands = nav.button(pb) if b.action else []
+        if popup and b.action and parse_action(b.action)[0] in ("audio", "subtitle"):
+            commands.append(hdmv.popup_off())
+        out.append(igs.Button(b.id, b.x, b.y, w, h, sel, act, nor, commands, dict(b.nav),
+                              b.auto))
+    return out
 
 
 def _lang(code):

{bdmvkit-0.3.0 → bdmvkit-0.5.0}/bdmvkit/encode.py

@@ -9,6 +9,7 @@ interlaced (1080i) stream, as the format has no 1080p at those rates.
 """
 
 import dataclasses
+import os
 import shutil
 import subprocess
 
@@ -184,22 +185,37 @@ def picture(path, size=None, ffmpeg=None):
     return w, h, p.stdout
 
 
-def encode_menu(background, sup, out, fps=(24000, 1001), seconds=1.0, fast=False, ffmpeg=None):
-    """A menu clip: the picture `background` (fitted into the HD frame) for
-    `seconds`, with the IG stream `sup` (igs.ig_stream) as its buttons; the
-    playlist holds its last picture."""
+def encode_menu(background, sup, out, fps=(24000, 1001), seconds=1.0, fast=False, ffmpeg=None,
+                motion=False, music=None, keys=()):
+    """A menu clip `seconds` long: the picture `background` (fitted into the
+    HD frame; with `motion`, a video played from its start), with the IG
+    stream `sup` (igs.ig_stream) as its buttons and, with `music`, that
+    sound file as its sound track (AC-3, padded with silence to the
+    length). A still menu's playlist holds its last picture; one with
+    motion or music plays again. `keys`: times (s) that become key frames
+    (the loop point, so its mark lands on it)."""
     ffmpeg = ffmpeg or shutil.which("ffmpeg")
     if not ffmpeg:
         raise BdmvError("encoding needs ffmpeg (with libx264)")
     from .igs import patch_ig_stream_type
     num, den = fps
-    cmd = [ffmpeg, "-hide_banner", "-nostdin", "-v", "error", "-y",
-           "-loop", "1", "-framerate", f"{num}/{den}", "-t", f"{seconds:.3f}", "-i", background,
-           "-f", "sup", "-i", sup,
-           "-filter_complex", f"[0:v]{fit_filter(fps)},format=yuv420p[v]",
-           "-map", "[v]", "-map", "1:0"] + video_args(fps, MAX_VIDEO_BPS, fast) + \
-        ["-c:s", "copy", "-streamid", f"0:{VIDEO_PID}", "-streamid", f"1:{IG_PID}",
-         "-t", f"{seconds:.3f}", "-f", "mpegts", "-mpegts_m2ts_mode", "1",
+    picture = ["-i", background] if motion else \
+        ["-loop", "1", "-framerate", f"{num}/{den}", "-t", f"{seconds:.3f}", "-i", background]
+    cmd = [ffmpeg, "-hide_banner", "-nostdin", "-v", "error", "-y"] + picture + \
+        ["-f", "sup", "-i", sup] + (["-i", music] if music else [])
+    graph = f"[0:v]{fit_filter(fps)},format=yuv420p[v]"
+    maps = ["-map", "[v]", "-map", "1:0"]
+    ids = ["-streamid", f"0:{VIDEO_PID}", "-streamid", f"1:{IG_PID}"]
+    sound = []
+    if music:
+        graph += ";[2:a:0]apad[a]"
+        maps += ["-map", "[a]"]
+        ids += ["-streamid", f"2:{AUDIO_PID}"]
+        sound = audio_args("ac3", 2)
+    keys = [t for t in keys if t and t > 0]
+    cmd += ["-filter_complex", graph] + maps + video_args(fps, MAX_VIDEO_BPS, fast, keys) + \
+        sound + ["-c:s", "copy"] + ids + \
+        ["-t", f"{seconds:.3f}", "-f", "mpegts", "-mpegts_m2ts_mode", "1",
          "-mpegts_pmt_start_pid", str(PMT_PID), out]
     p = subprocess.run(cmd, capture_output=True, text=True)
     if p.returncode != 0:
@@ -207,3 +223,73 @@ def encode_menu(background, sup, out, fps=(24000, 1001), seconds=1.0, fast=False
                         f"{p.stderr.strip()[-800:]}")
     patch_ig_stream_type(out)
     return out
+
+
+def is_video(path, ffmpeg=None):
+    """Whether `path` is a video (moving pictures) rather than a picture."""
+    ffmpeg = ffmpeg or shutil.which("ffmpeg") or "ffmpeg"
+    probe = shutil.which("ffprobe") or ffmpeg.replace("ffmpeg", "ffprobe")
+    p = subprocess.run([probe, "-v", "error", "-show_entries", "format=format_name", "-of",
+                        "csv=p=0", path], capture_output=True, text=True)
+    name = p.stdout.strip()
+    if not name:
+        raise BdmvError(f"cannot read {path}")
+    return not (name == "image2" or name.endswith("_pipe"))
+
+
+def media_seconds(path, ffmpeg=None):
+    """How long a video or sound file lasts (seconds)."""
+    ffmpeg = ffmpeg or shutil.which("ffmpeg") or "ffmpeg"
+    probe = shutil.which("ffprobe") or ffmpeg.replace("ffmpeg", "ffprobe")
+    p = subprocess.run([probe, "-v", "error", "-show_entries", "format=duration", "-of",
+                        "csv=p=0", path], capture_output=True, text=True)
+    try:
+        return float(p.stdout.strip())
+    except ValueError:
+        raise BdmvError(f"cannot tell how long {path} is")
+
+
+def add_ig_stream(clip, sup, out, ffmpeg=None):
+    """`clip` with the IG stream `sup` (igs.ig_stream, a pop-up menu) muxed
+    in, as `out`: the clip's streams copied with their PIDs and their times,
+    the buttons with IG_PID at the clip's first picture, marked Interactive
+    Graphics in the PMT. (Segments before the first picture are before the
+    play item's start, and players leave them out: so the buttons are timed
+    at it, not at the clip's own start, which the sound may begin.)"""
+    ffmpeg = ffmpeg or shutil.which("ffmpeg")
+    if not ffmpeg:
+        raise BdmvError("muxing needs ffmpeg")
+    from .igs import patch_ig_stream_type
+    probe = shutil.which("ffprobe") or ffmpeg.replace("ffmpeg", "ffprobe")
+    p = subprocess.run([probe, "-v", "error", "-show_entries", "stream=index,id", "-of",
+                        "csv=p=0", clip], capture_output=True, text=True)
+    # (ffprobe lists a stream again under its program: one each, by index)
+    streams = dict(line.split(",")[:2] for line in p.stdout.split() if "," in line)
+    pids = [int(streams[k], 16) for k in sorted(streams, key=int)]
+    if not pids:
+        raise BdmvError(f"cannot read the streams of {clip}")
+    from .m2ts import scan_m2ts
+    start = scan_m2ts(clip).first_pts
+    with open(sup, "rb") as f:
+        data = bytearray(f.read())
+    i = 0
+    while i + 13 <= len(data):                   # each segment's PTS and DTS: the start
+        data[i + 2:i + 10] = (start & 0xFFFFFFFF).to_bytes(4, "big") * 2
+        i += 13 + int.from_bytes(data[i + 11:i + 13], "big")
+    timed = out + ".sup"
+    with open(timed, "wb") as f:
+        f.write(data)
+    cmd = [ffmpeg, "-hide_banner", "-nostdin", "-v", "error", "-y", "-copyts", "-i", clip,
+           "-f", "sup", "-i", timed, "-map", "0", "-map", "1:0", "-c", "copy"]
+    for k, pid in enumerate(pids + [IG_PID]):
+        cmd += ["-streamid", f"{k}:{pid}"]
+    cmd += ["-f", "mpegts", "-mpegts_m2ts_mode", "1", "-mpegts_pmt_start_pid", str(PMT_PID),
+            out]
+    p = subprocess.run(cmd, capture_output=True, text=True)
+    os.remove(timed)
+    if p.returncode != 0:
+        raise BdmvError(f"ffmpeg could not add the pop-up menu to {clip}: "
+                        f"{p.stderr.strip()[-800:]}")
+    patch_ig_stream_type(out)
+    return out
+

{bdmvkit-0.3.0 → bdmvkit-0.5.0}/bdmvkit/nav.py

@@ -121,7 +121,7 @@ class Navigation:
         # own default subtitles over the chosen ones (_start)
         self.stream_links = any(
             (b.audio or b.subtitle is not None) and b.action and parse_action(b.action)[0] in PLAYS
-            for m in p.menus for b in m.buttons)
+            for b in p.buttons())
 
     def menu_number(self, menu_id):
         return self.numbers.get(f"menu:{menu_id}")

{bdmvkit-0.3.0 → bdmvkit-0.5.0}/bdmvkit/program.py

@@ -74,6 +74,10 @@ class Title:
     end: str = None              # action after it (None: stop)
     prohibit: list = dataclasses.field(default_factory=list)           # uops.KEYS names
     popup: bool = False          # its clip carries a pop-up menu (an IG stream)
+    popup_buttons: list = dataclasses.field(default_factory=list)
+    # (Buttons of a pop-up menu the Program writes into the clip, as
+    # Disc.add_popup does; empty when the clip's IG stream is made elsewhere
+    # from a menu's buttons)
     hold: bool = False           # each chapter a picture held until Next (a slideshow)
 
 
@@ -147,8 +151,15 @@ class Program:
             if m.loop is not None:
                 out.append(m.end)
         out += [t.end for t in self.titles] + [p.end for p in self.playlists]
+        for t in self.titles:
+            out += [b.action for b in t.popup_buttons] + [b.override for b in t.popup_buttons]
         return [a for a in out if a]
 
+    def buttons(self):
+        """Every button: the menus', then the pop-up menus' of the titles."""
+        return [b for m in self.menus for b in m.buttons] + \
+            [b for t in self.titles for b in t.popup_buttons]
+
     @property
     def uses_playall(self):
         return "playall" in self.actions()
@@ -157,7 +168,7 @@ class Program:
     def overrides(self):
         """End-action overrides buttons use, in a fixed order (1-based numbers
         in the override register)."""
-        return sorted({b.override for m in self.menus for b in m.buttons if b.override})
+        return sorted({b.override for b in self.buttons() if b.override})
 
     @property
     def link_transitions(self):
@@ -221,6 +232,11 @@ class Program:
                 if b.transition and b.transition not in self.transitions:
                     raise BdmvError(f"menu {m.id!r}, button {b.id!r}: no transition "
                                     f"{b.transition!r}")
+        for t in self.titles:
+            for b in t.popup_buttons:
+                if b.transition:
+                    raise BdmvError(f"title {t.id!r}: a pop-up menu's button ({b.id!r}) "
+                                    "cannot play a transition")
 
 
 def transition_key(button):

{bdmvkit-0.3.0 → bdmvkit-0.5.0/bdmvkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bdmvkit
-Version: 0.3.0
+Version: 0.5.0
 Summary: Blu-ray (BDMV) authoring in pure Python: playlists, clip information, HDMV navigation, PGS subtitles
 Author: kajisho5
 License-Expression: LGPL-3.0-or-later
@@ -35,14 +35,14 @@ only to encode.
 
 日本語の説明は [README.ja.md](README.ja.md) にあります。
 
-**Status: 0.3.** Titles with chapters, sound and subtitle tracks;
+**Status: 0.5.** Titles with chapters, sound and subtitle tracks;
 playlists (in order, at random or shuffled) and play all; menus whose
 buttons start titles, chapters, playlists and other menus, switch sound and
 subtitle tracks, or open a menu on a chosen button; loop counts, end-action
 overrides, link transitions, remote keys a title turns off, and 720p. This
 navigation is the one [oncemore](https://github.com/kajisho5/oncemore)
-writes, byte for byte. Encoding pop-up menus and menus with motion or music
-comes next.
+writes, byte for byte. 0.4 adds pop-up menus over a playing title, 0.5
+menus with motion or music.
 
 ## Why
 
@@ -132,6 +132,28 @@ disc.add_menu("main", "menu.png", [
 ], loop=3, end="playall", seconds=10)
 ```
 
+A menu's background may be a video, and a menu may have music. Such a menu
+plays again when it ends, from `loop_point` (seconds) the second time
+round; it lasts as long as its video, else its music, unless `seconds`
+says:
+
+```python
+disc.add_menu("main", "loop.mp4", buttons, music="theme.wav", loop_point=2.0)
+```
+
+A title can have a pop-up menu: buttons over its picture, opened with the
+remote's Pop-up Menu key. Their pictures are placed on the 1920 x 1080 frame
+as a menu's are; a button that only switches the sound or subtitle track
+closes the menu.
+
+```python
+disc.add_popup(a, [
+    MenuButton("scenes", 160, 900, "scenes.png", "scenes-on.png", "scenes-off.png",
+               action="menu:main"),
+    MenuButton("ja", 560, 900, "ja.png", normal="ja-off.png", action="audio:2"),
+])
+```
+
 Underneath, `bdmvkit.program` describes a disc made of encoded clips
 (titles, playlists, menu clips that carry their buttons, transitions) and
 `bdmvkit.nav.write_program` writes it; `nav.Navigation` gives the commands a
@@ -196,6 +218,10 @@ The tests encode real clips, write a disc, and read it back with
   the titles, chapters, playlists and menus they link to, that a shuffled
   playlist plays each item once, and that a menu with a loop count goes on
   by itself;
+* that a menu with a video and music plays again from its loop point, and
+  that one with a loop count goes on by itself after playing that often;
+* that a pop-up menu opens over a playing title with the Pop-up Menu key and
+  its buttons start another title or a chapter;
 * the commands every kind of action, title, playlist and menu turns into.
 
 The files' fixed bytes are checked as well.

{bdmvkit-0.3.0 → bdmvkit-0.5.0}/bdmvkit.egg-info/SOURCES.txt

@@ -25,5 +25,7 @@ bdmvkit.egg-info/top_level.txt
 tests/test_disc.py
 tests/test_files.py
 tests/test_menus.py
+tests/test_motion.py
 tests/test_nav.py
-tests/test_pgs.py
+tests/test_pgs.py
+tests/test_popup.py

{bdmvkit-0.3.0 → bdmvkit-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "bdmvkit"
-version = "0.3.0"
+version = "0.5.0"
 description = "Blu-ray (BDMV) authoring in pure Python: playlists, clip information, HDMV navigation, PGS subtitles"
 readme = "README.md"
 license = "LGPL-3.0-or-later"

bdmvkit-0.5.0/tests/test_motion.py

@@ -0,0 +1,104 @@
+"""Menus with motion or music: a video as the background, a sound file as
+the menu's sound, played again from a loop point; and a menu with music and
+a loop count that goes on by itself. Played by libbluray."""
+
+import os
+import shutil
+import subprocess
+import tempfile
+import unittest
+
+from bdmvkit import Disc, MenuButton
+from bdmvkit.encode import encode_clip, is_video, media_seconds
+from bdmvkit.formats import AUDIO_PID, CODING_AC3, IG_PID
+from bdmvkit.m2ts import stream_pids
+
+from .test_disc import ENCODE_OK, source
+from .test_menus import png
+
+try:
+    from . import bluray_sim
+    LIBBLURAY = bluray_sim.load_library()
+except Exception:  # pragma: no cover
+    LIBBLURAY = None
+
+
+def tone(path, seconds):
+    subprocess.run(["ffmpeg", "-hide_banner", "-v", "error", "-y", "-f", "lavfi", "-i",
+                    f"sine=frequency=330:d={seconds}:r=48000", path], check=True)
+    return path
+
+
+@unittest.skipUnless(ENCODE_OK and LIBBLURAY, "needs ffmpeg with libx264, and libbluray")
+class TestMotionMenus(unittest.TestCase):
+    """Menu "moving": a 2 s video with 3 s of music, from 0.5 s the second time
+    (the video decides its length). Menu "music": a picture with 1.5 s of
+    music, played twice, then title 1."""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.tmp = d = tempfile.mkdtemp(prefix="bdmvkit-motion-")
+        a = encode_clip(source(os.path.join(d, "a.mp4"), 2), os.path.join(d, "a.m2ts"),
+                        fast=True)
+        cls.video = source(os.path.join(d, "bg.mp4"), 2, tone=False)
+        cls.bg = png(os.path.join(d, "bg.png"), 1920, 1080, "navy")
+        lit = png(os.path.join(d, "lit.png"), 300, 60, "orange")
+        disc = Disc(first_play="menu:moving")
+        disc.add_title(a, end="menu:music")
+        disc.add_menu("moving", cls.video, [MenuButton("play", 160, 900, lit, action="title:1")],
+                      music=tone(os.path.join(d, "m.wav"), 3), loop_point=0.5)
+        disc.add_menu("music", cls.bg, [MenuButton("play", 160, 900, lit, action="title:1")],
+                      music=tone(os.path.join(d, "m2.wav"), 1.5), loop=2, end="title:1")
+        cls.out = os.path.join(d, "disc")
+        disc.write(cls.out, play_all=False, fast=True)
+
+    @classmethod
+    def tearDownClass(cls):
+        shutil.rmtree(cls.tmp, ignore_errors=True)
+
+    def clip(self, n):
+        return os.path.join(self.out, "BDMV", "STREAM", f"{n:05d}.m2ts")
+
+    def test_pictures_and_videos_told_apart(self):
+        self.assertTrue(is_video(self.video))
+        self.assertFalse(is_video(self.bg))
+
+    def test_clips_carry_the_music_and_the_buttons(self):
+        for n in (2, 3):
+            pids = stream_pids(self.clip(n))
+            self.assertEqual(pids.get(AUDIO_PID), CODING_AC3)
+            self.assertIn(IG_PID, pids)
+        # the video decides the moving menu's length; the music the other's
+        self.assertAlmostEqual(media_seconds(self.clip(2)), 2, delta=0.2)
+        self.assertAlmostEqual(media_seconds(self.clip(3)), 1.5, delta=0.2)
+
+    def test_read_back(self):
+        with bluray_sim.Disc(LIBBLURAY, self.out) as disc:
+            moving, music = disc.playlist(2), disc.playlist(3)
+        self.assertEqual(moving["audio"], [(CODING_AC3, 3, "und")])
+        # two marks: the start, and the loop point
+        self.assertEqual(len(moving["chapters"]), 2)
+        self.assertAlmostEqual(moving["chapters"][1], 0.5, delta=0.1)
+        self.assertEqual(len(music["chapters"]), 1)
+
+    def test_played_again_from_the_loop_point(self):
+        with bluray_sim.Disc(LIBBLURAY, self.out) as disc:
+            ev = disc.play(max_bytes=40 * 2**20)
+        seen = [e for e in ev if e[0] in ("playlist", "at_chapter")]
+        # the moving menu, then again and again from its loop point (mark 2)
+        self.assertEqual(seen[:4], [("playlist", 2), ("at_chapter", 1),
+                                    ("playlist", 2), ("at_chapter", 2)])
+
+    def test_a_loop_count_goes_on_by_itself(self):
+        disc = Disc(first_play="menu:music")
+        disc.add_title(self.clip(1), end="stop")
+        lit = os.path.join(self.tmp, "lit.png")
+        disc.add_menu("music", self.bg, [MenuButton("play", 160, 900, lit, action="title:1")],
+                      music=os.path.join(self.tmp, "m2.wav"), loop=2, end="title:1")
+        out = os.path.join(self.tmp, "disc2")
+        disc.write(out, play_all=False, fast=True)
+        with bluray_sim.Disc(LIBBLURAY, out) as d:
+            ev = d.play()
+        plays = [v for k, v in ev if k == "playlist"]
+        # the menu twice (playlist 2), then title 1
+        self.assertEqual(plays[:3], [2, 2, 1])

bdmvkit-0.5.0/tests/test_popup.py

@@ -0,0 +1,107 @@
+"""Pop-up menus: buttons over a playing title, muxed into its clip as an IG
+stream, opened with the remote's Pop-up Menu key and played by libbluray."""
+
+import os
+import shutil
+import tempfile
+import unittest
+
+from bdmvkit import BdmvError, Disc, MenuButton, hdmv
+from bdmvkit.encode import encode_clip
+from bdmvkit.formats import CODING_IG, IG_PID
+from bdmvkit.m2ts import stream_pids
+
+from .test_disc import ENCODE_OK, source
+from .test_menus import png
+
+try:
+    from . import bluray_sim
+    LIBBLURAY = bluray_sim.load_library()
+except Exception:  # pragma: no cover
+    LIBBLURAY = None
+
+
+@unittest.skipUnless(ENCODE_OK and LIBBLURAY, "needs ffmpeg with libx264, and libbluray")
+class TestPopup(unittest.TestCase):
+    """Title 1 has a pop-up menu: TWO (title 2) and SCENE (its own chapter 2)."""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.tmp = d = tempfile.mkdtemp(prefix="bdmvkit-popup-")
+        a = encode_clip(source(os.path.join(d, "a.mp4"), 8), os.path.join(d, "a.m2ts"),
+                        chapters=[0, 4], fast=True)
+        b = encode_clip(source(os.path.join(d, "b.mp4"), 2), os.path.join(d, "b.m2ts"),
+                        fast=True)
+        lit = png(os.path.join(d, "lit.png"), 300, 60, "orange")
+        off = png(os.path.join(d, "off.png"), 300, 60, "gray")
+        disc = Disc()
+        cls.a = a
+        disc.add_title(a, chapters=[0, 4], end="stop")
+        disc.add_title(b, end="stop")
+        disc.add_popup(1, [MenuButton("two", 160, 900, lit, normal=off, action="title:2"),
+                           MenuButton("scene", 760, 900, lit, normal=off,
+                                      action="chapter:1:2"),
+                           MenuButton("sub", 1360, 900, lit, normal=off, action="subtitle:off")])
+        cls.out = os.path.join(d, "disc")
+        disc.write(cls.out, play_all=False, fast=True)
+
+    @classmethod
+    def tearDownClass(cls):
+        shutil.rmtree(cls.tmp, ignore_errors=True)
+
+    def test_in_the_clip(self):
+        clip = os.path.join(self.out, "BDMV", "STREAM", "00001.m2ts")
+        self.assertEqual(stream_pids(clip).get(IG_PID), CODING_IG)
+        # (the clip given is left as it was)
+        self.assertNotIn(IG_PID, stream_pids(self.a))
+        # the second title has none
+        self.assertNotIn(IG_PID, stream_pids(os.path.join(self.out, "BDMV", "STREAM",
+                                                          "00002.m2ts")))
+
+    def test_opens_and_its_buttons_work(self):
+        with bluray_sim.Disc(LIBBLURAY, self.out) as disc:
+            disc.info()
+            ev = [e for e in disc.play(keys=("live:popup", "live:enter"))
+                  if e[0] in ("title", "key", "menu") and e[1] != 0xFFFF]
+        keys = [e for e in ev if e[0] in ("title", "key")]
+        # title 1, the pop-up opened over it, TWO chosen: title 2
+        self.assertEqual(keys[:4], [("title", 1), ("key", "live:popup"), ("key", "live:enter"),
+                                    ("title", 2)])
+        drawn = [d for e in ev if e[0] == "menu" for d in e[1]]
+        xs = sorted({d[1] for d in drawn if d[0] == "draw"})
+        self.assertTrue({160, 760, 1360} <= set(xs), drawn)
+
+    def test_a_chapter_from_the_popup(self):
+        with bluray_sim.Disc(LIBBLURAY, self.out) as disc:
+            disc.info()
+            ev = disc.play(keys=("live:popup", "live:right", "live:enter"))
+        after = ev[next(i for i, e in enumerate(ev) if e == ("key", "live:enter")):]
+        self.assertIn(("at_chapter", 2), after)
+
+    def test_a_stream_button_closes_the_menu(self):
+        disc = Disc()
+        disc.add_title("x.m2ts")
+        p = disc.program()
+        from bdmvkit.disc import _ig_buttons
+        from bdmvkit.nav import Navigation
+        lit = os.path.join(self.tmp, "lit.png")
+        nav = Navigation(p)
+        sub = MenuButton("sub", 100, 100, lit, action="subtitle:off")
+        two = MenuButton("one", 100, 300, lit, action="title:1")
+        from bdmvkit.disc import _button
+        ig = _ig_buttons("t", [sub, two], [_button(sub), _button(two)], nav, popup=True)
+        self.assertEqual(ig[0].commands[-1], hdmv.popup_off())
+        self.assertNotIn(hdmv.popup_off(), ig[1].commands)
+
+
+class TestChecks(unittest.TestCase):
+    def test_refused(self):
+        disc = Disc()
+        with self.assertRaises(BdmvError):
+            disc.add_popup(1, [MenuButton("a", 0, 0, "a.png", action="title:1")])
+        disc.add_title("x.m2ts")
+        with self.assertRaises(BdmvError):
+            disc.add_popup(1, [])
+        disc.add_popup(1, [MenuButton("a", 0, 0, "a.png", action="title:9")])
+        with self.assertRaises(BdmvError):               # leads nowhere
+            disc.program().check()