HDR 动态元数据生成：场景自适应与质检

关键词：HDR10+（ST 2094-40）、Dolby Vision（RPU）、动态元数据、场景分割、APL/MaxRGB、亮度映射曲线（roll-off/knee）、肤色与天空保护、一次映射、一致性评测、QC 脚本、容器与封装校验

摘要：
面向移动端与内容分发，动态元数据（如 HDR10+ 与 Dolby Vision）通过帧/场景级参数引导目标端的亮度映射和饱和度保护，实现“因画而异”的稳定观感。本文从工程角度给出一套可落地的元数据生成与质检闭环：以内容分析（场景切分、APL/MaxRGB 统计、肤色/天空 ROI）驱动曲线求解（中灰锚定、roll-off、自适应饱和保护），再映射到不同标准的元数据字段；同时提供自动化 QC 脚本与门限（EOTF 跟踪、ΔE/Δh°、带状/闪烁、元数据与容器一致性），确保编码、封装与回放链路的一致与可回归。

1. 问题界定与目标

在 HDR 视频工作流中，动态元数据（HDR10+ 的 ST 2094-40、Dolby Vision 的 RPU）以“场景/帧级参数”描述亮度映射曲线与饱和保护，让显示端因画而异地执行 一次映射（Tone Mapping）。工程上要解决三件事：

如何从画面自动提取特征（APL/MaxRGB、饱和像素比、肤色/天空 ROI、运动/纹理复杂度、噪声等）；如何把特征变成“意图曲线”（中灰锚定、knee/roll-off、高光减饱和、色相带限），并映射到不同标准字段（HDR10+、DV）；如何保证端到端一致（曲线—元数据—封装—回放），用质检脚本在离线和 CI 上自动把关。

1.1 约束与成功标准（建议口径）

维度	关键点	成功标准（建议）
观感一致	“意图曲线”在支持 HDR10+/DV 的设备上应呈现一致趋势	EOTF RMSE ≤ 0.03；ΔE00（肤 ROI）≤ 3.0；Δh°（肤 ROI）≤ 3.5°
稳定性	场景边界不过冲/无闪烁	Flicker（灰/肤）≤ 0.02、过冲 ≤ 25%、收敛 ≤ 20 帧
兼容性	封装、时间码、对齐	HEVC SEI / MP4 box / RPU 与帧时间戳严格对齐，无缺段/重复
性能	批处理/端侧	离线 ≥ 30 fps（1080p 单机）；端侧相机/相册 ≤ 1 帧时延（统计→决策→应用）
回退	失败路径	元数据不可用时回退 HDR10 静态或 HLG，导出/回放保持一致曲线

1.2 端到端组件（UML 组件图）

1.3 元数据时序与对齐（时序图）

1.4 数据契约（段级）


Segment {
  seg_id: int
  t_start_ms: int
  t_end_ms: int
  features: {APL, MaxRGB, Sat%, Face%, Sky%, Motion, Texture, Noise...}
  intent: {anchor, knee_start, knee_end, roll_slope, desat_alpha, hue_band_deg}
  hdr10p: {bezier_3pts[], saturation_gain, distribution...}
  dv_rpu: {nlq_params, saturation_protect, level6/8 fields...}
}

2. 内容分析：从画面到特征（含流程与可运行代码）

2.1 场景切分（外层镜头 + 内层“映射段”）

镜头级（Hard Cut/Gradual）：色度直方图卡方/EMD、SSIM 降幅、运动矢量突变。映射段（Tone Segment）：在同一镜头内，当 APL/MaxRGB/饱和比/肤色占比 的滑窗统计出现显著拐点（阈值/变点检测）时切段——使每段的“意图曲线”单调可解释。

切分流程（活动图）


flowchart TD
  A[逐帧采样] --> B[直方图/SSIM/光流]
  B --> C{镜头切分?}
  C -- 是 --> D[建立新镜头段]
  C -- 否 --> E[滑窗特征(APL/MaxRGB/Sat/Face/Sky)]
  E --> F{变点检测?}
  F -- 是 --> G[建立映射子段]
  F -- 否 --> H[聚合到当前段]

建议

滑窗 0.5–1.0 s，步长 1 帧；变点检测：CUSUM/BOCPD 简化或阈值 + 最小段时长（≥15 帧）。

2.2 特征定义（口径统一）

特征	定义	备注
APL	m e a n ( Y ) mathrm{mean}(Y) mean(Y)（线性 Y，BT.2020 采样）	每帧/滑窗均值
MaxRGB	max ⁡ ( R , G , B ) max(R,G,B) max(R,G,B) 的 P99	高光势能
Sat%	饱和像素占比（任一通道 ≥ 0.98）	抗溢出参考
Face% / Sky%	人脸/天空像素占比	ROI 置信度门限
Texture	高通能量（Laplacian/LoG）	抗带状、锐化参照
Motion	光流幅值 P95	快/慢场景
Noise	暗区方差/ISO 候选	降噪/锐化协同
HistSlope	亮度直方图斜率/斜坡平滑性	渐变质量

2.3 特征提取骨架（Python / OpenCV，可直接用）

仅依赖 numpy 与 opencv-python；示例把 YUV420/BT.2020 读成 BGR 后线性化近似。


# features.py
import cv2 as cv
import numpy as np

def srgb_to_linear(x):
    a=0.055
    return np.where(x<=0.04045, x/12.92, ((x+a)/(1+a))**2.4)

def bgr_to_linear_srgb(bgr_8u):
    rgb = cv.cvtColor(bgr_8u, cv.COLOR_BGR2RGB).astype(np.float32)/255.0
    return srgb_to_linear(rgb)

def luma_linear(rgb):
    return 0.2126*rgb[...,0]+0.7152*rgb[...,1]+0.0722*rgb[...,2]

def apl_maxrgb_sat(rgb_lin):
    L = luma_linear(rgb_lin)
    maxrgb = np.percentile(np.max(rgb_lin, axis=2), 99)
    sat = float(np.mean(np.max(rgb_lin, axis=2) >= 0.98))
    return float(np.mean(L)), float(maxrgb), sat

def texture_energy(gray_lin):
    g = (gray_lin*255).astype(np.uint8)
    lap = cv.Laplacian(g, cv.CV_16S, ksize=3)
    return float(np.mean(np.abs(lap)))

def motion_mag(prev_gray, gray):
    flow = cv.calcOpticalFlowFarneback(prev_gray, gray, None, 0.5, 3, 15, 3, 5, 1.2, 0)
    mag = np.sqrt(flow[...,0]**2 + flow[...,1]**2)
    return float(np.percentile(mag,95))

def face_sky_ratio(rgb_lin, face_mask=None, sky_mask=None):
    H,W,_ = rgb_lin.shape
    if face_mask is None: face_ratio = 0.0
    else: face_ratio = float(np.mean(face_mask>0))
    if sky_mask is None:
        # 简易天空近似：亮且蓝（可替换为分割网络）
        L = luma_linear(rgb_lin); B = rgb_lin[...,2]
        sky = (L>0.6) & (B>0.5) & (B>rgb_lin[...,1]) & (B>rgb_lin[...,0])
        sky_ratio = float(np.mean(sky))
    else:
        sky_ratio = float(np.mean(sky_mask>0))
    return face_ratio, sky_ratio

def hist_slope(gray_lin):
    h,_ = np.histogram(gray_lin, bins=64, range=(0,1), density=True)
    # 二阶差分能量越小，梯度越平滑
    d2 = h[2:] - 2*h[1:-1] + h[:-2]
    return float(np.mean(np.abs(d2)))

def extract_features_from_frame(bgr_8u, prev_gray=None, face_mask=None, sky_mask=None):
    rgb_lin = bgr_to_linear_srgb(bgr_8u)
    L = luma_linear(rgb_lin).astype(np.float32)
    APL, MaxRGB, Sat = apl_maxrgb_sat(rgb_lin)
    Tex = texture_energy(L)
    Mot = motion_mag(prev_gray, (L*255).astype(np.uint8)) if prev_gray is not None else 0.0
    Face, Sky = face_sky_ratio(rgb_lin, face_mask, sky_mask)
    Hs = hist_slope(L)
    return {
        "APL":APL, "MaxRGB":MaxRGB, "Sat":Sat, "Texture":Tex,
        "Motion":Mot, "Face":Face, "Sky":Sky, "HistSlope":Hs,
        "L_gray":L  # 可用于滑窗与可视化
    }, (L*255).astype(np.uint8)

人脸/天空建议用端侧分割网络替换示例中的启发式；噪声可用暗区方差 + ISO/增益推断。

2.4 变点检测（简化 CUSUM）


# change_points.py
import numpy as np

def cusum_change(series, k=0.02, h=0.08, min_gap=15):
    """对归一化特征做 CUSUM，返回变点索引；k: 漂移因子, h: 阈值"""
    x = (series - np.mean(series)) / (np.std(series)+1e-6)
    cp, gpos, gneg = [], 0.0, 0.0
    for i,xi in enumerate(x):
        gpos = max(0.0, gpos + xi - k)
        gneg = min(0.0, gneg + xi + k)
        if gpos > h or gneg < -h:
            if not cp or i - cp[-1] >= min_gap:
                cp.append(i)
            gpos = gneg = 0.0
    return cp

建议口径

对 APL/MaxRGB/Sat/Face%/Motion 分别检测，再做投票；合并相距 < 12–15 帧的近邻变点；首尾保留最小段时长（≥15 帧）。

2.5 段级聚合与可视化（Mermaid 时序 + 表格）

seg_id	t_start	t_end	APL_mean	MaxRGB_P99	Sat%	Face%	Sky%	Motion_P95	HistSlope
1	0.00s	2.37s	0.28	0.91	0.04	0.36	0.02	0.12	0.018
2	2.37s	5.10s	0.62	0.98	0.21	0.08	0.35	0.07	0.026
3	5.10s	7.00s	0.41	0.95	0.09	0.31	0.01	0.15	0.020

上表直接作为 IntentSolver 的输入：APL 高/低、MaxRGB 接近饱和、Face/Sky 主导等将决定 knee/roll-off 与减饱和强度。

2.6 工程注意点

统一线性口径：所有特征以线性域计算（避免伽马混乱）；漂移去除与归一：长片段中先做去趋势（detrend）再变点检测，减少慢漂移误报；多特征投票：避免单一特征导致“过度切段”；时间对齐：特征窗口中心用于时间戳，落盘时与帧 PTS 对齐；容错：检测失败时仍以固定时长（如 2–3 s）切段，保证后续元数据存在。

3. 曲线求解：中灰锚定与 roll-off 的自适应

3.1 策略与参数来源

锚点：中灰 18%（线性）必须映射回 18%（视觉稳定锚）。

自适应膝点：

knee_start 由 APL 与 Face% 决定：APL 高、人脸占比低 → 早点压高光；APL 低或人脸高 → 晚些压。knee_end 由 MaxRGB 与 Sat% 决定：高光势能强、饱和像素多 → 提前结束并加大压缩。

高光减饱和：desat_alpha 随 Sat%、Sky% 增强（天空大块+高光易“塑料感”）。

平滑性：曲线分两段：线性段（到 knee_start）与压缩段（knee_start→knee_end），采用锚定 Reinhard或Bézier 段，在 knee_start 保证一阶连续。

UML（求解流程）


flowchart TD
  A[段级统计{APL, MaxRGB, Sat%, Face%, Sky%}] --> B[估计 knee_start/end]
  B --> C[求解压缩强度 k / roll_slope]
  C --> D[构建意图曲线 f(x)]
  D --> E[验证: 单调+C¹+中灰锚]
  E -->|PASS| F[导出: 1D LUT + 风格参数]
  E -->|FAIL| B[回退: 放缓压缩/移动膝点]

3.2 Python：意图曲线生成（可运行）

依赖 numpy，输入段级特征，输出 1D LUT（线性域 0…1→0…1）与风格参数。可直接落地到 GPU LUT 或离线渲染。


# intent_curve.py
import numpy as np
from dataclasses import dataclass

@dataclass
class SegmentStats:
    APL: float        # [0,1]
    MaxRGB: float     # [0,1], P99
    Sat: float        # 饱和比例 [0,1]
    Face: float       # 人脸占比 [0,1]
    Sky: float        # 天空占比 [0,1]
    Motion: float     # 运动 P95 归一化 [0,1]

@dataclass
class IntentParams:
    anchor: float = 0.18
    knee_start: float = 0.75
    knee_end: float = 1.10
    k_reinhard: float = 0.30
    desat_alpha: float = 0.25
    hue_band_deg: float = 3.5

@dataclass
class IntentCurve:
    x: np.ndarray      # 输入采样 0..1
    y: np.ndarray      # 输出映射 0..1
    params: IntentParams

def decide_knees(st: SegmentStats, anchor=0.18):
    # APL 高/人脸少 -> 早压；APL 低/人脸多 -> 晚压
    ks = 0.70 + 0.10*(0.5 - st.APL) + 0.05*(st.Face - 0.2)
    ks = float(np.clip(ks, 0.60, 0.82))
    # MaxRGB 越高/Sat% 越多 -> 更早结束，压得更狠
    ke = 1.05 - 0.10*(st.MaxRGB - 0.85) - 0.08*(st.Sat - 0.05)
    ke = float(np.clip(ke, ks + 0.10, 1.15))
    return ks, ke

def decide_strength(st: SegmentStats):
    # 高光势能+饱和多+天空多 -> k 加强；人脸多 -> k 略减弱（保肤色层次）
    k = 0.25 + 0.25*max(0.0, st.MaxRGB-0.85) + 0.20*max(0.0, st.Sat-0.05) + 0.10*st.Sky - 0.10*st.Face
    return float(np.clip(k, 0.10, 0.70))

def decide_desat(st: SegmentStats):
    # 天空/高光占比越高，减饱和越强；人脸多则稍减
    a = 0.18 + 0.35*st.Sky + 0.25*max(0.0, st.Sat-0.05) - 0.10*st.Face
    return float(np.clip(a, 0.15, 0.35))

def reinhard_anchor(x, anchor, k, ks):
    # 线性段：到 ks 保线性缩放，使 anchor 落点稳定
    y = np.zeros_like(x)
    lin_mask = x <= ks
    y[lin_mask] = x[lin_mask] * (anchor/ks)
    # 压缩段：锚定 reinhard（保证 at anchor 落点一致）
    def f(xx): return (xx*(1+k*xx))/(1+xx)
    fa = f(anchor); s = anchor/ max(fa, 1e-6)
    non_mask = ~lin_mask
    y[non_mask] = s * f(x[non_mask])
    return np.clip(y, 0, 1)

def make_intent_curve(st: SegmentStats, lut_size=4096) -> IntentCurve:
    ks, ke = decide_knees(st)
    k = decide_strength(st)
    desat = decide_desat(st)
    p = IntentParams(anchor=0.18, knee_start=ks, knee_end=ke,
                     k_reinhard=k, desat_alpha=desat, hue_band_deg=3.5)
    x = np.linspace(0, 1, lut_size, dtype=np.float32)
    y = reinhard_anchor(x, p.anchor, p.k_reinhard, p.knee_start)
    # 使 knee_end 附近逐渐饱和，避免越界（拉到 1.0 内）
    if p.knee_end < 1.20:
        t = np.clip((x - p.knee_end)/(1.0 - p.knee_end + 1e-6), 0, 1)
        y = (1 - t)*y + t*1.0
    # C¹ 连续性检查（可选：若导数突变大则平滑 3×1D box）
    dy = np.diff(y)
    if np.max(np.abs(np.diff(dy))) > 0.05:
        for _ in range(2):
            y = np.convolve(y, [1/3,1/3,1/3], mode='same')
            y[0], y[-1] = 0.0, 1.0
    return IntentCurve(x=x, y=y, params=p)

# quick test
if __name__ == "__main__":
    st = SegmentStats(APL=0.62, MaxRGB=0.97, Sat=0.18, Face=0.10, Sky=0.30, Motion=0.12)
    ic = make_intent_curve(st)
    print(ic.params)
    print("LUT head:", ic.y[:8])

输出：

IntentCurve.y：1D LUT（线性亮度→目标亮度），可直接下发 GPU；IntentParams：knee_start/knee_end/k_reinhard/desat_alpha/hue_band_deg 用于风格保护与元数据映射（下一章）。

4. 标准映射：从“意图曲线”到 HDR10+ / Dolby Vision 元数据

目标：把第 3 章的“意图曲线”与段级统计，转换为标准动态元数据。工程上我们遵循统一口径：先在“我们自己的参数空间”收敛，再投影到各标准的字段/约束，便于维护与回归。

说明：不同编码器/打包器对元数据的具体字段与量化可能略有差异；本章给出通用映射与可运行的打包前 JSON。实际封装请使用你们的编码器工具链把 JSON → 比特流/SEI/RPU。

4.1 HDR10+（ST 2094-40）映射

常见要素（概念对齐）：

显示目标：target_system_display_max_luminance（例：1000/4000 nits）。内容亮度：maxscl（MaxRGB 三元）、average_maxrgb。分布/直方图：若编码器需要，可提供 distribution_values。亮度映射：Bézier/样条参数（等价表示我们的 knee_start/knee_end/k）。饱和保护：saturation_gain 等。

Python：从意图曲线近似 Bézier 控制点 + 构造 HDR10+ JSON


# hdr10plus_map.py
import numpy as np
from dataclasses import dataclass, asdict

@dataclass
class HDR10PlusSegment:
    start_ms: int
    end_ms: int
    target_nits: int
    maxscl: tuple     # (R,G,B) in nits
    avg_maxrgb: float # nits
    bezier_points: list # list of (x,y) in [0,1]
    saturation_gain: float

def bezier_fit_from_lut(x, y, knee_start, samples=16):
    """
    简化：用 4 点 Bézier (P0..P3) 近似 LUT 的 [knee_start..1] 段。
    P0=(ks, y(ks)), P3=(1,1); P1,P2 用最小二乘拟合。
    """
    ks_idx = int(np.clip(knee_start* (len(x)-1), 0, len(x)-1))
    xs = x[ks_idx:]; ys = y[ks_idx:]
    t = (xs - xs[0])/(xs[-1]-xs[0]+1e-6)
    P0 = np.array([xs[0], ys[0]], np.float32)
    P3 = np.array([1.0, 1.0], np.float32)

    # 构设计矩阵 B (Bernstein basis) 解 P1,P2
    T = np.stack([(1-t)**3, 3*(1-t)**2*t, 3*(1-t)*t**2, t**3], axis=1) # [N,4]
    # 目标：T @ [P0,P1,P2,P3] = [xs,ys]; 我们分别拟合 x 与 y
    # 固定 P0,P3，解 P1,P2 的最小二乘
    A = T[:,1:3]  # 对应 P1,P2 的系数
    bx = xs - (T[:,0]*P0[0] + T[:,3]*P3[0])
    by = ys - (T[:,0]*P0[1] + T[:,3]*P3[1])
    P1x,P2x = np.linalg.lstsq(A, bx, rcond=None)[0]
    P1y,P2y = np.linalg.lstsq(A, by, rcond=None)[0]
    P1 = np.array([P1x, P1y], np.float32)
    P2 = np.array([P2x, P2y], np.float32)

    # 采样导出控制点（部分编码器接受 4 点 Bézier 或会再离散）
    ctrl = [tuple(P0), tuple(P1), tuple(P2), tuple(P3)]
    return ctrl

def build_hdr10plus_segment(intent_curve, seg_ms, target_nits=1000,
                            content_max_nits=1000, sat_gain=1.0):
    x, y, p = intent_curve.x, intent_curve.y, intent_curve.params
    # MaxSCL/AvgMaxRGB：用段统计或估算（此处简化为 content_max_nits 的比例）
    maxscl = (content_max_nits, content_max_nits, content_max_nits)
    avg_maxrgb = 0.5 * content_max_nits

    ctrl = bezier_fit_from_lut(x, y, p.knee_start)
    seg = HDR10PlusSegment(
        start_ms=seg_ms[0], end_ms=seg_ms[1],
        target_nits=target_nits,
        maxscl=maxscl, avg_maxrgb=avg_maxrgb,
        bezier_points=[(float(cx), float(cy)) for (cx,cy) in ctrl],
        saturation_gain=float(max(0.8, 1.0 - 0.5*intent_curve.params.desat_alpha))
    )
    return seg

# quick test
if __name__ == "__main__":
    from intent_curve import SegmentStats, make_intent_curve
    st = SegmentStats(APL=0.45, MaxRGB=0.94, Sat=0.10, Face=0.25, Sky=0.05, Motion=0.08)
    ic = make_intent_curve(st)
    seg = build_hdr10plus_segment(ic, seg_ms=(2370, 5100))
    print(seg)

交付到编码器前，可把 HDR10PlusSegment 序列化为 JSON；具体字段名与量化需按使用的 HDR10+ 打包工具的 schema 做最后一跳映射。

4.2 Dolby Vision（以 P8.1 工作流为例）的映射

思路：把“意图曲线 + 饱和保护”转成 RPU 所需的曲线/保护参数集合。不同实现细节有 vendor 差异，工程上通常准备一个中立 JSON，由 DV 工具链转换为二进制 RPU 并封装。

典型要素（概念性对应）：

母版/目标显示：母版峰值、目标显示峰值（例 1000 nits）。亮度映射：等效的 knee / roll-off / spline 控制点。色彩保护：高光减饱和强度、肤色带限（如有）。段边界：起止时间戳（对齐 PTS）。

Python：构造中立的 “DV-like” 意图 JSON（供 RPU 生成器消费）


# dv_map.py
from dataclasses import dataclass, asdict

@dataclass
class DVIntent:
    start_ms: int
    end_ms: int
    mastering_nits: int
    target_display_nits: int
    tone_curve: dict          # {"knee_start":..,"knee_end":..,"k":..,"lut16": [...]}
    saturation_protect: dict  # {"alpha":..}
    skin_hue_guard: dict      # {"center_deg":28,"band_deg":3.5}
    notes: str = ""

def build_dv_intent(intent_curve, seg_ms, mastering_nits=1000, target_nits=1000):
    p = intent_curve.params
    # 16 点下采样 LUT，便于 RPU 侧再量化/拟合
    lut16_x = np.linspace(0, 1, 16)
    lut16_y = np.interp(lut16_x, intent_curve.x, intent_curve.y).tolist()
    tone = {"knee_start": float(p.knee_start),
            "knee_end": float(p.knee_end),
            "k": float(p.k_reinhard),
            "lut16": [float(v) for v in lut16_y]}
    dv = DVIntent(
        start_ms=seg_ms[0], end_ms=seg_ms[1],
        mastering_nits=mastering_nits,
        target_display_nits=target_nits,
        tone_curve=tone,
        saturation_protect={"alpha": float(p.desat_alpha)},
        skin_hue_guard={"center_deg": 28.0, "band_deg": float(p.hue_band_deg)},
        notes="auto-generated from intent curve"
    )
    return dv

# quick test
if __name__ == "__main__":
    from intent_curve import SegmentStats, make_intent_curve
    st = SegmentStats(APL=0.62, MaxRGB=0.97, Sat=0.18, Face=0.10, Sky=0.30, Motion=0.12)
    ic = make_intent_curve(st)
    dv = build_dv_intent(ic, seg_ms=(5100, 7000))
    print(asdict(dv))

上述 DVIntent 不是 RPU 二进制，而是对齐我们意图口径的中立表述。在 DV 工具链里可把 tone_curve.lut16 拟合为目标 Profile 需要的参数；saturation_protect 与 skin_hue_guard 映射到相应的饱和/色相保护字段或查表。

4.3 段列表与封装前产物（UML 数据流）


flowchart LR
  A[意图曲线生成(每段)] --> B[HDR10+ JSON 列表]
  A --> C[DV-Intent JSON 列表]
  B --> D[HDR10+ 打包器→HEVC SEI]
  C --> E[DV 工具链→RPU]
  D --> F[复用器→MP4 boxes]
  E --> F
  F --> G[码流+元数据 QC（第6章）]

4.4 映射注意事项

一条曲线多标准共用：尽可能让 HDR10+ 与 DV 共享同一意图曲线（同 knee_start/end/k），减少 A/B 漂移。段边界对齐：以滑窗中心时间戳对齐段边界，避免 SEI/RPU 生效帧滞后；必要时在边界插值 2–3 帧过渡，降低过冲。量化与夹带：标准侧会对控制点/参数做量化（如 10bit 量化）；提前在我们侧夹带/量化可减少落地偏差。失败回退：若某段拟合失败或封装失败，回退到静态 HDR10 或完整禁用动态段，保证回放一致（第 5/6 章详述）。

5. 生成管线：离线批处理与端侧实时（含 UML 与可运行脚本）

目标：把第 2–4 章的“特征→意图曲线→标准映射”落成可批处理（素材库一键跑）与端侧实时（相机/相册）的两条管线，并具备失败回退与版本化能力。

5.1 管线概览（UML 活动图）


flowchart TD
  A[输入视频/序列] --> B[内容分析 (features.py)]
  B --> C[变点切分 (change_points.py)]
  C --> D[段级统计聚合]
  D --> E[意图曲线求解 (intent_curve.py)]
  E --> F[标准映射 HDR10+/DV (hdr10plus_map.py / dv_map.py)]
  F --> G[产物落盘(JSON/片段图/日志)]
  G --> H{校验通过?}
  H -- 是 --> I[封装/交付 (编码器/复用器)]
  H -- 否 --> J[失败回退: 静态HDR10/HLG & 标记]

5.2 批处理 Orchestrator（Python，多进程可运行）

依赖：opencv-python, numpy。假设你已放置：features.py, change_points.py, intent_curve.py, hdr10plus_map.py, dv_map.py（与前文一致）。


# generate_meta.py
import os, json, math, glob
import cv2 as cv
import numpy as np
from multiprocessing import Pool, cpu_count
from dataclasses import asdict

from features import extract_features_from_frame
from change_points import cusum_change
from intent_curve import SegmentStats, make_intent_curve
from hdr10plus_map import build_hdr10plus_segment
from dv_map import build_dv_intent

def analyze_video(path, fps_hint=None):
    cap = cv.VideoCapture(path)
    fps = fps_hint or cap.get(cv.CAP_PROP_FPS) or 30.0
    frame_cnt = int(cap.get(cv.CAP_PROP_FRAME_COUNT))
    prev_gray = None
    feats = []
    for i in range(frame_cnt):
        ok, bgr = cap.read()
        if not ok: break
        f, prev_gray = extract_features_from_frame(bgr, prev_gray)
        feats.append(f)
    cap.release()
    return feats, fps

def cut_segments(feats, fps):
    # 对 APL/MaxRGB/Sat/Face/Motion 各做 CUSUM，再投票
    arr = {k: np.array([f[k] for f in feats], np.float32) for k in ["APL","MaxRGB","Sat","Face","Motion"]}
    cplist = []
    for k in arr:
        cp = cusum_change(arr[k], k=0.02, h=0.08, min_gap=int(max(15, fps*0.5)))
        cplist.extend(cp)
    cplist = sorted(set(cplist))
    # 合并近邻
    merged = []
    for idx in cplist:
        if not merged or idx - merged[-1] > int(fps*0.4):
            merged.append(idx)
    # 保证首尾
    seg_idx = [0] + merged + [len(feats)-1]
    # 最小时长
    segs = []
    for i in range(len(seg_idx)-1):
        s, e = seg_idx[i], seg_idx[i+1]
        if e - s + 1 >= max(15, int(fps*0.5)):
            segs.append((s,e))
    return segs

def agg_segment(feats, s, e):
    sl = feats[s:e+1]
    def P(x,p): return float(np.percentile([f[x] for f in sl], p))
    def M(x)  : return float(np.mean([f[x] for f in sl]))
    return dict(
      APL=M("APL"), MaxRGB=P("MaxRGB", 99), Sat=M("Sat"),
      Face=M("Face"), Sky=M("Sky"), Motion=P("Motion",95)
    )

def build_segments(path):
    feats, fps = analyze_video(path)
    segs = cut_segments(feats, fps)
    out = []
    for (s,e) in segs:
        stats = agg_segment(feats, s, e)
        st = SegmentStats(**stats)
        ic = make_intent_curve(st)
        t0_ms = int(1000*s/fps); t1_ms = int(1000*e/fps)
        hdr10p = asdict(build_hdr10plus_segment(ic, (t0_ms,t1_ms)))
        dv     = asdict(build_dv_intent(ic, (t0_ms,t1_ms)))
        out.append(dict(seg_ms=[t0_ms, t1_ms],
                        stats=stats,
                        intent_params=asdict(ic.params),
                        hdr10plus=hdr10p,
                        dolby_vision=dv))
    return out, fps

def process_one(path, outdir, target_nits=1000):
    meta, fps = build_segments(path)
    base = os.path.splitext(os.path.basename(path))[0]
    os.makedirs(outdir, exist_ok=True)
    out_json = os.path.join(outdir, f"{base}.dynamic_meta.json")
    with open(out_json, "w", encoding="utf-8") as f:
        json.dump({"video": base, "fps": fps, "segments": meta,
                   "version": "DM-1.0"}, f, ensure_ascii=False, indent=2)
    return out_json

def main(in_dir, out_dir, jobs=None):
    files = [p for p in glob.glob(os.path.join(in_dir, "*.*")) if p.lower().endswith((".mp4",".mov",".mkv",".mjpeg",".avi"))]
    jobs = jobs or max(1, cpu_count()-1)
    args = [(p, out_dir) for p in files]
    with Pool(jobs) as pool:
        outs = pool.starmap(process_one, args)
    print("DONE:", outs)

if __name__ == "__main__":
    import argparse
    ap = argparse.ArgumentParser()
    ap.add_argument("--in_dir", required=True)
    ap.add_argument("--out_dir", required=True)
    ap.add_argument("--jobs", type=int, default=0)
    a = ap.parse_args()
    main(a.in_dir, a.out_dir, a.jobs)

5.3 端侧实时路径（UML 时序）

端侧要点

低时延：统计在 ISP/硬件口径完成；段边界采用中心对齐与2–3 帧插值过渡。失败回退：任何环节异常，立即回退静态 HDR10（或 HLG）配置；同时记录失败段。版本化：DM-1.x 产物 JSON 与 LUT 参数一并标注版本，便于灰度/回滚。

6. 质检脚本（QC）：一致性与封装校验（含可运行脚本）

目标：对“生成→封装→回放”做自动化把关：
1）一致性：意图曲线应答（EOTF/ΔE/Δh°/Flicker）；
2）对齐：场景边界与元数据段对齐；
3）封装：码流中确实存在 HDR10+（T.35）与/或 DV（RPU）信息。

6.1 QC 流程（UML）


flowchart TD
  A[源视频 + dynamic_meta.json] --> B[模拟应答: 1D LUT 应用]
  B --> C[回放应答: 解码封装后文件]
  C --> D[指标比较: EOTF/ΔE/Δh°/Flicker]
  A --> E[段边界对齐: 帧索引/时间戳]
  C --> F[SEI/RPU 扫描: HDR10+ / DV]
  D & E & F --> G{门限通过?}
  G -- 是 --> H[通过/归档]
  G -- 否 --> I[失败报告: 段ID/原因/建议修复]

6.2 指标与门限（建议）

指标	目标
EOTF RMSE	≤ 0.03
ΔE00（肤 ROI）	≤ 3.0
Δh°（肤 ROI）	≤ 3.5°
Flicker-L	≤ 0.02
边界错位（帧）	≤ 1 帧
HDR10+/DV 存在性	必须检测到

6.3 回放对齐与应答评测（Python，可运行）

输入：源视频（或导出的 SDR 回放）、封装后回放视频、dynamic_meta.json。此脚本用OpenCV读取帧，调用第 7 章（前文）的评测函数思路；这里给出最小实现（ΔE/Δh°/Flicker）。


# qc_metrics.py
import json, cv2 as cv, numpy as np
from eval_skin_stability import srgb_to_linear, oklab_from_lin_srgb, deltaE2000, hue_deg_oklab, luma_lin

def read_frames(path, max_frames=300):
    cap = cv.VideoCapture(path); frames=[]
    while len(frames)<max_frames:
        ok,bgr=cap.read()
        if not ok: break
        frames.append(cv.cvtColor(bgr, cv.COLOR_BGR2RGB).astype(np.float32)/255.0)
    cap.release(); return frames

def apply_lut_to_luma(rgb, lut_y):
    # 线性化→替换 L 通道→回渲染（简化近似，工程建议在渲染口径再现）
    lin = srgb_to_linear(rgb)
    L  = luma_lin(lin); idx = np.clip((L*(len(lut_y)-1)).astype(np.int32),0,len(lut_y)-1)
    Lm = lut_y[idx]
    # 仅调亮度保持色相（与主文一致）
    scale = (Lm+1e-6)/(L+1e-6)
    out = np.clip(lin * scale[...,None], 0, 1)
    return out

def eval_pair(A_lin, B_lin, mask=None):
    labA, labB = oklab_from_lin_srgb(A_lin), oklab_from_lin_srgb(B_lin)
    if mask is None: mask = np.ones(A_lin.shape[:2], bool)
    skin = mask.astype(bool)
    hA, hB = hue_deg_oklab(labA), hue_deg_oklab(labB)
    dh = np.abs(((hB-hA+180)%360)-180)[skin]
    dE = deltaE2000(labA, labB)[skin]
    LA, LB = luma_lin(A_lin), luma_lin(B_lin)
    dLr = np.abs(LA-LB)/(np.maximum(LB,1e-6))
    return dict(
        dHue_skin_P95=float(np.percentile(dh,95)),
        dE00_skin_P95=float(np.percentile(dE,95)),
        dL_rel_skin_P95=float(np.percentile(dLr[skin],95))
    )

def qc_video(src_path, played_path, meta_json, lut_size=4096, max_frames=200):
    meta = json.load(open(meta_json, "r", encoding="utf-8"))
    frames_src = read_frames(src_path, max_frames)
    frames_play= read_frames(played_path, max_frames)
    N = min(len(frames_src), len(frames_play)); assert N>0
    # 取第一个段的 LUT（演示）；工程中应在每帧匹配所属段
    p = meta["segments"][0]["intent_params"]
    # 用与生成时相同的 LUT 构建（近似）
    x = np.linspace(0,1,lut_size,np.float32)
    # 复用意图曲线的参数生成 LUT（简化：只做锚定+Reinhard）
    def reinhard(x, anchor, k, ks):
        y = np.where(x<=ks, x*(anchor/ks), (x*(1+k*x))/(1+x))
        fa = (anchor*(1+k*anchor))/(1+anchor); s=anchor/max(fa,1e-6)
        y = np.where(x<=ks, y, s*y); return np.clip(y,0,1)
    lut = reinhard(x, p["anchor"], p["k_reinhard"], p["knee_start"])

    # 帧级评测
    from collections import defaultdict
    mets = defaultdict(list); flickL = []
    prevL = None
    for i in range(N):
        Al = apply_lut_to_luma(frames_src[i], lut)
        Bl = srgb_to_linear(frames_play[i])
        m = eval_pair(Al, Bl)
        for k,v in m.items(): mets[k].append(v)
        # Flicker（灰/肤近似用全局 L）
        Lp = luma_lin(Bl); flickL.append(float(np.std(Lp)))
        prevL = Lp

    out = {k: float(np.mean(v)) for k,v in mets.items()}
    # 简化 Flicker：序列标准差的 RMSE（工程中建议使用低通残差）
    out["flicker_L"] = float(np.std(flickL))
    return out

if __name__ == "__main__":
    import argparse, json as js
    ap = argparse.ArgumentParser()
    ap.add_argument("--src", required=True)      # 源（或参考）视频
    ap.add_argument("--played", required=True)   # 封装后回放录屏/解码视频
    ap.add_argument("--meta", required=True)     # dynamic_meta.json
    a = ap.parse_args()
    m = qc_video(a.src, a.played, a.meta)
    print(js.dumps(m, indent=2))

6.4 SEI / RPU 存在性扫描（Annex-B ES；可运行）

该脚本扫描 HEVC Annex-B 码流（*.h265）。如输入是 MP4，请先通过工具将视频轨转为 Annex-B（例如：hevc_mp4toannexb 转换），再扫描。脚本检查：
1）SEI（prefix/suffix） 是否存在；
2）SEI 中是否出现 ITU-T T.35 载荷（常用于 HDR10+）；
3）是否存在 NAL type=62（常见 DV RPU）。


# hevc_scan.py
import sys, struct

def find_start_codes(b):
    i=0
    while i < len(b)-3:
        if b[i]==0 and b[i+1]==0 and b[i+2]==1:
            yield i; i+=3
        elif i < len(b)-4 and b[i]==0 and b[i+1]==0 and b[i+2]==0 and b[i+3]==1:
            yield i; i+=4
        else:
            i+=1

def nal_type(byte0):
    # HEVC: (forbidden_zero_bit=1) | nal_unit_type(6) | nuh_layer_id(6) | temporal_id_plus1(3)
    return (byte0 >> 1) & 0x3F

def scan_hevc(path):
    with open(path, "rb") as f:
        data = f.read()
    idxs = list(find_start_codes(data)) + [len(data)]
    seen = {"sei_prefix":0, "sei_suffix":0, "t35":0, "dv_rpu":0}
    for i in range(len(idxs)-1):
        st = idxs[i]; en = idxs[i+1]
        # 跳过 startcode
        j = st
        while j < en and data[j]==0: j+=1
        if data[j]==1: j+=1
        if j>=en: continue
        ntype = nal_type(data[j])
        if ntype==39: seen["sei_prefix"]+=1
        if ntype==40: seen["sei_suffix"]+=1
        if ntype==62: seen["dv_rpu"]+=1  # Dolby Vision RPU (常见)
        # 粗略扫描 SEI payload 中的 T.35
        if ntype in (39,40):
            payload = data[j+2: en]  # 跳过两个字节的 nal header（近似）
            # 查找 ITU-T T.35 country_code 0xB5（常见），不严格解析
            if b'xB5' in payload:
                seen["t35"]+=1
    return seen

if __name__ == "__main__":
    p = sys.argv[1]
    s = scan_hevc(p)
    print(s)
    ok = (s["sei_prefix"]+s["sei_suffix"]>0) and (s["t35"]>0 or s["dv_rpu"]>0)
    print("HAS_HDR10plus_or_DV:", ok)

注意：这里的 T.35 与 DV RPU 检测为工程近似，便于 CI 快速把关；正式发版前建议用你们的编码器/厂商工具做深度解析（字段级校验）。

6.5 段边界与时间戳对齐（Python）


# qc_align.py
import json, cv2 as cv

def check_alignment(video_path, meta_json, slack_frames=1):
    meta = json.load(open(meta_json, "r", encoding="utf-8"))
    cap = cv.VideoCapture(video_path)
    fps = cap.get(cv.CAP_PROP_FPS) or 30.0
    errs=[]
    for seg in meta["segments"]:
        s_ms,e_ms = seg["seg_ms"]
        s_idx = round(s_ms/1000.0*fps)
        e_idx = round(e_ms/1000.0*fps)
        # 要求：两段间断点相差 ≤ slack_frames
        errs.append((s_idx,e_idx))
    bad=[]
    for i in range(len(errs)-1):
        # 相邻的 e 与 下一个 s 应差 ≤1 帧
        if abs(errs[i][1]-errs[i+1][0])>slack_frames:
            bad.append((i, errs[i], errs[i+1]))
    return {"fps": fps, "segments_idx": errs, "misaligned": bad}

if __name__ == "__main__":
    import sys, json as js
    r = check_alignment(sys.argv[1], sys.argv[2])
    print(js.dumps(r, indent=2))

6.6 QC Gate（统一判定）


# qc_gate.py
import json
THR = {"EOTF_RMSE":0.03, "dE00_skin_P95":3.0, "dHue_skin_P95":3.5,
       "flicker_L":0.02, "misaligned_frames":1, "has_meta":True}

def gate(metrics, align, sei_flags):
    bad={}
    # 主观一致性（若你也计算 EOTF RMSE，可加进 metrics）
    for k,thr in [("dE00_skin_P95",THR["dE00_skin_P95"]),
                  ("dHue_skin_P95",THR["dHue_skin_P95"]),
                  ("flicker_L",THR["flicker_L"])]:
        if metrics.get(k,0) > thr: bad[k]=(metrics[k],thr)
    # 对齐
    mis = len(align.get("misaligned",[]))
    if mis>0: bad["misaligned_frames"]=(mis,THR["misaligned_frames"])
    # 元数据存在性
    has_meta = (sei_flags.get("dv_rpu",0)>0) or (sei_flags.get("t35",0)>0)
    if not has_meta: bad["has_meta"]=(False, True)
    return "PASS" if not bad else ("FAIL", bad)

# 用法：将 qc_metrics.py / qc_align.py / hevc_scan.py 输出汇总再判定

6.7 失败报告（Mermaid）


flowchart TD
  A[QC FAIL] --> B{类别}
  B -- 一致性 --> B1[提升 knee_start/end 平滑/减小 k]
  B -- 对齐 --> B2[段边界插值 2–3 帧/重采 PTS]
  B -- 封装 --> B3[检查封装链 & AnnexB/MP4 转换 & RPU/SEI 写入]
  B1 & B2 & B3 --> C[回归重跑 → QC]

6.8 产物与版本化（清单）

*.dynamic_meta.json：段列表 + 意图参数 + HDR10+/DV 中立描述；qc_report.json：metrics + align + sei_flags + gate 结论；logs/*.csv：段级特征摘要（APL/MaxRGB/Sat/Face/Sky/Motion）；version.txt：DM-1.x；失败回退时附带 fallback=HDR10_static 或 HLG.

7. 回放验证：一次映射与应答测试（含自动化探测代码）

7.1 测试包设计与设备矩阵

图样组成（同一素材三版）
1）Ramp：0→1 线性灰阶（含 5/10/20/…/95% 台阶 + 1024 级细分），用于拟合 EOTF。
2）人像片段：多肤色+混光/逆光；用于 Δh°/ΔE00。
3）天空/夜景：检验带状与高光保护。

元数据版本
A：无动态元数据（基线）；B：启用 HDR10+；C：启用 Dolby Vision（与 B 同一“意图曲线”）。
各自段边界一致（对齐滑窗中心），边界插值 2–3 帧。

设备与面板条件

高峰值（1000–1500 nits）/中峰值（600–800 nits）/低峰值（<500 nits）亮度模式（标准/户外提升）系统是否已做 Tone（相册/播放器差异）

回放验证流程（UML 时序）

7.2 从回放帧拟合“应答曲线”（EOTF 近似）

思路：对Ramp 段逐帧计算输入灰阶

x

∈

[

0

,

1

]

xin[0,1]

x∈[0,1] 与回放亮度

y

y

y 的对应关系，拟合单调函数

g

(

x

)

g(x)

g(x) 作为“设备应答曲线”。


# fit_response.py
import numpy as np

def monotone_fit(x_in_01, y_meas_01, bins=256):
    """
    将采样点(x,y)聚合为单调 LUT: x∈[0,1] → y∈[0,1]
    适用于回放Ramp的灰阶块/条纹采样结果。
    """
    x = np.clip(np.asarray(x_in_01, np.float32), 0, 1)
    y = np.clip(np.asarray(y_meas_01, np.float32), 0, 1)
    # 先按 x 分桶取中位数，平滑噪声
    idx = np.clip((x*(bins-1)).astype(int), 0, bins-1)
    buckets = [[] for _ in range(bins)]
    for i in range(len(x)): buckets[idx[i]].append(float(y[i]))
    yb = np.array([np.median(b) if b else np.nan for b in buckets], np.float32)
    # 空桶线性插值
    xv = np.linspace(0,1,bins, dtype=np.float32)
    mask = ~np.isnan(yb)
    yb = np.interp(xv, xv[mask], yb[mask])
    # 单调化（累积最大）
    ymono = np.maximum.accumulate(yb)
    return xv, np.clip(ymono, 0, 1)

def compose_lut(x, f_xy, g_xy):
    """ 复合 g∘f（x先过f再过g），x为统一采样网格 """
    xf, yf = f_xy; xg, yg = g_xy
    fx = np.interp(x, xf, yf)
    gx = np.interp(fx, xg, yg)
    return gx

def rmse(a,b): 
    a,b = np.asarray(a), np.asarray(b)
    return float(np.sqrt(np.mean((a-b)**2)))

7.3 “一次映射 vs 双重映射 vs 忽略”的自动判别

输入：

f(x): 我们的“意图曲线” LUT；g_base(x): 无元数据回放拟合曲线（A 版）；g_meta(x): 有元数据回放拟合曲线（B 或 C 版）。
判决：比较下列三种假设的残差：
1）一次映射（后端执行）：

g

meta

≈

g

base

∘

f

g_{ ext{meta}} approx g_{ ext{base}}circ f

gmeta≈gbase∘f
2）应用先做 + 系统再做（双重）：

g

meta

≈

g

base

∘

f

∘

f

g_{ ext{meta}} approx g_{ ext{base}}circ fcirc f

gmeta≈gbase∘f∘f
3）忽略元数据：

g

meta

≈

g

base

g_{ ext{meta}} approx g_{ ext{base}}

gmeta≈gbase


# double_tone_detect.py
import numpy as np
from fit_response import compose_lut, rmse

def judge_response(intent_xy, base_xy, meta_xy, xgrid=None):
    """
    intent_xy/base_xy/meta_xy: (x, y) 形式的单调LUT
    返回：{rmse_single, rmse_double, rmse_ignore, verdict}
    """
    if xgrid is None: xgrid = np.linspace(0,1,1024, dtype=np.float32)
    f = intent_xy; g0 = base_xy; g1 = meta_xy

    # 单次映射（后端执行）
    pred_single = compose_lut(xgrid, f, g0)       # g0∘f
    # 双重映射（f 再被执行一次）
    f2 = (f[0], np.clip(np.interp(f[0], f[0], f[1]), 0, 1))  # 形式占位：f自身域上
    pred_double = compose_lut(xgrid, f, (f[0], f[1]))        # 先f→得到x'，再过f
    pred_double = compose_lut(xgrid, (xgrid, pred_double), g0)  # g0∘f∘f
    # 忽略元数据
    pred_ignore = np.interp(xgrid, g0[0], g0[1])

    gt = np.interp(xgrid, g1[0], g1[1])
    r_single = rmse(pred_single, gt)
    r_double = rmse(pred_double, gt)
    r_ignore = rmse(pred_ignore, gt)

    # 判决规则（经验阈值）
    best = min(r_single, r_double, r_ignore)
    if best == r_single and r_single <= min(r_double, r_ignore) * 0.8:
        verdict = "single_tone_ok"
    elif best == r_double and r_double <= min(r_single, r_ignore) * 0.85:
        verdict = "double_tone_suspect"
    elif best == r_ignore:
        verdict = "metadata_ignored"
    else:
        verdict = "uncertain"
    return dict(rmse_single=r_single, rmse_double=r_double, rmse_ignore=r_ignore, verdict=verdict)

阈值建议：single_tone_ok 要求 rmse_single 至少比其它候选好 20%；double_tone_suspect 至少好 15%。若三者相近则为 uncertain，建议人工复核或扩大 Ramp 采样。

7.4 段间过渡与“过冲/闪烁”验证

边界插值：在 t_boundary±2–3 帧线性插值控制点，降低过冲。闪烁度：回放 Luma 的帧间低通残差 RMSE ≤ 0.02；色彩稳定：Δh°（肤 ROI，P95） ≤ 3.5°。


# transition_qc.py
import numpy as np

def flicker_rmse(seq, win=3):
    x = np.asarray(seq, np.float32)
    ker = np.ones(win,np.float32)/win
    pad = (win-1)//2
    xs = np.pad(x,(pad,pad),'edge')
    smooth = np.convolve(xs,ker,'valid')
    return float(np.sqrt(np.mean((x-smooth)**2)))

def step_metrics(curve_series, tol=0.02):
    """curve_series: 段边界附近的响应曲线关键点(如50%灰)时间序列"""
    x = np.asarray(curve_series, np.float32)
    target = np.median(x[-10:])
    overshoot = float((np.max(np.abs(x-target)) - np.abs(x[0]-target)) / (np.abs(target)+1e-6))
    # 收敛帧计数
    settle = len(x)
    for i in range(len(x)):
        if np.all(np.abs(x[i:]-target) <= tol*np.abs(target+1e-6)):
            settle = i; break
    return dict(overshoot=overshoot, settle_frames=settle)

8. 工程经验与问题清单（配置示例与排障路径）

8.1 常见故障与修复

症状	典型根因	诊断提示	修复要点
元数据无效（观感与基线一致）	SEI/RPU 未封装、时间戳错位、播放器链路屏蔽	`hevc_scan.py` 无 T.35/RPU；`qc_align.py` 段错位	修复封装；边界对齐；必要时切换播放器/容器
双重映射（过度压缩/灰阶塌缩）	应用与系统各做了一次 Tone	`double_tone_detect.py = double_tone_suspect`	禁用应用曲线或关闭系统曲线（择一）；保持“只一次”
段间闪烁/过冲	边界硬切，控制点跃迁	`transition_qc.py` overshoot↑、flicker↑	边界插值 2–3 帧；放缓 `k`、平滑 Bézier 控制点
肤色偏移	高光减饱和过强/色域矩阵不一致	Δh° 超阈，亮度正常	降 `desat_alpha`；校核 2020→P3→sRGB 矩阵版本
带状/块效应外显	过度压缩 + 低码率/8-bit 导出	Banding↑；直方图二阶差分↑	导出前蓝噪抖动 0.5 LSB；去块在边界轻混合
设备差异明显	面板峰值/系统 tone 差异	高峰值设备与中低峰值分化	“意图曲线”收敛在中性强度；按峰值自适应 knee

8.2 发布前 Checklist（简版）

HDR10+/DV 段存在且与帧时间戳对齐（≤1 帧） 一次映射判定为 single_tone_ok EOTF RMSE ≤ 0.03，ΔE00（肤）≤ 3.0，Δh°（肤）≤ 3.5° 段边界 overshoot ≤ 25%，settle ≤ 20 帧，Flicker ≤ 0.02 回退策略验证（静态 HDR10 / HLG）产物版本与日志完备（DM-1.x）

8.3 远程参数与门限（YAML 模板）


version: "DM-1.2"
intent:
  anchor: 0.18
  knee_start_range: [0.60, 0.82]
  knee_end_min_gap: 0.10
  k_range: [0.10, 0.70]
protect:
  desat_alpha_base: 0.22
  hue_band_deg: 3.5
limits:
  flicker_rmse: 0.02
  de00_skin_p95: 3.0
  dh_skin_p95_deg: 3.5
  eotf_rmse: 0.03
  overshoot_max: 0.25
  settle_frames_max: 20
qc:
  require_hdr10plus_or_dv: true
  align_slack_frames: 1
rollout:
  canary_percent: 5
  ramp_insert_frames: 60

8.4 排障流程（故障树）


flowchart TD
  A[观感/指标异常] --> B{有SEI/RPU?}
  B -- 否 --> B1[封装/时间戳 → 修复]
  B -- 是 --> C{一次映射?}
  C -- 否 --> C1[double_tone_detect=双重 → 关一端曲线]
  C -- 是 --> D{段边界抖动?}
  D -- 是 --> D1[边界插值 & 平滑控制点]
  D -- 否 --> E{肤色偏移?}
  E -- 是 --> E1[降 desat; 校矩阵; Hue带限]
  E -- 否 --> F[检查码率/抖动/去块 → 导出链]

8.5 灰度节奏（Gantt）

8.6 产物归档（建议）

dynamic_meta.json（段级意图 + HDR10+/DV 中立映射）*_qc_report.json（一致性/对齐/封装三合一 Gate）hevc_annexb_scan.txt（SEI/RPU 快速扫描结果）segments_summary.csv（APL/MaxRGB/Sat/Face/Sky/Motion 概要）version.txt（DM-1.x）与失败回退标记

个人简介

作者简介：全栈研发，具备端到端系统落地能力，专注人工智能领域。
个人主页：观熵
个人邮箱：privatexxxx@163.com
座右铭：愿科技之光，不止照亮智能，也照亮人心！

专栏导航

观熵系列专栏导航：
具身智能：具身智能
国产 NPU × Android 推理优化：本专栏系统解析 Android 平台国产 AI 芯片实战路径，涵盖 NPU×NNAPI 接入、异构调度、模型缓存、推理精度、动态加载与多模型并发等关键技术，聚焦工程可落地的推理优化策略，适用于边缘 AI 开发者与系统架构师。
DeepSeek国内各行业私有化部署系列：国产大模型私有化部署解决方案
智能终端Ai探索与创新实践：深入探索智能终端系统的硬件生态和前沿 AI 能力的深度融合！本专栏聚焦 Transformer、大模型、多模态等最新 AI 技术在智能终端的应用，结合丰富的实战案例和性能优化策略，助力智能终端开发者掌握国产旗舰 AI 引擎的核心技术，解锁创新应用场景。
企业级 SaaS 架构与工程实战全流程：系统性掌握从零构建、架构演进、业务模型、部署运维、安全治理到产品商业化的全流程实战能力
GitHub开源项目实战：分享GitHub上优秀开源项目，探讨实战应用与优化策略。
大模型高阶优化技术专题
AI前沿探索：从大模型进化、多模态交互、AIGC内容生成，到AI在行业中的落地应用，我们将深入剖析最前沿的AI技术，分享实用的开发经验，并探讨AI未来的发展趋势
AI开源框架实战：面向 AI 工程师的大模型框架实战指南，覆盖训练、推理、部署与评估的全链路最佳实践
计算机视觉：聚焦计算机视觉前沿技术，涵盖图像识别、目标检测、自动驾驶、医疗影像等领域的最新进展和应用案例
国产大模型部署实战：持续更新的国产开源大模型部署实战教程，覆盖从模型选型 → 环境配置 → 本地推理 → API封装 → 高性能部署 → 多模型管理的完整全流程
Agentic AI架构实战全流程：一站式掌握 Agentic AI 架构构建核心路径：从协议到调度，从推理到执行，完整复刻企业级多智能体系统落地方案！
云原生应用托管与大模型融合实战指南
智能数据挖掘工程实践
Kubernetes × AI工程实战
TensorFlow 全栈实战：从建模到部署：覆盖模型构建、训练优化、跨平台部署与工程交付，帮助开发者掌握从原型到上线的完整 AI 开发流程
PyTorch 全栈实战专栏： PyTorch 框架的全栈实战应用，涵盖从模型训练、优化、部署到维护的完整流程
深入理解 TensorRT：深入解析 TensorRT 的核心机制与部署实践，助力构建高性能 AI 推理系统
Megatron-LM 实战笔记：聚焦于 Megatron-LM 框架的实战应用，涵盖从预训练、微调到部署的全流程
AI Agent：系统学习并亲手构建一个完整的 AI Agent 系统，从基础理论、算法实战、框架应用，到私有部署、多端集成
DeepSeek 实战与解析：聚焦 DeepSeek 系列模型原理解析与实战应用，涵盖部署、推理、微调与多场景集成，助你高效上手国产大模型
端侧大模型：聚焦大模型在移动设备上的部署与优化，探索端侧智能的实现路径
行业大模型 · 数据全流程指南：大模型预训练数据的设计、采集、清洗与合规治理，聚焦行业场景，从需求定义到数据闭环，帮助您构建专属的智能数据基座
机器人研发全栈进阶指南：从ROS到AI智能控制：机器人系统架构、感知建图、路径规划、控制系统、AI智能决策、系统集成等核心能力模块
人工智能下的网络安全：通过实战案例和系统化方法，帮助开发者和安全工程师识别风险、构建防御机制，确保 AI 系统的稳定与安全
智能 DevOps 工厂：AI 驱动的持续交付实践：构建以 AI 为核心的智能 DevOps 平台，涵盖从 CI/CD 流水线、AIOps、MLOps 到 DevSecOps 的全流程实践。
C++学习笔记？：聚焦于现代 C++ 编程的核心概念与实践，涵盖 STL 源码剖析、内存管理、模板元编程等关键技术
AI × Quant 系统化落地实战：从数据、策略到实盘，打造全栈智能量化交易系统
大模型运营专家的Prompt修炼之路：本专栏聚焦开发 / 测试人员的实际转型路径，基于 OpenAI、DeepSeek、抖音等真实资料，拆解从入门到专业落地的关键主题，涵盖 Prompt 编写范式、结构输出控制、模型行为评估、系统接入与 DevOps 管理。每一篇都不讲概念空话，只做实战经验沉淀，让你一步步成为真正的模型运营专家。