构建您的第一个视频AI智能体：实战指南

import os
import sys
from pathlib import Path
from transcriber import AudioTranscriber
from matcher import TextMatcher
from fcpxml_generator import FCPXMLGenerator

class VideoAgent:
    def __init__(self, video_path, script_path, output_path):
        self.video_path = video_path
        self.script_path = script_path
        self.output_path = output_path
        
    def run(self):
        """执行完整的初剪生成流程"""
        print("🎬 视频AI智能体启动...")
        
        # 步骤1：转录音频
        print("\n📝 步骤1：转录音频...")
        transcriber = AudioTranscriber(self.video_path)
        transcript = transcriber.transcribe()
        print(f"✓ 转录完成，共 {len(transcript)} 个字符")
        
        # 步骤2：读取文稿
        print("\n📄 步骤2：读取文稿...")
        with open(self.script_path, 'r', encoding='utf-8') as f:
            script = f.read()
        print(f"✓ 文稿读取完成，共 {len(script)} 个字符")
        
        # 步骤3：匹配文本
        print("\n🔍 步骤3：匹配文本...")
        matcher = TextMatcher(transcript, script)
        matches = matcher.match()
        print(f"✓ 匹配完成，找到 {len(matches)} 个匹配段落")
        
        # 步骤4：生成FCPXML
        print("\n🎞️  步骤4：生成FCPXML...")
        generator = FCPXMLGenerator(
            video_path=self.video_path,
            matches=matches,
            output_path=self.output_path
        )
        generator.generate()
        print(f"✓ FCPXML生成完成：{self.output_path}")
        
        print("\n✨ 完成！您可以在Final Cut Pro中打开生成的FCPXML文件。")

if __name__ == "__main__":
    # 使用示例
    agent = VideoAgent(
        video_path="interview.mov",
        script_path="transcript.txt",
        output_path="rough_cut.fcpxml"
    )
    agent.run()

import speech_recognition as sr
from moviepy.editor import VideoFileClip
import os

class AudioTranscriber:
    def __init__(self, video_path):
        self.video_path = video_path
        self.audio_path = "temp_audio.wav"
        
    def extract_audio(self):
        """从视频中提取音频"""
        print("  提取音频中...")
        video = VideoFileClip(self.video_path)
        audio = video.audio
        audio.write_audiofile(self.audio_path, verbose=False, logger=None)
        video.close()
        
    def transcribe(self):
        """转录音频为文本"""
        self.extract_audio()
        
        recognizer = sr.Recognizer()
        transcript = ""
        
        # 分块处理音频（避免内存溢出）
        with sr.AudioFile(self.audio_path) as source:
            audio = recognizer.record(source)
            
        try:
            print("  识别中（这可能需要一些时间）...")
            # 使用Google Speech Recognition API
            transcript = recognizer.recognize_google(audio, language='zh-CN')
        except sr.UnknownValueError:
            print("  无法识别音频")
        except sr.RequestError as e:
            print(f"  识别服务错误: {e}")
        
        # 清理临时文件
        if os.path.exists(self.audio_path):
            os.remove(self.audio_path)
            
        return transcript

import difflib
from typing import List, Tuple

class TextMatcher:
    def __init__(self, transcript: str, script: str):
        self.transcript = transcript
        self.script = script
        
    def match(self) -> List[Tuple[str, float, float]]:
        """
        匹配文稿中的段落在转录文本中的位置
        返回: [(段落文本, 开始时间, 结束时间), ...]
        """
        matches = []
        
        # 将文稿分成句子
        sentences = self.script.split('。')
        
        # 对每个句子进行匹配
        for sentence in sentences:
            sentence = sentence.strip()
            if not sentence:
                continue
                
            # 使用difflib查找最相似的段落
            ratio = difflib.SequenceMatcher(None, sentence, self.transcript).ratio()
            
            if ratio > 0.6:  # 相似度阈值
                # 在转录文本中查找该句子
                start_idx = self.transcript.find(sentence)
                if start_idx != -1:
                    # 简单估算时间码（假设平均语速）
                    # 这是一个简化的实现，实际应该使用更精确的方法
                    start_time = (start_idx / len(self.transcript)) * 3600  # 假设视频长1小时
                    end_time = start_time + (len(sentence) / len(self.transcript)) * 3600
                    
                    matches.append((sentence, start_time, end_time))
        
        return matches

import xml.etree.ElementTree as ET
from typing import List, Tuple
from pathlib import Path

class FCPXMLGenerator:
    def __init__(self, video_path: str, matches: List[Tuple[str, float, float]], output_path: str):
        self.video_path = video_path
        self.matches = matches
        self.output_path = output_path
        
    def generate(self):
        """生成FCPXML文件"""
        # 创建根元素
        root = ET.Element('fcpxml', version='1.10')
        
        # 创建resources
        resources = ET.SubElement(root, 'resources')
        media = ET.SubElement(resources, 'media', {
            'id': 'r1',
            'name': Path(self.video_path).stem,
            'src': f'file://{Path(self.video_path).absolute()}'
        })
        
        # 创建library
        library = ET.SubElement(root, 'library', {
            'location': f'file://{Path(self.output_path).absolute()}'
        })
        event = ET.SubElement(library, 'event', name='Timeline')
        project = ET.SubElement(event, 'project', name='Sequence 1')
        sequence = ET.SubElement(project, 'sequence', {
            'format': 'r0',
            'duration': '3600s'
        })
        spine = ET.SubElement(sequence, 'spine')
        
        # 添加clips
        for idx, (text, start_time, end_time) in enumerate(self.matches):
            duration = end_time - start_time
            clip = ET.SubElement(spine, 'clip', {
                'ref': 'r1',
                'offset': f'{start_time}s',
                'duration': f'{duration}s'
            })
            
            # 添加metadata（便签）
            metadata = ET.SubElement(clip, 'metadata')
            note = ET.SubElement(metadata, 'md', key='com.apple.proapps.clip.note')
            note.text = text[:100]  # 限制长度
        
        # 保存文件
        tree = ET.ElementTree(root)
        tree.write(self.output_path, encoding='utf-8', xml_declaration=True)