bdmvkit 0.2.0__py3-none-any.whl

bdmvkit/hdmv.py

@@ -0,0 +1,149 @@
+"""HDMV navigation: the 12-byte navigation commands, MovieObject.bdmv and
+index.bdmv."""
+
+import struct
+
+from .formats import VERSION
+
+
+def _u8(v):
+    return struct.pack(">B", v)
+
+
+def _u16(v):
+    return struct.pack(">H", v)
+
+
+def _u32(v):
+    return struct.pack(">I", v)
+
+
+def _pad(data, n):
+    return data + b"\0" * (-len(data) % n)
+
+
+def index_bdmv(title_objects, first_play, top_menu, video_format, frame_rate, interactive=()):
+    """title_objects: the movie object of every title (title 1 first);
+    interactive: the titles (1-based) that are menus."""
+    app = _u32(34) + bytes([0, video_format << 4 | frame_rate]) + bytes(32)
+
+    def hdmv(obj, playback_type):
+        # playback_type 0 = movie, 1 = interactive
+        return _u16(playback_type << 14) + _u16(obj) + _u32(0)
+
+    body = _u32(1 << 30) + hdmv(first_play, 1) + _u32(1 << 30) + hdmv(top_menu, 1)
+    body += _u16(len(title_objects))
+    for n, obj in enumerate(title_objects, 1):
+        body += _u32(1 << 30) + hdmv(obj, int(n in interactive))   # HDMV, access permitted
+    index_start = 40 + len(app)
+    return b"INDX" + VERSION + _u32(index_start) + _u32(0) + bytes(24) + app + \
+        _u32(len(body)) + body
+
+
+def _cmd(b0, b1, dst=0, src=0, b3=0, b2=0):
+    """A 12-byte navigation command: operand count / group / sub-group,
+    immediate flags / branch option, compare option, set option; operands."""
+    return bytes([b0, b1, b2, b3]) + _u32(dst) + _u32(src)
+
+
+def play_pl(playlist):
+    """Play PlayList <playlist> (an immediate number)."""
+    return _cmd(0x22, 0x80, playlist)
+
+
+def set_subtitles(number):
+    """Set Stream: subtitle (PG) track `number` shown, or 0 = none shown."""
+    # Set group, SetSystem sub-group, two immediate operands, option 1 (Set Stream);
+    # the first operand: PG stream number valid (0x8000), shown (0x4000)
+    return _cmd(0x51, 0xC0, 0xC000 | number if number else 0, 0, 0x01)
+
+
+def jump_title(title):
+    """Jump Title <title>: 1..N, 0 = top menu."""
+    return _cmd(0x21, 0x81, title)
+
+
+def jump_title_reg(reg):
+    """Jump Title to the number held in general register `reg`."""
+    return _cmd(0x21, 0x01, reg)
+
+
+def jump_object(obj):
+    """Jump Object <obj> (a movie object number)."""
+    return _cmd(0x21, 0x80, obj)
+
+
+def play_pl_mark(playlist, mark):
+    """Play PlayList <playlist> from mark <mark> (0-based)."""
+    return _cmd(0x42, 0xC2, playlist, mark)
+
+
+def goto(pc):
+    """Goto command <pc> of the same object."""
+    return _cmd(0x20, 0x81, pc)
+
+
+
+def move(reg, value):
+    """Move <value> into general register <reg>."""
+    return _cmd(0x50, 0x40, reg, value, 0x01)
+
+
+def set_button(button=None, reg=None):
+    """Set Button Page: select button `button` (an id), or the one held in
+    general register `reg`; the page stays."""
+    # Set group, SetSystem sub-group, option 3; the operand's top bit: button valid
+    if reg is not None:
+        return _cmd(0x51, 0x40, 0x80000000 | reg, 0, 0x03)
+    return _cmd(0x51, 0xC0, 0x80000000 | button, 0, 0x03)
+
+
+def add(reg, value):
+    """Add <value> to general register <reg>."""
+    return _cmd(0x50, 0x40, reg, value, 0x03)
+
+
+def if_at_least(reg, value):
+    """Compare: the next command runs only if general register `reg` >= value."""
+    return _cmd(0x48, 0x40, reg, value, b2=0x04)
+
+
+def if_equal(reg, value):
+    """Compare: the next command runs only if general register `reg` == value."""
+    return _cmd(0x48, 0x40, reg, value, b2=0x02)
+
+
+def if_not_equal(reg, value):
+    """Compare: the next command runs only if general register `reg` != value."""
+    return _cmd(0x48, 0x40, reg, value, b2=0x03)
+
+
+def popup_off():
+    """Pop-up Off: close the pop-up menu."""
+    return _cmd(0x11, 0x00, b3=0x07)
+
+
+def resume():
+    """Resume the title the menu was called from."""
+    return _cmd(0x01, 0x04)
+
+
+def set_streams(audio=None, subtitle=None):
+    """Set Stream: audio track `audio` (1-based) and/or subtitle track
+    `subtitle` shown (0 = subtitles off)."""
+    dst = 0
+    if audio:
+        dst |= 0x80000000 | audio << 16
+    if subtitle is not None:
+        dst |= (0xC000 | subtitle) if subtitle else 0
+    return _cmd(0x51, 0xC0, dst, 0, 0x01)
+
+
+def movie_objects(objects):
+    """objects: lists of 12-byte navigation commands."""
+    data = b""
+    for cmds in objects:
+        # resume_intention_flag set: a menu called during playback can resume it
+        data += _u16(1 << 15) + _u16(len(cmds)) + b"".join(cmds)
+    body = _u32(0) + _u16(len(objects)) + data
+    return b"MOBJ" + VERSION + _u32(0) + bytes(28) + _u32(len(body)) + body

bdmvkit/igs.py

@@ -0,0 +1,241 @@
+"""Interactive Graphics (IG) streams: a menu's buttons.
+
+A menu on a Blu-ray is a clip (its picture) carrying an IG stream: one
+interactive composition with a page of buttons, each with a picture for
+its normal, selected and activated states, the buttons it moves to with
+the arrow keys, and the navigation commands it runs when activated.
+
+    buttons = [Button("play", 200, 600, selected=rgba, activated=rgba, w=400, h=80,
+                      commands=[hdmv.jump_title(1)])]
+    data = ig_stream(buttons, frame_rate=1)      # write it as a .sup
+
+The state pictures are RGBA (straight alpha) of the button's size; they
+share one palette of up to 255 colours (quantize). Without a normal
+picture a button shows nothing until it is selected (the highlight
+is drawn over the menu's own picture). A pop-up composition (`popup`)
+is shown by the remote's Pop-up key over a title instead of a menu clip.
+
+ffmpeg muxes an IG stream given as a .sup like a subtitle stream; the
+clip's PMT is then corrected with patch_ig_stream_type.
+"""
+
+import dataclasses
+import struct
+
+from . import pgs
+from .errors import BdmvError
+from .formats import CODING_IG, HEIGHT, IG_PID, PMT_PID, WIDTH
+
+ICS, PDS, ODS, END = 0x18, 0x14, 0x15, 0x80
+NO_OBJECT = 0xFFFF
+DIRECTIONS = ("up", "down", "left", "right")
+
+
+@dataclasses.dataclass
+class Button:
+    id: str
+    x: int                      # top-left on the 1920 x 1080 frame
+    y: int
+    w: int
+    h: int
+    selected: bytes             # RGBA, w x h
+    activated: bytes = None     # (default: the selected picture)
+    normal: bytes = None        # (default: nothing until selected)
+    commands: list = dataclasses.field(default_factory=list)   # 12-byte commands
+    nav: dict = dataclasses.field(default_factory=dict)        # direction -> button id
+    auto: bool = False          # runs as soon as it is selected
+
+
+def quantize(images):
+    """RGBA pictures -> (palette [(r, g, b, a)] for indices 1.., index
+    pictures) with at most 255 colours; fully transparent pixels are index
+    0. Fewer bits per channel are kept until the colours fit; past that the
+    rarest go to their nearest kept colour."""
+    for bits in (8, 7, 6, 5, 4, 3):
+        mask = (0xFF << (8 - bits)) & 0xFF
+        table = bytes(v & mask for v in range(256))
+        q = [im.translate(table) for im in images]
+        counts = {}
+        for qi in q:
+            for i in range(0, len(qi), 4):
+                c = qi[i:i + 4]
+                if c[3]:
+                    counts[c] = counts.get(c, 0) + 1
+        if len(counts) <= 255:
+            break
+    kept = sorted(counts, key=counts.get, reverse=True)[:255]
+    index = {c: k + 1 for k, c in enumerate(kept)}
+    for c in counts:
+        if c not in index:
+            index[c] = min(index.items(), key=lambda kv: sum((a - b) ** 2 for a, b in
+                                                           zip(kv[0], c)))[1]
+    half = (~mask & 0xFF) >> 1
+    palette = [tuple(v | half if v else v for v in c) for c in kept]
+    out = [bytes(index.get(qi[i:i + 4], 0) if qi[i + 3] else 0 for i in range(0, len(qi), 4))
+           for qi in q]
+    return palette, out
+
+
+def auto_nav(buttons):
+    """The arrow keys between buttons that do not say where they go: the
+    nearest button whose centre is that way (closer across counts more
+    than along), else the button itself. Returns {id: {direction: id}}."""
+    centre = {b.id: (b.x + b.w / 2, b.y + b.h / 2) for b in buttons}
+    out = {}
+    for b in buttons:
+        cx, cy = centre[b.id]
+        nav = {}
+        for d in DIRECTIONS:
+            if d in b.nav:
+                nav[d] = b.nav[d]
+                continue
+            best, score = b.id, None
+            for o in buttons:
+                if o is b:
+                    continue
+                ox, oy = centre[o.id]
+                along = {"up": cy - oy, "down": oy - cy, "left": cx - ox, "right": ox - cx}[d]
+                across = abs(ox - cx) if d in ("up", "down") else abs(oy - cy)
+                if along <= 0:
+                    continue
+                s = along + 2 * across
+                if score is None or s < score:
+                    best, score = o.id, s
+            nav[d] = best
+        out[b.id] = nav
+    return out
+
+
+def _segment(kind, data):
+    return b"PG" + struct.pack(">IIBH", 0, 0, kind, len(data)) + data
+
+
+def _objects(oid, w, h, pixels):
+    """ODS segment(s) of one object (split when longer than a segment)."""
+    coded = pgs.rle(pixels, w, h)
+    data = (len(coded) + 4).to_bytes(3, "big") + struct.pack(">HH", w, h) + coded
+    size = pgs.MAX_SEGMENT - 4
+    chunks = [data[i:i + size] for i in range(0, len(data), size)]
+    out = b""
+    for k, chunk in enumerate(chunks):
+        flags = (0x80 if k == 0 else 0) | (0x40 if k == len(chunks) - 1 else 0)
+        out += _segment(ODS, struct.pack(">HBB", oid, 0, flags) + chunk)
+    return out
+
+
+def ig_stream(buttons, frame_rate, default=None, popup=False, button_offset=0,
+              follow_selection=False):
+    """The buttons as an IG stream (.sup layout: "PG" segments).
+
+    frame_rate: the menu clip's frame rate code (formats.FORMATS);
+    default: the id of the button selected when the menu starts (the
+    first); follow_selection: keep the player's selection instead (a menu
+    entered with a chosen button, set_button before playing it);
+    button_offset: the number keys select button n with n + this."""
+    if not buttons:
+        raise BdmvError("a menu needs at least one button")
+    ids = [b.id for b in buttons]
+    if len(set(ids)) != len(ids):
+        raise BdmvError("button ids must be unique")
+    for b in buttons:
+        if b.x < 0 or b.y < 0 or b.x + b.w > WIDTH or b.y + b.h > HEIGHT:
+            raise BdmvError(f"button {b.id!r} is not inside the {WIDTH} x {HEIGHT} frame")
+        for name in ("selected", "activated", "normal"):
+            pic = getattr(b, name)
+            if pic is not None and len(pic) != b.w * b.h * 4:
+                raise BdmvError(f"button {b.id!r}: its {name} picture is not {b.w} x {b.h} RGBA")
+        for d, to in b.nav.items():
+            if d not in DIRECTIONS or to not in ids:
+                raise BdmvError(f"button {b.id!r}: nav {d} -> {to!r}")
+    if default is not None and default not in ids:
+        raise BdmvError(f"no button {default!r}")
+    if button_offset + len(buttons) > 9999:
+        raise BdmvError("button numbers go up to 9999")
+    nav = auto_nav(buttons)
+    index = {b.id: k for k, b in enumerate(buttons)}
+    normal = any(b.normal is not None for b in buttons)
+    pictures = []
+    for b in buttons:
+        empty = bytes(b.w * b.h * 4)
+        pictures += [b.normal if b.normal is not None else empty, b.selected,
+                     b.activated if b.activated is not None else b.selected]
+    colours, indexed = quantize(pictures)
+    palette = [(0, 16, 128, 128, 0)]
+    for k, (r, g, bl, a) in enumerate(colours, 1):
+        y, cb, cr = pgs.ycbcr((r, g, bl))
+        palette.append((k, y, cr, cb, a))
+    objects, body_buttons = b"", b""
+    for k, b in enumerate(buttons):
+        oids = {}
+        for slot in (0, 1, 2):            # normal, selected, activated
+            if slot == 0 and not normal:
+                continue
+            oid = 3 * k + slot
+            objects += _objects(oid, b.w, b.h, indexed[3 * k + slot])
+            oids[slot] = oid
+        n_oid = oids.get(0, NO_OBJECT)
+        moves = [index[nav[b.id][d]] for d in DIRECTIONS]
+        cmds = list(b.commands)
+        for c in cmds:
+            if len(c) != 12:
+                raise BdmvError(f"button {b.id!r}: a navigation command is 12 bytes")
+        button = struct.pack(">HHBHH", k, button_offset + k + 1, 0x80 if b.auto else 0, b.x, b.y)
+        button += struct.pack(">HHHH", *moves)
+        button += struct.pack(">HHB", n_oid, n_oid, 0)
+        button += struct.pack(">BHHB", 0xFF, oids[1], oids[1], 0)
+        button += struct.pack(">BHH", 0xFF, oids[2], oids[2])
+        button += struct.pack(">H", len(cmds)) + b"".join(cmds)
+        # one button per overlap group: the buttons do not overlap
+        body_buttons += struct.pack(">HB", k, 1) + button
+    first = 0xFFFF if follow_selection else index.get(default, 0)
+    page = struct.pack(">BB", 0, 0) + bytes(8)            # page 0, no user-operation mask
+    page += bytes([0, 0]) + bytes([0, 0])                  # no in / out effects
+    page += struct.pack(">BHHBB", 0, first, NO_OBJECT, 0, len(buttons)) + body_buttons
+    # multiplexed; always on, or a pop-up (the Pop-up key shows it); no time-outs
+    body = bytes([0x40 if popup else 0x00]) + bytes(10)
+    body += (0).to_bytes(3, "big") + bytes([1]) + page     # no user time-out; one page
+    ics = struct.pack(">HHB", WIDTH, HEIGHT, frame_rate << 4)
+    ics += struct.pack(">HB", 0, 0x80)                     # composition 0, epoch start
+    ics += bytes([0xC0]) + len(body).to_bytes(3, "big") + body
+    if len(ics) > pgs.MAX_SEGMENT:
+        raise BdmvError("too many buttons or button commands for one composition")
+    pds = bytes([0, 0]) + b"".join(bytes(e) for e in palette)
+    return _segment(ICS, ics) + _segment(PDS, pds) + objects + _segment(END, b"")
+
+
+def patch_ig_stream_type(path, pmt_pid=PMT_PID, pid=IG_PID):
+    """ffmpeg muxes the IG stream as a PGS stream (stream type 0x90): mark it
+    0x91 in every PMT of the clip (and fix the section CRC)."""
+    with open(path, "r+b") as f:
+        data = bytearray(f.read())
+        for off in range(0, len(data), 192):
+            p = off + 4
+            if (data[p + 1] & 0x1F) << 8 | data[p + 2] != pmt_pid or not data[p + 1] & 0x40:
+                continue
+            q = p + 4
+            if data[p + 3] & 0x20:
+                q += 1 + data[q]
+            q += 1 + data[q]                                # pointer field
+            length = (data[q + 1] & 0x0F) << 8 | data[q + 2]
+            end = q + 3 + length - 4
+            info = (data[q + 10] & 0x0F) << 8 | data[q + 11]
+            e = q + 12 + info
+            while e < end:
+                es_pid = (data[e + 1] & 0x1F) << 8 | data[e + 2]
+                if es_pid == pid:
+                    data[e] = CODING_IG
+                e += 5 + ((data[e + 3] & 0x0F) << 8 | data[e + 4])
+            data[end:end + 4] = crc32(bytes(data[q:end])).to_bytes(4, "big")
+        f.seek(0)
+        f.write(data)
+
+
+def crc32(data):
+    """MPEG-2 section CRC (polynomial 0x04C11DB7, no reflection)."""
+    crc = 0xFFFFFFFF
+    for b in data:
+        crc ^= b << 24
+        for _ in range(8):
+            crc = ((crc << 1) ^ 0x04C11DB7) & 0xFFFFFFFF if crc & 0x80000000 else \
+                (crc << 1) & 0xFFFFFFFF
+    return crc

bdmvkit/m2ts.py

@@ -0,0 +1,78 @@
+"""Reading a BDAV transport stream (.m2ts) back: where its key frames are
+and the span of its pictures, for the clip information and chapter marks."""
+
+import dataclasses
+
+from .errors import BdmvError
+from .formats import VIDEO_PID
+
+
+@dataclasses.dataclass
+class ClipScan:
+    packets: int          # 192-byte source packets
+    first_pts: int        # 90 kHz, first picture shown
+    end_pts: int          # 90 kHz, end of the last picture
+    pcr_pid: int
+    entries: list         # [(pts, spn, size in bytes)] of the key frames, in order
+
+
+def _pts(b, i):
+    return (((b[i] >> 1) & 7) << 30 | b[i + 1] << 22 | (b[i + 2] >> 1) << 15 |
+            b[i + 3] << 7 | b[i + 4] >> 1)
+
+
+def scan_m2ts(path, video_pid=VIDEO_PID):
+    """Where the key frames of a .m2ts are (for the entry-point map) and the
+    span of its pictures. Every picture is one PES packet (ffmpeg); key
+    frames carry the random-access flag."""
+    entries = []
+    pts_all = []
+    pcr_pid = None
+    spn = 0
+    with open(path, "rb") as f:
+        while True:
+            buf = f.read(192 * 8192)
+            if not buf:
+                break
+            if len(buf) % 192:
+                raise BdmvError(f"{path} is not a BDAV stream (length is not 192 × n)")
+            for off in range(0, len(buf), 192):
+                p = off + 4
+                b1 = buf[p + 1]
+                if not b1 & 0x40:
+                    continue
+                if buf[p] != 0x47:
+                    raise BdmvError(f"{path}: lost sync at packet {spn + off // 192}")
+                pid = (b1 & 0x1F) << 8 | buf[p + 2]
+                if pid != video_pid:
+                    continue
+                afc = buf[p + 3] >> 4 & 3
+                q = p + 4
+                rai = False
+                if afc & 2:
+                    alen = buf[q]
+                    if alen:
+                        rai = bool(buf[q + 1] & 0x40)
+                        if buf[q + 1] & 0x10:
+                            pcr_pid = pid
+                    q += 1 + alen
+                # (a PES header must start in this packet with its PTS: 14 bytes)
+                if not afc & 1 or q + 14 > p + 188 or buf[q:q + 3] != b"\0\0\1" \
+                        or not buf[q + 7] & 0x80:
+                    continue
+                pts = _pts(buf, q + 9)
+                n = spn + off // 192
+                if entries and entries[-1][2] is None:
+                    entries[-1][2] = (n - entries[-1][1]) * 192
+                pts_all.append(pts)
+                if rai:
+                    entries.append([pts, n, None])
+            spn += len(buf) // 192
+    if not pts_all or not entries:
+        raise BdmvError(f"{path}: no pictures with key frames found")
+    if entries[-1][2] is None:
+        entries[-1][2] = (spn - entries[-1][1]) * 192
+    ordered = sorted(pts_all)
+    step = ordered[1] - ordered[0] if len(ordered) > 1 else 3003
+    return ClipScan(spn, ordered[0], ordered[-1] + step, pcr_pid or video_pid,
+                    [tuple(e) for e in entries])