video-edit-cli 0.1.0__py3-none-any.whl

video_edit_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,68 @@
+Metadata-Version: 2.3
+Name: video-edit-cli
+Version: 0.1.0
+Summary: Headless, project-agnostic video-editing CLI with atomic subcommands for AI agents.
+Keywords: video,editing,ffmpeg,agents,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Multimedia :: Video :: Conversion
+Requires-Dist: jsonschema>=4.21
+Requires-Dist: pyyaml>=6
+Requires-Dist: deepfilternet>=0.5 ; extra == 'df'
+Requires-Dist: mlx-whisper>=0.4 ; extra == 'mlx'
+Requires-Python: >=3.11
+Project-URL: Issues, https://github.com/computerlovetech/video-edit-cli/issues
+Project-URL: Repository, https://github.com/computerlovetech/video-edit-cli
+Provides-Extra: df
+Provides-Extra: mlx
+Description-Content-Type: text/markdown
+
+# video-edit-cli
+
+Headless, project-agnostic video-editing workbench for AI agents. One `video-edit-cli`
+CLI exposes atomic, non-interactive subcommands that inspect and transform media
+deterministically; the agent plans the edit and composes the primitives.
+
+Contract:
+
+- Machine-readable JSON on stdout (one result envelope per command), diagnostics on
+  stderr, meaningful non-zero exit codes on failure.
+- Source media is immutable. Every derived file is new and gets a
+  `*.provenance.json` sidecar recording inputs, hashes, tool versions, parameters,
+  and the exact tool commands.
+- Requires `ffmpeg` and `ffprobe` on PATH; commands fail with the stable error code
+  `missing-binary` when absent.
+
+Install the base CLI with `uv tool install video-edit-cli`. For local Apple Silicon
+transcription, install `uv tool install 'video-edit-cli[mlx]'`. FFmpeg and FFprobe must
+be installed separately and available on `PATH`.
+
+Usage discovery: `video-edit-cli --help` and `--help` on every subcommand. Inside this
+repository, prefix commands with `uv run`.
+
+Example:
+
+```sh
+uv run video-edit-cli workspace init --root /tmp/ep1 --source recording.mp4
+uv run video-edit-cli probe --input recording.mp4
+uv run video-edit-cli filmstrip create --input recording.mp4 \
+  --start 60 --end 90 --output /tmp/ep1/analysis/strip.png --workspace /tmp/ep1
+```
+
+The companion skill in `skills/video-editor/` teaches agents the editing method;
+this package owns the mechanics. Tests generate small deterministic fixtures at
+runtime (`tests/generate_fixtures.py`); no media is committed.
+
+Quality gates (run from this directory):
+
+```sh
+uv run ruff check .
+uv run ruff format --check .
+uv run ty check
+uv run pytest
+```

video_edit_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,37 @@
+video_editor/__init__.py,sha256=dmoIOd3jKxFn9QCPJ0SlTR1xmT7izGb-FCfgSdNC6Lw,122
+video_editor/assets.py,sha256=1gb9h9Hng2snqdYYWLBuozHKn0sU9SkcjsMn-sUmGJU,4776
+video_editor/audio/__init__.py,sha256=NENY7PjW2ZiasL-2N68b7el36mqjBhYsavVtj39VrxU,73
+video_editor/audio/analysis.py,sha256=3j-2hNzcKnyRf3-DrwuclQkYe8ong71YT5ddaLfLGXI,4253
+video_editor/audio/comparison.py,sha256=hbzTS8RIdeqlWpuq1-bn5z-eJNApvkQpKLvfBUGI77E,2352
+video_editor/audio/denoise.py,sha256=ux3LGvqlgGd5GWotrgHxT0cxI40Fb5d9MeBsG2aSapA,2332
+video_editor/audio/mastering.py,sha256=bRSTCQMRfH5K78MKcg8P_u45aW_qD1sInCGVvyUZgEU,2397
+video_editor/cli.py,sha256=J1ncrmDCXVDg5FPnZqsveW_sFUDSoVCvajOs5DRFJe4,37134
+video_editor/errors.py,sha256=I6yiB3FPZZuvjUu84OPQ57cbEjXs6UJMIH8gYkYWZQE,1056
+video_editor/ffmpeg.py,sha256=068UlLvGgPQ_XLwge_v5HN4xFhF0HCSlCYa_S7DERts,1494
+video_editor/inspection.py,sha256=f68kcmGJsEHFvuXW-o83AGyjwe3A2g54e2gtkEwRWB4,4775
+video_editor/media.py,sha256=tczuDXPGFvpVZkFWcQXPtfUCWu9MJ6eKkS2H4FxWQqM,3088
+video_editor/plans.py,sha256=uOjoXwBIRL4z0C6q1x3i4YeR4ruQDp7QqjXMj7tRmX0,3332
+video_editor/profiles.py,sha256=bY-qES_uIJU3HEnyGLnDk0E95hraQmE2pdgR7EK1YNc,2011
+video_editor/provenance.py,sha256=R6OaBycwpvqQtalZGNpEqo4vq-dzSyU_OuS3joAnmmk,1478
+video_editor/reframe.py,sha256=HyR_QLtgZJBEas2wJfBR-yE_PnpLJz-kTdpq6xR3ib0,3582
+video_editor/rendering.py,sha256=Z_o9mDMBiQDcYo7uJl4VcE2HRqpW9Za8iCRW12LoE1M,10655
+video_editor/result.py,sha256=s0QTDO-IYfr6CgugnqA34TyYmbNHwc3jV4GcSyK-zIg,1061
+video_editor/review.py,sha256=oWoJ-T3ng3H-x3VUm0i8_TPTPBEbOZmB82DccymRT1c,5947
+video_editor/schemas/__init__.py,sha256=JWuofAIou2z3z2sPB1fMCwc2njG6XaPC9fzCsV5bhfc,831
+video_editor/schemas/edit-plan.schema.json,sha256=qvtbrAOW5uOguNAK0HqXHHA0PKn2OJd-54igkTSKC2g,2287
+video_editor/schemas/project-profile.schema.json,sha256=j_9pxd2VuiUqPHK2EvYLi29e7FVIcWKFv2bukJ-pGxc,2483
+video_editor/schemas/result.schema.json,sha256=FY6K_6pPHQ5PtTpVU8fVueVY5CDLbe-b4nXWNyOqVPs,1055
+video_editor/schemas/transcript.schema.json,sha256=XPUP9I_MIh4FtIHf0NUmtPflJV0MtsRjkT5IWE5nwlc,1566
+video_editor/schemas/workspace.schema.json,sha256=MXiK3wu6oJOnmb1JUI44BUT6M7U2IIcMDdji-GcDrSg,1164
+video_editor/subtitles.py,sha256=HpHywKgCEofZc-WiqhskKO7wmPjOWytf6RtaWjKqITM,4449
+video_editor/sync.py,sha256=ftv-emys2G0NVzu3FmjemUvNUt-TDajxnUHoT4Zq8sE,5028
+video_editor/transcription/__init__.py,sha256=2pqIxnlvPA-WPRzXosKtZ4DKNjQjhXLOrQ8nAiJlHMM,67
+video_editor/transcription/base.py,sha256=nCa1v18_RAI0k5yJ5UNDopm1aS-BB07ilWSPkrnuXUw,2352
+video_editor/transcription/fixture.py,sha256=D8j4QHqPBxa4RYc9q8hLhkefgd2kmWBfZUBXl56AOCs,1054
+video_editor/transcription/mlx_whisper.py,sha256=EAAWJ47uOri7mlS53760XQ31RPEGGj8U13UJafbtqos,2214
+video_editor/transcription/views.py,sha256=fmeyk9_6qUFmx1vy1Y99IDF1qh_fNCZiDC5x6pfLPXU,2986
+video_editor/workspace.py,sha256=qec5J2ER_Q-DH_72M7g_7QuOrCjGJNjp2scdv5cUNmU,3270
+video_edit_cli-0.1.0.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+video_edit_cli-0.1.0.dist-info/entry_points.txt,sha256=3JDERJzuUKd-Z_ksGpt4M1DdEXFs0R8IhGEFD39_3a8,58
+video_edit_cli-0.1.0.dist-info/METADATA,sha256=z40XDWsUdQNG-vLbKfupeScS39Y5htkxhkK6WPl6QqI,2698
+video_edit_cli-0.1.0.dist-info/RECORD,,

video_edit_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.8.24
+Root-Is-Purelib: true
+Tag: py3-none-any

video_edit_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+video-edit-cli = video_editor.cli:main
+

video_editor/__init__.py

@@ -0,0 +1,5 @@
+"""Headless video-editing workbench: atomic CLI primitives for AI agents."""
+
+__version__ = "0.1.0"
+
+SCHEMA_VERSION = "1"

video_editor/assets.py

@@ -0,0 +1,133 @@
+"""External asset inspection and final-output validation."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from video_editor import media, subtitles
+from video_editor.audio.analysis import measure_loudness
+from video_editor.errors import InvalidInputError
+
+MEDIA_SUFFIXES = {
+    ".mp4",
+    ".mov",
+    ".mkv",
+    ".m4v",
+    ".webm",
+    ".wav",
+    ".mp3",
+    ".m4a",
+    ".aac",
+    ".flac",
+    ".ogg",
+}
+IMAGE_SUFFIXES = {".png", ".jpg", ".jpeg", ".webp", ".bmp"}
+FONT_SUFFIXES = {".ttf", ".otf", ".ttc", ".woff", ".woff2"}
+
+
+def inspect_asset(path: Path) -> dict[str, Any]:
+    """Classify and validate one external asset (media, image, font, subtitle)."""
+    if not path.is_file():
+        raise InvalidInputError(f"asset not found: {path}")
+    suffix = path.suffix.lower()
+    if suffix in FONT_SUFFIXES:
+        return {"path": str(path), "kind": "font", "size_bytes": path.stat().st_size}
+    if suffix in (".srt", ".vtt"):
+        last_end = subtitles.parse_srt_last_end(path)
+        return {"path": str(path), "kind": "subtitles", "last_cue_end": last_end}
+    if suffix in MEDIA_SUFFIXES or suffix in IMAGE_SUFFIXES:
+        info = media.probe(path)
+        types = {s["type"] for s in info["streams"]}
+        if suffix in IMAGE_SUFFIXES:
+            kind = "image"
+        elif "video" in types:
+            kind = "video"
+        else:
+            kind = "audio"
+        return {"kind": kind, **info}
+    raise InvalidInputError(
+        f"unrecognized asset type '{suffix}' for {path}; "
+        "expected media, image, font, or subtitle file"
+    )
+
+
+def validate_output(
+    path: Path,
+    profile: dict[str, Any] | None = None,
+    expect_duration: float | None = None,
+    duration_tolerance: float = 0.5,
+    loudness_tolerance: float = 1.5,
+    expect_subtitles: bool = False,
+    subtitle_file: Path | None = None,
+) -> dict[str, Any]:
+    """Check a final render against expected streams, canvas, duration, loudness."""
+    info = media.probe(path)
+    issues: list[str] = []
+    types = [s["type"] for s in info["streams"]]
+    if "video" not in types:
+        issues.append("no video stream")
+    if "audio" not in types:
+        issues.append("no audio stream")
+
+    video = next((s for s in info["streams"] if s["type"] == "video"), None)
+    checks: dict[str, Any] = {"streams": types}
+
+    if profile and video:
+        canvas = profile["canvas"]
+        if (video["width"], video["height"]) != (canvas["width"], canvas["height"]):
+            issues.append(
+                f"canvas {video['width']}x{video['height']} != "
+                f"expected {canvas['width']}x{canvas['height']}"
+            )
+        expected_fps = canvas.get("frame_rate")
+        if (
+            expected_fps
+            and video["frame_rate"]
+            and abs(video["frame_rate"] - expected_fps) > 0.1
+        ):
+            issues.append(
+                f"frame rate {video['frame_rate']} != expected {expected_fps}"
+            )
+        checks["canvas"] = f"{video['width']}x{video['height']}@{video['frame_rate']}"
+
+    duration = info["duration_seconds"] or 0.0
+    checks["duration_seconds"] = duration
+    if (
+        expect_duration is not None
+        and abs(duration - expect_duration) > duration_tolerance
+    ):
+        issues.append(
+            f"duration {duration:.3f}s differs from expected "
+            f"{expect_duration:.3f}s by more than {duration_tolerance}s"
+        )
+
+    if profile and profile.get("loudness") and "audio" in types:
+        loudness = measure_loudness(path)
+        checks["loudness"] = {k: v for k, v in loudness.items() if k != "raw"}
+        target = profile["loudness"]
+        if (
+            abs(loudness["integrated_lufs"] - target["integrated_lufs"])
+            > loudness_tolerance
+        ):
+            issues.append(
+                f"integrated loudness {loudness['integrated_lufs']} LUFS outside "
+                f"±{loudness_tolerance} of target {target['integrated_lufs']}"
+            )
+        if loudness["true_peak_dbtp"] > target["true_peak_dbtp"] + 0.3:
+            issues.append(
+                f"true peak {loudness['true_peak_dbtp']} dBTP above "
+                f"target {target['true_peak_dbtp']}"
+            )
+
+    if expect_subtitles and "subtitle" not in types:
+        issues.append("no subtitle stream in output")
+    if subtitle_file is not None:
+        last_end = subtitles.parse_srt_last_end(subtitle_file)
+        checks["subtitle_last_cue_end"] = last_end
+        if last_end > duration + 0.5:
+            issues.append(
+                f"subtitle timing runs to {last_end:.3f}s beyond output duration {duration:.3f}s"
+            )
+
+    return {"path": str(path), "passed": not issues, "issues": issues, "checks": checks}

video_editor/audio/__init__.py

@@ -0,0 +1 @@
+"""Audio analysis, restoration, mastering, and comparison primitives."""

video_editor/audio/analysis.py

@@ -0,0 +1,147 @@
+"""Deterministic audio quality measurement (BS.1770 loudness, peaks, silence)."""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Any
+
+from video_editor import ffmpeg
+from video_editor.errors import InvalidInputError, ToolFailureError
+
+
+def measure_loudness(
+    path: Path,
+    target_i: float = -16.0,
+    target_tp: float = -1.5,
+    target_lra: float = 11.0,
+) -> dict[str, Any]:
+    """First-pass loudnorm measurement: integrated LUFS, true peak, LRA, threshold."""
+    if not path.is_file():
+        raise InvalidInputError(f"input file not found: {path}")
+    proc = ffmpeg.run(
+        "ffmpeg",
+        [
+            "-hide_banner",
+            "-nostdin",
+            "-i",
+            str(path),
+            "-af",
+            f"loudnorm=I={target_i}:TP={target_tp}:LRA={target_lra}:print_format=json",
+            "-f",
+            "null",
+            "-",
+        ],
+    )
+    match = re.search(r"\{[^{}]*\"input_i\"[^{}]*\}", proc.stderr, re.DOTALL)
+    if not match:
+        raise ToolFailureError("loudnorm did not report measurement JSON")
+    raw = json.loads(match.group(0))
+    return {
+        "integrated_lufs": float(raw["input_i"]),
+        "true_peak_dbtp": float(raw["input_tp"]),
+        "loudness_range_lu": float(raw["input_lra"]),
+        "threshold_lufs": float(raw["input_thresh"]),
+        "raw": raw,
+    }
+
+
+def analyze(path: Path) -> dict[str, Any]:
+    """Loudness, true peak, clipping indicators, silence spans, bandwidth signal."""
+    loudness = measure_loudness(path)
+
+    proc = ffmpeg.run(
+        "ffmpeg",
+        [
+            "-hide_banner",
+            "-nostdin",
+            "-i",
+            str(path),
+            "-af",
+            "astats=measure_perchannel=none:measure_overall="
+            "Peak_level+Flat_factor+Peak_count+RMS_level,"
+            "silencedetect=n=-40dB:d=0.5",
+            "-f",
+            "null",
+            "-",
+        ],
+    )
+    log = proc.stderr
+
+    def stat(name: str) -> float | None:
+        found = re.search(rf"{name}: (-?[\d.]+|-inf)", log)
+        if not found or found.group(1) == "-inf":
+            return None
+        return float(found.group(1))
+
+    silence_starts = [float(t) for t in re.findall(r"silence_start: (-?[\d.]+)", log)]
+    silence_durations = [
+        float(t) for t in re.findall(r"silence_duration: ([\d.]+)", log)
+    ]
+
+    # Crude bandwidth signal: energy remaining above 8 kHz relative to full band.
+    hf = ffmpeg.run(
+        "ffmpeg",
+        [
+            "-hide_banner",
+            "-nostdin",
+            "-i",
+            str(path),
+            "-af",
+            "highpass=f=8000,volumedetect",
+            "-f",
+            "null",
+            "-",
+        ],
+    )
+    hf_mean = re.search(r"mean_volume: (-?[\d.]+)", hf.stderr)
+    full = ffmpeg.run(
+        "ffmpeg",
+        [
+            "-hide_banner",
+            "-nostdin",
+            "-i",
+            str(path),
+            "-af",
+            "volumedetect",
+            "-f",
+            "null",
+            "-",
+        ],
+    )
+    full_mean = re.search(r"mean_volume: (-?[\d.]+)", full.stderr)
+    hf_drop = (
+        round(float(full_mean.group(1)) - float(hf_mean.group(1)), 2)
+        if hf_mean and full_mean
+        else None
+    )
+
+    flat_factor = stat("Flat factor")
+    peak_level = stat("Peak level dB")
+    return {
+        "loudness": {k: v for k, v in loudness.items() if k != "raw"},
+        "peak_level_dbfs": peak_level,
+        "rms_level_dbfs": stat("RMS level dB"),
+        "clipping": {
+            "flat_factor": flat_factor,
+            "peak_count": stat("Peak count"),
+            "likely_clipped": bool(
+                flat_factor
+                and flat_factor > 0.1
+                and peak_level is not None
+                and peak_level > -0.2
+            ),
+        },
+        "silence": {
+            "spans": [
+                {"start": s, "duration": d}
+                for s, d in zip(silence_starts, silence_durations)
+            ],
+            "count": len(silence_starts),
+        },
+        "bandwidth": {
+            "high_frequency_dropoff_db": hf_drop,
+            "note": "full-band mean volume minus >8kHz mean volume; larger = duller",
+        },
+    }

video_editor/audio/comparison.py

@@ -0,0 +1,71 @@
+"""Loudness-matched A/B comparison of candidate audio treatments."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from video_editor import ffmpeg
+from video_editor.audio.analysis import measure_loudness
+from video_editor.errors import InvalidInputError
+from video_editor.provenance import utc_now
+
+
+def compare(
+    candidates: list[Path],
+    output_dir: Path,
+    match_lufs: float = -20.0,
+    sample_start: float = 0.0,
+    sample_duration: float = 12.0,
+) -> dict[str, Any]:
+    """Measure candidates and write loudness-matched review excerpts + report."""
+    if len(candidates) < 2:
+        raise InvalidInputError("audio compare needs at least two --input candidates")
+    for path in candidates:
+        if not path.is_file():
+            raise InvalidInputError(f"candidate not found: {path}")
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    entries = []
+    for index, path in enumerate(candidates):
+        loudness = measure_loudness(path)
+        gain = round(match_lufs - loudness["integrated_lufs"], 3)
+        sample = output_dir / f"candidate-{index}-{path.stem}-ab.wav"
+        ffmpeg.run_ffmpeg(
+            [
+                "-ss",
+                f"{sample_start:.3f}",
+                "-t",
+                f"{sample_duration:.3f}",
+                "-i",
+                str(path),
+                "-af",
+                f"volume={gain}dB",
+                "-c:a",
+                "pcm_s24le",
+                str(sample),
+            ]
+        )
+        entries.append(
+            {
+                "index": index,
+                "path": str(path),
+                "metrics": {k: v for k, v in loudness.items() if k != "raw"},
+                "match_gain_db": gain,
+                "ab_sample": str(sample),
+            }
+        )
+
+    report = {
+        "created_at": utc_now(),
+        "match_lufs": match_lufs,
+        "sample": {"start": sample_start, "duration": sample_duration},
+        "candidates": entries,
+        "note": "A/B samples are loudness-matched; metrics rank candidates but "
+        "do not prove speech remains natural — listen before choosing.",
+    }
+    report_path = output_dir / "audio-compare-report.json"
+    report_path.write_text(json.dumps(report, indent=2) + "\n")
+    report["report_path"] = str(report_path)
+    return report

video_editor/audio/denoise.py

@@ -0,0 +1,63 @@
+"""Conservative neural speech denoising behind an explicit backend interface.
+
+DeepFilterNet is the first backend; it is optional (`video-edit-cli[df]` extra)
+and never applied implicitly — the agent chooses to denoise. Stronger or
+generative restoration would be added as further explicit backends.
+"""
+
+from __future__ import annotations
+
+import importlib
+from pathlib import Path
+from typing import Any, Protocol
+
+from video_editor.errors import InvalidInputError, VideoEditorError
+
+
+class DenoiseBackend(Protocol):
+    name: str
+
+    def denoise(self, source: Path, output: Path) -> dict[str, Any]:
+        """Write denoised audio to `output`; return provenance details."""
+        ...
+
+
+class DeepFilterNetBackend:
+    name = "deepfilternet"
+
+    def denoise(self, source: Path, output: Path) -> dict[str, Any]:
+        try:
+            enhance_mod = importlib.import_module("df.enhance")
+        except ImportError as exc:
+            raise VideoEditorError(
+                "missing-dependency",
+                "the deepfilternet backend requires the optional 'df' extra; "
+                "install with `uv sync --extra df`",
+                exit_code=5,
+            ) from exc
+        model, df_state, _ = enhance_mod.init_df()
+        audio, _ = enhance_mod.load_audio(str(source), sr=df_state.sr())
+        enhanced = enhance_mod.enhance(model, df_state, audio)
+        enhance_mod.save_audio(str(output), enhanced, df_state.sr())
+        return {"model": "DeepFilterNet3", "sample_rate": df_state.sr()}
+
+
+def get_backend(name: str) -> DenoiseBackend:
+    if name == "deepfilternet":
+        return DeepFilterNetBackend()
+    raise InvalidInputError(f"unknown denoise backend '{name}'")
+
+
+def denoise(source: Path, output: Path, backend_name: str) -> dict[str, Any]:
+    if not source.is_file():
+        raise InvalidInputError(f"input file not found: {source}")
+    if output.suffix.lower() != ".wav":
+        raise InvalidInputError("audio denoise output must be a .wav path (lossless)")
+    backend = get_backend(backend_name)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    details = backend.denoise(source, output)
+    if not output.is_file():
+        raise VideoEditorError(
+            "tool-failure", f"backend produced no output at {output}"
+        )
+    return {"backend": backend.name, **details}

video_editor/audio/mastering.py

@@ -0,0 +1,77 @@
+"""Deterministic mastering: filtering, dynamics, and two-pass loudness normalization.
+
+This is the mastering-only baseline: no neural processing, fully reproducible
+from explicit parameters. Output is lossless WAV.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from video_editor import ffmpeg
+from video_editor.audio.analysis import measure_loudness
+from video_editor.errors import InvalidInputError
+
+
+def master(
+    source: Path,
+    output: Path,
+    target_i: float = -16.0,
+    target_tp: float = -1.5,
+    target_lra: float = 11.0,
+    highpass_hz: int = 70,
+    compress: bool = True,
+) -> tuple[list[str], dict[str, Any]]:
+    """Two-pass loudnorm mastering chain; returns (ffmpeg args, result metrics)."""
+    if output.suffix.lower() != ".wav":
+        raise InvalidInputError("audio master output must be a .wav path (lossless)")
+    measured = measure_loudness(source, target_i, target_tp, target_lra)["raw"]
+    output.parent.mkdir(parents=True, exist_ok=True)
+
+    chain = [f"highpass=f={highpass_hz}"]
+    if compress:
+        chain.append(
+            "acompressor=threshold=-18dB:ratio=2:attack=15:release=200:makeup=2"
+        )
+    chain.append(
+        "loudnorm=I={i}:TP={tp}:LRA={lra}:measured_I={mi}:measured_TP={mtp}:"
+        "measured_LRA={mlra}:measured_thresh={mth}:offset={off}:linear=true".format(
+            i=target_i,
+            tp=target_tp,
+            lra=target_lra,
+            mi=measured["input_i"],
+            mtp=measured["input_tp"],
+            mlra=measured["input_lra"],
+            mth=measured["input_thresh"],
+            off=measured["target_offset"],
+        )
+    )
+    args = [
+        "-i",
+        str(source),
+        "-af",
+        ",".join(chain),
+        "-ar",
+        "48000",
+        "-c:a",
+        "pcm_s24le",
+        str(output),
+    ]
+    ffmpeg.run_ffmpeg(args)
+
+    result_loudness = measure_loudness(output, target_i, target_tp, target_lra)
+    metrics = {
+        "target": {
+            "integrated_lufs": target_i,
+            "true_peak_dbtp": target_tp,
+            "lra": target_lra,
+        },
+        "input": {
+            "integrated_lufs": float(measured["input_i"]),
+            "true_peak_dbtp": float(measured["input_tp"]),
+        },
+        "output": {k: v for k, v in result_loudness.items() if k != "raw"},
+        "chain": chain,
+    }
+    return args, metrics