ffprobe -v error -show_entries format=bit_rate -of default=noprint_wrappers=1:nokey=1 input.mp4

CRF 工作流程：
1. 你把 CRF 设为 23
2. 编码器逐帧分析画面复杂度
3. 简单的帧（纯色背景）→ 分配低码率
4. 复杂的帧（快速运动、细节丰富）→ 分配高码率
5. 最终：所有帧的"视觉质量"一致

# 日常压缩（推荐）
ffmpeg -i input.mp4 -c:v libx264 -preset medium -crf 23 \
  -c:a aac -b:a 128k output.mp4

# 存档级（画质优先）
ffmpeg -i input.mp4 -c:v libx264 -preset slow -crf 18 \
  -c:a aac -b:a 192k output.mp4

# 分享级（体积优先）
ffmpeg -i input.mp4 -c:v libx264 -preset fast -crf 28 \
  -c:a aac -b:a 96k output.mp4

# 同时缩放分辨率（4K → 1080P，进一步减体积）
ffmpeg -i input.mp4 -c:v libx264 -preset medium -crf 23 \
  -vf "scale=1920:-2" -c:a aac -b:a 128k output.mp4

- 微信发送：视频必须 < 100MB（或 < 25MB）
- 上传到有限制的平台：比如某些 CMS 限制 50MB
- 批量处理：100 个视频，需要总大小控制在 10GB 以内
- 流媒体：需要生成固定码率的 ABR 档位

第一遍（Pass 1）：编码器快速扫描整个视频，记录每一帧的复杂度
  → 输出一个统计文件（.log），包含"哪里复杂、哪里简单"

第二遍（Pass 2）：根据第一遍的统计信息，合理分配码率
  → 复杂的帧多给码率，简单的帧少给
  → 在给定总体积下，实现最好的画质

# 目标体积 50MB，视频时长 600 秒
# 计算视频码率：
#   总码率 = 50MB × 8 × 1024 / 600s ≈ 682 kbps
#   视频码率 = 682 - 128(音频) = 554 kbps

# Pass 1
ffmpeg -i input.mp4 -c:v libx264 -preset medium \
  -b:v 554k -pass 1 -an -f mp4 NUL

# Pass 2
ffmpeg -i input.mp4 -c:v libx264 -preset medium \
  -b:v 554k -pass 2 -c:a aac -b:a 128k output.mp4

import subprocess
import json
import os

def compress_to_target_size(input_path, output_path, target_mb):
    """将视频压缩到指定体积"""
    # 获取视频时长
    cmd = ['ffprobe', '-v', 'error', '-show_entries',
           'format=duration', '-of', 'json', input_path]
    result = subprocess.run(cmd, capture_output=True, text=True)
    duration = float(json.loads(result.stdout)['format']['duration'])

    # 音频码率
    audio_bitrate = 128  # kbps

    # 计算视频码率
    # 目标体积 (bits) = 总码率 × 时长
    # 总码率 = 目标体积 / 时长
    total_bitrate = (target_mb * 8 * 1024) / duration  # kbps
    video_bitrate = max(100, int(total_bitrate - audio_bitrate))

    print(f"视频时长: {duration:.0f}s")
    print(f"目标体积: {target_mb}MB")
    print(f"视频码率: {video_bitrate} kbps")

    # 如果计算出的码率比原视频还高，直接用 CRF
    if video_bitrate > 5000:
        print("目标体积足够大，改用 CRF 23")
        subprocess.run([
            'ffmpeg', '-i', input_path,
            '-c:v', 'libx264', '-preset', 'medium', '-crf', '23',
            '-c:a', 'aac', '-b:a', f'{audio_bitrate}k',
            output_path, '-y'
        ], check=True)
        return

    # Pass 1
    subprocess.run([
        'ffmpeg', '-i', input_path,
        '-c:v', 'libx264', '-preset', 'medium',
        '-b:v', f'{video_bitrate}k',
        '-pass', '1', '-an',
        '-f', 'mp4', 'NUL' if os.name == 'nt' else '/dev/null',
        '-y'
    ], check=True)

    # Pass 2
    subprocess.run([
        'ffmpeg', '-i', input_path,
        '-c:v', 'libx264', '-preset', 'medium',
        '-b:v', f'{video_bitrate}k',
        '-pass', '2',
        '-c:a', 'aac', '-b:a', f'{audio_bitrate}k',
        output_path, '-y'
    ], check=True)

    # 清理临时文件
    for f in ['ffmpeg2pass-0.log', 'ffmpeg2pass-0.log.mbtree']:
        if os.path.exists(f):
            os.remove(f)

    actual_size = os.path.getsize(output_path) / 1024 / 1024
    print(f"实际体积: {actual_size:.1f}MB")


if __name__ == '__main__':
    compress_to_target_size('input.mp4', 'output.mp4', target_mb=50)

ultrafast → superfast → veryfast → faster → fast → medium → slow → slower → veryslow

速度快 ←————————————————————————————→ 压缩率高
体积大 ←————————————————————————————→ 体积小

用 H.264 的场景：
  ✅ 需要快速压缩（中等 CPU）
  ✅ 要发给别人（兼容性最好，所有设备都能播）
  ✅ 视频本身不大（< 500MB），压缩空间有限

用 H.265 的场景：
  ✅ 存档收藏（压一次，看很多次）
  ✅ 4K/HDR 视频（H.265 对高分辨率优势更大）
  ✅ 大量视频需要批量压缩（虽然慢，但省的空间值回时间）
  ✅ 自己用 Jellyfin 看（服务端转码，客户端兼容性不是问题）

# H.265 软件编码（慢但效果好）
ffmpeg -i input.mp4 -c:v libx265 -preset medium -crf 28 \
  -c:a aac -b:a 128k output.mp4

# H.265 硬件加速编码（Intel QSV，快但同码率画质略差）
ffmpeg -i input.mp4 -c:v hevc_qsv -preset medium -global_quality 25 \
  -c:a aac -b:a 128k output.mp4

#!/usr/bin/env python3
"""批量压缩目录下所有视频"""

import os
import subprocess
from pathlib import Path
from concurrent.futures import ThreadPoolExecutor


def compress_video(input_path, output_path, crf=23, preset='medium'):
    """压缩单个视频"""
    cmd = [
        'ffmpeg', '-i', str(input_path),
        '-c:v', 'libx264', '-preset', preset, '-crf', str(crf),
        '-c:a', 'aac', '-b:a', '128k',
        '-movflags', '+faststart',  # 网页渐进式加载
        str(output_path), '-y'
    ]

    try:
        subprocess.run(cmd, capture_output=True, check=True, timeout=3600)

        in_size = os.path.getsize(input_path) / 1024 / 1024
        out_size = os.path.getsize(output_path) / 1024 / 1024
        ratio = (1 - out_size / in_size) * 100 if in_size else 0

        return {
            'file': input_path.name,
            'in_mb': in_size,
            'out_mb': out_size,
            'saved': ratio,
            'success': True,
        }
    except Exception as e:
        return {'file': input_path.name, 'success': False, 'error': str(e)}


def batch_compress(input_dir, output_dir, crf=23, preset='medium',
                   workers=2, skip_existing=True):
    """批量压缩"""
    os.makedirs(output_dir, exist_ok=True)
    video_exts = {'.mp4', '.mkv', '.mov', '.avi', '.flv', '.webm', '.ts'}

    tasks = []
    for filepath in Path(input_dir).iterdir():
        if filepath.suffix.lower() in video_exts:
            out_path = Path(output_dir) / f'{filepath.stem}_compressed.mp4'
            if skip_existing and out_path.exists():
                print(f"跳过（已存在）: {filepath.name}")
                continue
            tasks.append((filepath, out_path))

    print(f"待压缩: {len(tasks)} 个视频")
    results = []

    with ThreadPoolExecutor(max_workers=workers) as executor:
        futures = {}
        for in_path, out_path in tasks:
            future = executor.submit(
                compress_video, in_path, out_path, crf, preset
            )
            futures[future] = in_path.name

        for i, future in enumerate(futures):
            result = future.result()
            results.append(result)

            name = futures[future]
            if result['success']:
                print(f"[{i+1}/{len(tasks)}] {name}: "
                      f"{result['in_mb']:.0f}MB → {result['out_mb']:.0f}MB "
                      f"({result['saved']:.0f}%)")
            else:
                print(f"[{i+1}/{len(tasks)}] {name}: 失败 - {result['error']}")

    # 汇总
    success = [r for r in results if r['success']]
    if success:
        total_in = sum(r['in_mb'] for r in success)
        total_out = sum(r['out_mb'] for r in success)
        total_saved = (1 - total_out / total_in) * 100
        print(f"\n总计: {total_in:.0f}MB → {total_out:.0f}MB "
              f"(节省 {total_saved:.0f}%)")

    return results


if __name__ == '__main__':
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument('input_dir')
    parser.add_argument('-o', '--output-dir', default='./compressed')
    parser.add_argument('--crf', type=int, default=23)
    parser.add_argument('--preset', default='medium')
    parser.add_argument('-w', '--workers', type=int, default=2)
    args = parser.parse_args()

    batch_compress(args.input_dir, args.output_dir,
                   args.crf, args.preset, args.workers)

# 用 VMAF 对比原片和压缩版
ffmpeg -i original.mp4 -i compressed.mp4 \
  -filter_complex "libvmaf=log_path=vmaf.json:log_fmt=json" \
  -f null /dev/null

# 查看分数
cat vmaf.json | grep VMAF_score

# 截取原片第 60 秒
ffmpeg -i original.mp4 -ss 60 -vframes 1 original_frame.png

# 截取压缩版第 60 秒
ffmpeg -i compressed.mp4 -ss 60 -vframes 1 compressed_frame.png

# 两张图放一起对比，差别一目了然