从技术视频到短视频：AI辅助剪辑全流程技术复盘

原始视频 (横屏 16:9)
    │
    ▼
┌─────────────────────────────────┐
│  Step 1: 素材评估与片段选取     │
│  ffprobe 检测分辨率/时长/编码    │
└────────────────┬────────────────┘
                 │
    ┌────────────▼────────────┐
    │  Step 2: 语音识别        │
    │  faster-whisper (CPU)   │
    │  输出时间戳+原文         │
    └────────────┬────────────┘
                 │
    ┌────────────▼────────────┐
    │  Step 3: 字幕制作        │
    │  人工/AI翻译 + ASS时间轴  │
    └────────────┬────────────┘
                 │
    ┌────────────▼────────────┐
    │  Step 4: 竖屏转制        │
    │  ffmpeg scale+pad 滤镜  │
    │  16:9 → 9:16 加黑边     │
    └────────────┬────────────┘
                 │
    ┌────────────▼────────────┐
    │  Step 5: 字幕烧录        │
    │  PyAV + PIL 逐帧绘制    │
    │  字幕嵌入画面（非外挂）  │
    └────────────┬────────────┘
                 │
    ┌────────────▼────────────┐
    │  Step 6: 封面图制作      │
    │  PIL 绘制静态封面        │
    │  ffmpeg zoompan 动态化  │
    └────────────┬────────────┘
                 │
    ┌────────────▼────────────┐
    │  Step 7: 视频合并        │
    │  ffmpeg concat 协议      │
    │  片头 + 正片 + 音轨     │
    └────────────┬────────────┘
                 │
              成品 MP4
         (9:16 竖屏，带字幕)

ffprobe -v quiet -show_entries \
  stream=codec_name,width,height,r_frame_rate \
  -of csv=p=0 input.mp4

h264,1280,720,25/1
aac,44100,2

ffprobe -v quiet -show_entries \
  format=duration -of csv=p=0 input.mp4

ffprobe -v quiet -show_entries \
  stream=codec_name,sample_rate,channels \
  -select_streams a:0 -of csv=p=0 input.mp4

pip install faster-whisper

import os
os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"

from faster_whisper import WhisperModel

# 模型选择：tiny(39M) / base(74M) / small(244M) / medium(769M)
# CPU推理推荐 base 或 small，精度和速度平衡
model = WhisperModel("base", compute_type="int8", cpu_threads=4)

segments, info = model.transcribe(
    "input_audio.wav",
    language="en",           # 源语言
    vad_filter=True,         # 启用语音活动检测，过滤静音
    vad_parameters=dict(min_silence_duration_ms=500)
)

print(f"语言: {info.language}, 时长: {info.duration:.1f}s")
for seg in segments:
    print(f"[{seg.start:.1f}s -> {seg.end:.1f}s] {seg.text.strip()}")

ffmpeg -y \
  -i input.mp4 \
  -vn -acodec pcm_s16le \
  -ar 16000 -ac 1 \
  -ss 0 -t 180 \
  audio_clip.wav

segments_en = [
    (18.8, 22.8, "BPF stands for Berkeley Packet Filter"),
    (22.8, 27.8, "It's a virtual machine that runs in the kernel"),
    # ...
]

def to_ass_time(seconds):
    """将秒数转为ASS时间格式 H:MM:SS.CS"""
    h = int(seconds // 3600)
    m = int((seconds % 3600) // 60)
    s = int(seconds % 60)
    cs = int((seconds % 1) * 100)
    return f"{h}:{m:02d}:{s:02d}.{cs:02d}"

[Script Info]
Title: eBPF Subtitles
ScriptType: v4.00+

[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
Style: Default,Arial,36,&H00FFFFFF,&H000000FF,&H00000000,&H00000000,-1,0,0,0,100,100,0,0,1,2,1,2,10,10,10,1

[Events]
Format: Layer, Start, End, Style, Text
Dialogue: 0,0:00:18.80,0:00:22.80,Default,,0,0,0,,BPF全称是Berkeley Packet Filter
Dialogue: 0,0:00:22.80,0:00:27.80,Default,,0,0,0,,它是一个运行在内核中的虚拟机

1=左下  2=中下  3=右下
4=左中  5=正中  6=右中
7=左上  8=中上  9=右上

原始: 1280 × 720
目标: 1080 × 1920

计算：
- 宽度缩放到1080，高度等比 → 1080 × 607
- 上下各加 (1920 - 607) / 2 = 656.5 像素的黑边

ffmpeg -y \
  -ss 18 -t 162 \
  -i input.mp4 \
  -vf "scale=1080:607:force_original_aspect_ratio=decrease,\
       pad=1080:1920:(ow-iw)/2:(oh-ih)/2:color=black" \
  -c:v libx264 -preset fast -crf 23 \
  -r 25 \
  -an \
  portrait_video.mp4

ffmpeg -y \
  -ss 18 -t 162 \
  -i input.mp4 \
  -vf "scale=1080:607:force_original_aspect_ratio=decrease,\
       pad=1080:1920:(ow-iw)/2:(oh-ih)/2:color=black" \
  -c:v libx264 -preset fast -crf 23 \
  -c:a aac -b:a 128k \
  -r 25 \
  portrait_with_audio.mp4

ffmpeg -filters 2>/dev/null | grep -E "subtitles|drawtext|ass"

pip install av Pillow

PyAV解码视频帧
    ↓
PIL Image 绘制字幕
    ↓
PyAV 编码为新视频

#!/usr/bin/env python3
import av
from PIL import Image, ImageDraw, ImageFont
from fractions import Fraction

# 字幕数据：(开始秒, 结束秒, 文本)
subtitles = [
    (18.8, 22.8, "BPF全称是Berkeley Packet Filter"),
    (22.8, 27.8, "它是一个运行在内核中的虚拟机"),
    # ...
]

defget_subtitle_at(time_sec):
    """根据当前时间返回字幕文本"""
    for start, end, text in subtitles:
        if start <= time_sec < end:
            return text
    returnNone

# 字体选择（按优先级尝试）
font = None
for fp in [
    "/System/Library/Fonts/STHeiti Light.ttc",   # macOS黑体
    "/System/Library/Fonts/PingFang.ttc",        # macOS苹方
    "/System/Library/Fonts/Hiragino Sans GB.ttc", # macOS冬青黑体
    "/Library/Fonts/Arial Unicode.ttf",           # 系统通用
]:
    if os.path.exists(fp):
        try:
            font = ImageFont.truetype(fp, 44)
            print(f"Font loaded: {fp}")
            break
        except Exception:
            pass

if font isNone:
    font = ImageFont.load_default()

# 视频参数
FPS = 25
WIDTH, HEIGHT = 1080, 1920
TEXT_MARGIN = 120   # 字幕距底部距离
SUB_BOX_PADDING = 20

defdraw_subtitle(draw, text, width, height):
    """在画面底部居中绘制字幕"""
    bbox = draw.textbbox((0, 0), text, font=font)
    text_w = bbox[2] - bbox[0]
    text_h = bbox[3] - bbox[1]
    
    # 计算字幕框尺寸
    box_w = text_w + SUB_BOX_PADDING * 2
    box_h = text_h + SUB_BOX_PADDING * 2 + 10
    box_x = (width - box_w) // 2
    box_y = height - TEXT_MARGIN - box_h
    
    # 圆角黑色半透明背景
    draw.rounded_rectangle(
        [box_x, box_y, box_x + box_w, box_y + box_h],
        radius=8, fill=(0, 0, 0, 200)
    )
    
    # 黑色描边（4个方向偏移）
    for dx in [-2, -1, 1, 2]:
        for dy in [-2, -1, 1, 2]:
            ifabs(dx) == abs(dy):  # 对角线方向
                draw.text(
                    (box_x + SUB_BOX_PADDING + dx, 
                     box_y + SUB_BOX_PADDING + dy),
                    text, font=font, fill=(0, 0, 0)
                )
    
    # 白色主体文字
    draw.text(
        (box_x + SUB_BOX_PADDING, box_y + SUB_BOX_PADDING),
        text, font=font, fill=(255, 255, 255)
    )

# 打开输入输出
in_container = av.open("input_portrait.mp4")
out_container = av.open("output_with_subs.mp4", 'w')

# 创建输出流
out_video = out_container.add_stream('libx264', rate=FPS)
out_video.width = WIDTH
out_video.height = HEIGHT
out_video.pix_fmt = 'yuv420p'
out_video.options = {'crf': '23', 'preset': 'fast'}

frame_idx = 0
frame_duration = 1.0 / FPS

# 逐帧处理
for packet in in_container.demux(video=0):
    if packet.dts isNone:
        continue
    for frame in packet.decode():
        current_time = frame_idx * frame_duration
        
        # 转PIL Image
        img = frame.to_image()
        
        # 绘制字幕
        sub = get_subtitle_at(current_time)
        if sub:
            draw = ImageDraw.Draw(img)
            draw_subtitle(draw, sub, WIDTH, HEIGHT)
        
        # 编码输出
        out_frame = av.VideoFrame.from_image(img)
        out_frame.pts = frame_idx
        out_frame.dts = frame_idx
        out_frame.time_base = Fraction(1, FPS)
        
        for p in out_video.encode(out_frame):
            out_container.mux(p)
        
        frame_idx += 1
        if frame_idx % 500 == 0:
            print(f"  Processed {frame_idx} frames...")

# flush编码器
for p in out_video.encode():
    out_container.mux(p)

out_container.close()
in_container.close()
print("Done!")

from PIL import Image, ImageDraw, ImageFont
import os

WIDTH, HEIGHT = 1080, 1920

# 创建深色背景
img = Image.new('RGB', (WIDTH, HEIGHT), color=(5, 8, 15))
draw = ImageDraw.Draw(img)

# 垂直渐变背景
for y inrange(HEIGHT):
    ratio = y / HEIGHT
    r = int(5 + ratio * 20)
    g = int(8 + ratio * 30)
    b = int(15 + ratio * 60)
    draw.line([(0, y), (WIDTH, y)], fill=(r, g, b))

# 装饰线条（顶部）
for i inrange(3):
    draw.rectangle(
        [50 - i*5, 200 - i*5, WIDTH - 50 + i*5, 205 - i*5],
        outline=(0, 150, 255, 100 - i * 25)
    )

# 主标题
font_title = ImageFont.truetype(
    "/System/Library/Fonts/STHeiti Light.ttc", 120
)
font_sub = ImageFont.truetype(
    "/System/Library/Fonts/STHeiti Light.ttc", 52
)
font_tag = ImageFont.truetype(
    "/System/Library/Fonts/STHeiti Light.ttc", 36
)

# 标题文字
title = "eBPF"
bbox = draw.textbbox((0, 0), title, font=font_title)
title_w = bbox[2] - bbox[0]
draw.text(((WIDTH - title_w) // 2, 400), title,
          font=font_title, fill=(0, 200, 255))

# 副标题
draw.text(((WIDTH - 240) // 2, 560), "内核黑科技",
          font=font_sub, fill=(255, 255, 255))

draw.text(((WIDTH - 420) // 2, 640), "从BPF到eBPF的演进史",
          font=font_sub, fill=(200, 200, 210))

# 分割线
draw.line([(200, 750), (WIDTH - 200, 750)],
          fill=(0, 150, 255), width=2)

# 标签
tags = ["Linux内核", "网络监控", "安全追踪", "性能分析"]
tag_y = 900
for tag in tags:
    bbox = draw.textbbox((0, 0), tag, font=font_tag)
    tag_w = bbox[2] - bbox[0]
    pad = 16
    bx = (WIDTH // 2) - (tag_w // 2) - pad
    draw.rounded_rectangle(
        [bx, tag_y - pad, bx + tag_w + pad * 2, tag_y - pad + 60],
        radius=8, fill=(0, 100, 200)
    )
    draw.text(((WIDTH - tag_w) // 2, tag_y), tag,
              font=font_tag, fill=(255, 255, 255))
    tag_y += 90

# 保存
img.save("cover.jpg", "JPEG", quality=95)

ffmpeg -y \
  -loop 1 \
  -i cover.jpg \
  -vf "
    scale=1200:-1,
    zoompan=z='min(zoom+0.0015,1.15)':d=125:
         x='iw/2-(iw/zoom/2)':y='ih/2-(ih/zoom/2)',
    fps=25
  " \
  -t 5 \
  -c:v libx264 -preset fast -crf 23 \
  -pix_fmt yuv420p \
  intro.mp4

ffmpeg -y \
  -f concat -safe 0 -i list.txt \
  -vf "zoompan=z='1.0+0.005*t':d=125:x='iw/2-(iw/zoom/2)':y='ih/2-(ih/zoom/2)',fps=25" \
  -t 5 -c:v libx264 intro.mp4

ffmpeg -y \
  -i intro_video.mp4 \
  -f lavfi -i "anullsrc=r=44100:cl=stereo" \
  -t 5 \
  -c:v copy -c:a aac -b:a 128k \
  -shortest \
  intro_with_audio.mp4

# 片头统一编码
ffmpeg -y -i intro_with_audio.mp4 \
  -c:v libx264 -preset fast -crf 23 \
  -r 25 -pix_fmt yuv420p \
  intro_u.mp4

# 正片统一编码
ffmpeg -y -i main_content.mp4 \
  -c:v libx264 -preset fast -crf 23 \
  -r 25 -pix_fmt yuv420p \
  main_u.mp4

# 创建文件列表
cat > concat_list.txt << 'EOF'
file 'intro_u.mp4'
file 'main_u.mp4'
EOF

# 合并
ffmpeg -y \
  -f concat -safe 0 \
  -i concat_list.txt \
  -c copy \
  final_output.mp4

ffprobe -v quiet -show_streams final_output.mp4 \
  | grep -E "codec_type|codec_name|width|height|duration"

#!/bin/bash
# video-to-short.sh — 技术视频转竖屏短视频

INPUT=$1
OUTPUT=${2:-output.mp4}
SS=${3:-0}
DURATION=${4:-180}

echo"开始处理: $INPUT"
echo"输出文件: $OUTPUT"
echo"截取范围: ${SS}s - $((SS+DURATION))s"

# 1. 提取音频
echo"[1/6] 提取音频..."
ffmpeg -y -i "$INPUT" -ss $SS -t $DURATION \
  -vn -acodec pcm_s16le -ar 16000 -ac 1 \
  audio.wav

# 2. 语音识别 (调用Python脚本)
echo"[2/6] 语音识别..."
python3 whisper_transcribe.py audio.wav > subtitles.srt

# 3. 翻译字幕 (调用Python脚本)
echo"[3/6] 翻译字幕..."
python3 translate_subtitles.py subtitles.srt subtitles_cn.ass

# 4. 竖屏转制
echo"[4/6] 竖屏转制..."
ffmpeg -y -i "$INPUT" -ss $SS -t $DURATION \
  -vf "scale=1080:607:force_original_aspect_ratio=decrease,\
       pad=1080:1920:(ow-iw)/2:(oh-ih)/2:color=black" \
  -c:v libx264 -preset fast -crf 23 -r 25 -an \
  portrait.mp4

# 5. 字幕烧录
echo"[5/6] 字幕烧录..."
python3 burn_subtitles.py portrait.mp4 subtitles_cn.ass portrait_sub.mp4

# 6. 合并
echo"[6/6] 合并..."
ffmpeg -y -i portrait_sub.mp4 \
  -i "$INPUT" -ss $SS -t $DURATION \
  -map 0:v -map 1:a \
  -c:v copy -c:a aac -b:a 128k -shortest \
"$OUTPUT"

echo "完成! 输出: $OUTPUT"