剪辑软件之间的时间线怎么交换：EDL、XML、FCPXML 与自动剪片

TITLE: MY_PROJECT
FCM: NON-DROP FRAME

001  AX       V     C        00:00:10:00 00:00:25:00 01:00:05:00 01:00:20:00
002  AX       V     C        00:00:30:00 00:00:45:00 01:00:20:00 01:00:35:00
003  AX       V     C        00:01:00:00 00:01:12:00 01:00:35:00 01:00:47:00

事件号  轨道  类型  转场   源入点       源出点       记录入点     记录出点
001     AX    V     C      00:00:10:00 00:00:25:00 01:00:05:00 01:00:20:00

01:23:45:12  → 1 小时 23 分 45 秒 第 12 帧

ffprobe -v error -show_entries stream_tags=timecode -show_entries format_tags=timecode \
  -of default=noprint_wrappers=1 input.mov
# timecode=01:00:00:00

ffmpeg -i in.mp4 -c copy -timecode 01:00:00:00 out.mov

真实经过 1 小时 = 107892 帧（29.97 × 3600）
时间码显示 = 01:00:00:00 → 按 30fps 算是 108000 帧

非丢帧（NDF）: 01:00:00:00     ← 冒号
丢帧（DF）:    01:00:00;00     ← 分号（最后的帧分隔符）

def df_timecode_to_seconds(tc: str, fps: float = 30000 / 1001) -> float:
    """丢帧时间码转秒。tc 形如 '01:02:03;04' 或 '01:02:03:04'。"""
    tc = tc.replace(';', ':')
    hh, mm, ss, ff = [int(x) for x in tc.split(':')]
    drop = ';' in tc or tc.count(':') == 3 and ';' in tc
    # 丢帧：每分钟跳过 2 帧（不跳每 10 分钟的整数分钟）
    total_minutes = hh * 60 + mm
    frame_number = (
        (total_minutes * 60 + ss) * 30 + ff
        - 2 * (total_minutes - total_minutes // 10) if drop
        else (hh * 3600 + mm * 60 + ss) * 30 + ff
    )
    return frame_number / (30.0 if not drop else 30000 / 1001)

# 方式 1：-ss 在 -i 之前（先 seek 再解码），快
ffmpeg -ss 100 -i input.mp4 -t 30 -c:v libx264 -crf 18 out.mp4

# 方式 2：-ss 在 -i 之后（解码到位置再输出），慢但"更精确"
ffmpeg -i input.mp4 -ss 100 -t 30 -c:v libx264 -crf 18 out.mp4

# 不重新编码：只能从关键帧开始
ffmpeg -ss 100 -i input.mp4 -t 30 -c copy out.mp4

import subprocess


def keyframes(path):
    out = subprocess.run(
        ['ffprobe', '-v', 'error', '-select_streams', 'v:0', '-skip_frame', 'nokey',
         '-show_entries', 'frame=pts_time', '-of', 'csv=p=0', path],
        capture_output=True, text=True, check=True).stdout
    return [float(x) for x in out.split() if x]


def snap(t: float, keys: list) -> float:
    """把时间点吸附到不晚于它的最近关键帧。"""
    prev = 0.0
    for k in keys:
        if k > t:
            break
        prev = k
    return prev

pip install OpenTimelineIO

import opentimelineio as otio


def read_timeline(path):
    tl = otio.adapters.read_from_file(path)
    print(f'时间线名: {tl.name}, 时长: {tl.duration()}')

    clips = []
    for clip in tl.find_clips():
        # 时间线上的范围
        rng = clip.range_in_parent()          # 可能为 None（未链接的片段）
        if rng is None:
            continue
        src = clip.source_range
        clips.append({
            'name': clip.name,
            'start': rng.start_time.to_seconds(),
            'duration': rng.duration.to_seconds(),
            'source_start': src.start_time.to_seconds() if src else None,
            'source_duration': src.duration.to_seconds() if src else None,
        })
    return clips


if __name__ == '__main__':
    for c in read_timeline('timeline.xml'):
        print(f"{c['name']}: 时间线 {c['start']:.2f}s 起，长 {c['duration']:.2f}s")

import opentimelineio as otio

tl = otio.adapters.read_from_file('timeline.xml')
otio.adapters.write_to_file(tl, 'timeline.edl', adapter_name='cmx_3600')

import subprocess
from concurrent.futures import ProcessPoolExecutor
from pathlib import Path


def cut_segment(args):
    src, out, start, dur, mode = args
    if mode == 'copy':
        cmd = ['ffmpeg', '-v', 'error', '-y', '-ss', f'{start:.3f}', '-i', src,
               '-t', f'{dur:.3f}', '-c', 'copy', '-avoid_negative_ts', 'make_zero', out]
    else:
        cmd = ['ffmpeg', '-v', 'error', '-y', '-ss', f'{start:.3f}', '-i', src,
               '-t', f'{dur:.3f}', '-c:v', 'libx264', '-crf', '18', '-preset', 'slow',
               '-c:a', 'aac', '-b:a', '192k', '-movflags', '+faststart', out]
    subprocess.run(cmd, check=True)
    return out


def auto_cut(source_video, timeline_path, out_dir, mode='copy', workers=4):
    clips = read_timeline(timeline_path)
    keys = keyframes(source_video) if mode == 'copy' else None

    jobs = []
    for i, c in enumerate(clips, 1):
        start = snap(c['start'], keys) if mode == 'copy' else c['start']
        name = f'{i:03d}_{sanitize(c["name"])}.mp4'
        jobs.append((source_video, str(Path(out_dir) / name), start, c['duration'], mode))

    Path(out_dir).mkdir(parents=True, exist_ok=True)
    with ProcessPoolExecutor(max_workers=workers) as ex:
        outs = list(ex.map(cut_segment, jobs))

    # 校验：每个片段的实际时长和预期是否一致
    report = []
    for (_, out, start, dur, _), o in zip(jobs, outs):
        real = probe_duration(o)
        report.append({'file': Path(o).name, 'expect': dur, 'real': real,
                       'diff': abs(real - dur)})
    return report

def frames_to_tc(frames: int, fps: float = 25.0, drop: bool = False) -> str:
    """帧号转时间码。"""
    ff = int(frames % round(fps))
    total_s = int(frames // round(fps))
    ss = total_s % 60
    mm = (total_s // 60) % 60
    hh = total_s // 3600
    sep = ';' if drop else ':'
    return f'{hh:02d}:{mm:02d}:{ss:02d}{sep}{ff:02d}'


def write_edl(clips, out_path, title='AUTO_CUT', fps=25.0, start_tc='01:00:00:00'):
    """clips: [{'reel': 'AX', 'src_in': 帧, 'src_out': 帧, 'rec_in': 帧, 'rec_out': 帧}]"""
    lines = [f'TITLE: {title}', 'FCM: NON-DROP FRAME', '']
    for i, c in enumerate(clips, 1):
        lines.append(
            f"{i:03d}  {c['reel']:<7} V     C        "
            f"{frames_to_tc(c['src_in'], fps)} {frames_to_tc(c['src_out'], fps)} "
            f"{frames_to_tc(c['rec_in'], fps)} {frames_to_tc(c['rec_out'], fps)}"
        )
    open(out_path, 'w').write('\n'.join(lines) + '\n')

import opentimelineio as otio

tl = otio.schema.Timeline(name='AUTO_CUT')
track = otio.schema.Track(name='V1', kind=otio.schema.TrackKind.Video)
tl.tracks.append(track)
# 添加 clip...
otio.adapters.write_to_file(tl, 'out.edl', adapter_name='cmx_3600')