Video Expert Analyzer

# Video Expert Analyzer v2.1 配置示例
# 将此文件复制到输出目录并按需修改

# === AI 评分模式 ===
# API 模式需要配置以下变量（Agent 模式无需配置）
VIDEO_ANALYZER_API_KEY=your-api-key-here
VIDEO_ANALYZER_BASE_URL=https://generativelanguage.googleapis.com/v1beta/openai
VIDEO_ANALYZER_MODEL=gemini-2.0-flash

# === 场景检测 ===
SCENE_THRESHOLD=27.0

# === 精选阈值 ===
BEST_SHOT_THRESHOLD=7.5

# === 输出选项 ===
GENERATE_FRAMES=true
GENERATE_TRANSCRIPT=true
GENERATE_REPORT=true

# Python
__pycache__/
*.py[cod]
*$py.class
*.so
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
*.egg-info/
.installed.cfg
*.egg

# Virtual environments
.env
.venv
env/
venv/
ENV/

# IDE
.idea/
.vscode/
*.swp
*.swo
*~

# OS
.DS_Store
.DS_Store?
._*
.Spotlight-V100
.Trashes
ehthumbs.db
Thumbs.db

# Output
output/
*.mp4
*.m4a
*.srt
*.wav

# Runtime logs
*.log
log.txt

# Temporary batch reports
batch_*_report.md

yt-dlp
scenedetect[opencv]
requests
funasr
modelscope
torch
torchaudio
openai
rapidocr-onnxruntime

#!/usr/bin/env python3
"""
AI Scene Analyzer v2.0
支持两种评分模式：
  - API 模式：通过 OpenAI 兼容 API 调用 Gemini/Kimi 等视觉大模型
  - Agent 模式：由宿主 AI 助手（IDE/OpenClaw 中的多模态模型）直接看图评分

环境变量（API 模式）：
  VIDEO_ANALYZER_API_KEY   - API 密钥
  VIDEO_ANALYZER_BASE_URL  - API 端点 (默认 https://generativelanguage.googleapis.com/v1beta/openai)
  VIDEO_ANALYZER_MODEL     - 模型名称 (默认 gemini-2.0-flash)
"""

import json
import base64
import os
import re
import shutil
import sys
import time
from pathlib import Path
from typing import Dict, List, Optional
from datetime import datetime


# ============================================================
# 术语对照表
# ============================================================
TERMINOLOGY = {
    "TYPE-A Hook": "TYPE-A Hook (钩子/开场型)",
    "TYPE-B Narrative": "TYPE-B Narrative (叙事/情感型)",
    "TYPE-C Aesthetic": "TYPE-C Aesthetic (氛围/空镜型)",
    "TYPE-D Commercial": "TYPE-D Commercial (商业/展示型)",
    "aesthetic_beauty": "美感 Aesthetic Beauty (构图/光影/色彩)",
    "credibility": "可信度 Credibility (真实感/表演自然度)",
    "impact": "冲击力 Impact (视觉显著性/动态张力)",
    "memorability": "记忆度 Memorability (独特符号/金句)",
    "fun_interest": "趣味度 Fun/Interest (参与感/娱乐价值)",
    "MUST KEEP": "MUST KEEP (强烈推荐保留)",
    "USABLE": "USABLE (可用素材)",
    "DISCARD": "DISCARD (建议舍弃)",
}


def get_term_chinese(term: str) -> str:
    return TERMINOLOGY.get(term, term)


# ============================================================
# System Prompt for Vision LLM
# ============================================================
SCORING_SYSTEM_PROMPT = """你是一位专业的视频剪辑/镜头分析专家，精通 Walter Murch 剪辑六法则。

你需要分析一张视频截帧，按以下维度打分（1-10 整数）：

1. **aesthetic_beauty** (美感): 构图（如三分法/对称）、光影质感、色彩和谐度
2. **credibility** (可信度): 画面真实感、物理逻辑、AI生成痕迹程度（痕迹越少分越高）
3. **impact** (冲击力): 第一眼视觉显著性、动态张力、能否瞬间吸引观众
4. **memorability** (记忆度): 独特视觉符号、冯·雷斯托夫效应、过目不忘程度
5. **fun_interest** (趣味度): 参与感、娱乐价值、社交货币潜力

同时判断场景类型：
- TYPE-A Hook: 高冲击力开场/高能片段
- TYPE-B Narrative: 叙事/情感表达
- TYPE-C Aesthetic: 空镜/氛围/纯美学
- TYPE-D Commercial: 产品展示/商业广告

你必须严格按以下 JSON 格式返回结果，不要附加任何其他文字：
```json
{
  "type_classification": "TYPE-X ...",
  "description": "一句话中文描述画面内容",
  "visual_summary": "视觉元素概要",
  "scores": {
    "aesthetic_beauty": 8,
    "credibility": 7,
    "impact": 9,
    "memorability": 8,
    "fun_interest": 7
  },
  "selection_reasoning": "入选/淘汰理由（中文）",
  "edit_suggestion": "剪辑建议（中文）"
}
```"""


SCORING_USER_PROMPT_TEMPLATE = """请分析以下视频的第 {scene_num} 个场景截帧。

视频标题：{video_title}
视频总场景数：{total_scenes}
{transcript_info}

请严格按 JSON 格式返回分析结果。"""


# ============================================================
# API 模式：调用远程视觉大模型
# ============================================================
def call_vision_api(
    frame_path: Path,
    scene_num: int,
    video_title: str = "",
    total_scenes: int = 0,
    transcript_text: str = "",
    api_key: str = "",
    base_url: str = "",
    model: str = "",
) -> Optional[Dict]:
    """通过 OpenAI 兼容 API 调用视觉大模型分析帧画面"""

    try:
        from openai import OpenAI
    except ImportError:
        print("   ⚠️  需要安装 openai 库: pip install openai")
        return None

    if not api_key:
        print("   ⚠️  未设置 VIDEO_ANALYZER_API_KEY 环境变量")
        return None

    # 读取图片并转 base64
    with open(frame_path, "rb") as f:
        image_data = base64.b64encode(f.read()).decode("utf-8")

    mime_type = "image/jpeg" if frame_path.suffix.lower() in [".jpg", ".jpeg"] else "image/png"

    transcript_info = f"对应转录文本片段：{transcript_text}" if transcript_text else "（该场景无转录文本）"

    user_prompt = SCORING_USER_PROMPT_TEMPLATE.format(
        scene_num=scene_num,
        video_title=video_title,
        total_scenes=total_scenes,
        transcript_info=transcript_info,
    )

    client = OpenAI(api_key=api_key, base_url=base_url)

    try:
        response = client.chat.completions.create(
            model=model,
            messages=[
                {"role": "system", "content": SCORING_SYSTEM_PROMPT},
                {
                    "role": "user",
                    "content": [
                        {"type": "text", "text": user_prompt},
                        {
                            "type": "image_url",
                            "image_url": {
                                "url": f"data:{mime_type};base64,{image_data}",
                            },
                        },
                    ],
                },
            ],
            temperature=0.3,
            max_tokens=1024,
        )

        content = response.choices[0].message.content.strip()

        # 提取 JSON（可能包裹在 ```json ... ``` 中）
        json_match = re.search(r"\{[\s\S]*\}", content)
        if json_match:
            return json.loads(json_match.group())
        else:
            print(f"   ⚠️  Scene {scene_num:03d}: 无法解析模型返回的 JSON")
            return None

    except Exception as e:
        print(f"   ⚠️  Scene {scene_num:03d}: API 调用失败 - {e}")
        return None


# ============================================================
# 加权评分计算
# ============================================================
def compute_weighted_score(analysis: Dict) -> Dict:
    """根据场景类型计算加权分数并确定筛选等级"""

    scores = analysis.get("scores", {})
    type_class = analysis.get("type_classification", "")

    # 根据类型动态调整权重
    if "TYPE-A" in type_class:
        weighted = (
            scores.get("impact", 5) * 0.40
            + scores.get("memorability", 5) * 0.30
            + scores.get("aesthetic_beauty", 5) * 0.20
            + scores.get("fun_interest", 5) * 0.10
        )
    elif "TYPE-B" in type_class:
        weighted = (
            scores.get("credibility", 5) * 0.40
            + scores.get("memorability", 5) * 0.30
            + scores.get("aesthetic_beauty", 5) * 0.20
            + scores.get("fun_interest", 5) * 0.10
        )
    elif "TYPE-C" in type_class:
        weighted = (
            scores.get("aesthetic_beauty", 5) * 0.50
            + scores.get("impact", 5) * 0.20
            + scores.get("memorability", 5) * 0.20
            + scores.get("credibility", 5) * 0.10
        )
    else:  # TYPE-D Commercial
        weighted = (
            scores.get("credibility", 5) * 0.40
            + scores.get("memorability", 5) * 0.40
            + scores.get("aesthetic_beauty", 5) * 0.20
        )

    analysis["weighted_score"] = round(weighted, 2)

    # 确定筛选等级
    if weighted >= 8.5 or any(v == 10 for v in scores.values()):
        analysis["selection"] = "[MUST KEEP]"
    elif weighted >= 7.0:
        analysis["selection"] = "[USABLE]"
    else:
        analysis["selection"] = "[DISCARD]"

    return analysis


# ============================================================
# 主流程：自动评分
# ============================================================
def auto_score_scenes(scores_path: Path, video_analysis_dir: Path, mode: str = "api") -> Dict:
    """自动为所有场景评分。mode='api' 使用远程API，mode='agent' 仅生成模板供宿主AI填写"""

    with open(scores_path, "r", encoding="utf-8") as f:
        data = json.load(f)

    scenes = data.get("scenes", [])
    frames_dir = video_analysis_dir / "frames"
    video_title = data.get("title", data.get("video_id", ""))
    total_scenes = len(scenes)

    # 读取转录文本
    transcript_text = ""
    for ext in ["_transcript.txt", ".srt"]:
        transcript_file = video_analysis_dir / f"{data.get('video_id', '')}{ext}"
        if transcript_file.exists():
            transcript_text = transcript_file.read_text(encoding="utf-8")
            break

    if mode == "agent":
        print(f"\n📋 Agent 模式：已准备 {total_scenes} 个场景的评分模板")
        print(f"   帧图片目录: {frames_dir}")
        print(f"   请使用宿主 AI 的视觉能力逐帧查看并填写评分")
        print(f"   评分结果写入: {scores_path}")
        return data

    # API 模式
    api_key = os.environ.get("VIDEO_ANALYZER_API_KEY", "")
    base_url = os.environ.get("VIDEO_ANALYZER_BASE_URL", "https://generativelanguage.googleapis.com/v1beta/openai")
    model = os.environ.get("VIDEO_ANALYZER_MODEL", "gemini-2.0-flash")

    if not api_key:
        print("\n❌ API 模式需要设置环境变量 VIDEO_ANALYZER_API_KEY")
        print("   export VIDEO_ANALYZER_API_KEY=\"your-api-key\"")
        print("   export VIDEO_ANALYZER_BASE_URL=\"https://...\"  # 可选")
        print("   export VIDEO_ANALYZER_MODEL=\"gemini-2.0-flash\"  # 可选")
        sys.exit(1)

    print(f"\n🤖 API 模式：使用 {model} 分析 {total_scenes} 个场景...")
    print(f"   API: {base_url}")

    success_count = 0
    for scene in scenes:
        scene_num = scene.get("scene_number", 0)
        frame_name = scene.get("filename", "").replace(".mp4", ".jpg")
        frame_path = frames_dir / frame_name

        if not frame_path.exists():
            # 尝试其他命名
            alt_name = f"{data.get('video_id', '')}-Scene-{scene_num:03d}.jpg"
            frame_path = frames_dir / alt_name

        if not frame_path.exists():
            print(f"  Scene {scene_num:03d}: ⚠️ 未找到帧图片，跳过")
            continue

        analysis = call_vision_api(
            frame_path=frame_path,
            scene_num=scene_num,
            video_title=video_title,
            total_scenes=total_scenes,
            transcript_text=transcript_text[:500] if transcript_text else "",
            api_key=api_key,
            base_url=base_url,
            model=model,
        )

        if analysis:
            analysis = compute_weighted_score(analysis)
            scene.update(analysis)
            success_count += 1
            print(f"  Scene {scene_num:03d}: {analysis['selection']} | 加权 {analysis['weighted_score']:.2f} | {analysis.get('type_classification', 'N/A')}")
        else:
            print(f"  Scene {scene_num:03d}: ❌ 分析失败")

        # 限流：每次请求间隔
        time.sleep(1.0)

    # 保存
    with open(scores_path, "w", encoding="utf-8") as f:
        json.dump(data, f, indent=2, ensure_ascii=False)

    print(f"\n✅ 评分完成：{success_count}/{total_scenes} 个场景成功")
    print(f"   已保存到: {scores_path}")
    return data


# ============================================================
# 精选镜头筛选与复制
# ============================================================
def select_and_copy_best_shots(scores_path: Path, threshold: float = 7.0) -> List[Dict]:
    """选择最佳镜头并复制到 best_shots 目录"""

    with open(scores_path, "r", encoding="utf-8") as f:
        data = json.load(f)

    scenes = data.get("scenes", [])
    video_dir = scores_path.parent
    best_shots_dir = video_dir / "scenes" / "best_shots"
    best_shots_dir.mkdir(exist_ok=True)

    # 清空旧的精选
    for old in best_shots_dir.glob("*.mp4"):
        old.unlink()

    # 筛选
    best_shots = [
        s for s in scenes
        if s.get("weighted_score", 0) >= threshold or "MUST KEEP" in s.get("selection", "")
    ]
    best_shots.sort(key=lambda x: x.get("weighted_score", 0), reverse=True)

    print(f"\n⭐ 发现 {len(best_shots)} 个精选镜头 (阈值: {threshold})")

    copied = []
    for i, scene in enumerate(best_shots, 1):
        src_path = Path(scene.get("file_path", ""))
        if src_path.exists():
            tag = scene.get("selection", "").replace("[", "").replace("]", "").replace(" ", "_")
            dst_name = f"{i:02d}_{tag}_{src_path.name}"
            dst_path = best_shots_dir / dst_name
            shutil.copy2(src_path, dst_path)
            copied.append(scene)
            desc = scene.get("description", "N/A")[:30]
            print(f"  {i}. Scene {scene.get('scene_number', 0):03d} | {scene.get('weighted_score', 0):.2f} | {desc}...")

    # 生成 README
    _generate_readme(best_shots_dir, copied, data.get("video_id", "unknown"))

    print(f"\n✅ 已复制 {len(copied)} 个精选镜头到: {best_shots_dir}")
    return copied


def _generate_readme(best_shots_dir: Path, best_shots: List[Dict], video_id: str):
    content = f"""# ⭐ 精选镜头 (Best Shots)

**视频 ID**: {video_id}
**入选数量**: {len(best_shots)} 个
**生成时间**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}

## 精选列表

| 排名 | 场景 | 加权分 | 类型 | 描述 |
|------|------|--------|------|------|
"""
    for i, s in enumerate(best_shots, 1):
        content += f"| {i} | Scene {s.get('scene_number', 0):03d} | {s.get('weighted_score', 0):.2f} | {s.get('type_classification', 'N/A')} | {s.get('description', '')[:40]} |\n"

    content += f"\n---\n*由 Video Expert Analyzer v2.0 筛选*\n"

    (best_shots_dir / "README.md").write_text(content, encoding="utf-8")


# ============================================================
# 分析报告生成
# ============================================================
def generate_complete_report(scores_path: Path) -> Path:
    with open(scores_path, "r", encoding="utf-8") as f:
        data = json.load(f)

    video_id = data.get("video_id", "unknown")
    url = data.get("url", "")
    scenes = data.get("scenes", [])
    total = len(scenes)

    if total == 0:
        print("⚠️ 没有场景数据")
        return scores_path

    # 统计
    scored_scenes = [s for s in scenes if "weighted_score" in s]
    if not scored_scenes:
        print("⚠️ 没有已评分的场景")
        return scores_path

    must_keep = sum(1 for s in scored_scenes if "MUST KEEP" in s.get("selection", ""))
    usable = sum(1 for s in scored_scenes if "USABLE" in s.get("selection", ""))
    discard = sum(1 for s in scored_scenes if "DISCARD" in s.get("selection", ""))
    avg = sum(s["weighted_score"] for s in scored_scenes) / len(scored_scenes)

    # 各维度平均
    dims = ["aesthetic_beauty", "credibility", "impact", "memorability", "fun_interest"]
    dim_avgs = {}
    for d in dims:
        vals = [s.get("scores", {}).get(d, 0) for s in scored_scenes if s.get("scores", {}).get(d)]
        dim_avgs[d] = sum(vals) / len(vals) if vals else 0

    report_path = scores_path.parent / f"{video_id}_complete_analysis.md"

    sorted_scenes = sorted(scored_scenes, key=lambda x: x.get("weighted_score", 0), reverse=True)

    # 构建报告
    report = f"""# 🎬 视频专家分析报告 (Video Expert Analysis Report)

## 📋 基本信息

| 项目 | 内容 |
|------|------|
| **视频 ID** | {video_id} |
| **来源 URL** | {url} |
| **分析时间** | {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} |
| **总场景数** | {total} |
| **已评分** | {len(scored_scenes)} |
| **平均加权得分** | {avg:.2f} |

### 筛选统计

| 等级 | 数量 | 占比 |
|------|------|------|
| 🌟 MUST KEEP | {must_keep} | {must_keep/len(scored_scenes)*100:.1f}% |
| 📁 USABLE | {usable} | {usable/len(scored_scenes)*100:.1f}% |
| 🗑️ DISCARD | {discard} | {discard/len(scored_scenes)*100:.1f}% |

### 各维度平均分

| 维度 | 平均分 |
|------|--------|
"""
    for d in dims:
        icon = "🟢" if dim_avgs[d] >= 7 else "🟡" if dim_avgs[d] >= 5 else "🔴"
        report += f"| {get_term_chinese(d)} | {dim_avgs[d]:.2f} {icon} |\n"

    report += f"""
---

## 🎞 场景排名

| 排名 | 场景 | 加权分 | 类型 | 等级 | 描述 |
|------|------|--------|------|------|------|
"""
    for i, s in enumerate(sorted_scenes, 1):
        desc = s.get("description", "N/A")[:30]
        report += f"| {i} | Scene {s.get('scene_number', 0):03d} | **{s.get('weighted_score', 0):.2f}** | {s.get('type_classification', 'N/A')} | {s.get('selection', '')} | {desc} |\n"

    report += f"""
---

## 📊 整体评价

### 综合评分: {avg:.2f} / 10

"""
    if avg >= 8:
        report += "🌟 **优秀** - 高质量素材，强烈推荐保留\n"
    elif avg >= 6.5:
        report += "📁 **良好** - 有可用价值，需要适当剪辑\n"
    else:
        report += "🗑️ **一般** - 整体质量较低\n"

    report += f"""
---
*本报告由 Video Expert Analyzer v2.0 自动生成*
*分析时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*
"""

    report_path.write_text(report, encoding="utf-8")
    print(f"✅ 完整分析报告已生成: {report_path}")
    return report_path


# ============================================================
# CLI 入口
# ============================================================
if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("""用法: python3 ai_analyzer.py <scene_scores.json> [--mode api|agent]

评分模式:
  --mode api    通过远程 API 调用视觉大模型评分（需设置 VIDEO_ANALYZER_API_KEY）
  --mode agent  生成评分模板，由宿主 AI 助手（如 IDE 中的 Gemini/Kimi）直接看图评分

环境变量 (API 模式):
  VIDEO_ANALYZER_API_KEY    API 密钥（必需）
  VIDEO_ANALYZER_BASE_URL   API 端点（默认 Gemini）
  VIDEO_ANALYZER_MODEL      模型名称（默认 gemini-2.0-flash）
""")
        sys.exit(1)

    scores_path = Path(sys.argv[1])
    video_dir = scores_path.parent

    # 解析模式
    mode = "api"
    if "--mode" in sys.argv:
        idx = sys.argv.index("--mode")
        if idx + 1 < len(sys.argv):
            mode = sys.argv[idx + 1]

    print("=" * 60)
    print(f"🤖 AI Scene Analyzer v2.0 ({mode.upper()} 模式)")
    print("=" * 60)

    # 1. 自动评分
    data = auto_score_scenes(scores_path, video_dir, mode=mode)

    if mode == "agent":
        print("\n" + "=" * 60)
        print("📝 Agent 模式说明")
        print("=" * 60)
        print(f"\n请使用宿主 AI 助手的视觉能力完成以下步骤：")
        print(f"  1. 查看 {video_dir}/frames/ 中的每张截帧")
        print(f"  2. 按 Walter Murch 法则五维度打分")
        print(f"  3. 将结果更新到 {scores_path}")
        print(f"  4. 再次运行本脚本（不带 --mode agent）生成报告")
        sys.exit(0)

    # 2. 复制精选镜头
    print("\n" + "=" * 60)
    print("⭐ 选择并复制精选镜头")
    print("=" * 60)
    select_and_copy_best_shots(scores_path, threshold=7.0)

    # 3. 生成完整报告
    print("\n" + "=" * 60)
    print("📄 生成完整分析报告")
    print("=" * 60)
    report_path = generate_complete_report(scores_path)

    print("\n" + "=" * 60)
    print("✅ AI 分析完成!")
    print("=" * 60)
    print(f"\n📊 评分文件: {scores_path}")
    print(f"⭐ 精选镜头: {video_dir}/scenes/best_shots/")
    print(f"📄 完整报告: {report_path}")

#!/usr/bin/env python3
"""
Video Expert Analyzer v2.1 环境检测和依赖安装脚本
检测所有必要和可选依赖
"""

import subprocess
import sys
import shutil

def check_command(cmd: str, version_arg: str = "--version") -> tuple:
    """检查命令行工具是否可用"""
    try:
        result = subprocess.run(
            [cmd, version_arg],
            capture_output=True,
            text=True,
            timeout=10
        )
        version = result.stdout.strip() or result.stderr.strip()
        return True, version.split('\n')[0]
    except (FileNotFoundError, subprocess.TimeoutExpired):
        return False, ""

def check_python_package(package: str) -> bool:
    """检查 Python 包是否已安装"""
    try:
        __import__(package)
        return True
    except ImportError:
        return False

def main():
    print("=" * 55)
    print("🔍 Video Expert Analyzer v2.1 环境检测")
    print("=" * 55)
    print()
    
    all_ok = True
    missing_cmds = []
    missing_pips = []
    
    # ── 1. 系统工具 ──
    print("1️⃣  系统工具")
    
    # 检查 FFmpeg
    ok, version = check_command("ffmpeg", "-version")
    if ok:
        print(f"   ✅ ffmpeg: {version[:60]}")
    else:
        print(f"   ❌ ffmpeg 未安装 → brew install ffmpeg / 下载 FFmpeg")
        all_ok = False
    
    # 检查 yt-dlp (支持多种调用方式)
    ok, version = False, ""
    
    # 方法1: 直接命令
    try:
        result = subprocess.run(["yt-dlp", "--version"], capture_output=True, text=True, timeout=10)
        if result.returncode == 0:
            ok, version = True, result.stdout.strip()
    except:
        pass
    
    # 方法2: 通过 py -m 调用
    if not ok:
        try:
            result = subprocess.run([sys.executable, "-m", "yt_dlp", "--version"], capture_output=True, text=True, timeout=10)
            if result.returncode == 0:
                ok, version = True, result.stdout.strip()
        except:
            pass
    
    if ok:
        print(f"   ✅ yt-dlp: {version}")
    else:
        print(f"   ❌ yt-dlp 未安装 → pip3 install yt-dlp")
        all_ok = False
    
    # ── 2. 核心 Python 依赖（必需） ──
    print("\n2️⃣  核心 Python 依赖（必需）")
    
    core_packages = {
        "scenedetect": "scenedetect[opencv]",
        "requests": "requests",
        "torch": "torch",
    }
    
    for import_name, pip_name in core_packages.items():
        if check_python_package(import_name):
            print(f"   ✅ {pip_name}")
        else:
            print(f"   ❌ {pip_name} 未安装")
            missing_pips.append(pip_name)
            all_ok = False
    
    # ── 3. 语音转录依赖（FunASR） ──
    print("\n3️⃣  语音转录 (FunASR)")
    
    funasr_packages = {
        "funasr": "funasr",
        "modelscope": "modelscope",
        "torchaudio": "torchaudio",
    }
    
    for import_name, pip_name in funasr_packages.items():
        if check_python_package(import_name):
            print(f"   ✅ {pip_name}")
        else:
            print(f"   ❌ {pip_name} 未安装")
            missing_pips.append(pip_name)
            all_ok = False
    
    # ── 4. 可选依赖 ──
    print("\n4️⃣  可选依赖")
    
    optional = {
        "openai": ("openai", "API 模式评分"),
        "rapidocr_onnxruntime": ("rapidocr-onnxruntime", "烧录字幕 OCR 检测"),
    }
    
    for import_name, (pip_name, desc) in optional.items():
        if check_python_package(import_name):
            print(f"   ✅ {pip_name} ({desc})")
        else:
            print(f"   ⚠️  {pip_name} 未安装 ({desc}) → pip3 install {pip_name}")
    
    # ── 5. CUDA / MPS 检测 ──
    print("\n5️⃣  GPU 加速")
    try:
        import torch
        if torch.cuda.is_available():
            print(f"   ✅ CUDA: {torch.cuda.get_device_name(0)}")
        elif hasattr(torch.backends, 'mps') and torch.backends.mps.is_available():
            print(f"   ✅ Apple MPS (Metal) 可用")
        else:
            print("   ⚠️  无 GPU 加速，将使用 CPU（FunASR 转录可能较慢）")
    except ImportError:
        print("   ⚠️  PyTorch 未安装，无法检测 GPU")
    
    # ── 结果汇总 ──
    print()
    print("=" * 55)
    
    if all_ok:
        print("✅ 所有核心依赖已满足！可以开始使用 Video Expert Analyzer。")
        print()
        print("快速开始：")
        print("  python3 scripts/pipeline_enhanced.py --setup")
        print("  python3 scripts/pipeline_enhanced.py <视频URL>")
    else:
        print("❌ 存在缺失依赖，请执行以下命令安装：")
        print()
        if missing_pips:
            print(f"  pip3 install {' '.join(missing_pips)}")
        for cmd in missing_cmds:
            print(f"  {cmd}")
        print()
        print("或一键安装所有依赖：")
        print("  pip3 install -r requirements.txt")
    
    print("=" * 55)
    return 0 if all_ok else 1

if __name__ == "__main__":
    sys.exit(main())

#!/usr/bin/env python3
"""
抖音视频下载脚本
支持从抖音分享链接提取并下载视频（无水印版本）

使用方法:
    python download_douyin.py <抖音链接> <输出路径>
    
示例:
    python download_douyin.py "https://v.douyin.com/xxxxx" ./video.mp4
    python download_douyin.py "https://www.douyin.com/video/xxxxx" ./video.mp4
"""

import requests
import re
import json
import sys
import os
from urllib.parse import unquote, urlparse


def is_douyin_url(url: str) -> bool:
    """检查是否为抖音链接"""
    douyin_patterns = [
        r'v\.douyin\.com',
        r'www\.douyin\.com',
        r'm\.douyin\.com',
        r'douyin\.com/video/',
        r'douyin\.com/jingxuan',
    ]
    return any(re.search(pattern, url) for pattern in douyin_patterns)


def extract_video_id(url: str) -> str:
    """从抖音链接中提取视频ID"""
    # 尝试从各种格式的链接中提取ID
    patterns = [
        r'/video/(\d+)',
        r'modal_id=(\d+)',
        r'share/video/(\d+)',
    ]
    
    for pattern in patterns:
        match = re.search(pattern, url)
        if match:
            return match.group(1)
    
    # 如果是短链接，返回None，需要获取重定向后的URL
    return None


def get_redirect_url(short_url: str) -> tuple:
    """获取重定向后的完整URL"""
    headers = {
        'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 13_2_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.0.3 Mobile/15E148 Safari/604.1',
        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
        'Accept-Language': 'zh-CN,zh;q=0.9',
    }

    try:
        response = requests.get(short_url, headers=headers, allow_redirects=True, timeout=10)
        return response.url, headers['User-Agent'], response.text
    except Exception as e:
        print(f"✗ 获取重定向URL失败: {e}")
        return None, None, None


def extract_render_data(html: str) -> dict:
    """从HTML中提取RENDER_DATA"""
    # 尝试多种可能的模式
    patterns = [
        r'<script id="RENDER_DATA" type="application/json">([^<]+)</script>',
        r'window\._ROUTER_DATA\s*=\s*(\{.+?\});?\s*</script>',
        r'window\._SSR_DATA\s*=\s*(\{.+?\});?\s*</script>',
        r'window\._SSR_HYDRATED_DATA\s*=\s*(\{.+?\});?\s*</script>',
    ]

    for pattern in patterns:
        matches = re.findall(pattern, html, re.DOTALL)
        if matches:
            data_str = matches[0]
            # URL解码
            if '%' in data_str:
                data_str = unquote(data_str)
            try:
                return json.loads(data_str)
            except json.JSONDecodeError:
                continue
    
    return None


def extract_video_url(data: dict) -> str:
    """从RENDER_DATA中提取视频URL"""
    
    def get_nested(obj, path):
        """安全地获取嵌套字典/列表值"""
        current = obj
        for key in path:
            if isinstance(current, dict) and key in current:
                current = current[key]
            elif isinstance(current, list) and isinstance(key, int) and key < len(current):
                current = current[key]
            else:
                return None
        return current

    # 尝试多种可能的路径
    possible_paths = [
        ['loaderData', 'video_(id)/page', 'videoInfoRes', 'item_list', 0, 'video', 'play_addr', 'url_list'],
        ['loaderData', 'video_(id)/page', 'aweme_detail', 'video', 'play_addr', 'url_list'],
        ['videoInfoRes', 'item_list', 0, 'video', 'play_addr', 'url_list'],
        ['app', 'videoInfoRes', 'item_list', 0, 'video', 'play_addr', 'url_list'],
        ['app', 'videoDetail', 'video', 'play_addr', 'url_list'],
        ['video', 'play_addr', 'url_list'],
        ['aweme_detail', 'video', 'play_addr', 'url_list'],
    ]

    for path in possible_paths:
        url_list = get_nested(data, path)
        if url_list and isinstance(url_list, list) and len(url_list) > 0:
            video_url = url_list[0]
            # 替换playwm为play获取无水印版本
            video_url = video_url.replace('playwm', 'play')
            return video_url

    # 如果路径查找失败，尝试正则搜索
    json_str = json.dumps(data)
    play_patterns = [
        r'"play_addr":\s*\{[^}]*"url_list":\s*\["([^"]+)"',
        r'"playAddr":\s*\["([^"]+)"',
        r'"download_addr":\s*\{[^}]*"url_list":\s*\["([^"]+)"',
    ]

    for pattern in play_patterns:
        matches = re.findall(pattern, json_str)
        if matches:
            video_url = matches[0].replace('playwm', 'play')
            return video_url

    return None


def download_video(video_url: str, output_path: str, user_agent: str) -> bool:
    """下载视频"""
    headers = {
        'User-Agent': user_agent,
        'Referer': 'https://www.douyin.com/',
        'Accept': '*/*',
        'Accept-Language': 'zh-CN,zh;q=0.9',
    }

    try:
        response = requests.get(video_url, headers=headers, stream=True, timeout=60)

        if response.status_code not in [200, 206]:
            print(f"✗ 下载失败，状态码: {response.status_code}")
            return False

        total_size = int(response.headers.get('content-length', 0))
        downloaded = 0

        with open(output_path, 'wb') as f:
            for chunk in response.iter_content(chunk_size=8192):
                if chunk:
                    f.write(chunk)
                    downloaded += len(chunk)
                    if total_size > 0:
                        percent = (downloaded / total_size) * 100
                        print(f"\r进度: {percent:.1f}% ({downloaded:,}/{total_size:,} bytes)", end='', flush=True)

        print()  # 换行
        return True

    except Exception as e:
        print(f"✗ 下载视频时出错: {e}")
        return False


def download_douyin_video(url: str, output_path: str) -> bool:
    """
    下载抖音视频的主函数
    
    Args:
        url: 抖音视频链接（支持短链接和长链接）
        output_path: 输出文件路径
        
    Returns:
        bool: 下载是否成功
    """
    print(f"🎬 开始下载抖音视频")
    print(f"   链接: {url}")
    print(f"   输出: {output_path}")
    print()

    # 步骤1: 获取重定向URL和页面内容
    print("步骤 1/4: 获取页面信息...")
    full_url, user_agent, html = get_redirect_url(url)
    if not full_url:
        return False
    print(f"✓ 获取到页面 ({len(html):,} 字符)")

    # 步骤2: 提取RENDER_DATA
    print("\n步骤 2/4: 提取视频数据...")
    render_data = extract_render_data(html)
    if not render_data:
        print("✗ 无法提取视频数据")
        return False
    print("✓ 提取到视频数据")

    # 步骤3: 提取视频URL
    print("\n步骤 3/4: 解析视频地址...")
    video_url = extract_video_url(render_data)
    if not video_url:
        print("✗ 无法获取视频下载地址")
        return False
    print(f"✓ 获取到视频地址")

    # 步骤4: 下载视频
    print("\n步骤 4/4: 下载视频...")
    success = download_video(video_url, output_path, user_agent)
    
    if success:
        file_size = os.path.getsize(output_path)
        print(f"✓ 下载完成: {file_size:,} bytes")
        return True
    else:
        return False


def main():
    if len(sys.argv) < 3:
        print("用法: python download_douyin.py <抖音链接> <输出路径>")
        print("示例: python download_douyin.py 'https://v.douyin.com/xxxxx' ./video.mp4")
        sys.exit(1)

    url = sys.argv[1]
    output_path = sys.argv[2]

    # 检查是否为抖音链接
    if not is_douyin_url(url):
        print(f"✗ 不是有效的抖音链接: {url}")
        sys.exit(1)

    success = download_douyin_video(url, output_path)
    sys.exit(0 if success else 1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
智能字幕提取脚本 - FunASR + RapidOCR 版本
流程：B站API字幕 → 内嵌字幕 → 烧录字幕检测(RapidOCR) → FunASR语音转录

技术栈：
- B站 API: 直接获取平台字幕（需 cookies）
- RapidOCR (ONNX): 轻量级 OCR，用于提取烧录字幕
- FunASR: 中文语音转录，配合 VAD 分段和标点模型
"""

import subprocess
import sys
import os
import re
import tempfile
from pathlib import Path
import json


# ============================================================
# L0: B站 API 字幕获取（最高优先级）
# ============================================================

def extract_bvid(video_url_or_path: str) -> str:
    """从 URL 或文件名中提取 B站 BV 号"""
    # 匹配 BV 号模式（BV + 10位字母数字）
    match = re.search(r'(BV[a-zA-Z0-9]{10})', video_url_or_path)
    if match:
        return match.group(1)
    return ""


def get_bilibili_subtitle(bvid: str, output_srt: str) -> bool:
    """
    通过 B站 API 获取字幕
    自动从浏览器读取 cookies，无需手动配置

    优先级: yt-dlp cookies > browser_cookie3 > 配置文件/环境变量
    """
    # 调用独立的字幕获取脚本
    script_dir = os.path.dirname(os.path.abspath(__file__))
    fetch_script = os.path.join(script_dir, "fetch_bilibili_subtitle.py")

    if os.path.exists(fetch_script):
        try:
            cmd = [sys.executable, fetch_script, bvid, output_srt]
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
            print(result.stdout)
            if result.stderr:
                print(result.stderr)

            if result.returncode == 0 and os.path.exists(output_srt):
                # 检查文件是否有实际内容
                if os.path.getsize(output_srt) > 10:
                    return True
            return False
        except subprocess.TimeoutExpired:
            print("   ⚠️ 字幕获取超时")
            return False
        except Exception as e:
            print(f"   ⚠️ 调用字幕获取脚本失败: {e}")
            return False
    else:
        print(f"   ⚠️ 未找到 fetch_bilibili_subtitle.py 脚本")
        # 回退到简单的无 cookies 尝试
        return _simple_bilibili_fetch(bvid, output_srt)


def _simple_bilibili_fetch(bvid: str, output_srt: str) -> bool:
    """简单的 B站字幕获取（无 cookies，通常会失败但不影响流程）"""
    try:
        import requests
    except ImportError:
        return False

    headers = {
        "User-Agent": "Mozilla/5.0",
        "Referer": "https://www.bilibili.com",
    }

    try:
        resp = requests.get(
            f"https://api.bilibili.com/x/player/pagelist?bvid={bvid}",
            headers=headers, timeout=10
        )
        data = resp.json()
        if data.get("code") != 0 or not data.get("data"):
            return False

        cid = data["data"][0]["cid"]
        resp = requests.get(
            f"https://api.bilibili.com/x/web-interface/view?bvid={bvid}",
            headers=headers, timeout=10
        )
        aid = resp.json()["data"]["aid"]

        resp = requests.get(
            f"https://api.bilibili.com/x/player/wbi/v2?aid={aid}&cid={cid}",
            headers=headers, timeout=10
        )
        subtitles = resp.json().get("data", {}).get("subtitle", {}).get("subtitles", [])

        if not subtitles:
            return False

        sub_url = subtitles[0].get("subtitle_url", "")
        if sub_url.startswith("//"):
            sub_url = "https:" + sub_url

        resp = requests.get(sub_url, headers=headers, timeout=10)
        body = resp.json().get("body", [])

        if not body:
            return False

        with open(output_srt, 'w', encoding='utf-8') as f:
            for i, item in enumerate(body, 1):
                start = format_timestamp(item.get("from", 0))
                end = format_timestamp(item.get("to", 0))
                content = item.get("content", "").strip()
                if content:
                    f.write(f"{i}\n{start} --> {end}\n{content}\n\n")

        return True
    except Exception:
        return False


# ============================================================
# L1: 内嵌字幕检测
# ============================================================

def check_embedded_subtitle(video_path: str) -> tuple[bool, str]:
    """
    检查视频是否包含内嵌字幕流
    返回: (是否有内嵌字幕, 字幕文件路径或错误信息)
    """
    try:
        cmd = [
            "ffprobe", "-v", "quiet", "-print_format", "json",
            "-show_streams", video_path
        ]
        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
        data = json.loads(result.stdout)

        streams = data.get("streams", [])
        subtitle_streams = [s for s in streams if s.get("codec_type") == "subtitle"]

        if subtitle_streams:
            output_srt = video_path.rsplit(".", 1)[0] + "_embedded.srt"
            cmd = [
                "ffmpeg", "-y", "-i", video_path,
                "-map", f"0:s:0", output_srt
            ]
            subprocess.run(cmd, capture_output=True, check=True)
            return True, output_srt
        else:
            return False, "无内嵌字幕流"
    except Exception as e:
        return False, f"检测失败: {e}"


# ============================================================
# L2: 烧录字幕检测与提取 (RapidOCR)
# ============================================================

def capture_frame(video_path: str, timestamp: str = "00:00:05") -> str:
    """截取视频指定时间的帧"""
    try:
        with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tmp:
            frame_path = tmp.name

        cmd = [
            "ffmpeg", "-y", "-ss", timestamp, "-i", video_path,
            "-vframes", "1", "-q:v", "2", frame_path
        ]
        subprocess.run(cmd, capture_output=True, check=True)
        return frame_path
    except Exception as e:
        return ""


def _format_time_hms(seconds: int) -> str:
    """将秒数格式化为 HH:MM:SS 格式（用于 ffmpeg 时间戳）"""
    h = seconds // 3600
    m = (seconds % 3600) // 60
    s = seconds % 60
    return f"{h:02d}:{m:02d}:{s:02d}"


def check_burned_subtitle(frame_path: str) -> bool:
    """使用 RapidOCR 检测画面是否有烧录字幕"""
    try:
        from rapidocr_onnxruntime import RapidOCR

        ocr = RapidOCR()
        result = ocr(frame_path)

        # 如果检测到文字，认为有烧录字幕
        if result and result[0]:
            text_count = len([line for line in result[0] if line])
            # 检测到至少2行文字，认为是字幕
            return text_count >= 2
        return False
    except ImportError:
        print("⚠️ RapidOCR 未安装，跳过烧录字幕检测")
        print("   安装命令: pip install rapidocr-onnxruntime")
        return False
    except Exception as e:
        print(f"⚠️ OCR 检测失败: {e}")
        return False


def extract_burned_subtitle_ocr(video_path: str, output_srt: str) -> bool:
    """使用 RapidOCR 提取烧录字幕"""
    try:
        from rapidocr_onnxruntime import RapidOCR

        print("🔍 使用 RapidOCR 提取烧录字幕...")

        cmd = [
            "ffprobe", "-v", "error", "-show_entries",
            "format=duration", "-of", "default=noprint_wrappers=1:nokey=1",
            video_path
        ]
        result = subprocess.run(cmd, capture_output=True, text=True)
        duration = float(result.stdout.strip())

        ocr = RapidOCR()

        # 每隔2秒截取一帧进行 OCR（减少计算量）
        subtitles = []
        for t in range(0, int(duration), 2):
            timestamp = _format_time_hms(t)
            frame_path = capture_frame(video_path, timestamp)
            if not frame_path:
                continue

            result = ocr(frame_path)
            if result and result[0]:
                # 提取文字
                texts = []
                for line in result[0]:
                    if line:
                        text = line[1]
                        confidence = line[2]
                        # 修复: confidence 可能是 str 类型，统一转为 float
                        try:
                            conf = float(confidence)
                        except (ValueError, TypeError):
                            conf = 0.0
                        if conf > 0.7:  # 置信度阈值
                            texts.append(text)

                if texts:
                    start_ts = format_timestamp(t)
                    end_ts = format_timestamp(t + 2)
                    subtitles.append({
                        'index': len(subtitles) + 1,
                        'start': start_ts,
                        'end': end_ts,
                        'text': ' '.join(texts)
                    })

            os.unlink(frame_path)

        # 写入 SRT 文件
        with open(output_srt, 'w', encoding='utf-8') as f:
            for sub in subtitles:
                f.write(f"{sub['index']}\n")
                f.write(f"{sub['start']} --> {sub['end']}\n")
                f.write(f"{sub['text']}\n\n")

        print(f"✅ OCR 提取完成: {len(subtitles)} 条字幕")
        return True

    except Exception as e:
        print(f"❌ OCR 提取失败: {e}")
        return False


# ============================================================
# L3: FunASR 语音转录
# ============================================================

def extract_audio(video_path: str, audio_path: str) -> bool:
    """从视频中提取音频"""
    try:
        cmd = [
            "ffmpeg", "-y", "-i", video_path,
            "-vn", "-acodec", "pcm_s16le",
            "-ar", "16000", "-ac", "1",
            audio_path
        ]
        subprocess.run(cmd, capture_output=True, check=True)
        return True
    except subprocess.CalledProcessError as e:
        print(f"❌ 音频提取失败: {e}")
        return False


def format_timestamp(seconds: float) -> str:
    """格式化时间戳为 SRT 格式"""
    hours = int(seconds // 3600)
    minutes = int((seconds % 3600) // 60)
    secs = int(seconds % 60)
    millis = int((seconds % 1) * 1000)
    return f"{hours:02d}:{minutes:02d}:{secs:02d},{millis:03d}"


def _split_text_by_punctuation(text: str, timestamps: list) -> list:
    """
    按标点符号切分带字级时间戳的文本为自然句
    timestamps: [[start_ms, end_ms], ...] 每个字/词的时间戳
    返回: [{'text': str, 'start_ms': int, 'end_ms': int}, ...]
    """
    # 句末标点
    sentence_endings = set('。！？!?；;…')
    # 次级切分标点（逗号等，仅在句子过长时切）
    clause_breaks = set('，,、')

    sentences = []
    current_chars = []
    current_start_idx = 0
    ts_len = len(timestamps)
    text_len = len(text)

    for char_idx, char in enumerate(text):
        current_chars.append(char)

        # 映射字符位置到时间戳位置
        ts_idx = min(int(char_idx / text_len * ts_len), ts_len - 1) if ts_len > 0 else 0

        is_end = char in sentence_endings
        is_clause = char in clause_breaks and len(current_chars) > 25  # 逗号切分仅在 >25 字时
        is_last = char_idx == text_len - 1

        if is_end or is_clause or is_last:
            sent_text = ''.join(current_chars).strip()
            if sent_text:
                start_ts_idx = min(int(current_start_idx / text_len * ts_len), ts_len - 1) if ts_len > 0 else 0
                end_ts_idx = ts_idx

                start_ms = timestamps[start_ts_idx][0] if ts_len > 0 else 0
                end_ms = timestamps[end_ts_idx][1] if ts_len > 0 else 0

                sentences.append({
                    'text': sent_text,
                    'start_ms': start_ms,
                    'end_ms': end_ms,
                })

            current_chars = []
            current_start_idx = char_idx + 1

    return sentences


def extract_with_funasr(video_path: str, output_srt: str) -> bool:
    """
    使用 FunASR 进行语音转录
    配合 VAD 分段模型 + 标点模型，正确处理长音频

    调用方式参照 FunASR 官方 demo:
    https://github.com/modelscope/FunASR/blob/main/examples/industrial_data_pretraining/paraformer/demo.py
    """
    try:
        from funasr import AutoModel

        print("🎤 使用 FunASR 进行语音转录...")
        print("   ASR 模型: paraformer-zh (含 VAD + 标点)")
        print("   ⚠️ 首次运行需下载约 2-3GB 模型文件，请耐心等待")

        # 提取音频
        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp:
            audio_path = tmp.name

        if not extract_audio(video_path, audio_path):
            return False

        # 加载 FunASR 模型（官方推荐的短名称 + VAD + 标点）
        model = AutoModel(
            model="paraformer-zh",
            vad_model="fsmn-vad",
            vad_kwargs={"max_single_segment_time": 60000},
            punc_model="ct-punc",
            disable_update=True,
        )

        # 转录（VAD 自动分段，标点自动恢复，cache={} 是官方推荐参数）
        result = model.generate(
            input=audio_path,
            batch_size_s=300,
            cache={},
        )

        # 生成 SRT
        subtitle_count = 0
        with open(output_srt, 'w', encoding='utf-8') as f:
            for res in result:
                text = res.get('text', '').strip()
                timestamps = res.get('timestamp', [])
                sentence_info = res.get('sentence_info', [])

                if sentence_info:
                    # 方案A: 使用句级时间戳（最佳，如果模型返回了）
                    for sent in sentence_info:
                        sent_text = sent.get('text', '').strip()
                        if sent_text:
                            subtitle_count += 1
                            start = format_timestamp(sent.get('start', 0) / 1000)
                            end = format_timestamp(sent.get('end', 0) / 1000)
                            f.write(f"{subtitle_count}\n{start} --> {end}\n{sent_text}\n\n")

                elif timestamps and text:
                    # 方案B: 按标点符号切分 + 字级时间戳映射
                    sentences = _split_text_by_punctuation(text, timestamps)
                    for sent in sentences:
                        subtitle_count += 1
                        start = format_timestamp(sent['start_ms'] / 1000)
                        end = format_timestamp(sent['end_ms'] / 1000)
                        f.write(f"{subtitle_count}\n{start} --> {end}\n{sent['text']}\n\n")

                elif text:
                    # 方案C: 无时间戳，仅输出文本
                    subtitle_count += 1
                    f.write(f"{subtitle_count}\n00:00:00,000 --> 00:00:00,000\n{text}\n\n")

        # 清理临时文件
        os.unlink(audio_path)

        print(f"✅ FunASR 转录完成: {subtitle_count} 条字幕")
        return subtitle_count > 0

    except ImportError:
        print("❌ FunASR 未安装")
        print("   安装命令: pip install funasr modelscope torchaudio")
        return False
    except Exception as e:
        print(f"❌ FunASR 转录失败: {e}")
        import traceback
        traceback.print_exc()
        return False


# ============================================================
# 主流程
# ============================================================

def smart_subtitle_extraction(video_path: str, output_srt: str, video_url: str = "") -> tuple[bool, str]:
    """
    智能字幕提取主函数
    流程: B站API字幕 → 内嵌字幕 → 烧录字幕(RapidOCR) → FunASR语音转录

    返回: (是否成功, 使用的模式)
    """
    print("=" * 50)
    print("🎬 智能字幕提取 (B站API + RapidOCR + FunASR)")
    print("=" * 50)
    print(f"视频: {video_path}")
    print()

    # 步骤0: 尝试从B站API获取字幕（最优先）
    bvid = extract_bvid(video_url) or extract_bvid(video_path)
    if bvid:
        print("步骤 0/4: 尝试B站API字幕获取...")
        if get_bilibili_subtitle(bvid, output_srt):
            return True, "bilibili_api"
        print()

    # 步骤1: 检查内嵌字幕
    print("步骤 1/3: 检查内嵌字幕...")
    has_embedded, result = check_embedded_subtitle(video_path)
    if has_embedded:
        print(f"✅ 发现内嵌字幕，已提取: {result}")
        if result != output_srt:
            import shutil
            shutil.copy(result, output_srt)
        return True, "embedded"
    else:
        print(f"⚠️ {result}")

    # 步骤2: 检测烧录字幕
    print("\n步骤 2/3: 检测烧录字幕 (RapidOCR)...")
    frame_path = capture_frame(video_path, "00:00:05")
    if frame_path:
        has_burned = check_burned_subtitle(frame_path)
        os.unlink(frame_path)

        if has_burned:
            print("✅ 检测到烧录字幕，使用 RapidOCR 提取...")
            if extract_burned_subtitle_ocr(video_path, output_srt):
                return True, "ocr"
        else:
            print("⚠️ 未检测到烧录字幕")

    # 步骤3: 使用 FunASR
    print("\n步骤 3/3: 使用 FunASR 语音转录...")
    if extract_with_funasr(video_path, output_srt):
        return True, "funasr"

    return False, "failed"


def main():
    if len(sys.argv) < 3:
        print("用法: python extract_subtitle_funasr.py <视频路径> <输出SRT路径> [视频URL]")
        print()
        print("参数说明:")
        print("  视频路径  - 本地视频文件路径")
        print("  输出SRT   - 输出的 SRT 字幕文件路径")
        print("  视频URL   - 可选，原始视频URL（用于B站API字幕获取）")
        sys.exit(1)

    video_path = sys.argv[1]
    output_srt = sys.argv[2]
    video_url = sys.argv[3] if len(sys.argv) > 3 else ""

    if not os.path.exists(video_path):
        print(f"❌ 视频文件不存在: {video_path}")
        sys.exit(1)

    success, mode = smart_subtitle_extraction(video_path, output_srt, video_url)

    if success:
        print(f"\n✅ 字幕提取成功！")
        print(f"   模式: {mode}")
        print(f"   输出: {output_srt}")
        sys.exit(0)
    else:
        print(f"\n❌ 字幕提取失败")
        sys.exit(1)


if __name__ == "__main__":
    main()