bdmvkit 0.2.0__py3-none-any.whl

bdmvkit/__init__.py

@@ -0,0 +1,16 @@
+"""bdmvkit: Blu-ray (BDMV) authoring in pure Python.
+
+* `bdmvkit.Disc`: a BDMV folder from encoded clips (titles, chapters, sound
+  and subtitle tracks, played in order) and menus (`MenuButton`).
+* `bdmvkit.igs`: a menu's buttons as an Interactive Graphics stream.
+* `bdmvkit.encode.encode_clip`: a clip encoded for Blu-ray with ffmpeg + x264.
+* `bdmvkit.pgs`: PGS subtitle streams (.sup) from pictures.
+* The files themselves: `playlist.mpls`, `clip.clpi`, `hdmv.index_bdmv`,
+  `hdmv.movie_objects` and the HDMV navigation commands, `m2ts.scan_m2ts`.
+"""
+
+from .disc import Disc, MenuButton
+from .errors import BdmvError
+
+__version__ = "0.2.0"
+__all__ = ["Disc", "MenuButton", "BdmvError"]

bdmvkit/__main__.py

@@ -0,0 +1,86 @@
+"""Command line:
+
+    bdmvkit encode SOURCE CLIP.m2ts [--fps 24000/1001] [--chapters 0,60,120] [--fast]
+    bdmvkit build DISC.json OUT_DIR
+
+DISC.json: {"titles": [{"clip": "a.m2ts", "fps": "24000/1001",
+"chapters": [0, 60], "audio": [["ac3", 2, "en"]], "subtitles": ["ja"],
+"end": "menu:main"}], "menus": [{"id": "main", "background": "menu.png",
+"buttons": [{"id": "play", "x": 160, "y": 700, "selected": "play.png",
+"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, ...}) and "auto"; a menu "default" (a button id) and "fps".
+"""
+
+import argparse
+import json
+import os
+import sys
+
+from . import __version__
+from .disc import Disc, MenuButton
+from .encode import encode_clip
+from .errors import BdmvError
+
+
+def _fps(text):
+    num, _, den = str(text).partition("/")
+    return int(num), int(den or 1)
+
+
+def _times(text):
+    return [float(t) for t in text.split(",") if t.strip()] if text else [0.0]
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser(prog="bdmvkit", description="Blu-ray (BDMV) authoring.")
+    p.add_argument("--version", action="version", version=f"bdmvkit {__version__}")
+    sub = p.add_subparsers(dest="command", required=True)
+    s = sub.add_parser("encode", help="encode a video into a Blu-ray clip (ffmpeg + x264)")
+    s.add_argument("source")
+    s.add_argument("clip", help="the .m2ts to write")
+    s.add_argument("--fps", default="24000/1001", help="24000/1001, 25 or 30000/1001")
+    s.add_argument("--chapters", help="chapter starts in seconds, e.g. 0,60,120")
+    s.add_argument("--fast", action="store_true", help="quick, lower-quality encoding")
+    s = sub.add_parser("build", help="write a BDMV folder from encoded clips and menus")
+    s.add_argument("disc", help="the disc description (JSON)")
+    s.add_argument("out", help="the folder to write BDMV into")
+    s.add_argument("--fast", action="store_true", help="quick encoding of the menus")
+    args = p.parse_args(argv)
+    try:
+        if args.command == "encode":
+            encode_clip(args.source, args.clip, fps=_fps(args.fps),
+                        chapters=_times(args.chapters), fast=args.fast)
+            print(args.clip)
+            return 0
+        with open(args.disc, encoding="utf-8") as f:
+            spec = json.load(f)
+        base = os.path.dirname(os.path.abspath(args.disc))
+        disc = Disc()
+        for t in spec.get("titles", []):
+            disc.add_title(os.path.join(base, t["clip"]), fps=_fps(t.get("fps", "24000/1001")),
+                           chapters=t.get("chapters", [0]),
+                           audio=[tuple(a) for a in t.get("audio", [["ac3", 2, "und"]])],
+                           subtitles=t.get("subtitles", []), end=t.get("end"))
+
+        def file(name):
+            return os.path.join(base, name) if name else None
+
+        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")))
+                for b in m["buttons"]], fps=_fps(m.get("fps", "24000/1001")),
+                default=m.get("default"))
+        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)
+        return 1
+    print(f"{args.out}: {res['titles']} title(s), {res['menus']} menu(s), "
+          f"chapters {res['chapters']}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

bdmvkit/clip.py

@@ -0,0 +1,70 @@
+"""Clip information (.clpi): a clip's streams, time span and entry-point map."""
+
+from .formats import (AUDIO_PID, CODING_H264, CODING_IG, IG_PID, PG_PID, PMT_PID, TS_RATE,
+                      VERSION, VIDEO_PID)
+from .hdmv import _pad, _u8, _u16, _u32
+from .playlist import _audio_attr, _pg_attr
+
+
+def ep_map(entries):
+    """EP_map() of the video stream: a coarse entry whenever the upper PTS or
+    packet-number bits change, a fine entry per key frame."""
+    coarse, fine = [], []
+    last = None
+    for i, (pts, spn, size) in enumerate(entries):
+        key = (pts >> 19, spn & 0xFFFE0000)
+        if key != last:
+            coarse.append((i, pts >> 19 & 0x3FFF, spn))
+            last = key
+        # I_end_position_offset: how many bytes the key picture takes, in steps
+        end = next((k for k, lim in enumerate((131072, 262144, 393216, 589824, 917504,
+                                               1310720), 1) if size < lim), 7)
+        fine.append(end << 28 | (pts >> 9 & 0x7FF) << 17 | spn & 0x1FFFF)
+    table = b"".join(_u32(ref << 14 | cpts) + _u32(cspn) for ref, cpts, cspn in coarse)
+    one = _u32(4 + len(table)) + table + b"".join(_u32(v) for v in fine)
+    # stream_PID, 10 reserved bits + EP_stream_type 1 (video), the coarse and
+    # fine counts (16 + 18 bits), then where the stream's map starts
+    counts = 1 << 34 | len(coarse) << 18 | len(fine)
+    head_len = 2 + 2 + 6 + 4        # (the address counts from the start of EP_map)
+    head = _u8(0) + _u8(1) + _u16(VIDEO_PID) + counts.to_bytes(6, "big") + _u32(head_len)
+    return head + one
+
+
+def clpi(scan, video_format, frame_rate, audio, pg=(), ig=False):
+    """Clip information of one .m2ts: its streams, time span and EP map.
+    audio: [(coding, channels, lang3)]; pg: [lang3]; ig: menu buttons."""
+    ts_type = bytes([0x80]) + b"HDMV" + bytes(9) + bytes(16)
+    info = _u16(0) + _u8(1) + _u8(1) + _u32(0) + _u32(TS_RATE) + _u32(scan.packets) + \
+        bytes(128) + _u16(len(ts_type)) + ts_type
+    info = _u32(len(info)) + info
+    start, end = scan.first_pts // 2, scan.end_pts // 2
+    seq = _u8(0) + _u8(1) + _u32(0) + _u8(1) + _u8(0) + _u16(scan.pcr_pid) + _u32(0) + \
+        _u32(start) + _u32(end)
+    seq = _u32(len(seq)) + seq
+    isrc = b"0" * 12
+    streams = _u16(VIDEO_PID)
+    coding = bytes([CODING_H264, video_format << 4 | frame_rate, 3 << 4, 0, 0]) + isrc + bytes(4)
+    streams += _u8(len(coding)) + coding
+    for k, tr in enumerate(audio):
+        coding = _audio_attr(tr) + isrc + bytes(4)
+        streams += _u16(AUDIO_PID + k) + _u8(len(coding)) + coding
+    for k, lang in enumerate(pg):
+        coding = _pg_attr(lang) + isrc + bytes(4)
+        streams += _u16(PG_PID + k) + _u8(len(coding)) + coding
+    if ig:
+        coding = _pg_attr("und", CODING_IG) + isrc + bytes(4)
+        streams += _u16(IG_PID) + _u8(len(coding)) + coding
+    prog = _u8(0) + _u8(1) + _u32(0) + _u16(PMT_PID) + \
+        _u8(1 + len(audio) + len(pg) + int(ig)) + _u8(0) + streams
+    prog = _u32(len(prog)) + prog
+    cpi = _u16(1) + ep_map(scan.entries)          # 12 reserved bits, CPI_type 1 (EP map)
+    cpi = _u32(len(cpi)) + cpi
+    parts = [info, seq, prog, cpi, _u32(0)]       # (the last one: no clip marks)
+    pos, offsets, body = 40, [], b""
+    for part in parts:
+        offsets.append(pos)
+        part = _pad(part, 4)
+        body += part
+        pos += len(part)
+    return b"HDMV" + VERSION + b"".join(_u32(o) for o in offsets[1:]) + _u32(0) + \
+        bytes(12) + body

bdmvkit/disc.py

@@ -0,0 +1,257 @@
+"""A BDMV folder from encoded clips: titles with chapters, played from the
+first one on (or each on its own), with their sound and subtitle tracks.
+
+    disc = Disc()
+    disc.add_title("feature.m2ts", chapters=[0, 300, 600], audio=[("ac3", 6, "en")],
+                   subtitles=["en", "ja"])
+    disc.add_title("extras.m2ts")
+    disc.write("out")            # out/BDMV/...
+
+Each title is a playlist with a chapter mark at every chapter (on the key
+frame nearest to it: encode the clip with key frames there, as
+encode.encode_clip does) and a movie object that plays it. First play and
+the Top Menu key start title 1; with `play_all`, each title goes on to the
+next when it ends. Clips are BDAV streams with the PIDs formats.py names.
+
+Menus: a picture with buttons, each linked to a title, a chapter or
+another menu:
+
+    disc.add_menu("main", "menu.png", [
+        MenuButton("play", 160, 700, "play.png", action="title:1"),
+        MenuButton("scenes", 160, 800, "scenes.png", "scenes-lit.png", action="menu:scenes"),
+    ])
+    disc.add_title("feature.m2ts", end="menu:main")     # back to the menu at the end
+
+A button's pictures are its selected (and activated) look, drawn over the
+menu where it is; with a `normal` picture it is drawn there before it is
+selected too. The arrow keys go to the nearest button that way unless
+`nav` says otherwise. Each menu is an interactive title after the titles:
+its picture held as a still, its buttons an IG stream (igs.py) in its clip.
+With menus, first play and the Top Menu key open the first menu.
+"""
+
+import dataclasses
+import os
+import shutil
+
+import tempfile
+
+from . import clip as clip_info
+from . import encode, hdmv, igs, playlist
+from .errors import BdmvError
+from .formats import CODECS, FORMATS, HEIGHT, WIDTH, lang3
+from .m2ts import scan_m2ts
+
+DIRS = ["BDMV/PLAYLIST", "BDMV/CLIPINF", "BDMV/STREAM", "BDMV/AUXDATA", "BDMV/BDJO",
+        "BDMV/JAR", "BDMV/META", "BDMV/BACKUP/PLAYLIST", "BDMV/BACKUP/CLIPINF",
+        "BDMV/BACKUP/BDJO", "CERTIFICATE/BACKUP"]
+
+
+@dataclasses.dataclass
+class Title:
+    clip: str                    # an encoded .m2ts
+    fps: tuple = (24000, 1001)   # its frame rate: 24000/1001, 25/1 or 30000/1001
+    chapters: list = dataclasses.field(default_factory=lambda: [0.0])   # starts, seconds
+    audio: list = dataclasses.field(default_factory=lambda: [("ac3", 2, "und")])
+    subtitles: list = dataclasses.field(default_factory=list)          # PG tracks: languages
+    end: str = None              # after it: "title:<n>", "menu:<id>" (None: the next with play_all)
+
+
+@dataclasses.dataclass
+class MenuButton:
+    id: str
+    x: int                       # top-left on the 1920 x 1080 menu
+    y: int
+    selected: str                # picture files (PNG ...): selected,
+    activated: str = None        # activated (default: the selected one),
+    normal: str = None           # and before it is selected (default: nothing)
+    action: str = None           # "title:<n>", "chapter:<n>:<c>", "menu:<id>"
+    nav: dict = dataclasses.field(default_factory=dict)    # direction -> button id
+    auto: bool = False           # runs as soon as it is selected
+
+
+@dataclasses.dataclass
+class Menu:
+    id: str
+    background: str              # picture file, fitted into the HD frame
+    buttons: list
+    fps: tuple = (24000, 1001)
+    default: str = None          # the button selected first (default: the first)
+
+
+def chapter_marks(chapters, scan):
+    """Chapter marks (45 kHz): each chapter on the key frame nearest to it,
+    the first at the start of the clip."""
+    marks = [scan.first_pts // 2]
+    keys = [pts for pts, _, _ in scan.entries]
+    for t in sorted(c for c in chapters if c > 0):
+        want = scan.first_pts + round(t * 90000)
+        near = min(keys, key=lambda k: abs(k - want))
+        if near // 2 > marks[-1]:
+            marks.append(near // 2)
+    return marks
+
+
+def _write(out_dir, rel, data):
+    for base in ("BDMV", os.path.join("BDMV", "BACKUP")):
+        with open(os.path.join(out_dir, base, rel), "wb") as f:
+            f.write(data)
+
+
+class Disc:
+    def __init__(self):
+        self.titles = []
+        self.menus = []
+
+    def add_title(self, clip, fps=(24000, 1001), chapters=(0.0,), audio=(("ac3", 2, "und"),),
+                  subtitles=(), end=None):
+        """Add a title; returns its number (1-based). audio: (codec, channels,
+        language) per track, codec "ac3", "lpcm" or "dts"; languages are ISO
+        639-1 ("en") or 639-2 ("eng") codes. end: where it goes when it ends,
+        "title:<n>" or "menu:<id>" (default: the next title with play_all)."""
+        if tuple(fps) not in FORMATS:
+            raise BdmvError(f"{fps[0]}/{fps[1]} fps has no Blu-ray format")
+        for codec, _, _ in audio:
+            if codec not in CODECS:
+                raise BdmvError(f"unknown audio codec {codec!r} (ac3, lpcm or dts)")
+        if not audio:
+            raise BdmvError("a title needs at least one audio track")
+        self.titles.append(Title(clip, tuple(fps), list(chapters) or [0.0], list(audio),
+                                 list(subtitles), end))
+        return len(self.titles)
+
+    def add_menu(self, menu_id, background, buttons, fps=(24000, 1001), default=None):
+        """Add a menu: `background` a picture, `buttons` MenuButtons. The
+        menu's clip is made when the disc is written (ffmpeg)."""
+        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")
+        self.menus.append(Menu(menu_id, background, list(buttons), tuple(fps), default))
+
+    def _links(self):
+        """{action: commands} for every link the titles and buttons use, and
+        the chapter objects [(title, chapter)] they need."""
+        n_titles = len(self.titles)
+        menu_title = {m.id: n_titles + k for k, m in enumerate(self.menus, 1)}
+        actions = [t.end for t in self.titles if t.end] + \
+            [b.action for m in self.menus for b in m.buttons if b.action]
+        links, chapter_objects = {}, []
+        for a in actions:
+            kind, _, rest = a.partition(":")
+            if kind == "title" and rest.isdigit() and 1 <= int(rest) <= n_titles:
+                links[a] = [hdmv.jump_title(int(rest))]
+            elif kind == "menu" and rest in menu_title:
+                links[a] = [hdmv.jump_title(menu_title[rest])]
+            elif kind == "chapter":
+                n, _, c = rest.partition(":")
+                if not (n.isdigit() and c.isdigit() and 1 <= int(n) <= n_titles):
+                    raise BdmvError(f"{a!r}: no such title")
+                key = (int(n), int(c))
+                if key not in chapter_objects:
+                    chapter_objects.append(key)
+                links[a] = key                  # (its object's number: once known)
+            else:
+                raise BdmvError(f"{a!r}: not title:<n>, chapter:<n>:<c> or menu:<id> "
+                                "of this disc")
+        return links, chapter_objects, menu_title
+
+    def write(self, out_dir, move=False, play_all=True, fast=False):
+        """Write the BDMV folder into `out_dir` (copying the clips into
+        BDMV/STREAM, or moving them with `move`; menu clips are encoded,
+        quickly with `fast`). Returns {"titles", "menus", "playlists",
+        "chapters"}."""
+        if not self.titles:
+            raise BdmvError("a disc needs at least one title")
+        links, chapter_objects, menu_title = self._links()
+        n_titles = len(self.titles)
+        # movie objects: one per title, one per menu, first play, top menu,
+        # then one per chapter a link starts
+        first_chapter_object = n_titles + len(self.menus) + 2
+        for a, v in links.items():
+            if isinstance(v, tuple):
+                links[a] = [hdmv.jump_object(first_chapter_object + chapter_objects.index(v))]
+        for d in DIRS:
+            os.makedirs(os.path.join(out_dir, d), exist_ok=True)
+        objects, chapters = [], []
+        for n, t in enumerate(self.titles, 1):
+            name = f"{n:05d}"
+            scan = scan_m2ts(t.clip)
+            video_format, frame_rate = FORMATS[t.fps]
+            audio = [(CODECS[c], ch, _lang(lang)) for c, ch, lang in t.audio]
+            pg = [_lang(lang) for lang in t.subtitles]
+            marks = chapter_marks(t.chapters, scan)
+            chapters.append(len(marks))
+            _write(out_dir, os.path.join("CLIPINF", f"{name}.clpi"),
+                   clip_info.clpi(scan, video_format, frame_rate, audio, pg))
+            item = (name, marks[0], scan.end_pts // 2, video_format, frame_rate, audio, pg,
+                    False, 0)
+            _write(out_dir, os.path.join("PLAYLIST", f"{name}.mpls"),
+                   playlist.mpls([item], [(0, m) for m in marks]))
+            dest = os.path.join(out_dir, "BDMV", "STREAM", f"{name}.m2ts")
+            if os.path.abspath(t.clip) != os.path.abspath(dest):
+                (shutil.move if move else shutil.copyfile)(t.clip, dest)
+            objects.append([hdmv.play_pl(n)] + self._end(t, n, play_all, links))
+        for k, m in enumerate(self.menus, n_titles + 1):
+            self._write_menu(out_dir, k, m, links, fast)
+            objects.append([hdmv.play_pl(k)])     # (its last picture held: a still)
+        # first play and the Top Menu key: the first menu, or title 1
+        objects.append([hdmv.jump_title(n_titles + 1 if self.menus else 1)])
+        start = len(objects) - 1
+        objects.append([hdmv.jump_title(n_titles + 1 if self.menus else 1)])
+        for n, c in chapter_objects:
+            t = self.titles[n - 1]
+            if c > chapters[n - 1]:
+                raise BdmvError(f"chapter:{n}:{c}: title {n} has {chapters[n - 1]} chapters")
+            objects.append([hdmv.play_pl_mark(n, c - 1)] + self._end(t, n, play_all, links))
+        first = FORMATS[self.titles[0].fps]
+        total = n_titles + len(self.menus)
+        _write(out_dir, "index.bdmv", hdmv.index_bdmv(
+            list(range(total)), start, start + 1, *first,
+            interactive=range(n_titles + 1, total + 1)))
+        _write(out_dir, "MovieObject.bdmv", hdmv.movie_objects(objects))
+        return {"titles": n_titles, "menus": len(self.menus),
+                "playlists": [f"{n:05d}.mpls" for n in range(1, total + 1)],
+                "chapters": chapters}
+
+    def _end(self, t, n, play_all, links):
+        if t.end:
+            return list(links[t.end])
+        return [hdmv.jump_title(n + 1)] if play_all and n < len(self.titles) else []
+
+    def _write_menu(self, out_dir, k, m, links, fast):
+        """Menu `m` as title / playlist / clip k: its buttons' pictures read,
+        the IG stream made and encoded with its picture into the clip."""
+        name = f"{k:05d}"
+        buttons = []
+        for b in m.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,
+                                      list(links[b.action]) if b.action else [],
+                                      dict(b.nav), b.auto))
+        video_format, frame_rate = FORMATS[m.fps]
+        dest = os.path.join(out_dir, "BDMV", "STREAM", f"{name}.m2ts")
+        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))
+            encode.encode_menu(m.background, sup, dest, m.fps, fast=fast)
+        scan = scan_m2ts(dest)
+        _write(out_dir, os.path.join("CLIPINF", f"{name}.clpi"),
+               clip_info.clpi(scan, video_format, frame_rate, [], [], ig=True))
+        item = (name, scan.first_pts // 2, scan.end_pts // 2, video_format, frame_rate, [], [],
+                True, 2)
+        _write(out_dir, os.path.join("PLAYLIST", f"{name}.mpls"),
+               playlist.mpls([item], [(0, scan.first_pts // 2)]))
+
+
+def _lang(code):
+    code = (code or "").lower()
+    return code if len(code) == 3 and code.isalpha() else lang3(code)

bdmvkit/encode.py

@@ -0,0 +1,152 @@
+"""Encoding a video into a Blu-ray clip (.m2ts) with ffmpeg and x264.
+
+The picture is fitted into the 1920 x 1080 frame (letter- or pillarboxed),
+encoded as H.264 High at level 4.1 with x264's Blu-ray settings (at most a
+second between key frames, key frames at the chapters), and muxed with its
+sound and any PGS subtitle streams into a BDAV transport stream with the
+PIDs the playlists name. 25 and 29.97 fps become progressive frames in an
+interlaced (1080i) stream, as the format has no 1080p at those rates.
+"""
+
+import shutil
+import subprocess
+
+from .errors import BdmvError
+from .formats import (AUDIO_PID, FORMATS, HEIGHT, IG_PID, MAX_VIDEO_BPS, PG_PID, PMT_PID,
+                      VBV_BUFFER, VIDEO_PID, WIDTH)
+
+
+def video_args(fps, max_bps=MAX_VIDEO_BPS, fast=False, keys=()):
+    """x264 options for a Blu-ray video stream at `fps` ((num, den)); `keys`:
+    times (s) to make key frames, e.g. the chapters."""
+    if fps not in FORMATS:
+        raise BdmvError(f"{fps[0]}/{fps[1]} fps has no Blu-ray format "
+                        f"(use one of {', '.join(f'{a}/{b}' for a, b in FORMATS)})")
+    gop = round(fps[0] / fps[1])            # at most one second between key frames
+    x264 = (f"bluray-compat=1:slices=4:aud=1:nal-hrd=vbr:keyint={gop}:min-keyint=1:"
+            "force-cfr=1")
+    if FORMATS[fps][0] == 4:
+        x264 += ":fake-interlaced=1:pic-struct=1"
+    args = ["-c:v", "libx264", "-preset", "ultrafast" if fast else "medium",
+            "-crf", "24" if fast else "19", "-profile:v", "high", "-level", "4.1",
+            "-maxrate", str(max_bps), "-bufsize", str(VBV_BUFFER), "-x264-params", x264,
+            "-r", f"{fps[0]}/{fps[1]}", "-pix_fmt", "yuv420p", "-aspect", "16:9",
+            "-color_primaries", "bt709", "-color_trc", "bt709", "-colorspace", "bt709",
+            "-forced-idr", "1"]
+    if keys:
+        args += ["-force_key_frames", ",".join(f"{t:.6f}" for t in sorted(keys))]
+    return args
+
+
+def audio_args(codec="ac3", channels=2, k=0, bitrate=None):
+    """Options for audio output stream k: "ac3", "lpcm" (16-bit stereo) or
+    "copy" (as it is, e.g. AC-3 or DTS)."""
+    if codec == "copy":
+        return [f"-c:a:{k}", "copy"]
+    if codec == "lpcm":
+        return [f"-c:a:{k}", "pcm_bluray", f"-sample_fmt:a:{k}", "s16", f"-ar:a:{k}", "48000",
+                f"-ac:a:{k}", "2"]
+    if codec != "ac3":
+        raise BdmvError(f"unknown audio codec {codec!r} (ac3, lpcm or copy)")
+    bitrate = bitrate or (448000 if channels > 2 else 192000)
+    return [f"-c:a:{k}", "ac3", f"-b:a:{k}", str(bitrate), f"-ar:a:{k}", "48000",
+            f"-ac:a:{k}", str(channels)]
+
+
+def fit_filter(fps):
+    """The picture fitted into the HD frame, square pixels, at `fps`."""
+    return (f"scale={WIDTH}:{HEIGHT}:force_original_aspect_ratio=decrease,"
+            f"pad={WIDTH}:{HEIGHT}:(ow-iw)/2:(oh-ih)/2,setsar=1,fps={fps[0]}/{fps[1]}")
+
+
+def encode_clip(source, out, fps=(24000, 1001), chapters=(), audio="ac3", channels=2,
+                sups=(), max_bps=MAX_VIDEO_BPS, fast=False, ffmpeg=None):
+    """Encode `source` (any video ffmpeg reads) into the Blu-ray clip `out`:
+    its first audio stream, or silence when it has none. `chapters`: times
+    (s) that become key frames, so chapter marks land on them. `sups`: PGS
+    streams (.sup, e.g. from pgs.write_sup) muxed in as subtitle tracks."""
+    ffmpeg = ffmpeg or shutil.which("ffmpeg")
+    if not ffmpeg:
+        raise BdmvError("encoding needs ffmpeg (with libx264)")
+    cmd = [ffmpeg, "-hide_banner", "-nostdin", "-v", "error", "-y", "-i", source]
+    if _has_audio(source, ffmpeg):
+        sound = ["-map", "0:a:0"]
+    else:
+        cmd += ["-f", "lavfi", "-i", "anullsrc=channel_layout=stereo:sample_rate=48000"]
+        sound = ["-map", "1:a:0", "-shortest"]
+    first_sup = cmd.count("-i")
+    for sup in sups:
+        cmd += ["-i", sup]
+    cmd += ["-filter_complex", f"[0:v:0]{fit_filter(fps)}[v]", "-map", "[v]"] + sound
+    for k in range(len(sups)):
+        cmd += ["-map", f"{first_sup + k}:s:0"]
+    cmd += video_args(fps, max_bps, fast, [t for t in chapters if t > 0])
+    cmd += audio_args(audio, channels)
+    if sups:
+        cmd += ["-c:s", "copy"]
+    cmd += ["-streamid", f"0:{VIDEO_PID}", "-streamid", f"1:{AUDIO_PID}"]
+    for k in range(len(sups)):
+        cmd += ["-streamid", f"{2 + k}:{PG_PID + k}"]
+    cmd += ["-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:
+        raise BdmvError(f"ffmpeg could not encode {source}: {p.stderr.strip()[-800:]}")
+    return out
+
+
+def _has_audio(source, ffmpeg):
+    probe = shutil.which("ffprobe") or ffmpeg.replace("ffmpeg", "ffprobe")
+    p = subprocess.run([probe, "-v", "error", "-select_streams", "a", "-show_entries",
+                        "stream=index", "-of", "csv=p=0", source], capture_output=True, text=True)
+    return bool(p.stdout.strip())
+
+
+def picture(path, size=None, ffmpeg=None):
+    """A picture file (PNG, JPEG ...) as (width, height, RGBA bytes), scaled
+    to `size` (w, h) when given."""
+    ffmpeg = ffmpeg or shutil.which("ffmpeg")
+    if not ffmpeg:
+        raise BdmvError("reading pictures needs ffmpeg")
+    if size is None:
+        probe = shutil.which("ffprobe") or ffmpeg.replace("ffmpeg", "ffprobe")
+        p = subprocess.run([probe, "-v", "error", "-select_streams", "v:0", "-show_entries",
+                            "stream=width,height", "-of", "csv=p=0", path],
+                           capture_output=True, text=True)
+        try:
+            w, h = (int(v) for v in p.stdout.strip().split(",")[:2])
+        except ValueError:
+            raise BdmvError(f"cannot read the picture {path}")
+    else:
+        w, h = size
+    p = subprocess.run([ffmpeg, "-hide_banner", "-nostdin", "-v", "error", "-i", path,
+                        "-frames:v", "1", "-vf", f"scale={w}:{h}", "-f", "rawvideo",
+                        "-pix_fmt", "rgba", "-"], capture_output=True)
+    if p.returncode != 0 or len(p.stdout) != w * h * 4:
+        why = p.stderr.decode(errors="replace")[-300:]
+        raise BdmvError(f"cannot read the picture {path}: {why}")
+    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."""
+    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",
+         "-mpegts_pmt_start_pid", str(PMT_PID), out]
+    p = subprocess.run(cmd, capture_output=True, text=True)
+    if p.returncode != 0:
+        raise BdmvError(f"ffmpeg could not encode the menu {background}: "
+                        f"{p.stderr.strip()[-800:]}")
+    patch_ig_stream_type(out)
+    return out

bdmvkit/errors.py

@@ -0,0 +1,9 @@
+"""The one exception bdmvkit raises."""
+
+
+class BdmvError(Exception):
+    """A disc cannot be written as asked."""
+
+    def __init__(self, message):
+        super().__init__(message)
+        self.message = message

bdmvkit/formats.py

@@ -0,0 +1,45 @@
+"""Numbers of the BD-ROM format bdmvkit writes: stream PIDs, coding types,
+video format and frame rate codes, languages."""
+
+VERSION = b"0200"              # of the navigation files
+WIDTH, HEIGHT = 1920, 1080
+
+MAX_VIDEO_BPS = 40_000_000     # primary video limit
+VBV_BUFFER = 30_000_000        # coded picture buffer at level 4.1
+TS_RATE = 48_000_000 // 8      # ts_recording_rate: the 48 Mbit/s maximum, in bytes/s
+
+VIDEO_PID = 0x1011
+AUDIO_PID = 0x1100             # + track number
+PG_PID = 0x1200                # + subtitle track number
+IG_PID = 0x1400                # a menu's buttons (Interactive Graphics)
+PMT_PID = 0x0100
+
+# frame rate -> (video_format, frame_rate) codes; 25 and 29.97 fps are coded
+# as progressive frames in an interlaced (1080i) stream, as the format has
+# no 1080p at those rates
+FORMATS = {
+    (24000, 1001): (6, 1),     # 1080p 23.976
+    (25, 1): (4, 3),           # 1080i 25
+    (30000, 1001): (4, 4),     # 1080i 29.97
+}
+CODING_H264, CODING_LPCM, CODING_AC3, CODING_DTS = 0x1B, 0x80, 0x81, 0x82
+CODING_PG, CODING_IG = 0x90, 0x91
+
+# ISO 639-1 -> ISO 639-2/B (the disc's codes)
+LANGS = {
+    "ar": "ara", "bg": "bul", "ca": "cat", "cs": "cze", "da": "dan", "de": "ger",
+    "el": "gre", "en": "eng", "es": "spa", "et": "est", "fa": "per", "fi": "fin",
+    "fr": "fre", "he": "heb", "hi": "hin", "hr": "hrv", "hu": "hun", "id": "ind",
+    "is": "ice", "it": "ita", "ja": "jpn", "ko": "kor", "lt": "lit", "lv": "lav",
+    "ms": "may", "nl": "dut", "no": "nor", "pl": "pol", "pt": "por", "ro": "rum",
+    "ru": "rus", "sk": "slo", "sl": "slv", "sr": "srp", "sv": "swe", "th": "tha",
+    "tr": "tur", "uk": "ukr", "vi": "vie", "zh": "chi",
+}
+
+
+def lang3(code):
+    return LANGS.get((code or "").lower(), "und")
+
+
+
+CODECS = {"ac3": CODING_AC3, "lpcm": CODING_LPCM, "dts": CODING_DTS}