MediaCrawler/mac-agent-os-main/05_tools/09_ave/scripts/composer/beat_sync.py

"""
AVE 06_composer/beat_sync — BGM 节拍驱动的卡点视频合成

流程:
  1. BGM 节拍检测 (librosa beat_track)
  2. 按 N拍 分组 (默认 4拍/组)
  3. 每组分配素材 (Pexels搜索 或 用户提供)
  4. 精确裁剪到组时长
  5. xfade 过渡拼接 (≤8组避免 FFmpeg 崩溃)
  6. 文字/字幕叠加

用法:
  from composer.beat_sync import compose_beat_sync
  compose_beat_sync(bgm_path="bgm.wav", output="beat_sync.mp4")
"""
import sys, os; sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import json
import os
import shutil
import subprocess
import tempfile
from pathlib import Path
from typing import Optional

from lib.logger import get_logger
from lib.ffmpeg import FFMPEG  # noqa: E402  (FFmpeg 绝对路径)

logger = get_logger("beat_sync")

CACHE_DIR = Path(os.environ.get("AVE_CACHE_DIR",
    str(Path.home() / "workbuddy-agent-os/agent-local/tools/ave/cache")))
BEAT_CACHE = CACHE_DIR / "beat_sync"
BEAT_CACHE.mkdir(parents=True, exist_ok=True)


def detect_beats(
    audio_path: str,
    group_size: int = 4,
    enable_energy: bool = False,
    detect_structure: bool = False,
) -> dict:
    """
    检测 BGM 节拍

    参数:
      audio_path: BGM 音频路径
      group_size: 每组节拍数 (默认4拍/组)
      enable_energy: 是否提取 RMS/频谱能量特征 (用于变速卡点)
      detect_structure: 是否检测歌曲结构 (Intro/Verse/Chorus/Bridge/Outro)

    返回:
      {
        "bpm": 120.0,
        "beat_times": [0.0, 0.5, 1.0, ...],
        "segments": [{"start": 0.0, "end": 2.0, "beats": 4, "energy": 0.8, ...}, ...],
        "structure": [{"label": "Intro", "start": 0.0, "end": 8.0, ...}],
        "total_duration": 30.0,
      }
    """
    import librosa
    import numpy as np

    y, sr = librosa.load(audio_path, sr=22050, mono=True)
    duration = librosa.get_duration(y=y, sr=sr)

    # 节拍检测
    tempo_arr, beats = librosa.beat.beat_track(y=y, sr=sr)
    tempo_val = float(tempo_arr.item() if hasattr(tempo_arr, 'item') else tempo_arr)
    beat_times = librosa.frames_to_time(beats, sr=sr).tolist()

    # 如果没检测到拍点, 按 BPM 估算
    if len(beat_times) < 2:
        bpm = tempo_val if tempo_val > 0 else 120.0
        interval = 60.0 / bpm
        beat_times = [i * interval for i in range(int(duration / interval))]
        logger.info(f"  无拍点, 按 BPM={bpm:.0f} 估算 {len(beat_times)} 拍")
    else:
        logger.info(f"  检测到 BPM={tempo_val:.1f}, {len(beat_times)} 拍")

    # 提取 RMS 和频谱能量
    rms_energy = None
    spectral_features = None
    if enable_energy:
        # 用短时傅立叶提取帧级能量
        hop_length = 512
        frame_dur = hop_length / sr
        rms = librosa.feature.rms(y=y, hop_length=hop_length)[0]
        rms_energy = rms.tolist()
        logger.debug(f"  能量帧: {len(rms_energy)} 帧, 帧时长={frame_dur:.3f}s")

        # 频谱 flux
        spec = np.abs(librosa.stft(y, hop_length=hop_length))
        flux = librosa.onset.onset_strength(y=y, sr=sr, hop_length=hop_length)
        spectral_features = {
            "rms": rms_energy,
            "flux": flux.tolist() if hasattr(flux, 'tolist') else [],
            "hop_length": hop_length,
            "frame_duration": frame_dur,
        }

    # 歌曲结构检测
    song_structure = None
    if detect_structure:
        song_structure = _detect_song_structure(y, sr, duration)
        if song_structure:
            logger.info(f"  歌曲结构: {len(song_structure)} 段")
            for s in song_structure:
                logger.info(f"    {s['label']:8s} {s['start']:.0f}s→{s['end']:.0f}s")

    # 按 N拍 分组
    segments = []
    max_beats_per_seg = 0
    for i in range(0, len(beat_times), group_size):
        start = beat_times[i]
        end = beat_times[min(i + group_size, len(beat_times) - 1)]
        actual_beats = min(group_size, len(beat_times) - i)
        if end - start > 0.3:
            seg = {
                "start": round(start, 2),
                "end": round(end, 2),
                "duration": round(end - start, 2),
                "beats": actual_beats,
            }
            # 计算该段平均能量
            if enable_energy and rms_energy is not None and spectral_features:
                seg["energy"] = _segment_energy(start, end, spectral_features)
            segments.append(seg)
            max_beats_per_seg = max(max_beats_per_seg, actual_beats)

    # 最后一段: 最后一个拍点到音频结束
    if segments and segments[-1]["end"] < duration - 0.3:
        seg = {
            "start": segments[-1]["end"],
            "end": round(duration, 2),
            "duration": round(duration - segments[-1]["end"], 2),
            "beats": 0,
        }
        if enable_energy and spectral_features:
            seg["energy"] = _segment_energy(seg["start"], seg["end"], spectral_features)
        segments.append(seg)

    # 限制 ≤8 组 (xfade 链限制)
    if len(segments) > 8:
        keep = segments[:7]
        remaining = segments[7:]
        merged = {
            "start": keep[-1]["end"],
            "end": round(duration, 2),
            "duration": round(duration - keep[-1]["end"], 2),
            "beats": sum(s["beats"] for s in remaining),
        }
        if enable_energy and "energy" in remaining[0]:
            merged["energy"] = sum(
                s.get("energy", 0) * s["duration"] for s in remaining
            ) / max(merged["duration"], 0.1)
        keep.append(merged)
        segments = keep
        logger.info(f"  合并为 {len(segments)} 组 (≤8)")

    result = {
        "bpm": tempo_val,
        "beat_count": len(beat_times),
        "beat_times": [round(float(t), 3) for t in beat_times],   # 文档承诺的字段（此前漏返回）
        "segments": segments,
        "total_duration": round(duration, 2),
    }
    if song_structure:
        result["structure"] = song_structure
    if spectral_features:
        result["spectral"] = spectral_features

    return result


def _segment_energy(start_sec: float, end_sec: float,
                    spectral: dict) -> float:
    """计算某时间段的平均归一化能量 (基于 RMS + Flux)"""
    frame_dur = spectral["frame_duration"]
    rms = spectral.get("rms", [])
    flux = spectral.get("flux", [])

    if not rms:
        return 0.5

    start_frame = int(start_sec / max(frame_dur, 0.001))
    end_frame = int(end_sec / max(frame_dur, 0.001))
    start_frame = max(0, min(start_frame, len(rms) - 1))
    end_frame = max(start_frame + 1, min(end_frame, len(rms)))

    seg_rms = rms[start_frame:end_frame]
    if not seg_rms:
        return 0.5

    avg_rms = sum(seg_rms) / len(seg_rms) if seg_rms else 0
    avg_flux = sum(flux[start_frame:end_frame]) / len(seg_rms) if flux and len(seg_rms) > 0 else 0

    # 归一化: 用全局均值和 std
    rms_mean = sum(rms) / len(rms) if rms else 0.1
    rms_std = (sum((v - rms_mean)**2 for v in rms) / len(rms)) ** 0.5 if rms and len(rms) > 1 else rms_mean
    rms_std = max(rms_std, rms_mean * 0.01)

    energy = (avg_rms - rms_mean) / rms_std * 0.3 + 0.5
    return max(0.0, min(1.0, energy))


def _detect_song_structure(y, sr, duration) -> list[dict]:
    """
    检测歌曲结构段落

    基于 chroma 特征 + 自相似矩阵 + 时序聚类,
    输出: Intro / Verse / Chorus / Bridge / Outro
    """
    import numpy as np
    import librosa

    try:
        # 提取 chroma 特征
        hop_length = 2048
        chroma = librosa.feature.chroma_cqt(y=y, sr=sr, hop_length=hop_length)
        frame_dur = hop_length / sr

        # 自相似矩阵 + 递归分割
        ssm = librosa.segment.recurrence_matrix(chroma, axis=0)
        bounds = librosa.segment.agglomerative(ssm, k=min(8, ssm.shape[0]))
        bounds_frames = librosa.segment.subsegment(ssm, bounds, n_segments=2)

        # 转换为时间
        boundaries = [0.0]
        for bf in bounds_frames:
            t = float(bf) * frame_dur
            if t < duration - 1:
                boundaries.append(round(t, 1))
        boundaries.append(round(duration, 1))

        # 按时间比例分配标签
        labels = _label_structure(boundaries, duration)

        result = []
        for i in range(len(boundaries) - 1):
            result.append({
                "label": labels[i] if i < len(labels) else "Section",
                "start": boundaries[i],
                "end": boundaries[i + 1],
                "duration": round(boundaries[i + 1] - boundaries[i], 1),
            })

        return result
    except Exception as e:
        logger.warning(f"  歌曲结构检测失败: {e}")
        return []


def _label_structure(boundaries: list[float], total_duration: float) -> list[str]:
    """根据段落在歌曲中的位置分配典型结构标签"""
    n = len(boundaries) - 1
    labels = []

    # 按位置比例分配
    positions = []
    for i in range(n):
        mid = (boundaries[i] + boundaries[i + 1]) / 2 / max(total_duration, 1)
        positions.append(mid)

    for i, pos in enumerate(positions):
        if i == 0 and pos < 0.05:
            labels.append("Intro")
        elif i >= n - 2 and pos > 0.85:
            labels.append("Outro")
        elif 0.15 <= pos <= 0.65:
            # 很可能在 Chorus 区
            labels.append("Chorus" if i % 2 == 1 else "Verse")
        elif pos < 0.15:
            labels.append("Verse")
        elif pos < 0.4:
            labels.append("Pre-Chorus" if i % 2 == 0 else "Chorus")
        else:
            labels.append("Bridge" if pos < 0.75 else "Outro")

    return labels


def compose_beat_sync(
    bgm_path: str,
    output_path: str = "beat_sync.mp4",
    material_clips: list[str] | None = None,
    group_size: int = 4,
    resolution: str = "1080x1920",
    texts: list[str] | None = None,
    pexels_api_key: str = "",
    pexels_search: str = "",
    enable_speed_ramp: bool = False,
    frame_locked: bool = True,
    base_speed: float = 1.0,
    high_speed: float = 1.5,
    low_speed: float = 0.7,
    target_bpm: float = 0.0,
) -> str:
    """
    BGM 节拍驱动的卡点视频合成 (V2: 能量感知 + 帧锁定)

    参数:
      bgm_path: BGM 音频路径
      output_path: 输出视频路径
      material_clips: 素材视频/图片列表 (可选, 不提供则 Pexels 搜索)
      group_size: 每组节拍数
      resolution: 输出分辨率
      texts: 每段叠加的文字 (可选)
      pexels_api_key: Pexels API Key
      pexels_search: Pexels 搜索关键词
      enable_speed_ramp: 是否启用能量驱动变速 (高能加速, 低能减速)
      frame_locked: 是否启用帧锁定时间线 (消除 xfade 漂移)
      base_speed: 基础速度 (默认 1.0)
      high_speed: 高能段速度 (默认 1.5)
      low_speed: 低能段速度 (默认 0.7)
      target_bpm: 目标 BPM (>0 时用 AudioLine StemAligner 预处理 BGM)

    返回: output_path
    """
    if not os.path.exists(bgm_path):
        raise FileNotFoundError(f"BGM 文件不存在: {bgm_path}")

    # 0. BPM 标准化预处理 (使用 AudioLine StemAligner)
    if target_bpm > 0:
        try:
            from audio_line.layer4_alignment.stem_aligner import StemAligner
            import librosa
            y_detect, sr_detect = librosa.load(bgm_path, sr=None, mono=True)
            tempo_arr, _ = librosa.beat.beat_track(y=y_detect, sr=sr_detect)
            source_bpm = float(tempo_arr.item() if hasattr(tempo_arr, 'item') else tempo_arr)
            logger.info(f"  BPM 标准化: {source_bpm:.0f} → {target_bpm:.0f}")

            if source_bpm > 0 and abs(source_bpm - target_bpm) > 1.0:
                aligner = StemAligner(method="phase_vocoder")
                result = aligner.align_to_bpm(
                    stems={"bgm": bgm_path},
                    source_bpm=source_bpm,
                    target_bpm=target_bpm,
                    output_dir=str(BEAT_CACHE / "aligned"),
                )
                if result.aligned_paths:
                    bgm_path = result.aligned_paths["bgm"]
                    logger.info(f"  ✅ 标准化完成: {bgm_path}")
            else:
                logger.info(f"  ⏭️ 无需标准化 (相近 BPM)")
        except ImportError:
            logger.info(f"  ⏭️ AudioLine 不可用, 跳过 BPM 标准化")
        except Exception as e:
            logger.warning(f"  ⚠ BPM 标准化失败: {e} (继续使用原 BGM)")

    # 1. 节拍检测 (启用能量)
    logger.info("=== Beat-Sync 卡点模式 ===")
    logger.info(f"BGM: {bgm_path}")
    beat_info = detect_beats(bgm_path, group_size, enable_energy=enable_speed_ramp)
    segments = beat_info["segments"]
    total_dur = beat_info["total_duration"]
    logger.info(f"BPM: {beat_info['bpm']}, {beat_info['beat_count']}拍, {len(segments)}组")

    if enable_speed_ramp and "energy" in segments[0]:
        energies = [s.get("energy", 0.5) for s in segments]
        avg_e = sum(energies) / len(energies) if energies else 0.5
        logger.info(f"  能量感知变速: ON (均值 {avg_e:.2f}, 范围 {min(energies):.2f}~{max(energies):.2f})")

    # 2. 准备素材
    clips = material_clips or []
    if len(clips) < len(segments) and pexels_api_key:
        from material_producer.pexels.search import search_videos
        needed = len(segments) - len(clips)
        logger.info(f"素材不足, 从 Pexels 搜索 {needed} 个...")
        kw = pexels_search or "background video"
        found = search_videos(kw, count=needed, api_key=pexels_api_key, orientation="portrait")
        for f in found:
            clips.append(f["path"])
        logger.info(f"  共 {len(clips)} 个素材")

    if not clips:
        raise ValueError("无可用素材")

    # 3. 为每组分配素材 (循环使用)
    seg_materials = []  # [(clip_path, adjusted_start, adjusted_end, adjusted_duration, speed), ...]
    for i, seg in enumerate(segments):
        clip = clips[i % len(clips)]

        # 计算本段速度 (能量驱动变速)
        speed = base_speed
        if enable_speed_ramp:
            energy = seg.get("energy", 0.5)
            if energy > 0.6:
                speed = base_speed + (high_speed - base_speed) * min((energy - 0.6) / 0.4, 1.0)
            elif energy < 0.3:
                speed = low_speed + (base_speed - low_speed) * (energy / 0.3)
            speed = max(0.5, min(2.0, speed))

        # 调整时长 (变速后实际画面时长)
        orig_dur = seg["duration"]
        if frame_locked:
            # 帧锁定: 以 BGM 节拍为准, 用 fps 对齐到整帧
            fps = 30
            orig_frames = round(orig_dur * fps)
            adjusted_dur = orig_frames / fps  # 帧对齐后的时长
        else:
            adjusted_dur = orig_dur

        # 变速后的素材播放时长 = adjusted_dur / speed
        # 即: 如果加速 (speed>1), 需要更短的素材
        material_time_needed = adjusted_dur / speed if speed > 0 else adjusted_dur

        seg_materials.append((clip, seg["start"], seg["end"],
                              adjusted_dur, speed, material_time_needed))

    logger.info(f"分配素材: {len(seg_materials)} 段, {len(clips)} 素材循环"
                + (f", 变速范围 {low_speed:.1f}~{high_speed:.1f}x" if enable_speed_ramp else ""))

    # 4. 帧锁定: 预计算精确的 xfade 偏移
    if frame_locked:
        fps = 30
        # 精确计算每段的累计偏移
        cumulative_frames = 0
        for idx, (clip, start, end, dur, speed, mt) in enumerate(seg_materials):
            seg_frames = round(dur * fps)
            seg_materials[idx] = (clip, start, dur, speed, mt, seg_frames)
        logger.info(f"  帧锁定: ON (30fps)")

    # 5. 渲染每组为独立视频片段 (带变速)
    temp_dir = tempfile.mkdtemp(prefix="ave_beat_")
    seg_files = []
    for idx in range(len(seg_materials)):
        clip, start_orig, dur, speed, mt, *rest = seg_materials[idx]
        if frame_locked:
            seg_frames = rest[0] if rest else round(dur * 30)
            # 帧对齐时长
            dur_aligned = seg_frames / 30.0
        else:
            dur_aligned = dur
            seg_frames = 0

        seg_file = os.path.join(temp_dir, f"seg_{idx:03d}.mp4")

        # 从素材中取一段 (考虑变速需要)
        clip_dur = _get_duration(clip)
        offset = (start_orig * 17) % max(clip_dur - mt, 0.1) if clip_dur > mt else 0

        # 先截取素材, 再变速
        raw_seg = os.path.join(temp_dir, f"seg_{idx:03d}_raw.mp4")
        subprocess.run([
            FFMPEG, "-y",
            "-ss", str(offset),
            "-i", clip,
            "-t", str(mt),
            "-vf", f"scale={resolution.replace('x',':')},setsar=1,fps=30",
            "-c:v", "libx264", "-preset", "fast", "-crf", "23",
            "-an", raw_seg,
        ], capture_output=True, timeout=120, check=True)

        if speed != 1.0 and speed >= 0.5 and speed <= 2.0:
            # 变速处理
            subprocess.run([
                FFMPEG, "-y", "-i", raw_seg,
                "-filter_complex",
                f"setpts={1/speed}*PTS[v]",
                "-map", "[v]",
                "-c:v", "libx264", "-preset", "fast", "-crf", "23",
                "-pix_fmt", "yuv420p",
                seg_file,
            ], capture_output=True, timeout=120, check=True)
        else:
            os.replace(raw_seg, seg_file)

        seg_files.append(seg_file)

    # 6. 使用帧锁定时间线拼接
    if len(seg_files) == 1:
        subprocess.run([FFMPEG, "-y", "-i", seg_files[0], "-i", bgm_path,
                        "-shortest", "-c:v", "copy", "-c:a", "aac", output_path],
                       capture_output=True, check=True, timeout=60)
        return _finalize(output_path, texts, seg_materials, resolution, temp_dir)

    if frame_locked:
        return _concat_frame_locked(seg_files, bgm_path, seg_materials,
                                     output_path, texts, resolution, temp_dir)
    else:
        return _concat_xfade(seg_files, bgm_path, seg_materials,
                              output_path, texts, resolution, temp_dir)


def _concat_frame_locked(
    seg_files: list[str],
    bgm_path: str,
    seg_materials: list,
    output_path: str,
    texts: list[str] | None,
    resolution: str,
    temp_dir: str,
) -> str:
    """帧锁定拼接: 用 concat demuxer 精确拼接, 无 xfade 漂移"""
    if len(seg_files) == 1:
        # 只有一段, 直接合并 BGM
        cmd = [FFMPEG, "-y", "-i", seg_files[0], "-i", bgm_path,
               "-shortest", "-c:v", "copy", "-c:a", "aac", "-b:a", "192k", output_path]
        subprocess.run(cmd, capture_output=True, timeout=120, check=True)
        return _finalize(output_path, texts, seg_materials, resolution, temp_dir)

    # 用 concat demuxer 拼接 (帧精确, 无过渡)
    concat_file = tempfile.NamedTemporaryFile(suffix=".txt", delete=False, mode="w").name
    with open(concat_file, "w") as f:
        for sf in seg_files:
            f.write(f"file '{os.path.abspath(sf)}'\n")

    # 先拼视频
    video_only = output_path.replace(".mp4", "_novideo.mp4")
    cmd = [FFMPEG, "-y", "-f", "concat", "-safe", "0", "-i", concat_file,
           "-c:v", "libx264", "-preset", "fast", "-crf", "23", "-an", video_only]
    subprocess.run(cmd, capture_output=True, timeout=300, check=True)

    # 叠加 BGM
    cmd2 = [FFMPEG, "-y", "-i", video_only, "-i", bgm_path,
            "-shortest", "-c:v", "copy", "-c:a", "aac", "-b:a", "192k", output_path]
    subprocess.run(cmd2, capture_output=True, timeout=120, check=True)

    os.unlink(concat_file)
    os.unlink(video_only)

    logger.info(f"  ✅ 帧锁定拼接完成: {len(seg_files)} 段")
    return _finalize(output_path, texts, seg_materials, resolution, temp_dir)


def _concat_xfade(
    seg_files: list[str],
    bgm_path: str,
    seg_materials: list,
    output_path: str,
    texts: list[str] | None,
    resolution: str,
    temp_dir: str,
) -> str:
    """xfade 过渡拼接: ≤8 段, 逐段交叉淡入淡出"""
    if len(seg_files) == 1:
        cmd = [FFMPEG, "-y", "-i", seg_files[0], "-i", bgm_path,
               "-shortest", "-c:v", "copy", "-c:a", "aac", "-b:a", "192k", output_path]
        subprocess.run(cmd, capture_output=True, timeout=120, check=True)
        return _finalize(output_path, texts, seg_materials, resolution, temp_dir)

    # 构建 xfade 链
    # xfade=transition=fade:duration=0.5:offset=offset1
    # 每段重叠 0.5s, 累计偏移
    filter_parts = []
    inputs = []
    offset = 0.0
    prev_label = "v0"

    for i in range(len(seg_files)):
        inputs += ["-i", seg_files[i]]
        if i == 0:
            continue
        # 前一段的时长
        seg_dur = seg_materials[i - 1][2] if i - 1 < len(seg_materials) else 1.0
        offset += float(seg_dur) - 0.5  # 减去过渡重叠
        label = f"v{i}"
        filter_parts.append(
            f"[{prev_label}][{label}]xfade=transition=fade:duration=0.5:offset={offset:.2f}[v{i}]"
        )
        prev_label = f"v{i}"

    # 最终输出标签是 v{len(seg_files)-1}
    last_label = f"v{len(seg_files) - 1}"
    full_filter = ";".join(filter_parts)

    video_xfade = output_path.replace(".mp4", "_xfade.mp4")
    cmd = [FFMPEG, "-y"] + inputs + [
        "-filter_complex", full_filter,
        "-map", f"[{last_label}]",
        "-c:v", "libx264", "-preset", "fast", "-crf", "23",
        "-pix_fmt", "yuv420p",
        video_xfade,
    ]
    try:
        subprocess.run(cmd, capture_output=True, timeout=300, check=True)
    except subprocess.CalledProcessError as e:
        logger.warning(f"  xfade 失败, 回落 concat: {e.stderr[:200]}")
        # 回落: concat demuxer
        concat_file = tempfile.NamedTemporaryFile(suffix=".txt", delete=False, mode="w").name
        with open(concat_file, "w") as f:
            for sf in seg_files:
                f.write(f"file '{os.path.abspath(sf)}'\n")
        cmd_fb = [FFMPEG, "-y", "-f", "concat", "-safe", "0", "-i", concat_file,
                   "-c:v", "libx264", "-preset", "fast", "-crf", "23", video_xfade]
        subprocess.run(cmd_fb, capture_output=True, timeout=300, check=True)
        os.unlink(concat_file)

    # 叠加 BGM
    cmd2 = [FFMPEG, "-y", "-i", video_xfade, "-i", bgm_path,
            "-shortest", "-c:v", "copy", "-c:a", "aac", "-b:a", "192k", output_path]
    subprocess.run(cmd2, capture_output=True, timeout=120, check=True)
    os.unlink(video_xfade)

    logger.info(f"  ✅ xfade 拼接完成: {len(seg_files)} 段")
    return _finalize(output_path, texts, seg_materials, resolution, temp_dir)


def _finalize(
    output_path: str,
    texts: list[str] | None,
    seg_materials: list,
    resolution: str,
    temp_dir: str,
) -> str:
    """最终处理: 叠加文字字幕 + 清理临时目录"""
    import shutil

    # 叠加文字
    if texts and len(texts) > 0 and seg_materials:
        _add_text_subtitles(output_path, texts, seg_materials, resolution)
        logger.info(f"  ✅ 文字叠加: {len(texts)} 段")

    # 清理临时目录
    if temp_dir and os.path.exists(temp_dir):
        shutil.rmtree(temp_dir, ignore_errors=True)
        logger.debug(f"  临时目录已清理: {temp_dir}")

    return output_path


def _get_duration(path: str) -> float:
    """获取媒体文件时长（秒）

    用 lib.ffmpeg.probe_duration（ffmpeg -i 解析）——
    本机 ffprobe 实为 ffmpeg 的符号链接，不支持 -show_entries（会静默失败）
    """
    try:
        from lib.ffmpeg import probe_duration
        d = probe_duration(path)
        return d if d > 0 else 30.0
    except Exception:
        return 30.0


def _add_text_subtitles(video_path: str, texts: list[str],
                        seg_materials: list, resolution: str):
    """为每段叠加文字 (ASS 字幕)"""
    width, height = (int(x) for x in resolution.split("x"))
    font_size = max(48, int(height * 0.05))
    margin_v = int(height * 0.3)

    lines = [
        "[Script Info]", "ScriptType: v4.00+",
        f"PlayResX: {width}", f"PlayResY: {height}",
        "ScaledBorderAndShadow: yes", "",
        "[V4+ Styles]",
        "Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding",
        f"Style: Default,Noto Sans SC,{font_size},&H00FFFFFF,&H0000FFFF,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,3,1,2,100,100,{margin_v},1",
        "", "[Events]",
        "Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text",
    ]

    for i, text in enumerate(texts):
        if i >= len(seg_materials):
            break
        start = seg_materials[i][1]
        end = seg_materials[i][2]
        h = int(start); m = int((start - h) * 60); s = int(start - h * 3600 - m * 60)
        he = int(end); me = int((end - he) * 60); se = int(end - he * 3600 - me * 60)
        lines.append(
            f"Dialogue: 0,{h}:{m:02d}:{s:02d}.00,{he}:{me:02d}:{se:02d}.00,Default,,0,0,0,,{text}"
        )

    ass_path = video_path.replace(".mp4", "_text.ass")
    with open(ass_path, "w", encoding="utf-8") as f:
        f.write("\n".join(lines))

    # 叠加字幕
    tmp = video_path.replace(".mp4", "_tmp.mp4")
    subprocess.run([
        FFMPEG, "-y", "-i", video_path,
        "-vf", f"subtitles={ass_path}",
        "-c:v", "libx264", "-preset", "fast", "-crf", "23",
        "-c:a", "copy", "-pix_fmt", "yuv420p", tmp,
    ], capture_output=True, timeout=120, check=True)
    os.replace(tmp, video_path)
    os.remove(ass_path)