@oh-story/dsh 0.1.7 → 0.1.9

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

@@ -17,21 +17,22 @@ def assembly_settings_fingerprint(work_dir=None):
     """Settings that affect the rendered video, used by pipeline resume cache. When work_dir is
     given, a user_subtitles presence flag is included so dropping in a user-subtitle file rebuilds
     the cached subtitles."""
-    burn_subtitles = bool(CONFIG.get("burn_subtitles", False))
+    burn_subtitles = CONFIG["burn_subtitles"]
     mask_policy = _source_subtitle_mask_policy(work_dir)
-    mask_source_subtitles = bool(mask_policy["active"])
-    user_subtitles = _has_user_subtitles(work_dir)
-    overlay_path = Path(work_dir) / VISUAL_OVERLAYS if work_dir is not None else None
+    mask_source_subtitles = mask_policy["active"]
+    overlay_fingerprint = (
+        _artifact_fingerprint(Path(work_dir) / VISUAL_OVERLAYS) if work_dir is not None else None
+    )
     fingerprint = {
         "version": SUBTITLE_RENDER_VERSION,
         "subtitle_text_normalize": SUBTITLE_TEXT_NORMALIZE_VERSION,
-        "user_subtitles": user_subtitles,
+        "user_subtitles": _has_user_subtitles(work_dir),
         "burn_subtitles": burn_subtitles,
-        "force_video_reencode": bool(CONFIG.get("force_video_reencode", False)),
+        "force_video_reencode": CONFIG["force_video_reencode"],
         "encode": {
-            "output_crf": CONFIG.get("output_crf", 18),
-            "output_preset": CONFIG.get("output_preset", "veryfast"),
-            "output_max_height": CONFIG.get("output_max_height", 0),
+            "output_crf": CONFIG["output_crf"],
+            "output_preset": CONFIG["output_preset"],
+            "output_max_height": CONFIG["output_max_height"],
         },
         "video_filters": {
             "mask_source_subtitles": mask_source_subtitles,
@@ -39,53 +40,53 @@ def assembly_settings_fingerprint(work_dir=None):
             "source_subtitle_mask_policy_declared": mask_policy["declared"],
             "source_subtitle_mask_policy_trigger": mask_policy["trigger"],
             "source_subtitle_mask_ratio": (
-                CONFIG.get("source_subtitle_mask_ratio", 0.14) if mask_source_subtitles else None
+                CONFIG["source_subtitle_mask_ratio"] if mask_source_subtitles else None
             ),
             "source_subtitle_mask_timing": (
-                CONFIG.get("source_subtitle_mask_timing", "narration") if mask_source_subtitles else None
+                CONFIG["source_subtitle_mask_timing"] if mask_source_subtitles else None
             ),
             "subtitle_mask_opacity": (
-                CONFIG.get("subtitle_mask_opacity", 0.6) if mask_source_subtitles else None
+                CONFIG["subtitle_mask_opacity"] if mask_source_subtitles else None
             ),
             "subtitle_mask_padding": (
-                CONFIG.get("subtitle_mask_padding", 4) if mask_source_subtitles else None
+                CONFIG["subtitle_mask_padding"] if mask_source_subtitles else None
             ),
-            "subtitle_y_top": CONFIG.get("subtitle_y_top", -1),
-            "subtitle_y_bot": CONFIG.get("subtitle_y_bot", -1),
+            "subtitle_y_top": CONFIG["subtitle_y_top"],
+            "subtitle_y_bot": CONFIG["subtitle_y_bot"],
             "visual_overlays": {
                 "artifact": VISUAL_OVERLAYS,
-                "present": bool(overlay_path and overlay_path.exists()),
-                "fingerprint": _artifact_fingerprint(overlay_path) if overlay_path and overlay_path.exists() else None,
+                "present": overlay_fingerprint is not None,
+                "fingerprint": overlay_fingerprint,
             },
         },
         "narration_timing": {
-            "delay_seconds": CONFIG.get("narration_delay_seconds", 0.0),
-            "tail_pad_seconds": CONFIG.get("narration_tail_pad_seconds", 0.1),
-            "fade_ms": CONFIG.get("fade_ms", 120),
-            "narration_speed": CONFIG.get("narration_speed", 1.0),
-            "narration_cumulative_tempo_max": CONFIG.get("narration_cumulative_tempo_max", 1.35),
-            "tts_segment_tempo_max": CONFIG.get("tts_segment_tempo_max", 1.20),
+            "delay_seconds": CONFIG["narration_delay_seconds"],
+            "tail_pad_seconds": CONFIG["narration_tail_pad_seconds"],
+            "fade_ms": CONFIG["fade_ms"],
+            "narration_speed": CONFIG["narration_speed"],
+            "narration_cumulative_tempo_max": CONFIG["narration_cumulative_tempo_max"],
+            "tts_segment_tempo_max": CONFIG["tts_segment_tempo_max"],
         },
         "audio_mix": {
-            "ducking_mode": CONFIG.get("ducking_mode", "fixed"),
-            "duck_fade_seconds": CONFIG.get("duck_fade_seconds", 0.3),
-            "duck_bridge_seconds": CONFIG.get("duck_bridge_seconds", 1.5),
-            "ducking_narr_weight": CONFIG.get("ducking_narr_weight", 1.5),
-            "ducking_orig_volume": CONFIG.get("ducking_orig_volume", 0.3),
-            "idle_orig_volume": CONFIG.get("idle_orig_volume", 1.0),
-            "speech_ducking_volume": CONFIG.get("speech_ducking_volume", 0.2),
-            "zone_ducking_volume": CONFIG.get("zone_ducking_volume", 0.12),
-            "ducking_threshold": CONFIG.get("ducking_threshold", 0.15),
-            "ducking_ratio": CONFIG.get("ducking_ratio", 3),
-            "ducking_attack": CONFIG.get("ducking_attack", 10),
-            "ducking_release": CONFIG.get("ducking_release", 300),
-            "ducking_level_sc": CONFIG.get("ducking_level_sc", 2.0),
-            "ducking_makeup": CONFIG.get("ducking_makeup", 1.2),
+            "ducking_mode": CONFIG["ducking_mode"],
+            "duck_fade_seconds": CONFIG["duck_fade_seconds"],
+            "duck_bridge_seconds": CONFIG["duck_bridge_seconds"],
+            "ducking_narr_weight": CONFIG["ducking_narr_weight"],
+            "ducking_orig_volume": CONFIG["ducking_orig_volume"],
+            "idle_orig_volume": CONFIG["idle_orig_volume"],
+            "speech_ducking_volume": CONFIG["speech_ducking_volume"],
+            "zone_ducking_volume": CONFIG["zone_ducking_volume"],
+            "ducking_threshold": CONFIG["ducking_threshold"],
+            "ducking_ratio": CONFIG["ducking_ratio"],
+            "ducking_attack": CONFIG["ducking_attack"],
+            "ducking_release": CONFIG["ducking_release"],
+            "ducking_level_sc": CONFIG["ducking_level_sc"],
+            "ducking_makeup": CONFIG["ducking_makeup"],
             "final_loudnorm": final_loudnorm_filter(),
             "loudness_mode": _loudness_mode(),
-            "bgm_path": CONFIG.get("bgm_path", ""),
-            "bgm_volume": CONFIG.get("bgm_volume", 0.18),
-            "bgm_ducking_volume": CONFIG.get("bgm_ducking_volume", 0.10),
+            "bgm_path": CONFIG["bgm_path"],
+            "bgm_volume": CONFIG["bgm_volume"],
+            "bgm_ducking_volume": CONFIG["bgm_ducking_volume"],
         },
     }
     if burn_subtitles:

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

@@ -10,7 +10,7 @@ def _round_keyframe(t_s, gain):
 
 
 def default_bridge(fade):
-    return 2 * float(fade or 0)
+    return 2 * float(fade)
 
 
 def coalesce_duck_windows(windows, bridge):
@@ -25,7 +25,7 @@ def coalesce_duck_windows(windows, bridge):
     )
     if not rel:
         return []
-    bridge = float(bridge or 0)
+    bridge = float(bridge)
     merged = [rel[0][:]]
     for s, e, gain in rel[1:]:
         if s - merged[-1][1] < bridge:
@@ -51,7 +51,7 @@ def duck_ramp_expression(start, end, fade):
     """
     start = float(start)
     end = float(end)
-    fade = float(fade or 0)
+    fade = float(fade)
     if fade <= 0:
         return f"between(t,{start:.2f},{end:.2f})"
     ramp_start = start - fade
@@ -61,32 +61,25 @@ def duck_ramp_expression(start, end, fade):
 
 def ducking_expression(windows, idle, fade):
     """Build the ffmpeg volume expression for coalesced duck windows."""
-    merged = list(windows or [])
-    if not merged:
+    if not windows:
         return None
     idle = float(idle)
     terms = [
         f"+({float(level) - idle:.3f})*{duck_ramp_expression(s, e, fade)}"
-        for s, e, level in merged
+        for s, e, level in windows
     ]
     return f"max(0,min(1,{idle}{''.join(terms)}))"
 
 
-def coalesce_release_duck_windows(windows, bridge, default_release_fade=0.0):
-    """Merge [(start, hold_end, gain, restore_at?)] while preserving safe releases."""
-    fade = max(0.0, float(default_release_fade or 0.0))
-    rel = []
-    for row in windows or []:
-        if len(row) < 3:
-            continue
-        start, end, gain = map(float, row[:3])
-        restore = float(row[3]) if len(row) > 3 and row[3] is not None else end + fade
-        if end > start:
-            rel.append([start, end, gain, max(end, restore)])
-    rel.sort(key=lambda row: row[0])
+def coalesce_release_duck_windows(windows, bridge):
+    """Merge [(start, hold_end, gain, restore_at)] while preserving safe releases."""
+    rel = sorted(
+        ([float(s), float(e), float(g), max(float(e), float(r))] for s, e, g, r in windows if float(e) > float(s)),
+        key=lambda row: row[0],
+    )
     if not rel:
         return []
-    bridge = max(0.0, float(bridge or 0.0))
+    bridge = float(bridge)
     merged = [rel[0][:]]
     for start, end, gain, restore in rel[1:]:
         if start - merged[-1][1] < bridge:
@@ -100,10 +93,10 @@ def coalesce_release_duck_windows(windows, bridge, default_release_fade=0.0):
 
 def release_ducking_expression(windows, idle, attack_fade, bridge=None):
     """FFmpeg gain expression with a fixed attack and a per-window safe release end."""
-    attack = max(0.0, float(attack_fade or 0.0))
+    attack = float(attack_fade)
     if bridge is None:
         bridge = default_bridge(attack)
-    merged = coalesce_release_duck_windows(windows, bridge, attack)
+    merged = coalesce_release_duck_windows(windows, bridge)
     if not merged:
         return None
     idle = float(idle)
@@ -125,19 +118,16 @@ def release_ducking_expression(windows, idle, attack_fade, bridge=None):
 
 def release_ducking_keyframes(windows, idle, attack_fade, span_start, span_end, bridge=None):
     """Timeline keyframes matching `release_ducking_expression` exactly."""
-    attack = max(0.0, float(attack_fade or 0.0))
+    attack = float(attack_fade)
     if bridge is None:
         bridge = default_bridge(attack)
     span_start, span_end = float(span_start), float(span_end)
-    normalized = []
-    for row in windows or []:
-        if len(row) < 3:
-            continue
-        start, end, gain = map(float, row[:3])
-        restore = float(row[3]) if len(row) > 3 and row[3] is not None else end + attack
-        if end > span_start and start < span_end and end > start:
-            normalized.append((max(span_start, start), min(span_end, end), gain, min(span_end, max(end, restore))))
-    merged = coalesce_release_duck_windows(normalized, bridge, attack)
+    normalized = [
+        (max(span_start, start), min(span_end, end), gain, min(span_end, max(end, restore)))
+        for start, end, gain, restore in ((float(s), float(e), float(g), float(r)) for s, e, g, r in windows)
+        if end > span_start and start < span_end and end > start
+    ]
+    merged = coalesce_release_duck_windows(normalized, bridge)
     if not merged:
         return []
     points = [(span_start, float(idle))]
@@ -161,7 +151,7 @@ def release_ducking_keyframes(windows, idle, attack_fade, span_start, span_end,
 
 def variable_ducking_keyframes(windows, idle, fade, span_start, span_end, bridge=None):
     """Volume keyframes for per-window duck gains using canonical semantics."""
-    fade = float(fade or 0)
+    fade = float(fade)
     if bridge is None:
         bridge = default_bridge(fade)
     span_start = float(span_start)