四个机位怎么对齐：时间码、音频波形同步与 ffmpeg 实现

1. 从每个视频里抽出音频（单声道、降采样到 8kHz 加快计算）
      ↓
2. 选一个"参考机位"（通常是主机位）
      ↓
3. 对每个其他机位，和参考机位做互相关
      ↓
4. 峰值位置 = 时间偏移（正数=这个机位比参考晚/早，看约定方向）
      ↓
5. 输出偏移值（给剪辑软件）或直接生成同步后的文件

corr = irfft(rfft(a, n) * conj(rfft(b, n)), n)

import json
import subprocess
import tempfile
from pathlib import Path

import numpy as np


def extract_audio_mono(video: str, out_wav: str, sr: int = 8000,
                       duration: float = None, start: float = 0.0) -> str:
    """抽音频为单声道低采样率 WAV（用于对齐）。"""
    cmd = ['ffmpeg', '-v', 'error', '-y']
    if start:
        cmd += ['-ss', f'{start:.3f}']
    cmd += ['-i', video]
    if duration:
        cmd += ['-t', f'{duration:.3f}']
    cmd += ['-vn', '-ac', '1', '-ar', str(sr), '-c:a', 'pcm_s16le', out_wav]
    subprocess.run(cmd, check=True)
    return out_wav


def read_wav(path: str) -> np.ndarray:
    """用 ffmpeg 读成 raw PCM（避免额外的音频库依赖）。"""
    cmd = ['ffmpeg', '-v', 'error', '-i', path,
           '-f', 's16le', '-ac', '1', '-ar', '8000', '-']
    p = subprocess.run(cmd, capture_output=True, check=True)
    return np.frombuffer(p.stdout, dtype=np.int16).astype(np.float64)


def cross_correlate(a: np.ndarray, b: np.ndarray, sr: int = 8000) -> tuple:
    """计算 b 相对于 a 的时间偏移（秒）。返回 (offset_seconds, 相关强度)。

    offset > 0 表示 b 比 a 晚开始（即 b 需要往前挪 |offset| 才能对齐）。
    """
    # 去直流
    a = a - a.mean()
    b = b - b.mean()

    n = 1
    while n < len(a) + len(b):
        n <<= 1                      # FFT 长度取 2 的幂

    fa = np.fft.rfft(a, n)
    fb = np.fft.rfft(b, n)
    corr = np.fft.irfft(fa * np.conj(fb), n)

    # 峰值
    idx = int(np.argmax(np.abs(corr)))
    if idx > n // 2:
        idx -= n                     # 负偏移

    peak = abs(corr[idx])
    # 归一化强度（用于判断是否可信）
    strength = peak / (np.linalg.norm(a) * np.linalg.norm(b) + 1e-9)
    return idx / float(sr), float(strength)


def align_multicam(videos: list, ref_index: int = 0,
                   duration: float = 90.0, sr: int = 8000) -> dict:
    """多机位对齐。返回 {文件名: {'offset': 秒, 'strength': 相关强度}}"""
    tmp = tempfile.mkdtemp(prefix='sync_')
    wavs = []
    for i, v in enumerate(videos):
        w = str(Path(tmp) / f'{i}.wav')
        extract_audio_mono(v, w, sr=sr, duration=duration)
        wavs.append(read_wav(w))

    ref = wavs[ref_index]
    result = {}
    for i, v in enumerate(videos):
        if i == ref_index:
            result[v] = {'offset': 0.0, 'strength': 1.0}
            continue
        off, strength = cross_correlate(ref, wavs[i], sr=sr)
        result[v] = {'offset': off, 'strength': strength}

    # 清理临时文件
    import shutil
    shutil.rmtree(tmp, ignore_errors=True)
    return result


if __name__ == '__main__':
    vids = ['cam1.mp4', 'cam2.mp4', 'cam3.mp4', 'cam4.mp4']
    res = align_multicam(vids)
    for v, r in res.items():
        flag = '' if r['strength'] > 0.1 else '  ⚠ 相关性低，需人工确认'
        print(f"{v}: 偏移 {r['offset']:+.3f}s (强度 {r['strength']:.3f}){flag}")
    Path('sync_offsets.json').write_text(json.dumps(res, indent=2, ensure_ascii=False))

cam1.mp4: 偏移 +0.000s (强度 1.000)
cam2.mp4: 偏移 +2.437s (强度 0.412)
cam3.mp4: 偏移 -1.208s (强度 0.388)
cam4.mp4: 偏移 +0.156s (强度 0.455)

50 ppm 的误差 = 每秒偏差 50 微秒 = 每小时 0.18 秒
两小时 → 0.36 秒

def align_with_drift(ref_video, other_video, total_duration,
                     window=120.0, step=600.0, sr=8000):
    """分段对齐，检测漂移。返回 [(时间点, 偏移)]"""
    points = []
    t = 0.0
    while t + window <= total_duration:
        w_ref = extract_audio_mono(ref_video, f'_r.wav', sr, window, t)
        w_oth = extract_audio_mono(other_video, f'_o.wav', sr, window, t)
        # 在这个窗口附近搜索（偏移不会突然跳变）
        off, strength = cross_correlate(read_wav(w_ref), read_wav(w_oth), sr)
        points.append((t, off, strength))
        t += step
    return points

# 如果 B 比 A 每小时慢 0.18 秒，需要把 B 加速 0.18/3600 = 0.00005 = 50 ppm
ffmpeg -i b.mp4 -filter:v "setpts=PTS/1.00005" -filter:a "atempo=1.00005" b_fixed.mp4

file,offset_seconds,offset_frames(fps25),strength
cam1.mp4,0.000,0,1.000
cam2.mp4,2.437,61,0.412
cam3.mp4,-1.208,-30,0.388
cam4.mp4,0.156,4,0.455

# 方式 A：给 B 加一个时间偏移（时间戳层面）
ffmpeg -itsoffset 2.437 -i cam2.mp4 -c copy -avoid_negative_ts make_zero cam2_synced.mp4

# 方式 B：直接裁掉 B 开头多出来的 2.437 秒
ffmpeg -ss 2.437 -i cam2.mp4 -c copy cam2_trimmed.mp4

ffmpeg -i cam1.mp4 -i cam2.mp4 -i cam3.mp4 -i cam4.mp4 \
  -itsoffset 2.437 -i cam2.mp4 \
  -filter_complex "
    [0:v]scale=960:540[v0];[1:v]scale=960:540[v1];
    [2:v]scale=960:540[v2];[3:v]scale=960:540[v3];
    [v0][v1]hstack[top];[v2][v3]hstack[bottom];
    [top][bottom]vstack[out]" \
  -map "[out]" -c:v libx264 -crf 23 multicam_preview.mp4

def verify(aligned_a, aligned_b, sr=8000):
    """对齐后重新计算，偏移应该接近 0。"""
    off, strength = cross_correlate(aligned_a, aligned_b, sr)
    return {'residual_offset': off, 'ok': abs(off) < 0.01}