code/make_clips.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
make_clips.py —— 把可用片段切成定长训练 clip（mp4 + 逐 cell 真值）

规格（与旧交付一致）：
    832x480 · 16 fps · 81 帧 = 21 个 latent cell · 步长 84 帧 · 无音轨
    832/1280 = 0.6500，480/720 = 0.6667，比值 0.9750 —— 即 2.5% 横向压缩(SAR 40:39)。
    直接 scale=832:480，不 crop、不加黑边。848x480 会静默炸：53 是奇数，
    DiT 的 stride-2 会丢掉最右一列 latent。

时间轴：源视频 30 fps，按 video_t 最近邻重采样到 16 fps。
    不用 ffmpeg 的 fps 滤镜 —— 那样无法保证每一帧对应哪个日志采样点，
    而这份数据的全部价值就在于「动作与画面逐帧对得上」。

cell 分组遵循 Wan2.2 因果 VAE：cell 0 = 帧 0；cell k = 帧 4k-3 .. 4k。
    81 帧 -> 1 + (81-1)//4 = 21 个 latent。

每个 clip 存：
    clips/<session>/clip_Eybx_<fight>_<start_cell>.mp4
    meta/<session>.jsonl 一行，含 21 个 cell 的 action / scene / purity / 亮度 /
    世界坐标 / rt_ratio，以及 video_t / log_vt / offset 供复核。
号段：s1 = 1e8 + seg_id，s2 = 2e8 + seg_id（burn 3e8 / hardcut 4e8 留给转场语料；
    1e7 是 vfx 段，撞了会静默丢批）。
"""
from __future__ import annotations

import argparse
import json
import os
import subprocess
import sys
import time
from concurrent.futures import ProcessPoolExecutor, as_completed

import numpy as np

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from scenes import REGION_SCENE, EXCLUDE_REGIONS, ACTIONS, SCENE_NL, compose  # noqa: E402

W, H = 832, 480
FPS = 16.0
FRAMES = 81
CELLS = 21
STRIDE_FRAMES = 84
SPEED_IDLE = 0.35          # m/s，低于此判「站着不动」
SESSION_BASE = {"20260821_190601_787": 100_000_000, "20260823_201942_753": 200_000_000}


def heading_to_action(hx, hy, speed):
    """屏幕速度 (hx, hy) -> 9 类动作索引。hy 向下为正（图像坐标）。"""
    out = np.zeros(hx.shape, np.int64)
    moving = speed > SPEED_IDLE
    ang = np.degrees(np.arctan2(-hy, hx))              # 转成「上为 +90°」的数学约定
    idx = 1 + (np.round((ang - 90.0) / 45.0).astype(np.int64) % 8)
    out[moving] = idx[moving]
    return out


def cell_frames(k):
    """cell k 覆盖的像素帧下标（相对 clip 内）。"""
    return [0] if k == 0 else list(range(4 * k - 3, 4 * k + 1))


def decode_span(path, t0, dur):
    cmd = ["ffmpeg", "-v", "error", "-ss", f"{t0:.4f}", "-t", f"{dur:.4f}", "-i", path,
           "-vf", f"scale={W}:{H}:flags=bicubic", "-f", "rawvideo", "-pix_fmt", "rgb24", "-"]
    raw = subprocess.run(cmd, capture_output=True).stdout
    n = len(raw) // (W * H * 3)
    if n == 0:
        return None
    return np.frombuffer(raw[:n * W * H * 3], np.uint8).reshape(n, H, W, 3)


def encode_clip(frames, out_path, crf=18):
    p = subprocess.Popen(
        ["ffmpeg", "-y", "-v", "error", "-f", "rawvideo", "-pix_fmt", "rgb24",
         "-s", f"{W}x{H}", "-r", f"{FPS:g}", "-i", "-",
         "-an", "-c:v", "libx264", "-crf", str(crf), "-preset", "veryfast",
         "-pix_fmt", "yuv420p", "-movflags", "+faststart", out_path],
        stdin=subprocess.PIPE)
    p.stdin.write(np.ascontiguousarray(frames).tobytes())
    p.stdin.close()
    return p.wait() == 0


def _off(tracks, video_t):
    """分段常数 offset 的纯数组版本（worker 侧用，闭包不能跨进程 pickle）。"""
    i = int(np.clip(np.searchsorted(tracks["off_los"], video_t, side="right") - 1,
                    0, tracks["off_vals"].size - 1))
    return float(tracks["off_vals"][i])


def process_segment(job):
    (sid, video, seg, base, tracks, out_clips, out_meta, crf, write_mp4) = job
    vlo, vhi = seg["video_lo"], seg["video_hi"]
    n_clips = seg["n_clips"]
    if n_clips <= 0:
        return sid, 0, []
    span = (n_clips - 1) * STRIDE_FRAMES / FPS + FRAMES / FPS
    frames = decode_span(video, vlo, span + 0.6)
    if frames is None:
        return sid, 0, []
    src_fps = tracks["src_fps"]
    rows = []
    made = 0
    for ci in range(n_clips):
        t_start = vlo + ci * STRIDE_FRAMES / FPS
        # 16fps 栅格 -> 源 30fps 帧下标（相对本次 decode 的起点）
        want_t = t_start + np.arange(FRAMES) / FPS
        idx = np.round((want_t - vlo) * src_fps).astype(np.int64)
        if idx[-1] >= frames.shape[0]:
            break
        pix = frames[idx]

        # 逐帧真值：按 video_t 最近邻取状态/输入
        st_i = np.searchsorted(tracks["vid_t"], want_t)
        st_i = np.clip(st_i, 1, tracks["vid_t"].size - 1)
        prev = st_i - 1
        st_i = np.where(np.abs(tracks["vid_t"][st_i] - want_t)
                        <= np.abs(tracks["vid_t"][prev] - want_t), st_i, prev)
        vx = tracks["vx"][st_i]; vy = tracks["vy"][st_i]; vz = tracks["vz"][st_i]
        spd = np.hypot(vx, vz)                      # 速度只看水平面，高度不算
        M = tracks["M"]                             # [3,2]: (世界 x,y,z 速度) -> (屏幕 x,y)
        hx = M[0, 0] * vx + M[1, 0] * vy + M[2, 0] * vz
        hy = M[0, 1] * vx + M[1, 1] * vy + M[2, 1] * vz
        act_f = heading_to_action(hx, hy, spd)
        scene_f = tracks["scene_id"][st_i]

        cells_act, cells_scene, cells_pur = [], [], []
        for k in range(CELLS):
            fr = cell_frames(k)
            a = np.bincount(act_f[fr], minlength=9)
            cells_act.append(int(np.argmax(a)))
            sc = scene_f[fr]
            sc = sc[sc >= 0]
            if sc.size == 0:
                cells_scene.append(-1); cells_pur.append(0.0); continue
            c = np.bincount(sc, minlength=len(tracks["scenes"]))
            top = int(np.argmax(c))
            cells_scene.append(top)
            cells_pur.append(float(c[top]) / sc.size)
        if min(cells_pur) <= 0.0:
            continue                                     # 有 cell 全落在排除区

        fight = base + seg["seg_id"]
        start_cell = ci * CELLS
        stem = f"clip_Eybx_{fight}_{start_cell:06d}"
        if write_mp4:
            if not encode_clip(pix, os.path.join(out_clips, stem + ".mp4"), crf):
                continue
        made += 1
        rows.append(dict(
            clip_id=stem, session=sid, seg_id=seg["seg_id"], fight=fight,
            start_cell=start_cell, leg=seg["leg"],
            video_t=float(t_start), log_vt=float(t_start - _off(tracks, t_start)),
            offset=float(_off(tracks, t_start)),
            region=seg["region"],
            scenes=[tracks["scenes"][s] for s in cells_scene],
            actions=cells_act, purity=[round(p, 3) for p in cells_pur],
            min_purity=round(float(min(cells_pur)), 3),
            lum=round(float(tracks["lum_mean"][np.clip(
                np.round(want_t * src_fps).astype(np.int64), 0,
                tracks["lum_mean"].size - 1)].mean()), 3),
            speed_med=round(float(np.median(spd)), 3),
            rt_ratio=round(float(np.median(tracks["rt"][st_i])), 3),
            x=round(float(tracks["x"][st_i[0]]), 1), z=round(float(tracks["z"][st_i[0]]), 1),
            prompts=[compose(tracks["scenes"][s], a) for s, a in zip(cells_scene, cells_act)],
        ))
    return sid, made, rows


def build_tracks(logs, sid, M):
    d = os.path.join(logs, sid)
    st = np.load(os.path.join(d, "state.npz")); o = np.argsort(st["vt"])
    vt = st["vt"][o]; x = st["x"][o].astype(np.float64); z = st["z"][o].astype(np.float64)
    y = st["y"][o].astype(np.float64)
    qf = st["qf"][o].astype(np.float64); rg = st["rg"][o]
    keep = np.concatenate([[True], np.diff(vt) > 1e-6])
    vt, x, y, z, qf, rg = vt[keep], x[keep], y[keep], z[keep], qf[keep], rg[keep]
    regions = json.load(open(os.path.join(d, "regions.json"), encoding="utf-8"))
    align = json.load(open(os.path.join(d, "offsets.json"), encoding="utf-8"))
    segs = align["segments"]
    los = np.array([s["vt_lo"] for s in segs]); offs = np.array([s["offset"] for s in segs])

    def off_at(video_t):
        i = np.clip(np.searchsorted(los, video_t, side="right") - 1, 0, offs.size - 1)
        return offs[i] if np.ndim(video_t) else float(offs[i])

    vid_t = vt + off_at(vt)   # 只在主进程用一次；worker 侧用下面的纯数组版本
    lum = np.load(os.path.join(d, "lum.npz")); mean = lum["mean"]; src_fps = float(lum["fps"])


    # 世界速度 + 实时率
    vx = np.gradient(x, vt); vy = np.gradient(y, vt); vz = np.gradient(z, vt)
    k = 20
    lo = np.maximum(np.arange(vt.size) - k // 2, 0); hi = np.minimum(np.arange(vt.size) + k // 2, vt.size - 1)
    dt = vt[hi] - vt[lo]
    rt = np.where(dt > 0.2, (qf[hi] - qf[lo]) / (60.0 * np.maximum(dt, 1e-9)), 1.0)

    scenes = sorted(SCENE_NL)
    s_idx = {s: i for i, s in enumerate(scenes)}
    scene_id = np.array([s_idx.get(REGION_SCENE.get(r, ""), -1) for r in regions], np.int64)[rg]
    return dict(vt=vt, vid_t=vid_t, x=x, z=z, y=y, vx=vx, vy=vy, vz=vz, rt=rt,
                scene_id=scene_id, scenes=scenes, src_fps=src_fps,
                lum_mean=mean, off_los=los, off_vals=offs, M=M)


def main():
    ap = argparse.ArgumentParser(description="切训练 clip")
    ap.add_argument("--raw", default="/data/zhiyangdeng/EYBXROAM")
    ap.add_argument("--logs", default="/data/zhiyangdeng/data_eybx/logs")
    ap.add_argument("--out", default="/data/zhiyangdeng/data_eybx")
    ap.add_argument("--sessions", nargs="*", default=None)
    ap.add_argument("--workers", type=int, default=24)
    ap.add_argument("--crf", type=int, default=18)
    ap.add_argument("--limit", type=int, default=None, help="调试：只处理前 N 段")
    ap.add_argument("--no_mp4", action="store_true", help="只出真值不写 mp4（调试）")
    args = ap.parse_args()

    sessions = args.sessions or sorted(SESSION_BASE)
    for sid in sessions:
        d = os.path.join(args.logs, sid)
        segs = json.load(open(os.path.join(d, "segments.json"), encoding="utf-8"))
        if args.limit:
            segs = segs[:args.limit]
        oj = json.load(open(os.path.join(d, "offsets.json"), encoding="utf-8"))
        if not oj.get("M_px1280"):
            sys.exit(f"[错误] {sid} 没有世界→屏幕映射，先跑 align_flow.py + finalize_offsets.py")
        M = np.array(oj["M_px1280"])
        print(f"== {sid}  {len(segs)} 段  M=[[{M[0,0]:+.2f} {M[0,1]:+.2f}]"
              f"[{M[1,0]:+.2f} {M[1,1]:+.2f}]]", flush=True)
        tracks = build_tracks(args.logs, sid, M)
        oc = os.path.join(args.out, "clips", sid); os.makedirs(oc, exist_ok=True)
        om = os.path.join(args.out, "meta"); os.makedirs(om, exist_ok=True)
        video = os.path.join(args.raw, sid, "video.mp4")
        base = SESSION_BASE[sid]

        jobs = [(sid, video, s, base, tracks, oc, om, args.crf, not args.no_mp4) for s in segs]
        t0 = time.time(); total = 0
        with open(os.path.join(om, f"{sid}.jsonl"), "w", encoding="utf-8") as fh, \
                ProcessPoolExecutor(args.workers) as ex:
            futs = [ex.submit(process_segment, j) for j in jobs]
            for i, f in enumerate(as_completed(futs)):
                _, made, rows = f.result()
                total += made
                for r in rows:
                    fh.write(json.dumps(r, ensure_ascii=False) + "\n")
                if (i + 1) % 200 == 0 or i == len(futs) - 1:
                    el = time.time() - t0
                    print(f"   [{i+1}/{len(futs)}] {total:,} clips · {el/60:.1f} min "
                          f"· ETA {(len(futs)-i-1)*el/(i+1)/60:.1f} min", flush=True)
        print(f"   {sid}: {total:,} clips -> {oc}")
    print("DONE")


if __name__ == "__main__":
    main()