@lemoncat7/dsh-partner 2.8.1 → 2.8.2

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

@@ -0,0 +1,122 @@
+"""Static packaging layers (frame / header / logo images) burned over the whole recap.
+
+The caller writes ``work_dir/packaging_layers.json`` (the orchestrator does so from a bound
+``packaging`` template). Each layer is a local image scaled into a rect on a declared
+canvas. ffmpeg reads the images with ``movie=`` sources, so the render stays a single-input
+video filter; ``timeline.json`` gets matching image segments for editable export.
+"""
+
+import json
+from pathlib import Path
+
+import lib
+from artifacts import file_identity
+from visual_render import _escape_subtitle_filter_path
+
+PACKAGING_LAYERS = "packaging_layers.json"
+_IMAGE_EXTS = {".png", ".jpg", ".jpeg", ".webp"}
+
+
+def load_packaging_layers(work_dir, canvas):
+    """Validated layers for this canvas, or [] when the work_dir declares none."""
+    path = Path(work_dir) / PACKAGING_LAYERS
+    if not path.exists():
+        return []
+    plan = json.loads(path.read_text(encoding="utf-8"))
+    declared = plan["canvas"]
+    if (declared["width"], declared["height"]) != (canvas["width"], canvas["height"]):
+        raise RuntimeError(
+            f"{PACKAGING_LAYERS} 按 {declared['width']}x{declared['height']} 设计，"
+            f"成片画布是 {canvas['width']}x{canvas['height']}"
+        )
+    layers = []
+    for layer in plan["layers"]:
+        image = Path(layer["path"]).expanduser().resolve()
+        rect = layer["rect"]
+        if not image.is_file() or image.suffix.lower() not in _IMAGE_EXTS:
+            raise RuntimeError(f"包装图层 {layer['name']} 的图片不可用: {image}")
+        if (min(rect["x"], rect["y"]) < 0 or rect["width"] <= 0 or rect["height"] <= 0
+                or rect["x"] + rect["width"] > canvas["width"]
+                or rect["y"] + rect["height"] > canvas["height"]):
+            raise RuntimeError(f"包装图层 {layer['name']} 超出画布")
+        layers.append({"name": layer["name"], "path": str(image), "rect": dict(rect),
+                       "image_size": _image_size(image)})
+    return layers
+
+
+def _image_size(image):
+    """Pixel size of a layer image; the editor fits by it, the render stretches to the rect."""
+    res = lib.run_cmd(["ffprobe", "-v", "error", "-select_streams", "v:0",
+                       "-show_entries", "stream=width,height", "-of", "json", str(image)])
+    try:
+        stream = json.loads(res.stdout)["streams"][0]
+        return {"width": int(stream["width"]), "height": int(stream["height"])}
+    except (ValueError, KeyError, IndexError):
+        raise RuntimeError(f"无法读取包装图层尺寸: {image}") from None
+
+
+def compose_video_filter(chain, layers, *, mask_first):
+    """Join the existing filter chain, inserting packaging layers after the source mask.
+
+    Order: source-subtitle mask → packaging layers → text overlays / burned subtitles →
+    scaling. Without layers this is the plain comma-joined chain.
+    """
+    if not layers:
+        return ",".join(chain)
+    head, tail = (chain[:1], chain[1:]) if mask_first else ([], list(chain))
+    graph = [
+        f"movie=filename='{_escape_subtitle_filter_path(layer['path'])}',"
+        f"scale={layer['rect']['width']}:{layer['rect']['height']},format=rgba[pk{i}]"
+        for i, layer in enumerate(layers)
+    ]
+    current = "in"
+    if head:
+        graph.append(f"[in]{head[0]}[pm]")
+        current = "pm"
+    for i, layer in enumerate(layers):
+        out = "out" if i == len(layers) - 1 and not tail else f"po{i}"
+        graph.append(f"[{current}][pk{i}]overlay=x={layer['rect']['x']}:y={layer['rect']['y']}[{out}]")
+        current = out
+    if tail:
+        graph.append(f"[{current}]{','.join(tail)}[out]")
+    return ";".join(graph)
+
+
+def timeline_image_segments(layers, canvas, duration_s):
+    """Full-length image segments in the timeline's center-origin, Y-up transform.
+
+    The editor shows an image fitted inside the canvas (keeping its own aspect) at scale 1;
+    the render stretches it to the rect, so x and y scales are derived separately.
+    """
+    width, height = canvas["width"], canvas["height"]
+    segments = []
+    for layer in layers:
+        rect, size = layer["rect"], layer["image_size"]
+        fit = min(width / size["width"], height / size["height"])
+        segments.append({
+            "source_path": layer["path"],
+            "timeline_start": 0.0,
+            "timeline_end": duration_s,
+            "scale": {"x": round(rect["width"] / (size["width"] * fit), 6),
+                      "y": round(rect["height"] / (size["height"] * fit), 6)},
+            "position": {
+                "x": round((rect["x"] + rect["width"] / 2 - width / 2) / (width / 2), 6),
+                "y": round((height / 2 - rect["y"] - rect["height"] / 2) / (height / 2), 6),
+            },
+        })
+    return segments
+
+
+def packaging_settings(work_dir):
+    """What the manifest records: the plan file and each layer image's identity."""
+    path = Path(work_dir) / PACKAGING_LAYERS if work_dir is not None else None
+    if path is None or not path.exists():
+        return {"artifact": PACKAGING_LAYERS, "present": False, "layers": []}
+    plan = json.loads(path.read_text(encoding="utf-8"))
+    layers = []
+    for layer in plan["layers"]:
+        image = Path(layer["path"]).expanduser().resolve()
+        layers.append({"name": layer["name"], "path": str(image), "rect": layer["rect"],
+                       **(file_identity(image) if image.is_file() else {})})
+    return {"artifact": PACKAGING_LAYERS, "present": True, "identity": file_identity(path),
+            "template": plan.get("template"), "layers": layers}

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

@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+"""Pair explicit picture and adopted audio assets without re-encoding either stream.
+
+This is asset pairing, not a claim of source reconstruction, correct editorial
+selection, speech alignment, or release approval. Existing assemble then consumes
+paired.mp4; its subtitle binding must be newly computed on that container/a:0.
+"""
+
+import argparse
+from fractions import Fraction
+import json
+from pathlib import Path
+import subprocess
+
+from assemble_constants import SUPPORTED_PICTURE_CODECS
+from adoption.frozen_audio import probe_audio_packets, verify_adopted_audio
+from adoption.strict_inputs import (
+    probe_json, require_declared_path, require_fields, require_integer, run_logged,
+    without_digests, write_json_atomic,
+)
+
+
+_probe = probe_json
+
+
+def _asset(value, audio=False):
+    value = without_digests(value, 'asset')
+    require_fields(value, ['path', 'selected_stream'] if audio else ['path'], 'asset')
+    path = require_declared_path(value, 'asset')
+    if audio:
+        return {'path': str(path),
+                'selected_stream': require_integer(value['selected_stream'], 'Audio selected_stream')}
+    return {'path': str(path)}
+
+
+def _time(value):
+    if value in (None, 'N/A'):
+        raise ValueError('Missing media timing')
+    try:
+        return Fraction(str(value))
+    except (ValueError, ZeroDivisionError) as exc:
+        raise ValueError('Invalid media timing') from exc
+
+
+def probe_picture(path):
+    """Actual full CFR presentation clock plus codec-order packet sizes and timestamps."""
+    data = _probe(path, '-select_streams', 'v:0', '-show_streams', '-show_packets',
+                  '-show_format', '-show_entries',
+                  'format=format_name:stream=codec_name,profile,level,width,height,pix_fmt,'
+                  'sample_aspect_ratio,field_order,color_range,color_space,color_transfer,'
+                  'color_primaries,chroma_location,time_base,start_pts,duration_ts,avg_frame_rate'
+                  ':packet=pts,dts,duration,size,side_data_list')
+    streams = data.get('streams', [])
+    if len(streams) != 1 or streams[0].get('codec_name') not in SUPPORTED_PICTURE_CODECS:
+        raise ValueError('Pairing requires one selected H264/HEVC picture stream')
+    if 'mp4' not in data.get('format', {}).get('format_name', '').split(','):
+        raise ValueError('Pairing currently requires MP4-family picture container')
+    v = streams[0]
+    fps, tb = _time(v.get('avg_frame_rate')), _time(v.get('time_base'))
+    if not 1 <= fps <= 120 or tb <= 0 or v.get('start_pts') != 0:
+        raise ValueError('Picture requires positive CFR and a known zero start')
+    duration = _time(v.get('duration_ts')) * tb
+    frames = _probe(path, '-select_streams', 'v:0', '-show_frames',
+                    '-show_entries', 'frame=pts')['frames']
+    pts = [_time(frame.get('pts')) * tb for frame in frames]
+    if not pts or any(t != Fraction(i, fps) for i, t in enumerate(pts)) or duration != len(pts) / fps:
+        raise ValueError('Picture requires complete zero-origin CFR frame clock and exact duration')
+    decoder_keys = ['codec_name', 'profile', 'level', 'width', 'height', 'pix_fmt',
+                    'sample_aspect_ratio', 'field_order', 'color_range', 'color_space',
+                    'color_transfer', 'color_primaries', 'chroma_location']
+    packets = []
+    for packet in data.get('packets', []):
+        if packet.get('size') is None:
+            raise ValueError('Picture packet missing size')
+        ticks = {key: str(_time(packet.get(key)) * tb) for key in ['pts', 'dts', 'duration']}
+        if _time(ticks['duration']) <= 0:
+            raise ValueError('Picture packet has invalid duration')
+        packets.append({**ticks, 'size': int(packet['size']),
+                        'side_data_list': packet.get('side_data_list', [])})
+    if len(packets) != len(pts):
+        raise ValueError('Picture packet/frame counts disagree')
+    return {'decoder': {key: v.get(key) for key in decoder_keys}, 'packets': packets,
+            'frame_pts': [str(t) for t in pts], 'frame_count': len(pts), 'fps': str(fps),
+            'duration': str(duration), 'start': '0'}
+
+
+def validate_aac_packet_interval(audio):
+    """Validate exact AAC packet continuity against the stream-header interval."""
+    if audio['codec'] != 'aac':
+        raise ValueError('Pairing requires AAC adopted audio')
+    packets = audio['packets']
+    rate = audio['sample_rate']
+    if type(rate) is not int or rate <= 0 or len(packets) < 2:
+        raise ValueError('AAC packet timing is incomplete')
+    nominal = _time(packets[0]['duration'])
+    # Accept known AAC frame sample counts, never an arbitrary huge duration.
+    if nominal * rate not in {960, 1024, 1920, 2048}:
+        raise ValueError('Unsupported AAC nominal packet duration')
+    for i, packet in enumerate(packets):
+        d = _time(packet['duration'])
+        if d <= 0 or d > nominal or (i < len(packets) - 1 and d != nominal):
+            raise ValueError('Nonuniform or invalid AAC packet duration')
+        p, t = _time(packet['pts']), _time(packet['dts'])
+        if p != t:
+            raise ValueError('Unsupported AAC PTS/DTS difference')
+        if i and p != _time(packets[i-1]['pts']) + _time(packets[i-1]['duration']):
+            raise ValueError('AAC packet clock has gaps or overlaps')
+    audio_start, audio_duration = _time(audio['start_time']), _time(audio['duration'])
+    if audio_duration <= 0:
+        raise ValueError('Invalid audio interval')
+    audio_end = audio_start + audio_duration
+    first_pts = _time(packets[0]['pts'])
+    last_end = _time(packets[-1]['pts']) + _time(packets[-1]['duration'])
+    if (not 0 <= audio_start - first_pts <= nominal
+            or abs(last_end - audio_end) > Fraction(1, rate)):
+        raise ValueError('AAC packet clock does not match stream interval')
+    return audio_start, audio_end, nominal
+
+
+def validate_pair_timing(picture, audio):
+    """Narrow AAC/CFR compatibility; not a perceptual synchronization verdict."""
+    audio_start, audio_end, nominal = validate_aac_packet_interval(audio)
+    tolerance = max(1 / Fraction(picture['fps']), nominal)
+    end_delta = audio_end - Fraction(picture['duration'])
+    if abs(audio_start) > tolerance or abs(end_delta) > tolerance:
+        raise ValueError('Picture/audio interval mismatch; no implicit trim, padding, offset or retime')
+    return {'start_delta': str(audio_start),
+            'end_delta': str(end_delta),
+            'tolerance': str(tolerance), 'nominal_aac_packet': str(nominal)}
+
+
+def _run_mux(command, directory):
+    run_logged(command, directory, 'mux', timeout=600)
+
+
+def _verify_output(path):
+    data = _probe(path, '-show_streams')
+    if [stream.get('codec_type') for stream in data['streams']] != ['video', 'audio']:
+        raise ValueError('Paired output must contain only v:0 and a:0')
+    result = subprocess.run(['ffmpeg', '-v', 'error', '-xerror', '-threads', '2', '-i', str(path),
+                             '-map', '0:v:0', '-map', '0:a:0', '-f', 'null', '-'],
+                            capture_output=True, text=True, timeout=600)
+    if result.returncode or result.stderr.strip():
+        raise ValueError('Paired output full decode failed')
+
+
+def run_pair(plan_path, output_dir, *, plan_only=False):
+    plan_path, directory = Path(plan_path).resolve(), Path(output_dir).resolve()
+    directory.mkdir(parents=True, exist_ok=False)
+    report_path = directory / 'pair_run.json'
+    staged, output = directory / 'paired.rendering.mp4', directory / 'paired.mp4'
+    report = {'artifact': 'media_pair_run', 'schema_version': 1, 'status': 'PREPARING',
+              'direct_listening': 'NOT_CHECKED', 'normal_speed_review': 'NOT_CHECKED',
+              'release_approved': False}
+    write_json_atomic(report_path, report)
+    try:
+        plan = json.loads(plan_path.read_bytes())
+        require_fields(plan, ['artifact', 'schema_version', 'picture', 'audio'], 'media_pair plan')
+        if plan['artifact'] != 'media_pair' or type(plan['schema_version']) is not int or plan['schema_version'] != 1:
+            raise ValueError('Unsupported media_pair schema')
+        picture, audio = _asset(plan['picture']), _asset(plan['audio'], audio=True)
+        report.update(plan={'path': str(plan_path)}, inputs={'picture': picture, 'audio': audio})
+        video_facts = probe_picture(picture['path'])
+        audio_facts = probe_audio_packets(audio['path'], audio['selected_stream'])
+        report['timing'] = validate_pair_timing(video_facts, audio_facts)
+        report['picture'] = {k: v for k, v in video_facts.items() if k not in ['packets', 'frame_pts']}
+        report['audio'] = {'input_stream': audio['selected_stream'], 'output_stream': 0,
+                           'packet_count': audio_facts['packet_count']}
+        if plan_only:
+            report['status'] = 'PLANNED'
+            write_json_atomic(report_path, report)
+            return report
+        command = ['ffmpeg', '-nostdin', '-v', 'error', '-n', '-copyts',
+                   '-i', picture['path'], '-i', audio['path'], '-map', '0:v:0',
+                   '-map', f"1:a:{audio['selected_stream']}", '-c', 'copy',
+                   '-movie_timescale', str(audio_facts['sample_rate']),
+                   '-movflags', '+faststart', str(staged)]
+        _run_mux(command, directory)
+        if probe_picture(staged) != video_facts:
+            raise ValueError('Paired picture packets, decoder, geometry/color or full frame clock changed')
+        proof = verify_adopted_audio(audio['path'], staged, audio['selected_stream'], 0)
+        output_timing = validate_pair_timing(video_facts, proof['output'])
+        if output_timing != report['timing']:
+            raise ValueError('Output audio presentation interval changed')
+        report['output_timing'] = output_timing
+        _verify_output(staged)
+        write_json_atomic(directory / 'picture_identity.json', video_facts)
+        write_json_atomic(directory / 'adopted_audio_identity.json', proof)
+        report['output'] = {'path': str(output), 'full_decode': 'PASS',
+                            'picture_identity': 'EXACT', 'audio_packet_identity': 'EXACT'}
+        staged.rename(output)
+        report['status'] = 'PAIR_RENDERED'
+        write_json_atomic(report_path, report)
+        return report
+    except Exception as exc:
+        # A partial unique run is evidence, never a final/current asset. Keep logs.
+        staged.unlink(missing_ok=True)
+        output.unlink(missing_ok=True)
+        report.pop('output', None)
+        report.update(status='FAILED', error=f'{type(exc).__name__}: {exc}')
+        write_json_atomic(report_path, report)
+        raise
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('plan')
+    parser.add_argument('--output-dir', required=True)
+    parser.add_argument('--plan-only', action='store_true')
+    args = parser.parse_args()
+    report = run_pair(args.plan, args.output_dir, plan_only=args.plan_only)
+    print(json.dumps(report, ensure_ascii=False, indent=2))
+
+
+if __name__ == '__main__':
+    main()

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

@@ -0,0 +1,33 @@
+"""Local ffmpeg capability preflight for subtitle burn-in."""
+
+import shutil
+import subprocess
+
+from lib import CONFIG
+
+def _ffmpeg_filters():
+    """Return ffmpeg's compiled-in filter names (caller has confirmed ffmpeg exists)."""
+    result = subprocess.run(["ffmpeg", "-hide_banner", "-filters"],
+                            text=True, capture_output=True, timeout=20)
+    if result.returncode != 0:
+        return set()
+    filters = set()
+    for line in result.stdout.splitlines():
+        parts = line.split()
+        if len(parts) >= 2 and parts[0] and parts[0][0] in ".TSCAPN|":
+            filters.add(parts[1])
+    return filters
+
+
+def _preflight_burn_subtitles():
+    """Fail before the (re-encoding) render when burn-in is on but ffmpeg lacks the libass
+    `subtitles` filter. Only fires when ffmpeg EXISTS but can't burn — an absent ffmpeg fails
+    the render regardless."""
+    if not CONFIG["burn_subtitles"]:
+        return
+    if shutil.which("ffmpeg") is None:
+        return
+    if "subtitles" not in _ffmpeg_filters():
+        raise SystemExit(
+            "字幕烧录已开启，但当前 ffmpeg 不支持 subtitles/libass 滤镜，渲染会在最后一步失败。\n"
+            "  解决：安装带 libass 的 ffmpeg，或加 --no-burn-subtitles 关闭烧录（仍输出 .srt 外挂字幕）。")