@lemoncat7/dsh-partner 2.8.1 → 2.8.2

package/resources/skills/video-recap-production/upstream/skills/video-assemble/scripts/jianying/model.py

@@ -0,0 +1,105 @@
+"""Thin internal model used at the JianYing adapter boundary."""
+
+from dataclasses import dataclass, field
+from collections.abc import Callable
+
+from jianying.schema import us
+from jianying.tracks import TrackAllocator
+
+
+ProbeFn = Callable[[str], tuple[int, int, int]]
+NewIdFn = Callable[[], str]
+
+
+@dataclass
+class DraftBuildContext:
+    """Normalized draft build state and overlap-safe track collection."""
+
+    width: int
+    height: int
+    fps: float
+    total_us: int
+    new_id: NewIdFn
+    probe: ProbeFn
+    resource_packages: dict = field(default_factory=dict)
+    style_presets: dict = field(default_factory=dict)
+    materials: dict[str, list] = field(
+        default_factory=lambda: {
+            key: []
+            for key in (
+                "audios",
+                "chromas",
+                "common_mask",
+                "drafts",
+                "effects",
+                "masks",
+                "speeds",
+                "stickers",
+                "text_templates",
+                "texts",
+                "transitions",
+                "video_effects",
+                "videos",
+            )
+        }
+    )
+    tracks: list[dict] = field(default_factory=list)
+    notes: list[str] = field(default_factory=list)
+    track_allocator: TrackAllocator = field(default_factory=TrackAllocator)
+
+    @classmethod
+    def from_timeline(cls, timeline, new_id, probe):
+        """Build from a timeline already validated by jianying.timeline_contract."""
+        canvas = timeline["canvas"]
+        return cls(
+            width=canvas["width"],
+            height=canvas["height"],
+            fps=float(canvas["fps"]),
+            total_us=us(timeline["duration"]),
+            new_id=new_id,
+            probe=probe,
+            resource_packages=timeline.get("resource_packages", {}),
+            style_presets=timeline.get("style_presets", {}),
+        )
+
+    def add_segment(self, kind, base_name, start_us, duration_us, segment):
+        allocated = self.track_allocator.allocate(kind, base_name, start_us, duration_us)
+        track = next(
+            (
+                item for item in self.tracks
+                if item["_semantic_kind"] == allocated.kind
+                and item["name"] == allocated.name
+            ),
+            None,
+        )
+        if track is None:
+            track = {
+                "attribute": 0,
+                "flag": 0,
+                "id": self.new_id(),
+                "is_default_name": True,
+                "name": allocated.name,
+                "segments": [],
+                "type": allocated.track_type,
+                "_semantic_kind": allocated.kind,
+                "_layout_order": allocated.layout_order,
+            }
+            self.tracks.append(track)
+        track["segments"].append(segment)
+        return track
+
+    def finalize_tracks(self):
+        # Python's stable sort preserves the timeline's authored order inside
+        # one semantic band (for example narration before BGM).
+        self.tracks.sort(key=lambda item: item["_layout_order"])
+        type_counts = {}
+        for track in self.tracks:
+            count = type_counts.get(track["type"], 0)
+            track["flag"] = 0 if count == 0 else 2
+            type_counts[track["type"]] = count + 1
+            del track["_semantic_kind"]
+            del track["_layout_order"]
+        return self.tracks
+
+    def note(self, message):
+        self.notes.append(message)

package/resources/skills/video-recap-production/upstream/skills/video-assemble/scripts/jianying/optional.py

@@ -0,0 +1,23 @@
+"""Failure-isolated optional JianYing export invoked after canonical rendering."""
+
+from pathlib import Path
+
+from lib import CONFIG, log
+
+def maybe_export_jianying(work_dir, out_dir, stem):
+    """Lazy-import the optional 剪映 exporter and write a draft from timeline.json.
+
+    The export is a documented fail-open sidecar: any failure is logged and never
+    fails the already-rendered recap."""
+    try:
+        from export_jianying import export_timeline_to_jianying
+        from timeline import load_timeline
+        parent = out_dir or CONFIG["jianying_draft_dir"] or str(work_dir)
+        draft_dir, notes = export_timeline_to_jianying(
+            load_timeline(Path(work_dir) / "timeline.json"), parent, draft_name=f"recap_{stem}",
+            bundle_media=CONFIG["jianying_bundle_media"])
+        for n in notes:
+            log(f"  注意: {n}")
+        log(f"剪映草稿已导出: {draft_dir}")
+    except Exception as exc:
+        log(f"  ⚠️ 剪映导出失败（不影响成片）: {exc}")

package/resources/skills/video-recap-production/upstream/skills/video-assemble/scripts/jianying/schema.py

@@ -0,0 +1,53 @@
+"""Schema constants and skeleton factories for JianYing export.
+
+This module is intentionally data-oriented: it owns draft version metadata and
+the full `materials` parallel-array shape.
+"""
+
+from jianying.templates import template
+
+# The full 剪映 materials object: ~45 parallel arrays. Only arrays backed by a
+# production builder are populated; retaining the full shape preserves compatibility.
+MATERIAL_KEYS = ["ai_translates", "audio_balances", "audio_effects", "audio_fades", "audio_track_indexes", "audios", "beats", "canvases", "chromas", "color_curves", "digital_humans", "drafts", "effects", "flowers", "green_screens", "handwrites", "hsl", "images", "log_color_wheels", "loudnesses", "manual_deformations", "masks", "common_mask", "material_animations", "material_colors", "multi_language_refs", "placeholders", "plugin_effects", "primary_color_wheels", "realtime_denoises", "shapes", "smart_crops", "smart_relights", "sound_channel_mappings", "speeds", "stickers", "tail_leaders", "text_templates", "texts", "time_marks", "transitions", "video_effects", "video_trackings", "videos", "vocal_beautifys", "vocal_separations"]
+
+
+def us(seconds):
+    """Seconds (float) -> integer microseconds. The single seconds->µs boundary."""
+    return int(round(float(seconds) * 1_000_000))
+
+
+def full_materials(filled):
+    """Return a complete JianYing `materials` object with all known arrays."""
+    out = {k: [] for k in MATERIAL_KEYS}
+    out.update(filled)
+    return out
+
+
+def scrub_platform_identity(project):
+    """Remove hardware fingerprints carried by the pinned upstream templates."""
+    for platform_key in ("last_modified_platform", "platform"):
+        for identity_key in ("device_id", "hard_disk_id", "mac_address"):
+            project[platform_key][identity_key] = ""
+    return project
+
+
+def draft_content_skeleton(draft_id, width, height, fps, total_us, materials, tracks):
+    """Build the root `draft_content.json` / `draft_info.json` skeleton."""
+    content = template("project")
+    scrub_platform_identity(content)
+    content["canvas_config"] = {"width": width, "height": height, "ratio": "original"}
+    content["duration"] = int(total_us)
+    content["fps"] = float(fps)
+    content["id"] = draft_id
+    content["materials"] = full_materials(materials)
+    content["tracks"] = tracks
+    return content
+
+
+def meta_info(draft_id, total_us):
+    """Build the companion `draft_meta_info.json` skeleton."""
+    meta = template("meta")
+    meta["draft_id"] = draft_id
+    meta["draft_timeline_materials_size_"] = 0
+    meta["tm_duration"] = int(total_us)
+    return meta

package/resources/skills/video-recap-production/upstream/skills/video-assemble/scripts/jianying/templates.py

@@ -0,0 +1,37 @@
+"""Load the pinned duo-video JianYing protocol templates."""
+
+import copy
+import json
+from functools import lru_cache
+from pathlib import Path
+
+
+_TEMPLATE_DIR = Path(__file__).resolve().parent.parent.parent / "references" / "jianying"
+_TEMPLATE_FILES = {
+    "project": "empty_jy_project_info.json",
+    "video": "empty_jy_material_video.json",
+    "audio": "empty_yj_material_audio.json",
+    "text": "empty_yj_material_text.json",
+    "text_style": "empty_jy_text_styles.json",
+    "segment": "empty_jy_segment.json",
+    "draft": "empty_jy_draft.json",
+    "combination_segment": "empty_jy_combination_segment.json",
+    "combination_video": "empty_jy_combination_video_material.json",
+    "meta": "empty_draft_meta_info.json",
+    "meta_material": "empty_jy_meta_material_value.json",
+}
+
+
+@lru_cache(maxsize=None)
+def _read_template(name):
+    try:
+        filename = _TEMPLATE_FILES[name]
+    except KeyError as exc:
+        raise ValueError(f"unknown JianYing template: {name}") from exc
+    with open(_TEMPLATE_DIR / filename, encoding="utf-8") as source:
+        return json.load(source)
+
+
+def template(name):
+    """Return a mutable deep copy of a pinned protocol template."""
+    return copy.deepcopy(_read_template(name))

package/resources/skills/video-recap-production/upstream/skills/video-assemble/scripts/jianying/timeline_contract.py

@@ -0,0 +1,223 @@
+"""Timeline validation and migration at the JianYing adapter boundary."""
+
+import copy
+import math
+
+
+CURRENT_SCHEMA_VERSION = 2
+RESOURCE_TRACK_KINDS = {
+    "face_effect", "sound", "sticker", "text_template", "video_effect",
+}
+
+def _error(path, expectation):
+    raise ValueError(f"invalid timeline {path}: {expectation}")
+
+
+def _is_number(value):
+    return isinstance(value, (int, float)) and not isinstance(value, bool) and math.isfinite(value)
+
+
+def _field_path(path, key):
+    return f"{path}.{key}" if path else key
+
+
+def _require_number(container, key, path, *, minimum=None):
+    field_path = _field_path(path, key)
+    if key not in container or not _is_number(container[key]):
+        _error(field_path, "must be a finite number")
+    value = container[key]
+    if minimum is not None and value < minimum:
+        _error(field_path, f"must be >= {minimum}")
+    return value
+
+
+def _require_string(container, key, path):
+    value = container.get(key)
+    if not isinstance(value, str) or not value:
+        _error(_field_path(path, key), "must be a non-empty string")
+    return value
+
+
+def _validate_span(item, path, start_key="timeline_start", end_key="timeline_end"):
+    start = _require_number(item, start_key, path, minimum=0)
+    end = _require_number(item, end_key, path, minimum=0)
+    if end <= start:
+        _error(f"{path}.{end_key}", f"must be greater than {start_key}")
+
+
+def _validate_transform(item, path):
+    for field in ("scale", "position", "flip"):
+        if field in item and not isinstance(item[field], dict):
+            _error(f"{path}.{field}", "must be an object")
+
+
+def _validate_resources(resources, path):
+    if not isinstance(resources, list) or any(not isinstance(item, dict) for item in resources):
+        _error(path, "must contain source_path objects")
+    for index, item in enumerate(resources):
+        _require_string(item, "source_path", f"{path}[{index}]")
+
+
+def _validate_video_clip(clip, path):
+    if not isinstance(clip, dict):
+        _error(path, "must be an object")
+    _require_string(clip, "source_path", path)
+    _validate_span(clip, path)
+    _validate_span(clip, path, "source_start", "source_end")
+    if "audio" in clip and not isinstance(clip["audio"], dict):
+        _error(f"{path}.audio", "must be an object")
+    if "speed" in clip:
+        speed = _require_number(clip, "speed", path)
+        if speed <= 0:
+            _error(f"{path}.speed", "must be greater than 0")
+        source_duration = float(clip["source_end"]) - float(clip["source_start"])
+        target_duration = float(clip["timeline_end"]) - float(clip["timeline_start"])
+        expected_source_duration = target_duration * float(speed)
+        if not math.isclose(source_duration, expected_source_duration, rel_tol=1e-6, abs_tol=1e-4):
+            _error(
+                path,
+                "source duration must equal target duration multiplied by speed "
+                f"({source_duration} != {target_duration} * {speed})",
+            )
+    if "reverse" in clip and not isinstance(clip["reverse"], bool):
+        _error(f"{path}.reverse", "must be a boolean")
+    # A reversed clip may omit reverse_path: export_timeline_to_jianying generates it.
+    if "reverse_path" in clip:
+        _require_string(clip, "reverse_path", path)
+    _validate_transform(clip, path)
+    for field in ("transition", "mask", "lut", "chroma"):
+        if field not in clip:
+            continue
+        spec = clip[field]
+        if isinstance(spec, dict):
+            if "resources" in spec:
+                _validate_resources(spec["resources"], f"{path}.{field}.resources")
+        elif not isinstance(spec, str):
+            _error(f"{path}.{field}", "must be an object or resource-package name")
+    if "compound" in clip and not isinstance(clip["compound"], bool):
+        _error(f"{path}.compound", "must be a boolean")
+    if clip.get("compound") or "green_background" in clip or "chroma" in clip:
+        # Any one of these makes the clip a green-screen compound, which needs both.
+        background = clip.get("green_background")
+        if not isinstance(background, dict):
+            _error(f"{path}.green_background", "must be a local media object")
+        _require_string(background, "source_path", f"{path}.green_background")
+        _validate_transform(background, f"{path}.green_background")
+        if "chroma" not in clip:
+            _error(f"{path}.chroma", "compound green-screen clips require a chroma object")
+
+
+def _validate_resource_config(config, path):
+    if not isinstance(config, dict):
+        _error(path, "must be an object")
+    if not isinstance(config.get("main_config"), dict):
+        _error(f"{path}.main_config", "must be an object")
+    _validate_resources(config.get("resources", []), f"{path}.resources")
+
+
+def _validate_segment(segment, path, kind):
+    if not isinstance(segment, dict):
+        _error(path, "must be an object")
+    _validate_span(segment, path)
+    _validate_transform(segment, path)
+    if "speed" in segment:
+        speed = _require_number(segment, "speed", path)
+        if speed <= 0:
+            _error(f"{path}.speed", "must be greater than 0")
+    if kind in {"audio", "image"}:
+        _require_string(segment, "source_path", path)
+    elif kind == "text" and not isinstance(segment.get("text"), str):
+        _error(f"{path}.text", "must be a string")
+    elif kind in RESOURCE_TRACK_KINDS:
+        sources = [key for key in ("material", "resource_config", "resource_package") if key in segment]
+        if len(sources) != 1:
+            _error(path, "must define exactly one of material, resource_config, or resource_package")
+        source = segment[sources[0]]
+        if sources[0] == "resource_package":
+            if not isinstance(source, str) or not source:
+                _error(f"{path}.resource_package", "must be a non-empty string")
+        elif sources[0] == "material" and not isinstance(source, dict):
+            _error(f"{path}.material", "must be an object")
+        elif sources[0] == "resource_config":
+            _validate_resource_config(source, f"{path}.resource_config")
+
+
+def _validate_track(track, path):
+    if not isinstance(track, dict):
+        _error(path, "must be an object")
+    kind = _require_string(track, "kind", path)
+    if "name" in track and (not isinstance(track["name"], str) or not track["name"]):
+        _error(f"{path}.name", "must be a non-empty string")
+
+    if kind == "video":
+        clips = track.get("clips")
+        if not isinstance(clips, list):
+            _error(f"{path}.clips", "must be an array")
+        for index, clip in enumerate(clips):
+            _validate_video_clip(clip, f"{path}.clips[{index}]")
+        return
+
+    if kind in {"audio", "image", "text"} | RESOURCE_TRACK_KINDS:
+        segments = track.get("segments")
+        if not isinstance(segments, list):
+            _error(f"{path}.segments", "must be an array")
+        if kind == "audio":
+            if "role" in track and not isinstance(track["role"], str):
+                _error(f"{path}.role", "must be a string")
+            if "loop" in track and not isinstance(track["loop"], bool):
+                _error(f"{path}.loop", "must be a boolean")
+        for index, segment in enumerate(segments):
+            _validate_segment(segment, f"{path}.segments[{index}]", kind)
+        return
+
+    _error(f"{path}.kind", f"unsupported track kind {kind!r}")
+
+
+def _validate_v2(timeline):
+    canvas = timeline.get("canvas")
+    if not isinstance(canvas, dict):
+        _error("canvas", "must be an object")
+    for dimension in ("width", "height"):
+        value = canvas.get(dimension)
+        if not isinstance(value, int) or isinstance(value, bool) or value <= 0:
+            _error(f"canvas.{dimension}", "must be a positive integer")
+    fps = _require_number(canvas, "fps", "canvas")
+    if fps <= 0:
+        _error("canvas.fps", "must be greater than 0")
+
+    _require_number(timeline, "duration", "", minimum=0)
+    resource_packages = timeline.get("resource_packages", {})
+    if not isinstance(resource_packages, dict):
+        _error("resource_packages", "must be an object")
+    for name, config in resource_packages.items():
+        _validate_resource_config(config, f"resource_packages.{name}")
+    if "style_presets" in timeline and not isinstance(timeline["style_presets"], dict):
+        _error("style_presets", "must be an object")
+    tracks = timeline.get("tracks")
+    if not isinstance(tracks, list):
+        _error("tracks", "must be an array")
+    for index, track in enumerate(tracks):
+        _validate_track(track, f"tracks[{index}]")
+
+
+def normalize_timeline(timeline):
+    """Return a validated schema-v2 copy, migrating schema v1 when necessary."""
+    if not isinstance(timeline, dict):
+        _error("root", "must be an object")
+    schema_version = timeline.get("schema_version")
+    if not isinstance(schema_version, int) or isinstance(schema_version, bool):
+        _error("schema_version", "must be integer 1 or 2")
+    if schema_version not in {1, CURRENT_SCHEMA_VERSION}:
+        raise ValueError(
+            f"unsupported timeline schema_version {schema_version}; "
+            f"supported versions are 1 and {CURRENT_SCHEMA_VERSION}"
+        )
+
+    normalized = copy.deepcopy(timeline)
+    if schema_version == 1:
+        # Schema v2 is an additive extension of v1 (local image tracks). The
+        # migration therefore preserves all authored v1 fields and only advances
+        # the version before applying the current contract.
+        normalized["schema_version"] = CURRENT_SCHEMA_VERSION
+    _validate_v2(normalized)
+    return normalized

package/resources/skills/video-recap-production/upstream/skills/video-assemble/scripts/jianying/tracks.py

@@ -0,0 +1,72 @@
+"""Semantic track ordering and overlap-safe allocation for JianYing export.
+
+The order mirrors duo-video's authoring layout. It is used only to order track
+objects; JianYing segment ``render_index`` remains the schema default and must
+not be confused with this semantic layout value.
+"""
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class TrackBand:
+    kind: str
+    track_type: str
+    layout_order: int
+    description: str
+
+
+SEGMENT_RENDER_INDEX = 2
+
+
+TRACK_LAYOUT_BANDS = {
+    "sound": TrackBand("sound", "audio", 10_000, "sound effects"),
+    "audio": TrackBand("audio", "audio", 20_000, "narration, music, and general audio"),
+    "green_screen": TrackBand("green_screen", "video", 30_000, "green-screen background"),
+    "video": TrackBand("video", "video", 40_000, "base video"),
+    "image": TrackBand("image", "video", 50_000, "image and photo overlays"),
+    "mask": TrackBand("mask", "video", 60_000, "masks"),
+    "effect": TrackBand("effect", "effect", 70_000, "video effects"),
+    "video_effect": TrackBand("video_effect", "effect", 70_000, "video effects"),
+    "face_effect": TrackBand("face_effect", "effect", 70_010, "face effects"),
+    "sticker": TrackBand("sticker", "sticker", 80_000, "stickers"),
+    "subtitle": TrackBand("subtitle", "text", 90_000, "subtitles"),
+    "text": TrackBand("text", "text", 100_000, "plain text"),
+    "text_template": TrackBand("text_template", "text", 110_000, "text templates"),
+}
+
+
+@dataclass(frozen=True)
+class AllocatedTrack:
+    kind: str
+    name: str
+    track_type: str
+    layout_order: int
+
+
+class TrackAllocator:
+    """Allocate deterministic suffix tracks when same-name segments overlap.
+
+    Intervals are half-open, so adjacent segments reuse a track while true
+    overlap creates ``name-1``, ``name-2``, and so on.
+    """
+
+    def __init__(self):
+        self._occupied = {}
+
+    @staticmethod
+    def _overlaps(start_us, duration_us, existing):
+        end_us = int(start_us) + int(duration_us)
+        return any(int(start_us) < old_end and end_us > old_start for old_start, old_end in existing)
+
+    def allocate(self, kind, base_name, start_us, duration_us):
+        band = TRACK_LAYOUT_BANDS[kind]
+        suffix = 0
+        while True:
+            name = base_name if suffix == 0 else f"{base_name}-{suffix}"
+            key = (kind, name)
+            occupied = self._occupied.setdefault(key, [])
+            if not self._overlaps(start_us, duration_us, occupied):
+                occupied.append((int(start_us), int(start_us) + int(duration_us)))
+                return AllocatedTrack(kind, name, band.track_type, band.layout_order + suffix)
+            suffix += 1