ffman 0.1.0__py3-none-any.whl

ffman/__init__.py

@@ -0,0 +1,27 @@
+"""ffman: opinionated media conversion on ffmpeg."""
+
+import tomllib
+from importlib.metadata import PackageNotFoundError, metadata
+from pathlib import Path
+from typing import Final, cast
+
+_ROOT: Final = Path(__file__).parents[2]  # in a source tree: the project, pyproject.toml beside src
+
+
+def about(root: Path = _ROOT) -> tuple[str, str]:
+    """The version and summary: the installed package's metadata, else pyproject.toml's.
+
+    Both come from pyproject.toml; installing writes them into the metadata. A
+    source tree run as is (the equivalence harness: PYTHONPATH=src) has no
+    metadata, and its pyproject.toml is ``root``, beside src.
+    """
+    try:
+        found = metadata("ffman")
+    except PackageNotFoundError:
+        pyproject = tomllib.loads((root / "pyproject.toml").read_text())
+        project = cast("dict[str, str]", pyproject["project"])
+        return project["version"], project["description"]
+    return found["Version"], found["Summary"]
+
+
+__version__, __summary__ = about()

ffman/__main__.py

@@ -0,0 +1,27 @@
+"""ffman's entry: the ``ffman`` command (pyproject's scripts) and ``python -m ffman``.
+
+ffman runs its tools as POSIX does -- process groups, SIGHUP (``media/run.py``) -- so on
+Windows its command line cannot even be imported: the platform is checked first, the command
+line imported after.
+"""
+
+import sys
+from typing import Final
+
+from ffman.errors import PROG
+
+WINDOWS: Final = f"{PROG}: error: ffman runs on Linux and macOS; on Windows, run it in WSL\n"
+
+
+def main() -> int:
+    """The exit status: refused on Windows, else the command line's."""
+    if sys.platform == "win32":
+        _ = sys.stderr.write(WINDOWS)
+        return 1
+    from ffman.cli import main as command_line  # noqa: PLC0415 -- after the check, as above
+
+    return command_line()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

ffman/cli.py

@@ -0,0 +1,176 @@
+"""The command line: the top level, and dispatch to a command."""
+
+import contextlib
+import os
+import signal
+import sys
+from collections.abc import Callable, Sequence
+from typing import Final
+
+from ffman import __summary__, __version__
+from ffman.effects import format_catalogue
+from ffman.errors import PROG, REFUSALS, refuse
+from ffman.jobs.convert.dispatch import convert
+from ffman.jobs.convert.options import validate
+from ffman.jobs.meta.options import validate as validate_meta
+from ffman.jobs.meta.run import run as meta
+from ffman.media.run import SIGNALS, Interrupted, Runner, install_signal_handlers
+from ffman.options import CONVERT, META, format_help, parse
+
+TOP_USAGE: Final = f"{PROG} COMMAND [options]"
+TOP_HELP: Final = f"""Usage: {TOP_USAGE}
+
+{__summary__}
+
+Commands:
+  convert   transform one media file: resize, effects, subtitles, encoding
+  effects   the video effects, their values and what auto means
+  meta      write or edit a metadata file: ffmetadata, Vorbis comments, a cue sheet
+
+Options:
+  -h, --help   show this help
+  --version    show the version
+
+See {PROG} COMMAND --help.
+"""
+
+# The bash commands, refused with their equivalent (D4; docs/ffman-spec.md section 7).
+OLD_COMMANDS: Final = {
+    "resize": f"resize is now: {PROG} convert ... (the same options)",
+    "overlay": f"overlay is now: {PROG} convert -i F --burn-subs S ...",
+    "attach": f"attach is now: {PROG} convert -i F --add-subs S [--language L] (-o O | --in-place)",
+}
+
+
+def run_convert(argv: list[str]) -> int:
+    """``ffman convert``: parse and check its options."""
+    parsed = parse("convert", CONVERT, argv)
+    if parsed.help:
+        print(
+            format_help(
+                f"{PROG} convert -i INPUT [options]",
+                "Transform one media file: resize, effects, subtitles, encoding.",
+                CONVERT,
+            ),
+            end="",
+        )
+        return 0
+    options = validate(parsed)
+    with Runner(dry_run=options.dry_run) as runner:
+        convert(options, runner)
+    return 0
+
+
+def run_meta(argv: list[str]) -> int:
+    """``ffman meta``: a metadata file written or edited (spec 8)."""
+    parsed = parse("meta", META, argv)
+    if parsed.help:
+        usage = f"{PROG} meta [-i INPUT] (-o OUTPUT | -o - | --in-place) [--set K=V ...] [options]"
+        print(
+            format_help(
+                usage,
+                "Write or edit a metadata file: ffmetadata, Vorbis comments, a cue sheet.",
+                META,
+            ),
+            end="",
+        )
+        return 0
+    options = validate_meta(parsed)
+    with Runner(dry_run=options.dry_run) as runner:
+        meta(options, runner)
+    return 0
+
+
+EFFECTS_HELP: Final = f"""Usage: {PROG} effects [video] [NAME]
+
+The effects --vfx takes, in the order they run, with what each value means
+when left out. NAME shows one.
+"""
+
+
+def run_effects(argv: list[str]) -> int:
+    """``ffman effects [video] [NAME]``: the catalogue."""
+    if any(arg in ("-h", "--help") for arg in argv):
+        print(EFFECTS_HELP, end="")
+        return 0
+    words = argv[1:] if argv[:1] == ["video"] else argv
+    if len(words) > 1 or (words and words[0].startswith("-")):
+        refuse(f"effects: unexpected: {' '.join(words)} (see {PROG} effects --help)")
+    print(format_catalogue(words[0] if words else None), end="")
+    return 0
+
+
+COMMANDS: Final[dict[str, Callable[[list[str]], int]]] = {
+    "convert": run_convert,
+    "effects": run_effects,
+    "meta": run_meta,
+}
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """Run ffman with ``argv`` (default: the process arguments); return the exit status."""
+    args = list(sys.argv[1:] if argv is None else argv)
+    previous = {sig: signal.getsignal(sig) for sig in SIGNALS}
+    install_signal_handlers()
+    try:
+        status = _dispatch(args)
+        # A pipe is block-buffered: flush here, where a reader gone is handled,
+        # not at exit, where Python reports it and exits 120 (the docs' recipe).
+        _ = sys.stdout.flush()
+    except Interrupted as stop:  # cleaned up on the way out; silent, as bash was
+        return stop.status
+    except REFUSALS as error:
+        print(f"{PROG}: error: {error}", file=sys.stderr)
+        return 1
+    except BrokenPipeError:  # the reader left (ffman ... | head): quiet, as bash died of SIGPIPE
+        _stdout_to_devnull()
+        return 128 + signal.SIGPIPE
+    except OSError as error:  # the environment: a folder not writable, a disk full
+        print(f"{PROG}: error: {_describe(error)}", file=sys.stderr)
+        return 1
+    else:
+        return status
+    finally:  # an in-process caller keeps its own handlers
+        for sig, handler in previous.items():
+            if handler is not None:
+                _ = signal.signal(sig, handler)
+
+
+def _stdout_to_devnull() -> None:
+    """Point stdout at /dev/null, so the exit's own flush cannot fail again.
+
+    The Python documentation's recipe (signal module, "Note on SIGPIPE"); not
+    SIG_DFL, which would let a signal end ffman mid-job, its ffmpeg orphaned.
+    """
+    # Best effort: a caller's stdout may have no descriptor (io.UnsupportedOperation).
+    with contextlib.suppress(OSError, ValueError):
+        devnull = os.open(os.devnull, os.O_WRONLY)
+        _ = os.dup2(devnull, sys.stdout.fileno())
+
+
+def _describe(error: OSError) -> str:
+    """``strerror: filename``: typeshed's ``filename`` is Any, narrowed to what it holds."""
+    filename: object = error.filename  # pyright: ignore[reportAny] -- typeshed: Any
+    what = error.strerror or str(error)
+    if isinstance(filename, str | bytes):
+        return f"{what}: {os.fsdecode(filename)}"
+    return what
+
+
+def _dispatch(args: list[str]) -> int:
+    if not args:
+        print(f"Usage: {TOP_USAGE}", file=sys.stderr)
+        return 1
+    word, rest = args[0], args[1:]
+    if word in ("-h", "--help"):
+        print(TOP_HELP, end="")
+        return 0
+    if word == "--version":
+        print(f"{PROG} {__version__}")
+        return 0
+    if word in OLD_COMMANDS:
+        refuse(OLD_COMMANDS[word])
+    command = COMMANDS.get(word)
+    if command is None:
+        refuse(f"unknown command: {word} (see {PROG} --help)")
+    return command(rest)

ffman/effects/__init__.py

@@ -0,0 +1,120 @@
+"""The effects registry: what each effect takes, the ``--vfx`` grammar, the catalogue.
+
+A spec is ``NAME[:ARG[,ARG...]]``; an ARG is the main parameter's value (first
+only) or ``KEY=VALUE``. Only the first ``:`` ends the name, only ``,`` separates
+arguments, only the first ``=`` ends a key -- so ``time=23:59:58`` parses. No
+value means auto. The order they run in is their stage's, not the listing's
+(docs/ffman-python.md section 3.3). Ranges and messages are the bash ffman's
+(``fx_validate``), the flag replaced by the spec.
+"""
+
+from types import MappingProxyType
+from typing import Final
+
+from ffman.effects import (
+    blur,
+    camcorder,
+    chromatic_aberration,
+    crt,
+    datamosh,
+    dither,
+    halation,
+    invert,
+    pixelate,
+    vhs,
+)
+from ffman.effects.spec import Effect, Param, Request
+from ffman.errors import refuse
+
+# The registry, in the order the bash ffman listed and ran them
+VIDEO: Final = (
+    blur.EFFECT,
+    pixelate.EFFECT,
+    invert.EFFECT,
+    chromatic_aberration.EFFECT,
+    halation.EFFECT,
+    datamosh.EFFECT,
+    camcorder.EFFECT,
+    vhs.EFFECT,
+    dither.EFFECT,
+    crt.EFFECT,
+)
+_BY_NAME: Final = {effect.name: effect for effect in VIDEO}
+
+
+def parse_spec(spec: str) -> Request:
+    """Parse one ``--vfx`` spec."""
+    name, colon, args = spec.partition(":")
+    effect = _BY_NAME.get(name)
+    if effect is None:
+        refuse(f"--vfx: unknown effect: {name} (see ffman effects)")
+    values: dict[str, str] = {}
+    if colon:
+        for position, arg in enumerate(args.split(",")):
+            key, equals, value = arg.partition("=")
+            if not equals:
+                key, value = _main_param(effect, spec, position), arg
+            _set(effect, values, key, value)
+    return Request(effect, MappingProxyType(values))  # read-only: validated once
+
+
+def parse_specs(specs: list[str]) -> tuple[Request, ...]:
+    """Parse every ``--vfx``; an effect twice is refused."""
+    requests = tuple(parse_spec(spec) for spec in specs)
+    seen: set[str] = set()
+    for request in requests:
+        if request.effect.name in seen:
+            refuse(f"--vfx {request.effect.name} given twice")
+        seen.add(request.effect.name)
+    return requests
+
+
+def _main_param(effect: Effect, spec: str, position: int) -> str:
+    if not effect.params:
+        refuse(f"--vfx {effect.name} takes no value: {spec}")
+    if not effect.positional:
+        keys = ", ".join(f"{p.name}=" for p in effect.params)
+        refuse(f"--vfx {effect.name} takes named values ({keys}): {spec}")
+    if position > 0:
+        refuse(f"--vfx {effect.name}: only the first value may go without a name: {spec}")
+    return effect.params[0].name
+
+
+def _set(effect: Effect, values: dict[str, str], key: str, value: str) -> None:
+    param = next((p for p in effect.params if p.name == key), None)
+    if param is None:
+        known = ", ".join(p.name for p in effect.params) or "none"
+        refuse(f"--vfx {effect.name}: unknown parameter: {key} ({known})")
+    if key in values:
+        refuse(f"--vfx {effect.name}: {key} given twice")
+    if not ((param.auto and value == "auto") or param.check(value)):
+        refuse(f"--vfx {effect.name}: {param.must}: {value}")
+    values[key] = value
+
+
+def format_catalogue(name: str | None = None) -> str:
+    """The catalogue: every video effect in stage order, or the one named."""
+    effects = sorted(VIDEO, key=lambda e: e.stage) if name is None else [_named(name)]
+    lines = (
+        []
+        if name is not None
+        else ["Video effects, in the order they run (--vfx NAME[:VALUE]):", ""]
+    )
+    for effect in effects:
+        lines.append(f"  {effect.name:<22}{effect.about}")
+        lines += [f"  {'':<22}  {_describe(param)}" for param in effect.params]
+    return "\n".join(lines) + "\n"
+
+
+def _describe(param: Param) -> str:
+    """``name: range (auto: meaning)``, the range read from the refusal's own text."""
+    allowed = param.must.removeprefix(f"{param.name} ").removeprefix("must be ")
+    unset = "auto" if param.auto else "left out"
+    return f"{param.name}: {allowed} ({unset}: {param.unset})"
+
+
+def _named(name: str) -> Effect:
+    effect = _BY_NAME.get(name)
+    if effect is None:
+        refuse(f"unknown effect: {name} (see ffman effects)")
+    return effect

ffman/effects/blur.py

@@ -0,0 +1,36 @@
+"""``--vfx blur``: the picture blurred in light, round on screen (decisions.md: Blurs review)."""
+
+from fractions import Fraction
+from typing import Final
+
+from ffman.effects.frame import Frame
+from ffman.effects.spec import Effect, Param, Request, Stage, asked, between
+from ffman.fmt import calc, round_int
+from ffman.graph import Filter, Labels, Open
+from ffman.graph.light import DECODE, ENCODE, curves
+
+EFFECT: Final = Effect(
+    "blur",
+    Stage.PICTURE,
+    "blur the picture, in light (a near-Gaussian)",
+    (
+        Param(
+            "sigma",
+            between(Fraction(0), Fraction(1024), integer=False, low_open=True),
+            "must be auto or a sigma above 0, up to 1024",
+            "1% of the displayed shorter side",
+        ),
+    ),
+)
+
+
+def build(graph: Open, request: Request, frame: Frame, _: Labels) -> Open:
+    """In light, 16-bit RGB; round on screen: sigma across divided by the SAR."""
+    sar = calc(float(frame.sar))
+    across = min(round_int(calc(frame.width * float(sar))), frame.height)
+    sigma = asked(request, "sigma") or calc(across / 100)
+    gblur = Filter(
+        "gblur", (("sigma", calc(float(sigma) / float(sar))), ("sigmaV", sigma), ("steps", "6"))
+    )
+    rgb16 = Filter("format", ("gbrp16le",))
+    return graph.then(rgb16, curves(DECODE, frame.video), gblur, curves(ENCODE, frame.video))

ffman/effects/camcorder.py

@@ -0,0 +1,171 @@
+"""The camcorder's stamp: PLAY, SP, the counter and a running clock, as ASS (bash's cam_prepare).
+
+The clock starts at --date and --time; each left out comes from the file's
+creation time -- as the bash ffman read it: ``date -d`` gave it in *local* time,
+and that wall-clock text was then read as UTC (``date -u -d``); so the stamp
+shows the local time of the recording -- else from now. The text is gawk's
+under LC_ALL=C: English names, whatever the locale.
+"""
+
+import math
+import re
+import time
+from datetime import UTC, datetime
+from fractions import Fraction
+from typing import Final
+
+from ffman.effects.frame import Frame
+from ffman.effects.spec import Effect, Param, Request, Stage
+from ffman.errors import refuse
+from ffman.fmt import calc, round_int
+from ffman.graph import Filter, Labels, Open
+
+_DATE: Final = re.compile(r"([0-9]{4})([-:])([0-9]{2})([-:])([0-9]{2})")
+_TIME: Final = re.compile(r"([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]")
+
+STAMP_FONT: Final = "IBM Plex Mono"  # the Style line's, bold (-1), no override
+STAMP_FILE: Final = "IBMPlexMono-Bold.otf"  # its one weight, which ffman carries (6.7.3)
+
+
+def _real_date(text: str) -> bool:
+    """A real date, one separator throughout; from 0001-01-01 (GNU date also takes 0000)."""
+    match = _DATE.fullmatch(text)
+    if match is None or match[2] != match[4]:
+        return False
+    try:
+        _ = datetime(int(match[1]), int(match[3]), int(match[5]), tzinfo=UTC)  # real, or ValueError
+    except ValueError:
+        return False
+    return True
+
+
+def _is_time(text: str) -> bool:
+    return _TIME.fullmatch(text) is not None
+
+
+EFFECT: Final = Effect(
+    "camcorder",
+    Stage.CAMCORDER,
+    "a camcorder's stamp: PLAY, the counter, SP, a running clock",
+    (
+        Param(
+            "date",
+            _real_date,
+            "date must be a real date, YYYY-MM-DD or YYYY:MM:DD",
+            "the file's creation date, else today",
+            auto=False,
+        ),
+        Param(
+            "time",
+            _is_time,
+            "time must be HH:MM:SS (24-hour)",
+            "the file's creation time, else now",
+            auto=False,
+        ),
+    ),
+    positional=False,
+)
+
+
+def build(graph: Open, _request: Request, frame: Frame, _: Labels) -> Open:
+    """The stamp's script, burned (bash's CAMASS), with its fonts folder."""
+    if frame.camcorder is None:
+        msg = "the camcorder's script must be written first"
+        raise ValueError(msg)
+    stamp = frame.camcorder
+    return graph.then(Filter("ass", (("filename", stamp.script), ("fontsdir", stamp.fonts))))
+
+
+MARGIN: Final = 60  # px from the frame's edges, at 1080 lines
+HEIGHT: Final = 1080  # the script's PlayResY: sizes are in its pixels
+ASS_BREAK: Final = r"\N"  # a hard line break in an ASS event's text
+_MONTHS: Final = (
+    "JAN",
+    "FEB",
+    "MAR",
+    "APR",
+    "MAY",
+    "JUN",
+    "JUL",
+    "AUG",
+    "SEP",
+    "OCT",
+    "NOV",
+    "DEC",
+)
+_HEAD: Final = """[Script Info]
+ScriptType: v4.00+
+PlayResX: {width}
+PlayResY: 1080
+WrapStyle: 2
+ScaledBorderAndShadow: yes
+
+[V4+ Styles]
+Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
+Style: Cam,{font},64,&H00FFFFFF,&H000000FF,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,3,1.5,7,0,0,0,1
+
+[Events]
+Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+"""  # noqa: E501 -- the script's own lines
+
+
+def clock(
+    creation_time: str | None, date: str | None, time_of_day: str | None, now: datetime
+) -> int:
+    """The stamp's first second, as a UTC epoch (bash's ``e``)."""
+    start = _local_wall_clock(creation_time) or now.strftime("%Y-%m-%d %H:%M:%S")
+    day, _, hour = start.partition(" ")
+    wall = f"{(date or day).replace(':', '-')} {time_of_day or hour}"
+    try:
+        return int(datetime.strptime(wall, "%Y-%m-%d %H:%M:%S").replace(tzinfo=UTC).timestamp())
+    except ValueError:
+        refuse("the camcorder clock could not be set")
+
+
+def _local_wall_clock(creation_time: str | None) -> str | None:
+    """``date -d CT '+%Y-%m-%d %H:%M:%S'``: the creation time, in local time; None if unreadable."""
+    if not creation_time:
+        return None
+    try:
+        moment = datetime.fromisoformat(creation_time)
+    except ValueError:
+        return None
+    local = moment.astimezone() if moment.tzinfo else moment
+    return local.strftime("%Y-%m-%d %H:%M:%S")
+
+
+def width(frame_width: int, frame_height: int) -> int:
+    """The script's PlayResX: the frame's shape at 1080 lines (bash's px)."""
+    return round_int(calc(HEIGHT * frame_width / frame_height))
+
+
+def script(epoch: int, duration: Fraction | None, play_width: int) -> str:
+    """The ASS script: the fixed marks for the whole clip, a counter and clock a second."""
+    seconds = float(duration) if duration is not None else 1.0
+    n = max(math.ceil(seconds), 1)
+    m, right, bottom = MARGIN, play_width - MARGIN, HEIGHT - MARGIN
+    lines = [_HEAD.format(width=play_width, font=STAMP_FONT)]
+    lines.append(_event(0, n, rf"{{\an7\pos({m},{m})}}PLAY {{\p1}}m 0 10 l 36 30 0 50{{\p0}}"))
+    lines.append(_event(0, n, rf"{{\an1\pos({m},{bottom})}}SP"))
+    for k in range(n):
+        counter = f"{k // 3600}:{k % 3600 // 60:02d}:{k % 60:02d}"
+        lines.append(_event(k, k + 1, rf"{{\an9\pos({right},{m})}}{counter}"))
+        lines.append(_event(k, k + 1, rf"{{\an3\pos({right},{bottom})}}{_stamp(epoch + k)}"))
+    return "".join(lines)
+
+
+def _event(start: int, end: int, text: str) -> str:
+    return f"Dialogue: 0,{_time(start)},{_time(end)},Cam,,0,0,0,,{text}\n"
+
+
+def _time(s: int) -> str:
+    return f"{s // 3600}:{s % 3600 // 60:02d}:{s % 60:02d}.00"
+
+
+def _stamp(epoch: int) -> str:
+    r"""Gawk's strftime("%I:%M:%S %p", e, 1) \N toupper(strftime("%b. %d %Y", e, 1)), C locale."""
+    t = time.gmtime(epoch)
+    hour = t.tm_hour % 12 or 12
+    noon = "AM" if t.tm_hour < 12 else "PM"  # noqa: PLR2004 -- noon
+    day = f"{_MONTHS[t.tm_mon - 1]}. {t.tm_mday:02d} {t.tm_year}"
+    return f"{hour:02d}:{t.tm_min:02d}:{t.tm_sec:02d} {noon}{ASS_BREAK}{day}"

ffman/effects/chromatic_aberration.py

@@ -0,0 +1,50 @@
+"""``--vfx chromatic-aberration``: red and blue apart, growing to the edges.
+
+decisions.md: Effects review.
+"""
+
+from fractions import Fraction
+from typing import Final
+
+from ffman.effects.frame import Frame
+from ffman.effects.spec import Effect, Param, Request, Stage, asked, between
+from ffman.fmt import calc, round_int
+from ffman.graph import Chain, Filter, Labels, Open
+
+EFFECT: Final = Effect(
+    "chromatic-aberration",
+    Stage.LENS,
+    "lateral chromatic aberration: red and blue apart, growing to the edges",
+    (
+        Param(
+            "px",
+            between(Fraction(1), Fraction(255), integer=True),
+            "must be auto or a shift from 1 to 255 px",
+            "red and blue 1/135 of the shorter side apart at the edges",
+        ),
+    ),
+)
+
+
+def build(graph: Open, request: Request, frame: Frame, labels: Labels) -> Open:
+    """Green and blue scaled up from the centre, red kept: the shift grows to the edges."""
+    w, h = frame.width, frame.height
+    px = asked(request, "px") or str(max((frame.shorter + 67) // 135, 1))
+    k = float(calc(int(px) / w))
+    green, blue, red = (labels.new(n) for n in ("cg", "cb", "cr"))
+    green2, blue2, red2 = (labels.new(n) for n in ("cg2", "cb2", "cr2"))
+    split = graph.then(Filter("format", ("gbrp",)), Filter("extractplanes", ("g+b+r",))).end(
+        (green, blue, red)
+    )
+    shown = "1" if frame.squared else f"{frame.sar.numerator}/{frame.sar.denominator}"
+    sar = Filter("setsar", (shown,))
+
+    def grown(plane: str, by: float, out: str) -> Chain:
+        size = (str(round_int(calc(w * (1 + by * k)))), str(round_int(calc(h * (1 + by * k)))))
+        scaled = Filter("scale", (*size, ("flags", "bicubic")))
+        return Chain((scaled, Filter("crop", (str(w), str(h))), sar), (plane,), (out,))
+
+    planes = (grown(green, 1, green2), grown(blue, 2, blue2), Chain((sar,), (red,), (red2,)))
+    maps = tuple((f"map{i}{part}", str(v)) for i in range(3) for part, v in (("s", i), ("p", 0)))
+    merge = Filter("mergeplanes", (*maps, ("format", "gbrp")))
+    return Open((green2, blue2, red2), (merge,), (*split, *planes))