自动找出镜头切换：场景检测、章节生成与精彩片段提取

ffmpeg -i input.mp4 \
  -filter:v "select='gt(scene,0.4)',showinfo" \
  -f null - 2>&1 | grep showinfo

[Parsed_showinfo_1 @ 0x...] n:   0 pts:1024    pts_time:0.0213 ...
[Parsed_showinfo_1 @ 0x...] n: 312 pts:645120  pts_time:13.4400 ...
[Parsed_showinfo_1 @ 0x...] n: 887 pts:1830912 pts_time:38.1440 ...

ffmpeg -i input.mp4 \
  -filter:v "select='gt(scene,0.4)',scale=320:-2" \
  -vsync vfr -frame_pts 1 \
  scene_%04d.jpg

ffmpeg -i input.mp4 \
  -filter:v "select='gt(scene,0.4)',metadata=print:file=scenes.txt" \
  -f null -

# scenes.txt 里会有：
# frame:1234 pts:645120 pts_time:13.44
#   lavfi.scene_score=0.523411

import cv2
import numpy as np


class SceneDetector:
    """基于多种度量的场景切换检测。"""

    def __init__(self, threshold: float = None, min_interval: float = 1.5):
        self.threshold = threshold
        self.min_interval = min_interval      # 两个切换点之间的最小间隔（秒）
        self.prev = None
        self.scores = []                      # (timestamp, score)

    def _features(self, frame):
        """提取一帧的特征：灰度直方图 + 缩小后的灰度图 + 边缘。"""
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        small = cv2.resize(gray, (64, 36), interpolation=cv2.INTER_AREA)
        hist = cv2.calcHist([gray], [0], None, [64], [0, 256])
        hist = cv2.normalize(hist, hist).flatten()
        edges = cv2.Canny(small, 50, 150)
        return small.astype(np.float32), hist, edges.astype(np.float32) / 255.0

    def _diff(self, a, b):
        """综合差异度：直方图距离 + 结构差异 + 边缘差异。"""
        # 1. 直方图相关性（对亮度变化鲁棒）
        hist_d = 1.0 - cv2.compareHist(
            a[1].astype(np.float32), b[1].astype(np.float32), cv2.HISTCMP_CORREL)
        # 2. 结构差异（对整体亮度变化不敏感）
        mean_a, mean_b = a[0].mean(), b[0].mean()
        if mean_a > 1 and mean_b > 1:
            na, nb = a[0] / mean_a, b[0] / mean_b
            struct_d = float(np.abs(na - nb).mean()) / 2.0
        else:
            struct_d = 0.0
        # 3. 边缘差异（对内容变化敏感）
        edge_d = float(np.abs(a[2] - b[2]).mean())
        return 0.4 * hist_d + 0.4 * struct_d + 0.2 * edge_d

    def feed(self, frame, timestamp):
        """喂一帧，返回是否是切换点。"""
        feat = self._features(frame)
        if self.prev is not None:
            score = self._diff(self.prev[0], feat)
            self.scores.append((timestamp, score))
        self.prev = (feat, timestamp)
        return None

    def finalize(self):
        """所有帧喂完后，用自适应阈值挑出切换点。"""
        scores = np.array([s for _, s in self.scores])
        ts = [t for t, _ in self.scores]
        if len(scores) == 0:
            return []

        if self.threshold is None:
            # 自适应：均值 + 3 倍标准差（对大多数内容效果不错）
            thr = scores.mean() + 3 * scores.std()
            thr = min(max(thr, 0.15), 0.6)      # 夹在合理区间
        else:
            thr = self.threshold

        candidates = [(ts[i], scores[i]) for i in np.where(scores > thr)[0]]

        # 后处理 1：合并间隔过近的点（保留分数最高的）
        merged = []
        for t, s in candidates:
            if merged and t - merged[-1][0] < self.min_interval:
                if s > merged[-1][1]:
                    merged[-1] = (t, s)
            else:
                merged.append((t, s))

        return merged

def find_dissolves(scores, ts, window=15, min_score=0.08, min_sum=1.5):
    """找渐变区间：连续多帧的中等差异累积。"""
    arr = np.array(scores)
    out = []
    for i in range(len(arr) - window):
        seg = arr[i:i + window]
        if (seg > min_score).all() and seg.sum() > min_sum:
            # 渐变的中点作为切换点
            out.append((ts[i + window // 2], float(seg.mean())))
    # 去重（渐变区间会重叠）
    return dedupe(out, min_interval=2.0)

def scenes_to_chapters(scene_points, duration, min_chapter=60, max_chapters=30):
    """把场景切换点转成章节起点。"""
    # 1. 去掉开头的（0 秒处不算切换）
    pts = [t for t, s in scene_points if t > 3.0]
    # 2. 强制最小章节时长
    chapters = [0.0]
    for t in pts:
        if t - chapters[-1] >= min_chapter:
            chapters.append(t)
    # 3. 限制章节数量：太多就只保留分数最高的
    if len(chapters) > max_chapters:
        ranked = sorted(
            [(t, s) for t, s in scene_points if t in chapters],
            key=lambda x: -x[1],
        )[:max_chapters - 1]
        chapters = [0.0] + sorted(t for t, _ in ranked)
    # 4. 补上结束时间
    bounds = []
    for i, start in enumerate(chapters):
        end = chapters[i + 1] if i + 1 < len(chapters) else duration
        bounds.append((start, end))
    return bounds

;FFMETADATA1
[CHAPTER]
TIMEBASE=1/1000
START=0
END=45000
title=课程介绍

[CHAPTER]
TIMEBASE=1/1000
START=45000
END=123000
title=第一章：基础概念

[CHAPTER]
TIMEBASE=1/1000
START=123000
END=245000
title=第二章：进阶用法

ffmpeg -i input.mp4 -i chapters.txt -map_metadata 1 -c copy output.mp4

ffprobe -v error -show_chapters -of json output.mp4 | jq '.chapters[] | {start:.start_time, end:.end_time, title:.tags.title}'

def write_chapters(bounds, titles, path):
    lines = [';FFMETADATA1']
    for (start, end), title in zip(bounds, titles):
        lines += [
            '[CHAPTER]',
            'TIMEBASE=1/1000',
            f'START={int(start * 1000)}',
            f'END={int(end * 1000)}',
            f'title={title}',
            '',
        ]
    with open(path, 'w', encoding='utf-8') as f:
        f.write('\n'.join(lines))

def highlight_score(audio_energy, motion, has_face):
    """综合精彩度打分（简化示例）。"""
    return 0.4 * norm(audio_energy) + 0.4 * norm(motion) + 0.2 * float(has_face)

1. 把视频切成固定窗口（比如 5 秒）
2. 每个窗口打分
3. 取分数最高的 N 个窗口，且彼此间隔 > 30 秒
4. 按时间顺序拼接，窗口之间加 0.5 秒转场
5. 输出 60~120 秒的摘要

# 用 concat demuxer（需要先按时间段截取）
ffmpeg -i input.mp4 -ss 120 -t 5 -c copy part1.mp4
ffmpeg -i input.mp4 -ss 480 -t 5 -c copy part2.mp4
# list.txt
ffmpeg -f concat -safe 0 -i list.txt -c copy summary.mp4

300 小时 × 3600 秒 × 25 fps = 2700 万帧

ffmpeg -i input.mp4 -vf "fps=2,scale=320:-2" -f rawvideo -pix_fmt bgr24 -

import subprocess

W, H = 320, 180
cmd = ['ffmpeg', '-i', 'input.mp4', '-vf', f'fps=2,scale={W}:{H}',
       '-f', 'rawvideo', '-pix_fmt', 'bgr24', '-an', '-']
proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
frame_size = W * H * 3
idx = 0
detector = SceneDetector()
while True:
    raw = proc.stdout.read(frame_size)
    if len(raw) != frame_size:
        break
    frame = np.frombuffer(raw, np.uint8).reshape(H, W, 3)
    detector.feed(frame, idx / 2.0)      # fps=2，所以时间戳是 idx/2
    idx += 1
scenes = detector.finalize()

ffmpeg -ss 119 -i input.mp4 -t 2 -vf showinfo -f null - 2>&1 | grep showinfo

ffmpeg -i input.mp4 -vf "select='eq(pict_type,I)'" ...