@oh-story/dsh 0.1.8 → 0.1.10

package/lib/video-recap/skills/video-assemble/scripts/media.py

@@ -8,6 +8,7 @@ from artifacts import _explicit_source_video, _value_fingerprint
 from lib import log, run_cmd
 
 def _load_cut_timeline_plan(work_dir):
+    """The cut plan, preferring clip_plan_validated.json when it matches the raw plan; None in full mode."""
     raw_plan_path = Path(work_dir) / "clip_plan.json"
     validated_plan_path = Path(work_dir) / "clip_plan_validated.json"
     if not validated_plan_path.exists():
@@ -16,73 +17,79 @@ def _load_cut_timeline_plan(work_dir):
         return json.loads(validated_plan_path.read_text(encoding="utf-8"))
     raw_plan = json.loads(raw_plan_path.read_text(encoding="utf-8"))
     validated_plan = json.loads(validated_plan_path.read_text(encoding="utf-8"))
-    if (
-        isinstance(validated_plan, dict)
-        and validated_plan.get("raw_plan_fingerprint") == _value_fingerprint(raw_plan)
-    ):
+    if validated_plan.get("raw_plan_fingerprint") == _value_fingerprint(raw_plan):
         return validated_plan
     return raw_plan
 
 
-def _ratio_to_float(value, default=1.0):
-    value = str(value or "").strip()
-    if not value or value in {"0:1", "0/1", "N/A"}:
-        return default
-    try:
-        if ":" in value:
-            num, den = value.split(":", 1)
-        elif "/" in value:
-            num, den = value.split("/", 1)
+def _plan_clip_spans(work_dir):
+    """Cut-mode clip spans [{source_start, source_end, output_start, output_end, entry}], or None.
+
+    clip_plan.json is either a bare list or {"clips": [...]}; a clip names its source range as
+    source_start/source_end or start/end. Clips without explicit output_start/output_end are laid
+    out back to back on the output timeline.
+    """
+    plan = _load_cut_timeline_plan(work_dir)
+    if plan is None:
+        return None
+    entries = plan["clips"] if isinstance(plan, dict) else plan
+    spans, cursor = [], 0.0
+    for entry in entries:
+        ss = float(entry.get("source_start", entry.get("start")))
+        se = float(entry.get("source_end", entry.get("end")))
+        if "output_start" in entry:
+            out_s, out_e = float(entry["output_start"]), float(entry["output_end"])
+            cursor = max(cursor, out_e)
         else:
-            return float(value)
-        den_f = float(den or 0)
-        return float(num) / den_f if den_f else default
-    except (TypeError, ValueError, ZeroDivisionError):
+            out_s, out_e = cursor, cursor + (se - ss)
+            cursor = out_e
+        spans.append({
+            "source_start": ss, "source_end": se,
+            "output_start": out_s, "output_end": out_e,
+            "entry": entry,
+        })
+    return spans
+
+
+def _ratio_to_float(value, default=1.0):
+    """Parse an ffprobe ratio ("4:3", "16/9" or a bare number); unknown ratios yield `default`."""
+    value = value.strip()
+    if value in {"", "0:1", "0/1", "N/A"}:
         return default
+    if ":" in value:
+        num, den = value.split(":", 1)
+    elif "/" in value:
+        num, den = value.split("/", 1)
+    else:
+        return float(value)
+    return float(num) / float(den) if float(den) else default
 
 
 def _fps_from_rate(value, default=30.0):
-    try:
-        if "/" in str(value):
-            num, den = str(value).split("/", 1)
-            den_f = float(den or 0)
-            return round(float(num) / den_f, 3) if den_f else default
-        return round(float(value), 3)
-    except (TypeError, ValueError, ZeroDivisionError):
-        return default
+    """Parse an ffprobe frame rate ("30000/1001" or a bare number); a 0/0 rate yields `default`."""
+    if "/" in value:
+        num, den = value.split("/", 1)
+        return round(float(num) / float(den), 3) if float(den) else default
+    return round(float(value), 3)
 
 
 def _stream_rotation(stream):
     """Extract rotation from tags or side_data_list in ffprobe JSON."""
-    if not isinstance(stream, dict):
-        return 0
-    for source in (
-        (stream.get("tags") or {}).get("rotate"),
-        stream.get("rotation"),
-    ):
+    for source in (stream.get("tags", {}).get("rotate"), stream.get("rotation")):
         if source not in (None, ""):
-            try:
-                return int(round(float(source))) % 360
-            except (TypeError, ValueError):
-                pass
-    for item in stream.get("side_data_list") or []:
-        if not isinstance(item, dict):
-            continue
-        for key in ("rotation", "displaymatrix"):
-            if item.get(key) not in (None, ""):
-                try:
-                    return int(round(float(item.get(key)))) % 360
-                except (TypeError, ValueError):
-                    pass
+            return int(round(float(source))) % 360
+    for item in stream.get("side_data_list", []):
+        if item.get("rotation") not in (None, ""):
+            return int(round(float(item["rotation"]))) % 360
     return 0
 
 
-def _canvas_from_stream(stream, *, default_width=1280, default_height=720, default_fps=30.0):
-    storage_w = int(stream.get("width") or default_width)
-    storage_h = int(stream.get("height") or default_height)
-    fps = _fps_from_rate(stream.get("r_frame_rate") or stream.get("avg_frame_rate"), default_fps)
-    sar_text = stream.get("sample_aspect_ratio") or "1:1"
-    dar_text = stream.get("display_aspect_ratio") or ""
+def _canvas_from_stream(stream):
+    storage_w = stream["width"]
+    storage_h = stream["height"]
+    fps = _fps_from_rate(stream["r_frame_rate"])
+    sar_text = stream.get("sample_aspect_ratio", "1:1")
+    dar_text = stream.get("display_aspect_ratio", "")
     sar = _ratio_to_float(sar_text, 1.0)
     rotation = _stream_rotation(stream)
 
@@ -91,9 +98,9 @@ def _canvas_from_stream(stream, *, default_width=1280, default_height=720, defau
     if dar_text and dar_text not in {"0:1", "N/A"}:
         dar = _ratio_to_float(dar_text, 0.0)
         # ffprobe sources are not consistent: some report DAR before rotation
-        # (landscape value > 1 for a 90° stream), while simple line mocks and
-        # some containers report the already-rotated portrait DAR (< 1). Only
-        # apply DAR before swapping when it describes the stored orientation.
+        # (landscape value > 1 for a 90° stream), while some containers report the
+        # already-rotated portrait DAR (< 1). Only apply DAR before swapping when it
+        # describes the stored orientation.
         if dar > 0 and not (rotation in {90, 270} and dar < 1.0):
             # Preserve height and adjust width. This keeps legacy square-pixel landscape
             # byte-identical while honoring non-square pixel DAR metadata.
@@ -110,10 +117,6 @@ def _canvas_from_stream(stream, *, default_width=1280, default_height=720, defau
         "rotation": rotation,
         "sample_aspect_ratio": sar_text,
         "display_aspect_ratio": dar_text or f"{display_w}:{display_h}",
-        "sar": sar_text,
-        "dar": dar_text or f"{display_w}:{display_h}",
-        "display_width": display_w,
-        "display_height": display_h,
     }
 
 
@@ -122,44 +125,19 @@ def _probe_canvas(video_path, *, command_runner=run_cmd):
 
     ``width``/``height`` are the display canvas used by subtitle/overlay geometry.
     For legacy square-pixel landscape sources, these remain the raw storage dimensions.
-    Extra storage/rotation/SAR/DAR fields are visual QC facts and are safe for callers
-    that only consume width/height/fps.
     """
-    defaults = {"width": 1280, "height": 720, "fps": 30.0}
     res = command_runner([
         "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),
     ])
-    if res.returncode == 0:
-        try:
-            data = json.loads(res.stdout or "{}")
-            stream = (data.get("streams") or [{}])[0]
-            if isinstance(stream, dict) and stream:
-                return _canvas_from_stream(stream)
-        except (ValueError, TypeError, KeyError):
-            pass
-        # Tests and older mocks may still feed default=nw=1:nk=0 style lines.
-        stream = {}
-        for line in (res.stdout or "").splitlines():
-            line = line.strip()
-            if not line or "=" not in line:
-                continue
-            key, value = line.split("=", 1)
-            stream[key] = value
-        if stream:
-            return _canvas_from_stream(stream)
-    return {
-        **defaults,
-        "storage_width": defaults["width"],
-        "storage_height": defaults["height"],
-        "rotation": 0,
-        "sample_aspect_ratio": "1:1",
-        "display_aspect_ratio": "16:9",
-        "display_width": defaults["width"],
-        "display_height": defaults["height"],
-    }
+    if res.returncode != 0:
+        raise RuntimeError(f"ffprobe 无法读取视频流 {video_path}: {res.stderr}")
+    streams = json.loads(res.stdout)["streams"]
+    if not streams:
+        raise RuntimeError(f"{video_path} 没有视频流")
+    return _canvas_from_stream(streams[0])
 
 
 def _has_audio_stream(video_path, *, command_runner=run_cmd):
@@ -183,61 +161,39 @@ def _build_video_clips(
 
     In cut mode each plan entry becomes a clip referencing the ORIGINAL source
     range. Multi-source validated plans carry per-clip source_path and do not
-    require an explicit ambient --source-video.
+    require an explicit ambient --source-video. Without any declared source (full
+    mode, or cut mode rendered without --source-video) the rendered input is one clip.
     """
     explicit_source_video = source_video_getter()
-    try:
-        plan = _load_cut_timeline_plan(work_dir)
-        if plan is not None:
-            entries = plan.get("clips", plan) if isinstance(plan, dict) else plan
-            # A plan is "multi-source" once any clip carries its own source_path; such
-            # clips must never be silently dropped — a missing one is degraded in place.
-            multi_source = any(
-                isinstance(c, dict) and str(c.get("source_path") or "").strip() for c in entries
-            )
-            clips, cursor = [], 0.0
-            for c in entries:
-                per_clip_source = str(c.get("source_path") or "").strip()
-                source_path = per_clip_source or explicit_source_video
-                ss = float(c.get("source_start", c.get("start")))
-                se = float(c.get("source_end", c.get("end")))
-                timeline_start = c.get("output_start")
-                timeline_end = c.get("output_end")
-                dur = max(0.0, se - ss)
-                if dur <= 0:
-                    continue
-                if timeline_start is None or timeline_end is None:
-                    timeline_start = cursor
-                    timeline_end = cursor + dur
-                    cursor += dur
-                else:
-                    timeline_start = float(timeline_start)
-                    timeline_end = float(timeline_end)
-                    cursor = max(cursor, timeline_end)
-                if not source_path or not os.path.exists(source_path):
-                    if per_clip_source or multi_source:
-                        # Degrade ONLY this clip — point it at the rendered cut for its own
-                        # output window — and keep real provenance for every present source,
-                        # instead of collapsing the whole multi-source timeline.
-                        seg = max(0.0, float(timeline_end) - float(timeline_start))
-                        logger(f"  时间线: source_path 不存在，该片段降级为剪后成片片段: {source_path or '(unset)'}")
-                        clips.append({"source_id": c.get("source_id"),
-                                      "source_path": str(input_video),
-                                      "source_start": float(timeline_start),
-                                      "source_end": float(timeline_start) + seg,
-                                      "timeline_start": float(timeline_start),
-                                      "timeline_end": float(timeline_end),
-                                      "provenance_degraded": True,
-                                      "provenance_reason": f"missing_source_path:{source_path or 'unset'}"})
-                    continue
-                clips.append({"source_id": c.get("source_id"),
-                              "source_path": source_path, "source_start": ss,
-                              "source_end": se, "timeline_start": timeline_start,
-                              "timeline_end": timeline_end})
-            if clips:
-                return clips
-    except (TypeError, ValueError, KeyError, OSError) as exc:
-        logger(f"  时间线: clip_plan 解析失败，回退单片 ({exc})")
-    return [{"source_path": str(input_video), "source_start": 0.0,
-             "source_end": float(duration_s), "timeline_start": 0.0,
-             "timeline_end": float(duration_s)}]
+    spans = _plan_clip_spans(work_dir)
+    multi_source = spans is not None and any(span["entry"].get("source_path") for span in spans)
+    if spans is None or not (explicit_source_video or multi_source):
+        return [{"source_path": str(input_video), "source_start": 0.0,
+                 "source_end": float(duration_s), "timeline_start": 0.0,
+                 "timeline_end": float(duration_s)}]
+    clips = []
+    for span in spans:
+        entry = span["entry"]
+        source_path = entry.get("source_path") or explicit_source_video
+        timeline_start, timeline_end = span["output_start"], span["output_end"]
+        if not source_path or not os.path.exists(source_path):
+            # Degrade ONLY this clip — point it at the rendered cut for its own output
+            # window — and keep real provenance for every present source, instead of
+            # collapsing the whole multi-source timeline.
+            logger(f"  时间线: source_path 不存在，该片段降级为剪后成片片段: {source_path or '(unset)'}")
+            clips.append({"source_id": entry.get("source_id"),
+                          "source_path": str(input_video),
+                          "source_start": timeline_start,
+                          "source_end": timeline_end,
+                          "timeline_start": timeline_start,
+                          "timeline_end": timeline_end,
+                          "provenance_degraded": True,
+                          "provenance_reason": f"missing_source_path:{source_path or 'unset'}"})
+            continue
+        clips.append({"source_id": entry.get("source_id"),
+                      "source_path": source_path,
+                      "source_start": span["source_start"],
+                      "source_end": span["source_end"],
+                      "timeline_start": timeline_start,
+                      "timeline_end": timeline_end})
+    return clips