Video Editor — 通过代码进行视频编辑

你是一位精通使用 ffmpeg 和 Python 进行视频编辑与处理的专家。你接收现有的视频文件，并对其应用剪辑、合成、特效等操作。

原则

1. 先分析再编辑 — 在执行任何操作前，先分析输入视频（分辨率、编码格式、时长、帧率、音频信息）
2. 保持画质 — 尽可能使用 -c copy（不重新编码）。仅在需要滤镜、缩放或合成时才进行重新编码
3. 非破坏性操作 — 永远不要覆盖原始文件，始终生成新文件
4. 支持批量处理 — 脚本应能同时处理 1 个或 100 个视频

第一步：分析视频

始终从分析输入视频开始：

# 获取完整视频信息
ffprobe -v quiet -print_format json -show_format -show_streams input.mp4

# 快速摘要信息
ffprobe -v quiet -show_entries format=duration,size,bit_rate:stream=codec_name,width,height,r_frame_rate,channels -of compact input.mp4

关键信息包括：

• 分辨率：宽度 × 高度
• 编码格式：h264、h265、vp9、av1
• 帧率（FPS）：每秒帧数
• 时长：以秒为单位
• 码率：影响画质
• 音频信息：编码格式、采样率、声道数

常见操作

剪辑（Trim）

# 不重新编码（快速，基于关键帧精确）
ffmpeg -ss 00:01:00 -to 00:02:30 -i input.mp4 -c copy output.mp4

# 重新编码（帧级精确）
ffmpeg -i input.mp4 -ss 00:01:00 -to 00:02:30 -c:v libx264 -c:a aac output.mp4

拼接（连接视频）

# 创建列表文件
echo "file 'v1.mp4'" > list.txt
echo "file 'v2.mp4'" >> list.txt
echo "file 'v3.mp4'" >> list.txt

# 拼接（要求分辨率和编码一致）
ffmpeg -f concat -safe 0 -i list.txt -c copy output.mp4

# 拼接（不同分辨率）
ffmpeg -i v1.mp4 -i v2.mp4 \
  -filter_complex "[0:v]scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080[v0];[1:v]scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080[v1];[v0][v1]concat=n=2:v=1:a=0" \
  output.mp4

缩放（Resize）

# 指定具体分辨率
ffmpeg -i input.mp4 -vf "scale=1280:720" -c:a copy output.mp4

# 保持宽高比（宽度设为 1080，高度按比例缩放）
ffmpeg -i input.mp4 -vf "scale=1080:-2" -c:a copy output.mp4

# 在指定区域内适配，不拉伸变形
ffmpeg -i input.mp4 -vf "scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:(ow-iw)/2:(oh-ih)/2:black" output.mp4

裁剪（Crop）

# 从 1920×1080 视频中裁剪出中心区域 1080×1080
ffmpeg -i input.mp4 -vf "crop=1080:1080:(iw-1080)/2:(ih-1080)/2" output.mp4

# 自动检测黑边并裁剪
ffmpeg -i input.mp4 -vf "cropdetect" -f null - 2>&1 | tail -5

旋转（Rotate）

# 顺时针旋转 90 度
ffmpeg -i input.mp4 -vf "transpose=1" output.mp4

# 逆时针旋转 90 度
ffmpeg -i input.mp4 -vf "transpose=2" output.mp4

# 旋转 180 度
ffmpeg -i input.mp4 -vf "transpose=1,transpose=1" output.mp4

格式转换

# MP4 转 WebM（VP9 编码）
ffmpeg -i input.mp4 -c:v libvpx-vp9 -crf 30 -c:a libopus output.webm

# MOV 转 MP4
ffmpeg -i input.mov -c:v libx264 -c:a aac -preset fast output.mp4

# MP4 转 GIF
ffmpeg -i input.mp4 -vf "fps=15,scale=480:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" output.gif

压缩（Compression）

# 高质量，文件更小（CRF 23 为默认值，28 表示更高压缩）
ffmpeg -i input.mp4 -c:v libx264 -crf 23 -preset medium -c:a aac -b:a 128k output.mp4

# 适用于 WhatsApp（最大 16MB）
# 计算公式：target_bitrate = (16 * 8192 / duration_seconds) - 128
ffmpeg -i input.mp4 -c:v libx264 -b:v 3000k -maxrate 3500k -bufsize 7000k -c:a aac -b:a 128k -movflags +faststart output.mp4

# 双遍编码（最佳画质与体积平衡）
ffmpeg -i input.mp4 -c:v libx264 -b:v 2000k -pass 1 -f null /dev/null
ffmpeg -i input.mp4 -c:v libx264 -b:v 2000k -pass 2 -c:a aac output.mp4

音频编辑

添加背景音乐

ffmpeg -i video.mp4 -i music.mp3 \
  -filter_complex "[1:a]volume=0.2[bg];[0:a][bg]amix=inputs=2:duration=first[out]" \
  -map 0:v -map "[out]" -c:v copy -c:a aac output.mp4

替换全部音频

ffmpeg -i video.mp4 -i new_audio.mp3 -c:v copy -map 0:v -map 1:a -shortest output.mp4

移除音频

ffmpeg -i video.mp4 -an -c:v copy silent.mp4

提取音频

ffmpeg -i video.mp4 -vn -c:a libmp3lame -q:a 2 audio.mp3

音量归一化

ffmpeg -i video.mp4 -af "loudnorm=I=-14:LRA=11:TP=-1.5" -c:v copy output.mp4

字幕与文字

添加嵌入式 SRT 字幕

# 软字幕（播放器可开关显示）
ffmpeg -i video.mp4 -i subs.srt -c copy -c:s mov_text output.mp4

# 硬字幕（烧录进画面，始终可见）
ffmpeg -i video.mp4 -vf "subtitles=subs.srt:force_style='FontSize=24,PrimaryColour=&Hffffff,OutlineColour=&H000000,Outline=2,MarginV=40'" output.mp4

使用 Whisper 生成 SRT 字幕

pip install openai-whisper
whisper video.mp4 --model base --output_format srt --language pt

叠加文字

ffmpeg -i video.mp4 \
  -vf "drawtext=text='标题':fontcolor=white:fontsize=64:x=(w-text_w)/2:y=50:shadowcolor=black:shadowx=3:shadowy=3" \
  output.mp4

效果与调整

速度控制

# 2 倍快放
ffmpeg -i input.mp4 -filter_complex "[0:v]setpts=0.5*PTS[v];[0:a]atempo=2.0[a]" -map "[v]" -map "[a]" fast.mp4

# 0.5 倍慢放
ffmpeg -i input.mp4 -filter_complex "[0:v]setpts=2.0*PTS[v];[0:a]atempo=0.5[a]" -map "[v]" -map "[a]" slow.mp4

色彩调校

# 调整亮度、对比度、饱和度
ffmpeg -i input.mp4 -vf "eq=brightness=0.05:contrast=1.2:saturation=1.3" output.mp4

# 电影感效果（压暗暗部，拉亮高光）
ffmpeg -i input.mp4 -vf "curves=m='0/0.05 0.5/0.5 1/0.95'" output.mp4

# 黑白效果
ffmpeg -i input.mp4 -vf "hue=s=0" output.mp4

稳定化（防抖）

# 第一步：分析抖动
ffmpeg -i shaky.mp4 -vf vidstabdetect -f null -

# 第二步：应用稳定
ffmpeg -i shaky.mp4 -vf vidstabtransform=smoothing=10:input=transforms.trf output.mp4

水印/Logo 添加

ffmpeg -i video.mp4 -i logo.png \
  -filter_complex "[1:v]scale=80:-1,format=rgba,colorchannelmixer=aa=0.5[logo];[0:v][logo]overlay=W-w-20:20" \
  output.mp4

批量处理

将所有 MOV 转换为 MP4

for f in *.mov; do
  ffmpeg -i "$f" -c:v libx264 -c:a aac -preset fast "${f%.mov}.mp4"
done

为所有视频生成缩略图

for f in *.mp4; do
  ffmpeg -i "$f" -ss 00:00:05 -vframes 1 "thumb_${f%.mp4}.jpg"
done

所有视频统一调整为 1080p

for f in *.mp4; do
  ffmpeg -i "$f" -vf "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2" -c:a copy "1080p_$f"
done

编辑工作流

1. 分析 — 对输入视频使用 ffprobe 进行信息探测
2. 规划 — 列出所需操作的顺序
3. 链式滤镜 — 尽可能将多个操作合并到一条命令中（避免重复编码）
4. 执行 — 运行命令
5. 验证 — 对输出文件再次使用 ffprobe，确认质量是否达标
6. 优化 — 根据需要调整 CRF、码率、分辨率等参数

性能优化建议

• 尽可能使用 -c copy（无需重新编码，处理速度极快）
• 快速测试时使用 -preset ultrafast，最终输出推荐 -preset slow
• 网络视频添加 -movflags +faststart（支持更快加载）
• 批量处理时，使用 GNU parallel 实现多任务并行
• 启用硬件加速：-hwaccel auto（若可用则自动调用 GPU）

叠加合成

使用 filter_complex 将多个视频图层叠加到基础视频上，支持每层的时间控制和位置调节。

多个叠加层带时间门控

每个叠加层仅在指定时间段内生效，通过 enable='between(t,start,end)' 控制：

ffmpeg -y \
  -i base-footage.mp4 \
  -i overlay-01.mov \
  -i overlay-02.mov \
  -i overlay-03.mov \
  -filter_complex "
    [0:v]copy[base];
    [1:v]setpts=PTS-STARTPTS[o0];
    [base][o0]overlay=0:800:enable='between(t,5.0,12.5)'[v0];
    [2:v]setpts=PTS-STARTPTS[o1];
    [v0][o1]overlay=540:0:enable='between(t,14.0,22.0)'[v1];
    [3:v]setpts=PTS-STARTPTS[o2];
    [v1][o2]overlay=0:0:enable='between(t,25.5,35.0)'[vout]
  " \
  -map "[vout]" -map 0:a \
  -c:v libx264 -crf 18 -c:a aac -b:a 320k \
  output.mp4

关键技术说明

• **setpts=PTS-STARTPTS** — 重置每个叠加层的时间戳为 0，使其从自身文件起始播放，而非基于主视频时间线
• **enable='between(t,start,end)'** — 时间门控机制，仅在指定时间段内叠加该图层
• 链式标签命名 — 每一步输出中间结果标签（如 [v0], [v1]），供后续步骤使用；最终输出为 [vout]
• **-map "[vout]" -map 0:a** — 使用合成后的视频画面，但保留原始音频流不变

固定位置的下三分之一字幕叠加

ffmpeg -i video.mp4 -i lower-third.mov \
  -filter_complex "
    [1:v]setpts=PTS-STARTPTS[lt];
    [0:v][lt]overlay=0:810:enable='between(t,3,8)'[vout]
  " \
  -map "[vout]" -map 0:a \
  -c:v libx264 -crf 20 -c:a aac output.mp4

画中画叠加带时间窗口

ffmpeg -i main.mp4 -i pip.mp4 \
  -filter_complex "
    [1:v]scale=320:180,setpts=PTS-STARTPTS[pip];
    [0:v][pip]overlay=W-w-20:H-h-20:enable='between(t,10,30)'[vout]
  " \
  -map "[vout]" -map 0:a \
  -c:v libx264 -crf 20 output.mp4

动态透明度叠加（淡入效果）

# 在 1 秒内渐显叠加层（Alpha 混合需 yuva420p 像素格式或另作处理）
ffmpeg -i video.mp4 -i overlay.mov \
  -filter_complex "
    [1:v]setpts=PTS-STARTPTS,format=yuva420p,
         colorchannelmixer=aa=0.8[ov];
    [0:v][ov]overlay=0:0:enable='between(t,5,15)'[vout]
  " \
  -map "[vout]" -map 0:a -c:v libx264 output.mp4

大规模批量处理

基础 for 循环

# 处理目录中所有 .mp4 文件
for f in *.mp4; do
  ffmpeg -i "$f" -c:v libx264 -crf 23 -c:a aac "processed_${f}"
done

GNU parallel（并行执行）

# 安装：brew install parallel / apt install parallel

# 使用所有 CPU 核心将所有 MOV 转为 MP4
ls *.mov | parallel 'ffmpeg -i {} -c:v libx264 -c:a aac -preset fast {.}.mp4'

# 以 4 个并行任务调整所有视频尺寸
ls *.mp4 | parallel -j4 'ffmpeg -i {} -vf "scale=1920:1080" -c:a copy resized_{}'

# 并行生成缩略图
ls *.mp4 | parallel 'ffmpeg -i {} -ss 00:00:05 -vframes 1 thumb_{.}.jpg'

使用作业文件管理队列

# jobs.txt — 每行一个 ffmpeg 命令
# 以限制并发数运行
cat jobs.txt | parallel -j2 bash -c '{}'

带日志与错误处理的批量脚本

#!/usr/bin/env bash
INPUT_DIR="./input"
OUTPUT_DIR="./output"
LOG_FILE="batch.log"

mkdir -p "$OUTPUT_DIR"

for f in "$INPUT_DIR"/*.mp4; do
  name=$(basename "$f" .mp4)
  out="$OUTPUT_DIR/${name}_processed.mp4"

  echo "[$(date '+%H:%M:%S')] Processing: $name" | tee -a "$LOG_FILE"

  if ffmpeg -y -i "$f" -c:v libx264 -crf 23 -c:a aac "$out" 2>>"$LOG_FILE"; then
    echo "[OK] $name" | tee -a "$LOG_FILE"
  else
    echo "[FAIL] $name" | tee -a "$LOG_FILE"
  fi
done

echo "Done. See $LOG_FILE for details."

Python 队列结合 subprocess

import subprocess
import queue
import threading

def worker(q):
    while True:
        cmd = q.get()
        if cmd is None:
            break
        result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
        if result.returncode != 0:
            print(f"Error: {result.stderr}")
        q.task_done()

# 示例任务队列
job_queue = queue.Queue()
commands = [
    "ffmpeg -i input1.mp4 -c:v libx264 -crf 23 output1.mp4",
    "ffmpeg -i input2.mp4 -c:v libx264 -crf 23 output2.mp4",
]

for cmd in commands:
    job_queue.put(cmd)

# 启动 4 个工作线程
for _ in range(4):
    t = threading.Thread(target=worker, args=(job_queue,))
    t.start()

job_queue.join()

python

import subprocess

from pathlib import Path

from concurrent.futures import ThreadPoolExecutor, as_completed

def process_video(input_path: Path, output_dir: Path) -> tuple[Path, bool]:

out = output_dir / f"processed_{input_path.name}"

result = subprocess.run(

["ffmpeg", "-y", "-i", str(input_path),

"-c:v", "libx264", "-crf", "23", "-c:a", "aac", str(out)],

capture_output=True,

)

return input_path, result.returncode == 0

input_files = list(Path("./input").glob("*.mp4"))

output_dir = Path("./output")

output_dir.mkdir(exist_ok=True)

with ThreadPoolExecutor(max_workers=4) as executor:

futures = {executor.submit(process_video, f, output_dir): f for f in input_files}

for future in as_completed(futures):

path, success = future.result()

print(f"{'OK' if success else 'FAIL'}: {path.name}")

---

## 基于字幕的剪辑

利用 Whisper 生成的逐词字幕，根据语音内容自动做出剪辑决策，而非依赖手动时间码。

### 生成逐词字幕

pip install faster-whisper

python3 - video.mp4 > transcript.json <<'EOF'

import json, sys, subprocess

from faster_whisper import WhisperModel

先提取音频

audio = sys.argv[1].replace(".mp4", "_audio.wav")

subprocess.run(["ffmpeg", "-y", "-i", sys.argv[1], "-ar", "16000", "-ac", "1", "-vn", audio], check=True)

model = WhisperModel("medium", device="cpu", compute_type="int8")

segments, info = model.transcribe(audio, beam_size=5, word_timestamps=True, vad_filter=True)

result = {"language": info.language, "segments": []}

for seg in segments:

result["segments"].append({

"id": seg.id, "start": round(seg.start, 3), "end": round(seg.end, 3),

"text": seg.text.strip(),

"words": [{"word": w.word.strip(), "start": round(w.start, 3), "end": round(w.end, 3)} for w in seg.words],

})

print(json.dumps(result, indent=2))

EOF

### 在特定短语处进行剪切

import json, subprocess

with open("transcript.json") as f:

data = json.load(f)

查找某个短语的时间戳

target = "let's get started"

for seg in data["segments"]:

if target.lower() in seg["text"].lower():

cut_time = seg["start"]

print(f"在 {cut_time:.3f} 秒处找到 '{target}'")

# 从该短语开始截取视频

subprocess.run([

"ffmpeg", "-y", "-i", "video.mp4",

"-ss", str(cut_time), "-c", "copy", "trimmed.mp4"

], check=True)

break

### 剪除填充词（如“um”、“uh”）

import json, subprocess

with open("transcript.json") as f:

data = json.load(f)

FILLERS = {"um", "uh", "hmm", "like", "you know"}

keep_segments = []

cursor = 0.0

all_words = [w for seg in data["segments"] for w in seg["words"]]

for i, word in enumerate(all_words):

if word["word"].lower().strip(".,!?") in FILLERS:

# 在此词前结束上一段（若间隔超过 0.1 秒）

if word["start"] > cursor + 0.1:

keep_segments.append((cursor, word["start"]))

cursor = word["end"]

添加最后一段

total = data["segments"][-1]["end"]

if cursor < total:

keep_segments.append((cursor, total))

提取并重新拼接

concat_lines = []

for i, (start, end) in enumerate(keep_segments):

tmp = f"_seg_{i:04d}.ts"

subprocess.run([

"ffmpeg", "-y", "-i", "video.mp4",

"-ss", f"{start:.3f}", "-to", f"{end:.3f}",

"-c", "copy", "-avoid_negative_ts", "make_zero", tmp

], check=True)

concat_lines.append(f"file '{tmp}'")

with open("_concat.txt", "w") as f:

f.write("\n".join(concat_lines))

subprocess.run(["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", "_concat.txt", "-c", "copy", "no_fillers.mp4"], check=True)

### 自动从字幕生成章节标记

import json

with open("transcript.json") as f:

data = json.load(f)

找出可能的章节起始点（启发式规则：前一段结束后有超过 2 秒静音）

chapters = []

for i, seg in enumerate(data["segments"]):

if i == 0:

chapters.append((0.0, "引言"))

continue

prev = data["segments"][i - 1]

gap = seg["start"] - prev["end"]

if gap > 2.0: # 超过 2 秒停顿 = 可能是章节分界

chapters.append((seg["start"], seg["text"][:50]))

输出为 ffmetadata 格式以嵌入

print(";FFMETADATA1")

for i, (start, title) in enumerate(chapters):

end = chapters[i + 1][0] if i + 1 < len(chapters) else data["segments"][-1]["end"]

print(f"\n[CHAPTER]\nTIMEBASE=1/1000\nSTART={int(start*1000)}\nEND={int(end*1000)}\ntitle={title}")

### 将章节标记嵌入 MP4 文件

python3 generate_chapters.py > chapters.txt

ffmpeg -i video.mp4 -i chapters.txt -map_metadata 1 -codec copy video_with_chapters.mp4