@lemoncat7/dsh-partner 2.8.0 → 2.8.2

package/resources/skills/video-recap-production/upstream/skills/video-cut/scripts/cut_render.py

@@ -0,0 +1,304 @@
+"""Render edited source media and write delivery QC."""
+
+import json
+
+
+from pathlib import Path
+
+from lib import CONFIG, filter_file_args, get_video_duration, log, run_cmd
+
+from cut_contract import _write_edited_source_meta
+from media_geometry import _has_audio_stream
+from sentence_boundaries import _continuous_source_join
+
+
+def _audio_segment_filter(
+    label_in, label_out, start, end, duration, fade_in_ms, fade_out_ms, extra_filters=""
+):
+    max_fade = duration / 2
+    fade_in = max(0.0, min(fade_in_ms / 1000.0, max_fade))
+    fade_out = max(0.0, min(fade_out_ms / 1000.0, max_fade))
+    base = f"{label_in}atrim=start={start:.3f}:end={end:.3f},asetpts=PTS-STARTPTS"
+    if fade_in > 0:
+        base += f",afade=t=in:st=0:d={fade_in:.3f}"
+    if fade_out > 0:
+        base += f",afade=t=out:st={max(0.0, duration - fade_out):.3f}:d={fade_out:.3f}"
+    if extra_filters:
+        base += f",{extra_filters}"
+    return f"{base}{label_out}"
+
+
+def _clip_audio_edge_fades(clips, idx, fade_ms):
+    """Do not create an audible dip where adjacent clips are a lossless source continuation."""
+    fade_in = (
+        0.0
+        if idx > 0 and _continuous_source_join(clips[idx - 1], clips[idx])
+        else fade_ms
+    )
+    fade_out = (
+        0.0
+        if idx + 1 < len(clips) and _continuous_source_join(clips[idx], clips[idx + 1])
+        else fade_ms
+    )
+    return fade_in, fade_out
+
+
+def _probe_audio_sample_rate(video_path):
+    """Sample rate of the first audio stream, or None when it cannot be observed.
+
+    Delivery QC is observational and runs even on a plan that was never rendered, so an
+    ffprobe that is absent (OSError) reads the same as one that reports no audio stream.
+    """
+    cmd = [
+        "ffprobe",
+        "-v",
+        "error",
+        "-select_streams",
+        "a:0",
+        "-show_entries",
+        "stream=sample_rate",
+        "-of",
+        "csv=p=0",
+        str(video_path),
+    ]
+    try:
+        result = run_cmd(cmd)
+    except OSError:
+        return None
+    text = result.stdout.strip()
+    if result.returncode != 0 or not text:
+        return None
+    return int(float(text))
+
+
+def _delivery_reencode_reason(source_paths, clips):
+    reasons = ["trim_concat_filter_requires_reencode"]
+    if len(source_paths) > 1:
+        reasons.append("multi_source_geometry_audio_normalization")
+    if any("source_path" not in clip for clip in clips):
+        reasons.append("single_source_filter_concat_no_stream_copy")
+    return "+".join(reasons)
+
+
+def update_delivery_qc(validated_plan, *, source_paths, output_path=None, rendered=False):
+    """Attach cut delivery facts to qc.delivery_qc without writing visual_qc."""
+    qc = validated_plan["qc"]
+    clips = validated_plan["clips"]
+    target_sample_rate = 48000
+    probed_sample_rate = (
+        _probe_audio_sample_rate(output_path)
+        if output_path and Path(output_path).exists()
+        else None
+    )
+    delivery_qc = {
+        "schema_version": 1,
+        "video_encode_passes": 1,
+        "reencode_reason": _delivery_reencode_reason(source_paths, clips),
+        "stream_copy_risk": {
+            "status": "avoided",
+            "reason": "cut uses trim/concat/filtergraph with explicit libx264/aac encode; no risky stream-copy path",
+        },
+        "audio_sample_rate": {
+            "target": target_sample_rate,
+            "probed": probed_sample_rate,
+        },
+        "final_compat_notes": [
+            "video encoded with libx264/yuv420p-compatible filter path",
+            "audio encoded as AAC with 48000 Hz target for delivery compatibility",
+            "edited_source.mp4 is an intermediate; downstream assembly may perform another intentional encode",
+        ],
+        "output_geometry": qc["output_geometry"],
+        "rendered": rendered,
+        "planned": not rendered,
+    }
+    if probed_sample_rate and probed_sample_rate != target_sample_rate:
+        delivery_qc["final_compat_notes"].append(
+            f"probed audio sample rate {probed_sample_rate} differs from target {target_sample_rate}"
+        )
+    qc["delivery_qc"] = delivery_qc
+    return delivery_qc
+
+
+def write_cut_delivery_qc(work_dir, validated_plan):
+    path = Path(work_dir) / "cut_delivery_qc.json"
+    path.write_text(
+        json.dumps(validated_plan["qc"]["delivery_qc"], ensure_ascii=False, indent=2),
+        encoding="utf-8",
+    )
+    return path
+
+
+def build_edited_source_video(input_video, validated_plan, work_dir, output_path=None):
+    """Build `edited_source.mp4` by concatenating validated source ranges.
+
+    `validated_plan["qc"]["output_geometry"]` is required: the caller (cut_cli, or any
+    public user of this API) selects the canvas with `_select_output_geometry` first, so the
+    same geometry is recorded in clip_plan_validated.json and used for the render."""
+    work_dir = Path(work_dir)
+    output_path = Path(output_path or work_dir / "edited_source.mp4")
+    clips = validated_plan["clips"]
+    qc = validated_plan["qc"]
+    if "output_geometry" not in qc:
+        raise KeyError(
+            "validated_plan['qc']['output_geometry'] is required: select the canvas with "
+            "media_geometry._select_output_geometry before build_edited_source_video"
+        )
+
+    source_paths = []
+    for clip in clips:
+        source_path = clip.get("source_path", str(input_video))
+        if source_path not in source_paths:
+            source_paths.append(source_path)
+    source_index = {path: idx for idx, path in enumerate(source_paths)}
+    audio_by_input = {path: _has_audio_stream(path) for path in source_paths}
+    join_fade_ms = CONFIG["clip_join_audio_fade_ms"]
+    qc["join_fade_ms"] = round(join_fade_ms, 3)
+
+    parts = []
+    concat_inputs = []
+    extra_inputs = []
+    if len(source_paths) > 1:
+        # Distinct sources almost always differ in resolution/SAR/fps/pixel-format (and
+        # some may lack audio), which the bare concat filter rejects. Normalize every video
+        # segment to one canvas and give every clip an audio segment (real or synthesized
+        # silence) so concat always succeeds with a continuous track and no source's audio
+        # is dropped just because a sibling source is silent.
+        geometry_qc = qc["output_geometry"]
+        canvas_w, canvas_h, canvas_fps = (
+            geometry_qc["width"],
+            geometry_qc["height"],
+            geometry_qc["fps"],
+        )
+        vnorm = (
+            f"scale={canvas_w}:{canvas_h}:force_original_aspect_ratio=decrease,"
+            f"pad={canvas_w}:{canvas_h}:(ow-iw)/2:(oh-ih)/2,setsar=1,"
+            f"fps={canvas_fps},format=yuv420p"
+        )
+        for clip_pos, clip in enumerate(clips):
+            idx = clip["clip_id"]
+            clip_source = clip.get("source_path", str(input_video))
+            input_idx = source_index[clip_source]
+            start = clip["source_start"]
+            end = clip["source_end"]
+            dur = end - start
+            fade_in_ms, fade_out_ms = _clip_audio_edge_fades(clips, clip_pos, join_fade_ms)
+            parts.append(
+                f"[{input_idx}:v]trim=start={start:.3f}:end={end:.3f},setpts=PTS-STARTPTS,{vnorm}[v{idx}]"
+            )
+            if audio_by_input[clip_source]:
+                parts.append(
+                    _audio_segment_filter(
+                        f"[{input_idx}:a]",
+                        f"[a{idx}]",
+                        start,
+                        end,
+                        dur,
+                        fade_in_ms,
+                        fade_out_ms,
+                        extra_filters="aresample=48000,aformat=sample_rates=48000:channel_layouts=stereo",
+                    )
+                )
+            else:
+                parts.append(
+                    f"anullsrc=r=48000:cl=stereo,atrim=duration={dur:.3f},asetpts=PTS-STARTPTS,"
+                    f"aformat=sample_rates=48000:channel_layouts=stereo[a{idx}]"
+                )
+            concat_inputs.append(f"[v{idx}][a{idx}]")
+        parts.append("".join(concat_inputs) + f"concat=n={len(clips)}:v=1:a=1[v][a]")
+        maps = ["-map", "[v]", "-map", "[a]"]
+    else:
+        has_audio = all(audio_by_input.values())
+        for clip_pos, clip in enumerate(clips):
+            idx = clip["clip_id"]
+            input_idx = source_index[clip.get("source_path", str(input_video))]
+            start = clip["source_start"]
+            end = clip["source_end"]
+            parts.append(
+                f"[{input_idx}:v]trim=start={start:.3f}:end={end:.3f},setpts=PTS-STARTPTS[v{idx}]"
+            )
+            concat_inputs.append(f"[v{idx}]")
+            if has_audio:
+                fade_in_ms, fade_out_ms = _clip_audio_edge_fades(
+                    clips, clip_pos, join_fade_ms
+                )
+                parts.append(
+                    _audio_segment_filter(
+                        f"[{input_idx}:a]",
+                        f"[a{idx}]",
+                        start,
+                        end,
+                        end - start,
+                        fade_in_ms,
+                        fade_out_ms,
+                    )
+                )
+                concat_inputs.append(f"[a{idx}]")
+
+        if has_audio:
+            parts.append(
+                "".join(concat_inputs) + f"concat=n={len(clips)}:v=1:a=1[v][a]"
+            )
+            maps = ["-map", "[v]", "-map", "[a]"]
+        else:
+            parts.append("".join(concat_inputs) + f"concat=n={len(clips)}:v=1:a=0[v]")
+            maps = ["-map", "[v]", "-map", f"{len(source_paths)}:a", "-shortest"]
+            extra_inputs = [
+                "-f",
+                "lavfi",
+                "-t",
+                f"{validated_plan['total_duration']:.3f}",
+                "-i",
+                "anullsrc=channel_layout=stereo:sample_rate=48000",
+            ]
+
+    filter_complex = ";".join(parts)
+    if len(filter_complex.encode("utf-8")) > 7000:
+        filter_script = work_dir / "edit_filter_complex.txt"
+        filter_script.write_text(filter_complex, encoding="utf-8")
+        filter_args = filter_file_args("filter_complex", filter_script)
+    else:
+        filter_args = ["-filter_complex", filter_complex]
+
+    input_args = []
+    for source_path in source_paths:
+        input_args.extend(["-i", str(source_path)])
+    cmd = [
+        "ffmpeg",
+        "-y",
+        *input_args,
+        *extra_inputs,
+        *filter_args,
+        *maps,
+        "-c:v",
+        "libx264",
+        "-preset",
+        "veryfast",
+        "-crf",
+        "18",
+        "-pix_fmt",
+        "yuv420p",
+        "-c:a",
+        "aac",
+        "-b:a",
+        "192k",
+        "-ar",
+        "48000",
+        "-movflags",
+        "+faststart",
+        str(output_path),
+    ]
+    result = run_cmd(cmd)
+    if result.returncode != 0:
+        raise RuntimeError(f"剪辑源视频失败: {result.stderr}")
+
+    update_delivery_qc(
+        validated_plan,
+        source_paths=source_paths,
+        output_path=output_path,
+        rendered=True,
+    )
+    write_cut_delivery_qc(work_dir, validated_plan)
+    _write_edited_source_meta(output_path, validated_plan, input_video)
+    duration = get_video_duration(output_path)
+    log(f"剪辑源视频: {output_path} ({duration:.1f}s, {len(clips)} clips)")
+    return output_path

package/resources/skills/video-recap-production/upstream/skills/video-cut/scripts/lib.py

@@ -0,0 +1,114 @@
+"""Self-contained utilities for the video-cut skill (no cross-skill imports)."""
+import functools
+import math
+import os
+import shutil
+import subprocess
+import tempfile
+
+
+def log(msg):
+    print(f"[video-cut] {msg}", flush=True)
+
+
+def env_bool(name, default):
+    """Read an env var as a boolean (1/true/yes → True; 0/false/no → False)."""
+    val = os.environ.get(name)
+    if val is None:
+        return default
+    text = val.strip().lower()
+    if text in ("1", "true", "yes"):
+        return True
+    if text in ("0", "false", "no"):
+        return False
+    raise ValueError(f"{name} must be 1/true/yes or 0/false/no, got {val!r}")
+
+
+def env_float(name, default, min_val=None):
+    """Read an env var as a float, rejecting malformed or below-minimum values."""
+    val = os.environ.get(name)
+    if val is None:
+        return default
+    try:
+        result = float(val)
+    except ValueError as exc:
+        raise ValueError(f"{name} must be a number, got {val!r}") from exc
+    if not math.isfinite(result):
+        raise ValueError(f"{name} must be finite, got {val!r}")
+    if min_val is not None and result < min_val:
+        raise ValueError(f"{name} must be >= {min_val}, got {val!r}")
+    return result
+
+
+CONFIG = {
+    "snap_clip_line_end": env_bool("SNAP_CLIP_LINE_END", True),
+    "clip_snap_max_extend": env_float("CLIP_SNAP_MAX_EXTEND", 2.0, min_val=0.0),
+    "clip_start_snap_max_prepend": env_float("CLIP_START_SNAP_MAX_PREPEND", 1.8, min_val=0.0),
+    "clip_start_snap_max_trim": env_float("CLIP_START_SNAP_MAX_TRIM", 0.35, min_val=0.0),
+    "clip_join_audio_fade_ms": env_float("CLIP_JOIN_AUDIO_FADE_MS", 30.0, min_val=0.0),
+    # video-cut is the only skill that implements clip padding, so it is the only skill that
+    # may declare the knob. cut_cli reads this as the default for --clip-padding.
+    "clip_padding": env_float("CLIP_PADDING", 0.0, min_val=0.0),
+    # Keep clip boundaries off the ORIGINAL footage's hard cuts: a clip that opens/closes a few
+    # tenths of a second from a source shot-change shows a brief sliver of the adjacent shot that
+    # then hard-cuts again — a visible 闪烁/flicker at the edit point. Snap source_start forward
+    # past (and source_end back before) any shot-change within the margin.
+    "scene_cut_snap": env_bool("SCENE_CUT_SNAP", True),
+    "scene_cut_snap_margin": env_float("SCENE_CUT_SNAP_MARGIN", 0.5, min_val=0.0),    # 边界±此秒内有切镜头才避让
+    "scene_cut_detect_threshold": env_float("SCENE_CUT_DETECT_THRESHOLD", 0.4, min_val=0.0),  # ffmpeg scene 分数阈值(硬切)
+}
+
+
+def file_identity(path):
+    """{size, mtime_ns} — the cache identity of an input file (no content read)."""
+    st = os.stat(os.fspath(path))
+    return {"size": st.st_size, "mtime_ns": st.st_mtime_ns}
+
+
+def run_cmd(cmd, **kwargs):
+    """Run a command list and return the CompletedProcess (stdout/stderr captured)."""
+    display = " ".join(
+        str(part) if len(str(part)) <= 240 else str(part)[:237] + "..." for part in cmd
+    )
+    log(f"运行: {display}")
+    return subprocess.run(cmd, capture_output=True, text=True, **kwargs)
+
+
+# ffmpeg 7 added `-/option path` to read any option's value from a file; ffmpeg 9 removed the
+# older `-filter_complex_script` / `-filter_script` spellings, which are all ffmpeg <= 6 knows.
+_LEGACY_FILTER_FILE_OPTIONS = {
+    "filter_complex": "-filter_complex_script",
+    "filter:v:0": "-filter_script:v:0",
+}
+
+
+@functools.lru_cache(maxsize=None)
+def _ffmpeg_reads_option_files():
+    """Whether the ffmpeg on PATH accepts `-/option path` (asked once per process)."""
+    if shutil.which("ffmpeg") is None:
+        return False
+    with tempfile.TemporaryDirectory() as tmp:
+        graph = os.path.join(tmp, "probe_filter.txt")
+        with open(graph, "w", encoding="utf-8") as fh:
+            fh.write("null")
+        result = subprocess.run(["ffmpeg", "-hide_banner", "-/filter_complex", graph],
+                                stdin=subprocess.DEVNULL, capture_output=True, text=True,
+                                timeout=20)
+    return "Unrecognized option" not in result.stderr
+
+
+def filter_file_args(option, path):
+    """ffmpeg arguments that load `option`'s filtergraph from `path`, spelled for this ffmpeg."""
+    if _ffmpeg_reads_option_files():
+        return [f"-/{option}", str(path)]
+    return [_LEGACY_FILTER_FILE_OPTIONS[option], str(path)]
+
+
+def get_video_duration(video_path):
+    """Return media duration in seconds via ffprobe."""
+    cmd = ["ffprobe", "-v", "error", "-show_entries", "format=duration",
+           "-of", "csv=p=0", str(video_path)]
+    result = run_cmd(cmd)
+    if result.returncode != 0:
+        raise RuntimeError(f"ffprobe 无法读取时长: {video_path}: {result.stderr.strip()}")
+    return float(result.stdout.strip())

package/resources/skills/video-recap-production/upstream/skills/video-cut/scripts/media_geometry.py

@@ -0,0 +1,238 @@
+"""Probe display geometry and select a stable output canvas."""
+
+import json
+
+from lib import run_cmd
+
+
+def _has_audio_stream(video_path):
+    cmd = [
+        "ffprobe",
+        "-v",
+        "error",
+        "-select_streams",
+        "a:0",
+        "-show_entries",
+        "stream=index",
+        "-of",
+        "csv=p=0",
+        str(video_path),
+    ]
+    result = run_cmd(cmd)
+    return result.returncode == 0 and bool(result.stdout.strip())
+
+
+class VideoGeometry(tuple):
+    """Tuple-compatible (width, height, fps) with probe facts attached for QC callers."""
+
+    def __new__(cls, width, height, fps, facts):
+        obj = super().__new__(cls, (width, height, fps))
+        obj.facts = facts
+        return obj
+
+
+def _parse_ratio(value):
+    """ffprobe aspect ratios are 'N:D' (or 'N/D'); '0:1' and 'N/A' mean unknown."""
+    if value in (None, "", "0:1", "0/1", "N/A"):
+        return None
+    left, _, right = str(value).replace("/", ":").partition(":")
+    num, den = float(left), float(right)
+    return num / den if den > 0 and num > 0 else None
+
+
+def _stream_rotation(stream):
+    """Rotation from the legacy `rotate` tag or the display-matrix side data, else 0."""
+    tags = stream.get("tags", {})
+    if "rotate" in tags:
+        return int(round(float(tags["rotate"]))) % 360
+    for side_data in stream.get("side_data_list", []):
+        if "rotation" in side_data:
+            return int(round(float(side_data["rotation"]))) % 360
+    return 0
+
+
+def _fps_from_rate(rate):
+    """ffprobe frame rates are 'N/D' fractions; '0/0' means unknown."""
+    num, _, den = rate.partition("/")
+    return float(num) / float(den) if float(den) > 0 else 0.0
+
+
+def _geometry_from_stream(stream):
+    coded_width, coded_height = stream["width"], stream["height"]
+    parsed_sar = _parse_ratio(stream.get("sample_aspect_ratio"))
+    dar = _parse_ratio(stream.get("display_aspect_ratio"))
+    rotation = _stream_rotation(stream)
+    display_height = float(coded_height)
+    if parsed_sar:
+        sar = parsed_sar
+        display_width = float(coded_width) * sar
+        aspect_source = "sample_aspect_ratio"
+    elif dar:
+        sar = 1.0
+        display_width = display_height * dar
+        aspect_source = "display_aspect_ratio_fallback"
+    else:
+        sar = 1.0
+        display_width = float(coded_width)
+        aspect_source = "square_pixel_fallback"
+    rotation_swaps_axes = rotation in {90, 270}
+    if rotation_swaps_axes:
+        display_width, display_height = display_height, display_width
+
+    width, height = _clamp_even_geometry(round(display_width), round(display_height))
+    fps = _fps_from_rate(stream["r_frame_rate"]) or _fps_from_rate(
+        stream.get("avg_frame_rate", "0/0")
+    )
+    if not 0 < fps <= 120:
+        fps = 30.0
+    facts = {
+        "coded_width": coded_width,
+        "coded_height": coded_height,
+        "width": width,
+        "height": height,
+        "fps": round(fps, 3),
+        "sample_aspect_ratio": stream.get("sample_aspect_ratio", "1:1"),
+        "sample_aspect_ratio_float": round(sar, 6),
+        "display_aspect_ratio": stream.get("display_aspect_ratio"),
+        "display_aspect_ratio_float": round(dar or 0.0, 6),
+        "display_aspect_source": aspect_source,
+        "display_width": width,
+        "display_height": height,
+        "rotation": rotation,
+        "rotation_swaps_axes": rotation_swaps_axes,
+    }
+    return VideoGeometry(width, height, round(fps, 3), facts)
+
+
+def _probe_video_geometry(video_path):
+    """Display geometry (width, height, fps) of the first video stream, rotation/SAR/DAR-aware.
+
+    Unpacks like a 3-tuple while exposing `.facts` for QC. Used to normalize heterogeneous
+    multi-source segments to one square-pixel geometry before concat (ffmpeg's concat filter
+    rejects mismatched width/height/SAR/pixel-format/fps).
+    """
+    cmd = [
+        "ffprobe",
+        "-v",
+        "error",
+        "-select_streams",
+        "v:0",
+        "-show_entries",
+        "stream=width,height,r_frame_rate,avg_frame_rate,sample_aspect_ratio,display_aspect_ratio:stream_tags=rotate:stream_side_data=rotation",
+        "-of",
+        "json",
+        str(video_path),
+    ]
+    result = run_cmd(cmd)
+    if result.returncode != 0:
+        raise RuntimeError(f"ffprobe 无法读取视频几何信息: {video_path}: {result.stderr.strip()}")
+    streams = json.loads(result.stdout).get("streams", [])
+    if not streams:
+        raise RuntimeError(f"没有视频流: {video_path}")
+    return _geometry_from_stream(streams[0])
+
+
+def _orientation(width, height):
+    if width > height:
+        return "landscape"
+    if height > width:
+        return "portrait"
+    return "square"
+
+
+def _fps_bucket(fps):
+    common = [23.976, 24.0, 25.0, 29.97, 30.0, 50.0, 59.94, 60.0]
+    nearest = min(common, key=lambda x: abs(fps - x))
+    bucket = nearest if abs(fps - nearest) <= 0.15 else round(fps)
+    return max(1.0, min(60.0, bucket))
+
+
+def _clamp_even_geometry(width, height):
+    return max(2, width - width % 2), max(2, height - height % 2)
+
+
+def _select_output_geometry(source_paths, clips):
+    """Deterministically select canvas/fps from all used sources, not just the first."""
+    used = {}
+    for clip in clips:
+        if "source_path" in clip:
+            used[clip["source_path"]] = used.get(clip["source_path"], 0.0) + clip["duration"]
+    if not used:  # single-source plans carry no per-clip source_path
+        used = {str(path): 0.0 for path in source_paths}
+    rows = []
+    for path in sorted(used):
+        probed = _probe_video_geometry(path)
+        width, height, fps = probed
+        facts = probed.facts
+        rows.append(
+            {
+                "path": path,
+                "source_id": next(
+                    (c["source_id"] for c in clips if c.get("source_path") == path), None
+                ),
+                "used_duration": round(used[path], 3),
+                "width": width,
+                "height": height,
+                "coded_width": facts["coded_width"],
+                "coded_height": facts["coded_height"],
+                "display_width": facts["display_width"],
+                "display_height": facts["display_height"],
+                "area": width * height,
+                "fps": fps,
+                "fps_bucket": _fps_bucket(fps),
+                "orientation": _orientation(width, height),
+                "rotation": facts["rotation"],
+                "sample_aspect_ratio": facts["sample_aspect_ratio"],
+                "sample_aspect_ratio_float": facts["sample_aspect_ratio_float"],
+                "display_aspect_ratio": facts["display_aspect_ratio"],
+                "rotation_swaps_axes": facts["rotation_swaps_axes"],
+            }
+        )
+
+    orientation_duration = {}
+    for row in rows:
+        orientation_duration[row["orientation"]] = (
+            orientation_duration.get(row["orientation"], 0.0) + row["used_duration"]
+        )
+    chosen_orientation = sorted(
+        orientation_duration.items(),
+        key=lambda kv: (
+            kv[1],
+            max(r["area"] for r in rows if r["orientation"] == kv[0]),
+            kv[0],
+        ),
+        reverse=True,
+    )[0][0]
+    eligible = [r for r in rows if r["orientation"] == chosen_orientation]
+    selected = sorted(
+        eligible, key=lambda r: (-r["area"], r["source_id"] or "", r["path"])
+    )[0]
+
+    fps_duration = {}
+    for row in rows:
+        fps_duration[row["fps_bucket"]] = (
+            fps_duration.get(row["fps_bucket"], 0.0) + row["used_duration"]
+        )
+    fps = sorted(fps_duration.items(), key=lambda kv: (kv[1], kv[0]), reverse=True)[0][0]
+
+    width, height = selected["width"], selected["height"]
+    reason = {
+        "width": width,
+        "height": height,
+        "fps": round(fps, 3),
+        "reason": "weighted_orientation_area_fps",
+        "source_id": selected["source_id"],
+        "source_path": selected["path"],
+        "orientation": chosen_orientation,
+        "orientation_used_duration": round(orientation_duration[chosen_orientation], 3),
+        "fps_bucket_used_duration": round(fps_duration[fps], 3),
+        "rotation": selected["rotation"],
+        "sample_aspect_ratio": selected["sample_aspect_ratio"],
+        "display_aspect_ratio": selected["display_aspect_ratio"],
+        "coded_width": selected["coded_width"],
+        "coded_height": selected["coded_height"],
+        "display_width": selected["display_width"],
+        "display_height": selected["display_height"],
+        "sources": rows,
+    }
+    return width, height, round(fps, 3), reason