dvdcc 0.1.0__py3-none-any.whl

dvdcc/__init__.py

@@ -0,0 +1,10 @@
+"""dvdcc: line-21 closed captions (CEA-608, CC1) for DVD-Video.
+
+Captions come from a Scenarist (.scc) file, used as it is, or from subtitles
+(SubRip, WebVTT, ASS / SSA, text scripts) sent as pop-on captions, and go
+into an MPEG-2 video elementary stream as the DVD's GOP user data ("CC"),
+in place, without re-encoding. Author the disc with the titleset marked as
+having line-21 captions (dvdauthor: <video caption="field1"/>).
+"""
+
+__version__ = "0.1.0"

dvdcc/__main__.py

@@ -0,0 +1,52 @@
+"""Command line: `dvdcc VIDEO.m2v CAPTIONS [-o OUT] [--offset T] [--top]`."""
+
+import argparse
+import shutil
+import sys
+
+from . import __version__, captions
+from .errors import CaptionError
+from .subtitles import timecode_seconds
+
+
+def _offset(value):
+    try:
+        return float(value)
+    except ValueError:
+        return timecode_seconds(value)
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser(
+        prog="dvdcc", description="Put line-21 closed captions (CEA-608, CC1) into the MPEG-2 "
+        "video of a DVD (29.97 fps NTSC), without re-encoding it.")
+    p.add_argument("--version", action="version", version=f"dvdcc {__version__}")
+    p.add_argument("video", help="an MPEG-2 video elementary stream (.m2v)")
+    p.add_argument("captions", help="a Scenarist .scc file, or subtitles: .srt, .vtt, .ass, "
+                                    ".txt (text script)")
+    p.add_argument("-o", "--output", help="write here (default: change the video in place)")
+    p.add_argument("--offset", type=_offset, default=0.0,
+                   help="taken off every time: seconds, or a timecode such as 01;00;00;00")
+    p.add_argument("--top", action="store_true", help="subtitles' captions at the top")
+    args = p.parse_args(argv)
+    try:
+        schedule, notes = captions.load(args.captions, args.offset,
+                                        "top" if args.top else "bottom")
+        target = args.output or args.video
+        if args.output:
+            shutil.copyfile(args.video, args.output)
+        frames = captions.inject_file(target, schedule)
+    except (CaptionError, ValueError) as e:
+        print(f"dvdcc: {getattr(e, 'message', e)}", file=sys.stderr)
+        return 1
+    except OSError as e:
+        print(f"dvdcc: {e.filename}: {e.strerror}", file=sys.stderr)
+        return 1
+    for n in notes:
+        print(f"dvdcc: note: {n}", file=sys.stderr)
+    print(f"{target}: captions over {frames} frames")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

dvdcc/captions.py

@@ -0,0 +1,272 @@
+"""Closed captions (line 21, CEA-608) on a DVD.
+
+A DVD carries line-21 captions in its MPEG-2 video: user data after every
+GOP header, "CC", then one caption word pair per frame of the GOP (in
+display order) for each field. A caption decoder in the player or TV turns
+them back into text. They come from
+
+* a Scenarist (.scc) file: CEA-608 byte pairs with the timecode they start
+  at, as caption tools write them, used as they are; or
+* subtitles (SubRip, WebVTT, ...): each one sent as a "pop-on" caption: the
+  text is loaded into the hidden memory before its time, shown at its start
+  (end of caption) and erased at its end.
+
+Captions are NTSC only (line 21 of a 525-line picture), on 29.97 fps
+video, field 1 (CC1).
+"""
+
+import mmap
+import os
+import re
+
+from . import subtitles
+from .errors import CaptionError
+
+FPS = 30000 / 1001
+COLUMNS = 32
+FILLER = (0x80, 0x80)          # no data (two nulls with odd parity)
+
+# preamble address code, first and second byte base, for rows 1..15
+_PAC_ROWS = {1: (0x11, 0x40), 2: (0x11, 0x60), 3: (0x12, 0x40), 4: (0x12, 0x60),
+             5: (0x15, 0x40), 6: (0x15, 0x60), 7: (0x16, 0x40), 8: (0x16, 0x60),
+             9: (0x17, 0x40), 10: (0x17, 0x60), 11: (0x10, 0x40), 12: (0x13, 0x40),
+             13: (0x13, 0x60), 14: (0x14, 0x40), 15: (0x14, 0x60)}
+# the basic character set is ASCII but for these
+_SPECIAL = {"á": 0x2A, "é": 0x5C, "í": 0x5E, "ó": 0x5F, "ú": 0x60, "ç": 0x7B, "÷": 0x7C,
+            "Ñ": 0x7D, "ñ": 0x7E, "█": 0x7F}
+_NOT_BASIC = set("*\\^_`{|}~")
+
+
+def parity(b):
+    """The byte with its odd-parity bit (bit 7)."""
+    b &= 0x7F
+    return b | 0x80 if bin(b).count("1") % 2 == 0 else b
+
+
+def pair(a, b):
+    return parity(a), parity(b)
+
+
+# CC1 control codes (first byte 0x14, field 1, data channel 1), with parity
+RCL, EDM, ENM, EOC = (pair(0x14, x) for x in (0x20, 0x2C, 0x2E, 0x2F))
+
+
+def pac(row, column=0):
+    """Preamble address code: row 1..15, white, indented to `column` (a
+    multiple of 4; the rest is padding with spaces)."""
+    first, base = _PAC_ROWS[row]
+    return pair(first, base + 0x10 + (column // 4) * 2 if column >= 4 else base)
+
+
+def text_pairs(text):
+    """Characters of one caption row as byte pairs; what the basic set has
+    no character for becomes a space. Returns (pairs, characters dropped)."""
+    codes, dropped = [], 0
+    for ch in text:
+        if ch in _SPECIAL:
+            codes.append(_SPECIAL[ch])
+        elif " " <= ch <= "~" and ch not in _NOT_BASIC:
+            codes.append(ord(ch))
+        else:
+            codes.append(0x20)
+            dropped += 1
+    if len(codes) % 2:
+        codes.append(0x00)
+    return [pair(a, b) for a, b in zip(codes[0::2], codes[1::2])], dropped
+
+
+def wrap(lines):
+    """Caption rows of at most 32 characters (words wrapped), at most 4."""
+    rows = []
+    for line in lines:
+        words, cur = line.split(), ""
+        for w in words:
+            while len(w) > COLUMNS:
+                if cur:
+                    rows.append(cur)
+                    cur = ""
+                rows.append(w[:COLUMNS])
+                w = w[COLUMNS:]
+            if not cur:
+                cur = w
+            elif len(cur) + 1 + len(w) <= COLUMNS:
+                cur += " " + w
+            else:
+                rows.append(cur)
+                cur = w
+        if cur:
+            rows.append(cur)
+    return rows[:4]
+
+
+def frame_of(t):
+    return int(round(t * FPS))
+
+
+class Schedule:
+    """Caption word pairs per frame (field 1)."""
+
+    def __init__(self):
+        self.frames = {}
+
+    def free(self, f):
+        return f not in self.frames
+
+    def put(self, f, p):
+        self.frames[f] = p
+
+    def put_from(self, f, pairs):
+        """Put pairs on the free frames from `f` on; returns the last frame used."""
+        last = f
+        for p in pairs:
+            while not self.free(f):
+                f += 1
+            self.put(f, p)
+            last, f = f, f + 1
+        return last
+
+    def pairs(self, count):
+        return [self.frames.get(f, FILLER) for f in range(count)]
+
+
+def from_cues(cues, position="bottom"):
+    """A Schedule from subtitles: one pop-on caption each. Returns
+    (schedule, notes)."""
+    s = Schedule()
+    notes = []
+    dropped = 0
+    shown_until = -1            # the frame the last caption was shown at (its EOC)
+    last_end = None
+    for c in cues:
+        rows = wrap(c.lines)
+        if not rows:
+            continue
+        load = [RCL, RCL, ENM, ENM]
+        top = (c.position or position) == "top"
+        first_row = 2 if top else 16 - len(rows)
+        for k, row in enumerate(rows):
+            col = (COLUMNS - len(row)) // 2
+            p = pac(first_row + k, col)
+            chars, d = text_pairs(" " * (col % 4) + row)
+            dropped += d
+            load += [p, p] + chars
+        start, end = frame_of(c.start), frame_of(c.end)
+        # load into the hidden memory after the previous caption went up
+        # (its EOC swaps the memories), ending just before this one's start
+        first = max(shown_until + 2, start - len(load) - 2)
+        loaded = s.put_from(first, load)
+        show = max(start, loaded + 1)
+        if show > start + 2:
+            notes.append(f"a caption at {c.start:.2f}s is {(show - start) / FPS:.2f}s late "
+                         "(too much text since the previous one)")
+        if last_end is not None and last_end < show:
+            s.put_from(last_end, [EDM, EDM])       # the previous one goes at its end
+        shown_until = s.put_from(show, [EOC, EOC])
+        last_end = max(end, shown_until + 1)
+    if last_end is not None:
+        s.put_from(last_end, [EDM, EDM])
+    if dropped:
+        notes.append(f"{dropped} character(s) have no closed-caption character and became spaces")
+    return s, notes
+
+
+_SCC_LINE = re.compile(r"^(\d{1,2}[:;]\d{2}[:;]\d{2}[:;.]\d{2})\s+((?:[0-9a-fA-F]{4}\s*)+)$")
+
+
+def parse_scc(text):
+    """A Scenarist caption file -> Schedule (its byte pairs as they are,
+    from the frame of their timecode on)."""
+    lines = [line.strip() for line in text.splitlines() if line.strip()]
+    if not lines or not lines[0].startswith("Scenarist_SCC"):
+        raise ValueError("not a Scenarist caption file (no Scenarist_SCC header)")
+    s = Schedule()
+    for n, line in enumerate(lines[1:], 2):
+        m = _SCC_LINE.match(line)
+        if not m:
+            raise ValueError(f"line {n}: expected a timecode and byte pairs")
+        tc = m[1].replace(".", ";")
+        try:
+            f = frame_of(subtitles.timecode_seconds(tc, "NTSC"))
+        except ValueError as e:
+            raise ValueError(f"line {n}: {e}")
+        words = m[2].split()
+        s.put_from(f, [(int(w[:2], 16), int(w[2:], 16)) for w in words])
+    return s
+
+
+def load(path, offset=0.0, position="bottom", standard="NTSC"):
+    """Captions of a file: .scc as they are, anything else as subtitles.
+    `offset` (seconds) is taken off every time. Returns (schedule, notes)."""
+    if path.lower().endswith(".scc"):
+        with open(path, encoding="utf-8-sig", errors="replace") as f:
+            try:
+                s = parse_scc(f.read())
+            except ValueError as e:
+                raise CaptionError(f"{path}: {e}")
+        if offset:
+            shift = frame_of(offset)
+            s.frames = {f - shift: p for f, p in s.frames.items() if f >= shift}
+        return s, []
+    cues = subtitles.shifted(subtitles.load_subtitles(path, standard), offset)
+    return from_cues(cues, position)
+
+
+# -- the MPEG-2 video stream ------------------------------------------------------
+
+def gop_sizes(b):
+    """Pictures in each GOP of an MPEG-2 elementary stream, in order."""
+    sizes, i = [], 0
+    while True:
+        i = b.find(b"\x00\x00\x01", i)
+        if i < 0 or i + 4 > len(b):
+            break
+        code = b[i + 3]
+        if code == 0xB8:
+            sizes.append(0)
+        elif code == 0x00 and sizes:
+            sizes[-1] += 1
+        i += 4
+    return sizes
+
+
+def user_data(pairs):
+    """The DVD caption user data for a GOP: its frames' word pairs (field 1,
+    with field 2 empty), odd field first."""
+    n = len(pairs)
+    if n > 31:
+        raise ValueError("a GOP of more than 31 pictures cannot carry DVD captions")
+    out = bytearray(b"\x00\x00\x01\xb2CC\x01\xf8")
+    out.append(0x80 | (n << 1))
+    for a, b in pairs:
+        out += bytes([0xFF, a, b, 0xFE, 0x80, 0x80])
+    return bytes(out)
+
+
+def inject_file(path, schedule):
+    """Write the captions into an MPEG-2 elementary stream (in place): after
+    each GOP header, the user data for that GOP's frames. Returns the number
+    of frames."""
+    with open(path, "rb") as f:
+        mm = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ)
+        try:
+            sizes = gop_sizes(mm)
+            frames = schedule.pairs(sum(sizes))
+            tmp = path + ".cc"
+            with open(tmp, "wb") as out:
+                pos = i = 0
+                k = frame = 0
+                while True:
+                    i = mm.find(b"\x00\x00\x01\xb8", i)
+                    if i < 0:
+                        break
+                    head = i + 8                  # start code and the 4 header bytes
+                    out.write(mm[pos:head])
+                    out.write(user_data(frames[frame:frame + sizes[k]]))
+                    frame += sizes[k]
+                    k += 1
+                    pos = i = head
+                out.write(mm[pos:])
+        finally:
+            mm.close()
+    os.replace(tmp, path)
+    return frame

dvdcc/errors.py

@@ -0,0 +1,9 @@
+"""The one exception dvdcc raises."""
+
+
+class CaptionError(Exception):
+    """A caption or subtitle file cannot be used as it is."""
+
+    def __init__(self, message):
+        super().__init__(message)
+        self.message = message

dvdcc/subtitles.py

@@ -0,0 +1,281 @@
+"""Subtitle files read as cues: SubRip, WebVTT, ASS / SSA and text scripts
+(number, start and end timecode, text), with drop-frame and non-drop
+timecodes."""
+
+import dataclasses
+import os
+import re
+from dataclasses import dataclass
+
+from .errors import CaptionError
+
+_TIME = re.compile(r"(\d+):(\d{1,2}):(\d{1,2})[,.](\d{1,3})")
+_TAG = re.compile(r"</?[a-zA-Z][^>]*>|\{\\[^}]*\}")
+
+
+@dataclass
+class Cue:
+    start: float
+    end: float
+    lines: list
+    position: str = None   # "top" | "bottom" | None (the track's / default)
+    color: str = None      # "#RRGGBB" fill colour from the cue itself, or None
+    style_color: str = None  # the subtitle file's style colour (after the track's)
+    image: str = None      # an image script's picture (absolute path): no text
+
+
+_AN = re.compile(r"\\an?(\d)")
+_ASS_COLOR = re.compile(r"\\1?c&H([0-9A-Fa-f]{2,8})&?")
+_FONT_COLOR = re.compile(r'<font[^>]*color\s*=\s*"?#?([0-9A-Fa-f]{6})"?', re.I)
+
+
+def _style_of(text):
+    r"""(position, colour) from override tags in a cue's text: ASS-style {\an8}
+    (also common in SRT) and {\c&HBBGGRR&}, or SRT <font color="#RRGGBB">."""
+    pos = color = None
+    for block in re.findall(r"\{([^}]*)\}", text):
+        m = _AN.search(block)
+        if m:
+            n = int(m.group(1))
+            # \an7-9 = top (numpad layout); the legacy \a5-7,9-11 also mean top
+            pos = "top" if (n in (7, 8, 9) if "an" in block else n >= 5) else "bottom"
+        m = _ASS_COLOR.search(block)
+        if m:
+            bgr = m.group(1)[-6:].rjust(6, "0")
+            color = "#" + (bgr[4:6] + bgr[2:4] + bgr[0:2]).upper()
+    m = _FONT_COLOR.search(text)
+    if m:
+        color = "#" + m.group(1).upper()
+    return pos, color
+
+def _t(m):
+    h, mi, s, ms = m.groups()
+    return int(h) * 3600 + int(mi) * 60 + int(s) + int(ms.ljust(3, "0")) / 1000
+
+
+def parse_srt(text, vtt=False):
+    """Parse SubRip (or, with vtt=True, WebVTT) text into a sorted list of
+    non-overlapping Cues."""
+    text = text.lstrip("\ufeff").replace("\r\n", "\n").replace("\r", "\n")
+    if vtt:
+        text = _VTT_TIME.sub(lambda m: "00:" + m.group(0), text)   # MM:SS.mmm -> H:MM:SS.mmm
+    cues = []
+    for block in re.split(r"\n\s*\n", text.strip()):
+        lines = block.split("\n")
+        idx = next((i for i, l in enumerate(lines) if "-->" in l), None)
+        if idx is None:
+            continue
+        times = _TIME.findall(lines[idx])
+        if len(times) < 2:
+            raise ValueError(f"bad SRT timing line: {lines[idx]!r}")
+        start = _t(_TIME.match(":".join(times[0][:3]) + "," + times[0][3]))
+        end = _t(_TIME.match(":".join(times[1][:3]) + "," + times[1][3]))
+        raw_body = lines[idx + 1:]
+        pos, color = _style_of("\n".join(raw_body))
+        if pos is None and vtt:
+            m = re.search(r"\bline:(-?\d+(?:\.\d+)?)(%?)", lines[idx])
+            if m:
+                v = float(m.group(1))
+                pos = "top" if (0 <= v < 50 if m.group(2) else 0 <= v < 6) else "bottom"
+        body = [_TAG.sub("", l).strip() for l in raw_body]
+        body = [l for l in body if l]
+        if body and end > start:
+            cues.append(Cue(start, end, body, pos, color))
+    return _tidy(cues)
+
+
+def _tidy(cues):
+    cues.sort(key=lambda c: c.start)
+    # a subpicture stream shows one image at a time: clip overlaps
+    for a, b in zip(cues, cues[1:]):
+        if a.end > b.start:
+            a.end = b.start
+    return [c for c in cues if c.end - c.start >= 0.04]
+
+
+_VTT_TIME = re.compile(r"(?<![\d:])\d{1,2}:\d{2}\.\d{3}")
+
+
+def parse_vtt(text):
+    if not text.lstrip("\ufeff").startswith("WEBVTT"):
+        raise ValueError("not a WebVTT file (no WEBVTT header)")
+    blocks = re.split(r"\n\s*\n", text.replace("\r\n", "\n").replace("\r", "\n"))
+    keep = [b for b in blocks if "-->" in b]          # drop header, NOTE and STYLE blocks
+    return parse_srt("\n\n".join(keep), vtt=True)
+
+
+def parse_ass(text):
+    """Dialogue lines of an ASS / SSA script (styles: alignment and colour)."""
+    text = text.lstrip("\ufeff").replace("\r\n", "\n").replace("\r", "\n")
+    styles, fmt, sfmt, cues = {}, None, None, []
+    section = ""
+    for line in text.split("\n"):
+        line = line.strip()
+        if line.startswith("["):
+            section = line.lower()
+            continue
+        key, _, val = line.partition(":")
+        if "styles" in section and key == "Format":
+            sfmt = [x.strip().lower() for x in val.split(",")]
+        elif "styles" in section and key == "Style" and sfmt:
+            f = dict(zip(sfmt, [x.strip() for x in val.split(",", len(sfmt) - 1)]))
+            align = int(f.get("alignment", "2") or 2)
+            colour = f.get("primarycolour", "")
+            styles[f.get("name", "")] = (
+                "top" if align in (7, 8, 9) else None,
+                _style_of("{\\c" + colour + "&}")[1] if colour.startswith("&H") else None)
+        elif "events" in section and key == "Format":
+            fmt = [x.strip().lower() for x in val.split(",")]
+        elif "events" in section and key == "Dialogue" and fmt:
+            f = dict(zip(fmt, [x.strip() for x in val.split(",", len(fmt) - 1)]))
+            try:
+                start = _t(_TIME.match(f["start"].replace(".", ",") + "0"))
+                end = _t(_TIME.match(f["end"].replace(".", ",") + "0"))
+            except (KeyError, AttributeError):
+                raise ValueError(f"bad ASS dialogue line: {line[:60]!r}")
+            raw = f.get("text", "")
+            spos, scol = styles.get(f.get("style", ""), (None, None))
+            pos, color = _style_of(raw)
+            body = re.sub(r"\{[^}]*\}", "", raw).replace("\\h", " ")
+            body = [l.strip() for l in re.split(r"\\[Nn]", body) if l.strip()]
+            if body and end > start:
+                cues.append(Cue(start, end, body, pos or spos, color, scol))
+    if fmt is None:
+        raise ValueError("no [Events] Format line: not an ASS / SSA script")
+    return _tidy(cues)
+
+
+# -- text scripts ---------------------------------------------------------------
+# The plain subtitle script of disc authoring tools: a number, the start and
+# end timecode, the text; lines after it (up to the next numbered line) are
+# more lines of the same subtitle. Spaces or tabs between the fields.
+#   1 00;00;02;02 00;00;03;15 The cat never came back.
+#   She just walked away.
+# Timecode: hh;mm;ss;ff is NTSC drop frame; hh:mm:ss:ff counts frames of 30
+# (NTSC, non drop frame) or 25 (PAL); leading zeros may be left out. A time
+# hh:mm:ss,mmm (or .mmm) is read too.
+_TC = TIMECODE = re.compile(r"^(\d{1,2})([:;])(\d{1,2})([:;])(\d{1,2})([:;.,])(\d{1,3})$")
+_SCRIPT_LINE = re.compile(r"^\s*(\d+)[ \t]+(\S+)[ \t]+(\S+)(?:[ \t]+(.*))?$")
+# an image script: the same lines with a picture file instead of the text
+#   1 00;00;02;02 00;00;03;15 sub0001.png
+IMAGE_FILE = re.compile(r"\.(png|bmp|tiff?|jpe?g|webp)$", re.I)
+
+
+def timecode_seconds(tc, standard="NTSC"):
+    """Seconds from a timecode of the disc's `standard`."""
+    m = _TC.match(str(tc).strip())
+    if not m:
+        raise ValueError(f"{tc!r} is not a timecode (hh;mm;ss;ff or hh:mm:ss:ff)")
+    h, mi, s, last, f = int(m[1]), int(m[3]), int(m[5]), m[6], m[7]
+    if mi > 59 or s > 59:
+        raise ValueError(f"{tc!r}: minutes and seconds go to 59")
+    if last in ".,":
+        return h * 3600 + mi * 60 + s + int(f.ljust(3, "0")) / 1000
+    f = int(f)
+    drop = ";" in (m[2], m[4], last)
+    base = 30 if drop or standard == "NTSC" else 25
+    if f >= base:
+        raise ValueError(f"{tc!r}: frame {f} of {base}")
+    frames = (h * 3600 + mi * 60 + s) * base + f
+    if drop:
+        # two frame numbers are left out every minute, except every tenth
+        minutes = h * 60 + mi
+        frames -= 2 * (minutes - minutes // 10)
+    return frames * 1001 / 30000 if base == 30 else frames / 25
+
+
+def seconds_timecode(t, standard="NTSC"):
+    """The timecode of a moment: drop frame on NTSC (;), frames of 25 on PAL (:)."""
+    if standard != "NTSC":
+        frames = int(round(t * 25))
+        f, s = frames % 25, frames // 25
+        return f"{s // 3600:02d}:{s // 60 % 60:02d}:{s % 60:02d}:{f:02d}"
+    frames = int(round(t * 30000 / 1001))
+    # (drop frame: 17982 frames per ten minutes, 1798 in each but the first minute)
+    tens, rest = divmod(frames, 17982)
+    frames += 18 * tens + (2 * ((rest - 2) // 1798) if rest > 1 else 0)
+    f, s = frames % 30, frames // 30
+    return f"{s // 3600:02d};{s // 60 % 60:02d};{s % 60:02d};{f:02d}"
+
+
+def parse_text_script(text, standard="NTSC", base=None):
+    """Cues of a text script. With `base` (the script's folder), a subtitle
+    whose text is just a picture file's name (relative to it) is that
+    picture: an image script."""
+    cues, cur = [], None
+    for n, raw in enumerate(text.splitlines(), 1):
+        line = raw.strip()
+        m = _SCRIPT_LINE.match(line)
+        if m and _TC.match(m[2]) and _TC.match(m[3]):
+            try:
+                start, end = timecode_seconds(m[2], standard), timecode_seconds(m[3], standard)
+            except ValueError as e:
+                raise ValueError(f"line {n}: {e}")
+            if end <= start:
+                raise ValueError(f"line {n}: subtitle {m[1]} ends before it starts")
+            cur = Cue(start, end, [m[4].strip()] if m[4] and m[4].strip() else [])
+            cues.append(cur)
+        elif line and cur is not None:
+            cur.lines.append(line)
+        elif line:
+            raise ValueError(f"line {n}: expected \"number start end text\", got {line[:40]!r}")
+    if not cues:
+        raise ValueError("no subtitles (lines of number, start and end timecode, text)")
+    if base is not None:
+        for n, c in enumerate(cues, 1):
+            if len(c.lines) == 1 and IMAGE_FILE.search(c.lines[0]):
+                path = os.path.normpath(os.path.join(base, c.lines[0]))
+                if not os.path.isfile(path):
+                    raise ValueError(f"subtitle {n}: picture {c.lines[0]!r} not found next to "
+                                     "the script")
+                c.image, c.lines = path, []
+    return _tidy([c for c in cues if c.lines or c.image])
+
+
+def to_text_script(cues, standard="NTSC"):
+    """Cues -> a text script (no positions or colours: a script has none)."""
+    out = []
+    for n, c in enumerate(cues, 1):
+        # (a picture: its file name, as an image script has it)
+        lines = [os.path.basename(c.image)] if c.image else list(c.lines) or [""]
+        out.append(f"{n}\t{seconds_timecode(c.start, standard)}\t"
+                   f"{seconds_timecode(c.end, standard)}\t{lines[0]}")
+        out += lines[1:]
+    return "\n".join(out) + "\n"
+
+
+def shifted(cues, offset):
+    """Cues `offset` seconds earlier (a script timed against a source's own
+    timecode, e.g. one starting at 01;00;00;00); what ends before 0 goes."""
+    if not offset:
+        return cues
+    out = []
+    for c in cues:
+        if c.end - offset > 0:
+            out.append(dataclasses.replace(c, start=max(0.0, c.start - offset),
+                                           end=c.end - offset))
+    return out
+
+
+PARSERS = {".srt": parse_srt, ".vtt": parse_vtt, ".ass": parse_ass, ".ssa": parse_ass,
+           ".txt": parse_text_script}
+
+
+def load_subtitles(path, standard="NTSC"):
+    """Cues of a subtitle file (timecodes of a text script are the disc
+    `standard`'s)."""
+    ext = os.path.splitext(path)[1].lower()
+    parse = PARSERS.get(ext, parse_srt)
+    if ext == ".txt":
+        base = os.path.dirname(os.path.abspath(path))
+        parse = lambda text: parse_text_script(text, standard, base)     # noqa: E731
+    with open(path, "rb") as f:
+        raw = f.read()
+    for enc in ("utf-8-sig", "cp932", "latin-1"):
+        try:
+            return parse(raw.decode(enc))
+        except UnicodeDecodeError:
+            continue
+        except ValueError as e:
+            raise CaptionError(f"{path}: {e}")
+    raise CaptionError(f"{path}: cannot decode subtitle file")

dvdcc-0.1.0.dist-info/METADATA

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: dvdcc
+Version: 0.1.0
+Summary: Line-21 (CEA-608) closed captions for DVD-Video: Scenarist SCC or subtitles into MPEG-2 GOP user data
+Author: kajisho5
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/kajisho5/dvdcc
+Keywords: closed captions,cea-608,line 21,dvd,scc,mpeg-2
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Multimedia :: Video
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Dynamic: license-file
+
+<p><img src="docs/images/logo/lockup-dark.svg" alt="dvdcc" height="56"></p>
+
+# dvdcc
+
+Put **line-21 closed captions** (CEA-608, CC1) into the MPEG-2 video of a
+**DVD**, without re-encoding it. Pure Python, no dependencies.
+
+* **From a Scenarist (.scc) file:** the byte pairs caption tools write are
+  used as they are, from the frame of their timecode.
+* **From subtitles** (SubRip, WebVTT, ASS / SSA, text scripts): each is sent as
+  a pop-on caption.
+  * It is loaded into the hidden memory before its time, shown at its start,
+    and erased at its end.
+  * Long lines are wrapped to 32 columns and 4 rows.
+  * A caption with too much text to load in time is shown late, with a note.
+* **Into the video:** the captions go into the stream as the DVD's GOP user
+  data (`00 00 01 B2 'C' 'C' 01 F8`), one word pair per frame. This is the
+  data a DVD player sends to line 21.
+
+日本語の説明は [README.ja.md](README.ja.md) にあります。
+
+## Why
+
+Plenty of tools read DVD captions back, but very few put them in. ffmpeg
+cannot embed .scc files. The open caption libraries that write CEA-608
+target H.264 and HEVC (A/53 SEI), not the DVD's MPEG-2 user data.
+
+## Install
+
+```sh
+pip install dvdcc
+```
+
+A release is made by the version: when the version in `pyproject.toml`
+(and `dvdcc/__init__.py`) reaches `main` without a tag of its own,
+`.github/workflows/release.yml` runs the tests, builds the package, makes
+the GitHub release with its tag and publishes to PyPI (trusted publishing,
+environment `pypi`). Merging the version bump is all it takes.
+
+## Use
+
+```sh
+dvdcc video.m2v captions.scc              # in place
+dvdcc video.m2v subs.srt -o captioned.m2v --offset 01;00;00;00
+```
+
+```python
+from dvdcc import captions
+
+schedule, notes = captions.load("subs.srt")      # or a .scc
+frames = captions.inject_file("video.m2v", schedule)
+```
+
+Then mux and author the disc as usual. Tell the authoring tool that the
+titleset has line-21 captions, so players that look find them. With
+dvdauthor, that is `<video ... caption="field1"/>`.
+
+**Limits:**
+
+* NTSC only, since line 21 belongs to the 525-line picture.
+* 29.97 frames per second. Film with soft 3:2 pulldown counts its fields
+  differently, so it is not supported.
+* Field 1 (CC1) only.
+
+## Tests
+
+```sh
+python -m unittest discover -s tests -t .
+```
+
+The tests cover:
+
+* the caption bytes: parity, preamble address codes, the character set;
+* pop-on timing and Scenarist parsing;
+* the user data layout;
+* with ffmpeg, captions put into a test video that **ffmpeg's own caption
+  decoder** (lavfi `subcc`) reads back as the text at the right times;
+* with dvdauthor as well, a whole authored disc whose VOB decodes to the
+  captions and whose IFO marks line-21 captions.
+
+dvdcc was first written for [oncemore](https://github.com/kajisho5/oncemore),
+a DVD and Blu-ray authoring app.
+
+## Support
+
+dvdcc is free and stays free. If it saves you time, you can support its
+development through [GitHub Sponsors](https://github.com/sponsors/kajisho5)
+(the **Sponsor** button at the top of this repository). Bug reports help just
+as much: [Issues](https://github.com/kajisho5/dvdcc/issues).
+
+The logo, colours and writing rules: [docs/DESIGN.md](docs/DESIGN.md).
+
+## License
+
+Apache License 2.0. See [LICENSE](LICENSE) and [NOTICE](NOTICE).

dvdcc-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+dvdcc/__init__.py,sha256=hlINlBSpyM1aPbxEAoYlt_OkNZTIXeYj2Ckn9kiq27Y,456
+dvdcc/__main__.py,sha256=qcK6EMjC7yWTXGmTL2ogaxNrxdWC9ceg7xEm6yPGaLU,1999
+dvdcc/captions.py,sha256=ThgZ0nOCwlHbZIv7OMUaLg-fswB9bHCwobMcRTGi9eQ,9489
+dvdcc/errors.py,sha256=-zokiF5x2nIAx4_1vLd6nwx9ojD9d1uAgpVd4KRn_s8,232
+dvdcc/subtitles.py,sha256=hzvrwM7lZyNK_e_leNxTiTUrRA0ulf5p6yvvQG24Ssc,11971
+dvdcc-0.1.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+dvdcc-0.1.0.dist-info/licenses/NOTICE,sha256=XiU9Vmb1gZrPLzGZVLwlcO40auoXcm63SAbnReOHK6s,155
+dvdcc-0.1.0.dist-info/METADATA,sha256=IC1ZWT9QlQvpWTA_xaWJbw6J2iHUMumgWyGb11GbpvI,3885
+dvdcc-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+dvdcc-0.1.0.dist-info/entry_points.txt,sha256=ac3qc88nNtgvoT0OPOJZyq4GClQY3WlfbCQuPTFkUCE,46
+dvdcc-0.1.0.dist-info/top_level.txt,sha256=zXeEowPx8y7aKaMfSKfY_MJZ1UFSsds2Spfg3XfdeIw,6
+dvdcc-0.1.0.dist-info/RECORD,,

dvdcc-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dvdcc-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dvdcc = dvdcc.__main__:main

dvdcc-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

dvdcc-0.1.0.dist-info/licenses/NOTICE

@@ -0,0 +1,5 @@
+dvdcc
+Copyright 2026 kajisho5
+
+This product was first written as part of oncemore
+(https://github.com/kajisho5/oncemore), a DVD and Blu-ray authoring app.

dvdcc-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dvdcc