低端机 Ultra HDR（JPEG\_R）降级渲染与 SDR 一致性

低端机 Ultra HDR（JPEG_R）降级渲染与 SDR 一致性

关键词：Ultra HDR、JPEG_R、增益图（Gain Map）、SDR 降级、一次 Tone Mapping、色彩一致性、Banding 抑制、蓝噪抖动、Android 14/15、ImageDecoder、ARGB_8888、Display P3→sRGB、瓦片化处理、性能/内存约束、自动化回归

摘要：
在大量不具备 HDR 面板或图形算力受限的低端机上，App 仍需要稳定展示与导出来自高端机拍摄的 Ultra HDR（JPEG_R）素材。本文从工程实践出发，给出可落地的降级渲染方案：在线性域或等效近似下完成增益图重建，采用统一的单次 Tone Mapping与色相/饱和度保护，并通过瓦片化 + 缓存把内存与耗时控制在低端 SoC 可承受范围。针对低端机容易出现的带状、块效应、偏色、双重映射等问题，本文给出抖动与量化策略、一致性评测指标与阈值，以及端侧自动化回归与灰度发布要点，确保低端机 SDR 观感与主流机型保持一致。

1. 约束

Ultra HDR（JPEG_R）在低端机上的典型限制：无 HDR 面板、图形算力有限、内存紧张、系统栈不稳定支持 RGBA_F16。但产品仍需保证观感稳定、滚动流畅、导出/分享一致。

1.1 环境与资源边界

维度	低端机现状	对渲染的影响	约束建议
显示	SDR 面板（Gamma 2.2 / sRGB）	无法直接显示 HDR 亮度	统一降级到 sRGB，单次 Tone Mapping
图形	GLES 3.0 / 部分设备仅 ES 3.0-lite	F16 纹理/FP16 混合性能弱	优先 ARGB_8888 管线，HDR→SDR 在 app 内完成
内存	3–4 GB，总量紧	F16 全幅大图易 OOM	采用瓦片化与分辨率分级 L1/L2/详情
解码	Android 13/14/15 混场	JPEG_R 支持不一致	安全解码→失败即高质量 SDR 回退
编解码	低码率 JPEG 基底常见	Banding/块效应风险大	蓝噪抖动、SDR Q≥90、避免二次压缩

1.2 质量与性能目标（建议值）

指标	目标	说明
详情页掉帧率（长图滚动）	≤ 2%	30/60 fps 环境
首帧解码+降级耗时（12 MP）	≤ 150 ms	IO 视机型浮动
峰值内存（详情）	≤ 350 MB	含 1 幅全幅、1 幅 L2
SDR 一致性：ΔE00（肤色/天空）	≤ 3.0（P95）	以主力机 HDR→SDR 参考为对比
亮度一致：ΔL_rel	≤ 3%（P95）	灰卡/天空 ROI
BandingScore	≤ 0.30	渐变抑制
直方图 RMSE（SDR 代理 vs 详情）	≤ 2%	一致性核验

1.3 决策流程（设备探测 → 管线选择）


flowchart TD
  A[载入 JPEG_R] --> B{系统是否稳定支持 JPEG_R 解码?}
  B -- 否 --> C[解码为 SDR 基底(ARGB_8888)]
  B -- 是 --> D[解 HDR 元数据+增益图]
  D --> E{是否可安全线性重建?}
  E -- 否 --> C
  E -- 是 --> F[线性重建→单次 Tone Mapping→sRGB]
  C --> G[高质量 SDR 近似→sRGB]
  F --> H[渲染/导出/分享(一致曲线)]
  G --> H

2. 降级渲染管线（单次映射）

2.1 数据流与模块边界

关键点

线性重建优先：可用即 L_hdr = L_sdr · G；不可靠时使用稳定近似（见 2.3）。单次映射：应用层完成 Tone Mapping；若系统已做 HDR 合成，应用内禁止再次映射，只做色域与色相/饱和度保护。色域：来源可能接近 Display P3，输出统一到 sRGB/ARGB_8888。

2.2 单次 Tone Mapping（中灰锚定 + 高光 roll-off）

中灰锚定：统一 18% 灰映射位置，避免整体偏灰/偏黄。高光 roll-off：在 70–90% 亮度区缓和压缩，保护脸部高光与天空层次。Hue 锁定：在 OKLCh 或 IPT 空间对肤色施加 Δh° 带限（建议 ≤ 3.5°）。高光减饱和：高光区适度降低 C*，抑制“塑料感”。

实现形态：低端机建议查表（LUT 1D/2D）+ 分段多项式；GLES 3.0 支持 256/512 尺寸的 1D LUT，可在 CPU 预生成。

2.3 当线性重建不可用时的稳定近似

若平台无法可靠获取/应用增益图（G）：

等效近似：从 SDR 基底估计“高光保护+中灰对齐”的单调曲线。渐进增强：对高光亮域使用更保守的曲线（避免过冲），在细节 ROI（天空/肤色）增加微弱局部对比。抗带状：曲线后 蓝噪抖动（0.5 LSB）再量化到 8bit，减轻渐变台阶。

2.4 色域与伽马

P3→sRGB：使用 3×3 矩阵 + sRGB EOTF，避免链路中隐式二次 Gamma。Gamma 设备：输出端固定 sRGB Gamma 2.2；不要叠加设备端“显眼增强”模式（可通过系统标志禁用）。

2.5 列表/详情一致策略

L1/L2（缩略图）：全部由同一套 LUT生成的 SDR 图，尺寸建议长边 256/640。详情：若 HDR→SDR 需要在线计算，采用瓦片化按屏渲染，曲线/LUT 与 L1/L2 保持一致。一致性核验：直方图（线性域）RMSE ≤ 2%。

3. 性能与内存控制

3.1 分辨率分级与吞吐

级别	用途	长边建议	平均耗时（12MP 基线）	备注
L1	网格	256 px	3–8 ms/张	纯 SDR 缩略
L2	瀑布流/预览	640 px	10–25 ms/张	LUT 映射
详情	全幅或屏幕等比	1920–2560 px	60–120 ms/张	瓦片化/分段

避免一次性解满分辨率；进入详情页后，先以 L2 占位，再逐瓦片替换为全幅。

3.2 瓦片化与并发

瓦片尺寸：512×512 或 640×640；边界 16 px 重叠 以消除接缝。并发：CPU 2–3 线程或 GL 1–2 Pass；避免超过 2 幅大 tile 同时在内存。缓存：LruCache 保留最近 12–24 个 tile；列表与详情使用同一缓存键空间。

3.3 查表与分段多项式

1D LUT（Tone Curve）：256/512 采样点，线性插值；占用极小、分支可预测。2D LUT（Hue/Sat 保护）：亮度 × 色相的小 LUT（如 64×32），只在肤色 ROI 上应用。分段多项式：中灰附近二次近似、roll-off 段三次近似；保证单调与端点连续。

3.4 内存预算与峰值控制

项	估算	说明
ARGB_8888 全幅（12MP ≈ 4000×3000）	~ 45.8 MB	4 B/px
2× Tile（640×640×2）	~ 3.3 MB	双缓冲
L2 缓存（20 张 × 640px）	~ 60–90 MB	视压缩比
总峰值（典型）	≤ 300 MB	含少量元数据

控制要点

详情页只允许 1 幅全幅 + 2 瓦片在内存；L2/L1 命中率 ≥ 90%，否则调大缓存或延迟解码；释放策略：离开页面立即清空 tile 与临时缓冲。

3.5 监控与告警

渲染耗时（P50/P95）、内存峰值、L1/L2 命中率、瓦片回收率、掉帧率。画质触发：BandingScore>0.30 或 ΔE00>3.0 时，自动降低局部对比/提高抖动幅度并记录日志。

3.6 端到端流程（整合图）

4. 画质风控与抗伪影（低端机友好）

4.1 风险触发矩阵（阈值建议）

风险	触发（P95 或均值）	一线动作（≤1 帧内见效）	二线动作（可见场景再启用）
带状（Banding）	BandingScore > 0.30	蓝噪抖动 0.5 LSB → 量化	直方图微抖（1D LUT 抖动）、局部对比 −20%
块效应	BlockinessIndex > 1.6	局部反锐化（USM ×0.7）	SDR 基底 Q≥90、放大瓦片重采样核
亮度台阶	ΔL_rel > 3%	roll-off +0.03；中灰对齐	局部 tone 分段重拟合
色相跳变（肤色/天空）	Δh° > 3.5°	HueLock 收紧（3.0°）	通道收束至 ±5%
塑料感	ΔC* > 4.0	高光区减饱和 α×0.85	局部对比 −15%
光晕/振铃	HaloMag > 5% 或 Width>3px	边缘锐化 ×0.7	增益斜率抑制、边缘导向平滑
二次映射	系统已 HDR→SDR 又应用曲线	禁用应用 Tone；仅色域与 Hue/Sat	——

注：阈值与第 5 章一致性评测保持一致，避免双标。

4.2 带状抑制：蓝噪抖动 + 量化（Kotlin，真实可编译）


/**
 * 对 ARGB_8888 的 sRGB 图像进行 8bit 量化抖动（蓝噪风格高通近似）
 * 适用于 Tone/LUT 之后、落盘或上传前的带状抑制
 */
fun ditherBlueNoise(bitmap: Bitmap, strengthLSB: Float = 0.5f, seed: Long = 17L): Bitmap {
    require(bitmap.config == Bitmap.Config.ARGB_8888)
    val w = bitmap.width; val h = bitmap.height
    val out = bitmap.copy(Bitmap.Config.ARGB_8888, true)
    val rng = java.util.Random(seed)
    val row = IntArray(w)
    // 7x7 盒滤作为高通近似：noise - boxblur(noise)
    val k = 3; val win = (2 * k + 1)
    val tmp = FloatArray(w * h)
    // 先生成白噪
    var idx = 0
    for (y in 0 until h) for (x in 0 until w) tmp[idx++] = (rng.nextFloat() * 2f - 1f)
    // 粗糙高通：每行/列做均值减法
    // 行
    for (y in 0 until h) {
        var sum = 0f
        val base = y * w
        for (x in 0 until w) {
            sum += tmp[base + x]
            val left = x - win
            if (left >= 0) sum -= tmp[base + left]
            val avg = sum / win.coerceAtMost(x + 1)
            tmp[base + x] = tmp[base + x] - avg
        }
    }
    // 列
    for (x in 0 until w) {
        var sum = 0f
        for (y in 0 until h) {
            val i = y * w + x
            sum += tmp[i]
            val up = y - win
            if (up >= 0) sum -= tmp[up * w + x]
            val avg = sum / win.coerceAtMost(y + 1)
            tmp[i] = tmp[i] - avg
        }
    }
    // 应用到像素
    for (y in 0 until h) {
        out.getPixels(row, 0, w, 0, y, w, 1)
        for (x in 0 until w) {
            val c = row[x]
            val a = (c ushr 24) and 0xff
            var r = (c ushr 16) and 0xff
            var g = (c ushr 8) and 0xff
            var b = (c) and 0xff
            val n = tmp[y * w + x] * strengthLSB // ±0.5 LSB
            r = (r + n).toInt().coerceIn(0, 255)
            g = (g + n).toInt().coerceIn(0, 255)
            b = (b + n).toInt().coerceIn(0, 255)
            row[x] = (a shl 24) or (r shl 16) or (g shl 8) or b
        }
        out.setPixels(row, 0, w, 0, y, w, 1)
    }
    return out
}

4.3 锐化与增益斜率互斥（USM 自适应）


/**
 * 自适应 USM：边缘强/高斜率区域降低锐化，减光晕与块边共振
 */
fun unsharpMaskAdaptive(
    bmp: Bitmap, amount: Float = 0.6f, radius: Int = 1, threshold: Int = 3
): Bitmap {
    val w = bmp.width; val h = bmp.height
    val out = bmp.copy(Bitmap.Config.ARGB_8888, true)
    val src = IntArray(w * h); val dst = IntArray(w * h)
    bmp.getPixels(src, 0, w, 0, 0, w, h)

    // 简单盒滤近似高斯
    fun blur(ch: IntArray): IntArray {
        val r = ch.copyOf()
        val k = radius
        // 行
        for (y in 0 until h) {
            var sum = 0
            val base = y * w
            for (x in 0 until w) {
                sum += ch[base + x]
                val left = x - (2 * k + 1)
                if (left >= 0) sum -= ch[base + left]
                r[base + x] = sum / (2 * k + 1).coerceAtMost(x + 1)
            }
        }
        // 列
        for (x in 0 until w) {
            var sum = 0
            for (y in 0 until h) {
                val i = y * w + x
                sum += r[i]
                val up = y - (2 * k + 1)
                if (up >= 0) sum -= r[up * w + x]
                r[i] = sum / (2 * k + 1).coerceAtMost(y + 1)
            }
        }
        return r
    }

    // 拆分通道
    val R = IntArray(w*h); val G = IntArray(w*h); val B = IntArray(w*h); val A = IntArray(w*h)
    for (i in src.indices) {
        A[i] = (src[i] ushr 24) and 0xff
        R[i] = (src[i] ushr 16) and 0xff
        G[i] = (src[i] ushr 8) and 0xff
        B[i] = (src[i]) and 0xff
    }
    val Rb = blur(R); val Gb = blur(G); val Bb = blur(B)

    // 边缘强度（亮度梯度）
    fun lum(r:Int,g:Int,b:Int)= (0.2126*r + 0.7152*g + 0.0722*b)
    val edge = FloatArray(w*h)
    for (y in 1 until h-1) for (x in 1 until w-1) {
        val i = y*w + x
        val l = lum(R[i-1],G[i-1],B[i-1]); val rgt = lum(R[i+1],G[i+1],B[i+1])
        val u = lum(R[i-w],G[i-w],B[i-w]); val d = lum(R[i+w],G[i+w],B[i+w])
        val gx = kotlin.math.abs(rgt - l); val gy = kotlin.math.abs(d - u)
        edge[i] = (gx + gy).toFloat() / 2f
    }

    // 斜率/边缘越大，amount 越小
    for (i in src.indices) {
        val dr = R[i] - Rb[i]; val dg = G[i] - Gb[i]; val db = B[i] - Bb[i]
        val mag = maxOf(kotlin.math.abs(dr), kotlin.math.abs(dg), kotlin.math.abs(db))
        val pass = if (mag >= threshold) 1f else 0f
        val scale = (amount * (1f - (edge[i]/64f).coerceIn(0f,1f)))
        val r = (R[i] + scale * dr * pass).toInt().coerceIn(0,255)
        val g = (G[i] + scale * dg * pass).toInt().coerceIn(0,255)
        val b = (B[i] + scale * db * pass).toInt().coerceIn(0,255)
        dst[i] = (A[i] shl 24) or (r shl 16) or (g shl 8) or b
    }
    out.setPixels(dst, 0, w, 0, 0, w, h)
    return out
}

4.4 肤色/天空 ROI 保护（阈值 + HueLock）


/** 粗略肤色掩码（YCbCr），低端机实时可用；参数需按数据微调 */
fun skinMaskYCbCr(r:Int,g:Int,b:Int): Boolean {
    val y  = (  77*r + 150*g +  29*b) shr 8
    val cb = ((-43*r -  85*g + 128*b) shr 8) + 128
    val cr = ((128*r - 107*g -  21*b) shr 8) + 128
    return y in 40..235 && cb in 85..135 && cr in 135..180
}

/** 亮度分段的高光减饱和（避免塑料感），只在 Skin/Highlight 生效 */
fun satMapHighLight(r:Int,g:Int,b:Int, alpha:Float=0.25f): IntArray {
    val l = (0.2126f*r + 0.7152f*g + 0.0722f*b) / 255f
    val wh = ((l - 0.8f) / (1f - 0.8f)).coerceIn(0f,1f)   // 高光权重
    val k = 1f - alpha*wh
    val mean = (r + g + b)/3f
    val rr = (mean + (r-mean)*k).toInt().coerceIn(0,255)
    val gg = (mean + (g-mean)*k).toInt().coerceIn(0,255)
    val bb = (mean + (b-mean)*k).toInt().coerceIn(0,255)
    return intArrayOf(rr,gg,bb)
}

4.5 风控闭环（流程）


flowchart TD
  A[LUT/Tone 输出帧] --> B[统计: Banding/ΔL/ΔE/Δh]
  B -->|触发| C[抖动↑ / 对比↓ / HueLock↑ / USM↓]
  C --> D[帧缓存/落盘]
  B -->|通过| D

5. SDR 一致性评测方法（自动化 + 轻主观）

5.1 数据与 ROI

数据：人像（多肤色）、天空渐变、夜景/高反差、室内混光；每类 ≥ 50 张。ROI：肤色、灰卡/中灰、天空大面积渐变、边缘/高频、阴影。基准：同一素材在参考机上按“单次映射 + sRGB”导出为基准 SDR。

5.2 指标集与阈值（建议）

指标	说明	阈值（P95 或均值）
ΔE00（肤色/天空）	CIEDE2000	≤ 3.0
Δh°（肤色）	色相角差	≤ 3.5°
ΔL_rel（灰/天空）	相对亮度误差	≤ 3%
BandingScore（天空）	二阶差分能量	≤ 0.30
BlockinessIndex	8×8 边界比	≤ 1.6
直方图 RMSE（全图/ROI）	线性域直方图 RMSE	≤ 2%
SSIM（全图）	结构相似度	≥ 0.95（可选）

5.3 Python 评测脚本（可直接跑，依赖 `numpy`）


# sdr_eval.py
import numpy as np

def p95(x): return float(np.percentile(x.reshape(-1), 95))

# ---- 基础色彩：sRGB <-> Lab（D65） ----
def srgb_to_linear(rgb):
    a = 0.055
    out = np.where(rgb <= 0.04045, rgb/12.92, ((rgb+a)/(1+a))**2.4)
    return out.astype(np.float32)

def rgb_to_xyz(rgb):
    M = np.array([[0.4124564,0.3575761,0.1804375],
                  [0.2126729,0.7151522,0.0721750],
                  [0.0193339,0.1191920,0.9503041]], np.float32)
    return rgb @ M.T

def xyz_to_lab(xyz):
    Xn,Yn,Zn = 0.95047,1.0,1.08883
    x,y,z = xyz[...,0]/Xn, xyz[...,1]/Yn, xyz[...,2]/Zn
    eps, k = 216/24389, 24389/27
    f = lambda t: np.where(t>eps, np.cbrt(t), (k*t+16)/116)
    fx, fy, fz = f(x), f(y), f(z)
    L = 116*fy-16; a = 500*(fx-fy); b = 200*(fy-fz)
    return np.stack([L,a,b], -1).astype(np.float32)

def deltaE2000(lab1, lab2):
    L1,a1,b1 = lab1[...,0],lab1[...,1],lab1[...,2]
    L2,a2,b2 = lab2[...,0],lab2[...,1],lab2[...,2]
    kL=kC=kH=1.0
    C1 = np.sqrt(a1*a1 + b1*b1); C2 = np.sqrt(a2*a2 + b2*b2)
    Cm = 0.5*(C1+C2)
    G = 0.5*(1 - np.sqrt((Cm**7)/((Cm**7)+(25**7))))
    a1p = (1+G)*a1; a2p=(1+G)*a2
    C1p = np.sqrt(a1p*a1p + b1*b1); C2p=np.sqrt(a2p*a2p + b2*b2)
    h1p = np.degrees(np.arctan2(b1, a1p))%360.0
    h2p = np.degrees(np.arctan2(b2, a2p))%360.0
    dLp = L2-L1; dCp = C2p-C1p
    dhp = h2p-h1p; dhp = np.where(dhp>180, dhp-360, dhp); dhp = np.where(dhp<-180, dhp+360, dhp)
    dHp = 2*np.sqrt(C1p*C2p)*np.sin(np.radians(dhp)/2)
    Lpm = 0.5*(L1+L2); Cpm = 0.5*(C1p+C2p)
    hp_sum = h1p+h2p
    Hpm = np.where(np.abs(h1p-h2p)>180, (hp_sum+360)/2, hp_sum/2)
    T = 1 - 0.17*np.cos(np.radians(Hpm-30)) + 0.24*np.cos(np.radians(2*Hpm)) 
          + 0.32*np.cos(np.radians(3*Hpm+6)) - 0.20*np.cos(np.radians(4*Hpm-63))
    Sl = 1 + (0.015*(Lpm-50)**2)/np.sqrt(20+(Lpm-50)**2)
    Sc = 1 + 0.045*Cpm; Sh = 1 + 0.015*Cpm*T
    Rt = -2*np.sqrt((Cpm**7)/((Cpm**7)+(25**7))) * np.sin(np.radians(60*np.exp(-((Hpm-275)/25)**2)))
    dE = np.sqrt((dLp/(kL*Sl))**2 + (dCp/(kC*Sc))**2 + (dHp/(kH*Sh))**2 + Rt*(dCp/(kC*Sc))*(dHp/(kH*Sh)))
    return dE.astype(np.float32)

# ---- 指标 ----
def deltaL_rel(L1, L2, mask=None):
    r = np.abs(L1-L2)/(np.abs(L2)+1e-6)
    return p95(r[mask]) if mask is not None else p95(r)

def banding_score(gray):
    d2x = gray[:,2:]-2*gray[:,1:-1]+gray[:,:-2]
    d2y = gray[2:,:]-2*gray[1:-1,:]+gray[:-2,:]
    return float(np.mean(np.abs(d2x))) + float(np.mean(np.abs(d2y)))

def blockiness_index(gray):
    H,W = gray.shape
    v = np.mean(np.abs(gray[:,7::8]-gray[:,6::8]))
    h = np.mean(np.abs(gray[7::8,:]-gray[6::8,:]))
    vin = np.mean(np.abs(gray[:,4::8]-gray[:,3::8]))
    hin = np.mean(np.abs(gray[4::8,:]-gray[3::8,:]))
    return float((v+h)/(vin+hin+1e-6))

def hist_rmse_linear(rgbA, rgbB, bins=64, mask=None):
    la = 0.2126*rgbA[...,0] + 0.7152*rgbA[...,1] + 0.0722*rgbA[...,2]
    lb = 0.2126*rgbB[...,0] + 0.7152*rgbB[...,1] + 0.0722*rgbB[...,2]
    if mask is not None: la, lb = la[mask], lb[mask]
    ha,_ = np.histogram(la, bins=bins, range=(0,1), density=True)
    hb,_ = np.histogram(lb, bins=bins, range=(0,1), density=True)
    return float(np.sqrt(np.mean((ha-hb)**2)))

def eval_pair(sdr_ref_srgb, sdr_low_srgb, roi_skin=None, roi_gray=None, roi_sky=None):
    # 输入范围 [0,1] sRGB
    linA, linB = srgb_to_linear(sdr_ref_srgb), srgb_to_linear(sdr_low_srgb)
    L1 = 0.2126*linA[...,0] + 0.7152*linA[...,1] + 0.0722*linA[...,2]
    L2 = 0.2126*linB[...,0] + 0.7152*linB[...,1] + 0.0722*linB[...,2]
    labA, labB = xyz_to_lab(rgb_to_xyz(linA)), xyz_to_lab(rgb_to_xyz(linB))
    dE = deltaE2000(labA, labB)
    dE_skin = p95(dE[roi_skin]) if roi_skin is not None else p95(dE)
    # 色相角差（Lab）
    hA = (np.degrees(np.arctan2(labA[...,2], labA[...,1]))%360)
    hB = (np.degrees(np.arctan2(labB[...,2], labB[...,1]))%360)
    dh = hB-hA; dh = np.where(dh>180, dh-360, dh); dh = np.where(dh<-180, dh+360, dh)
    dHue_skin = p95(np.abs(dh[roi_skin])) if roi_skin is not None else p95(np.abs(dh))
    # ΔL_rel
    dL_gray = deltaL_rel(L1, L2, mask=roi_gray) if roi_gray is not None else deltaL_rel(L1, L2)
    # Banding/Blockiness（天空 ROI）
    sky_mask = roi_sky if roi_sky is not None else np.ones(L1.shape, bool)
    bs = banding_score(L2[sky_mask].reshape(-1, int(np.sqrt(sky_mask.sum()))))
    bi = blockiness_index((L2*255).astype(np.uint8))
    # 直方图 RMSE
    rmse_all = hist_rmse_linear(linA, linB, bins=64)
    return {
        "dE00_skin_P95": dE_skin,
        "dHue_skin_P95": dHue_skin,
        "deltaL_gray_P95": dL_gray,
        "BandingScore": bs,
        "Blockiness": bi,
        "HistRMSE_all": rmse_all
    }

说明：脚本假设你已将低端机输出与参考 SDR 对齐到同尺寸，并准备好 ROI 掩码（roi_skin/roi_gray/roi_sky）。若没有 ROI，可先用阈值法生成（人像用 YCbCr 范围；天空用高亮+低纹理阈值）。

5.4 PASS/FAIL 判定（示例）


thr = {
  "dE00_skin_P95": 3.0,
  "dHue_skin_P95": 3.5,
  "deltaL_gray_P95": 0.03,
  "BandingScore": 0.30,
  "Blockiness": 1.60,
  "HistRMSE_all": 0.02
}
def pass_fail(m):
    bad = {k:(m[k],thr[k]) for k in thr if ((m[k] > thr[k]) if k!="SSIM" else (m[k] < thr[k]))}
    return "PASS" if not bad else f"FAIL: {bad}"

5.5 评测流程（Mermaid）


flowchart TD
  A[参考机 SDR 基准导出] --> B[低端机降级渲染输出]
  B --> C[尺寸/对齐统一]
  C --> D[ROI 生成：肤/灰/天/边缘/阴影]
  D --> E[指标计算：ΔE/Δh/ΔL/Banding/Blockiness/RMSE]
  E --> F{阈值通过?}
  F -- 否 --> G[回溯：抖动/对比/HueLock/USM 参数]
  F -- 是 --> H[归档与回归基线]

5.6 轻量 A/B 主观对齐

每个版本至少 30–50 张样本，15 人参与二选一评分（更接近参考）。与客观指标不一致时，以失败样本回归为准，微调 LUT/roll-off/抖动强度。

6. 兼容性与回退策略（探测 → 降级 → 导出/分享）

6.1 能力探测与管线选择


// Kotlin (API 23+ 兼容写法，面向低端机)
object DeviceCapability {

    /** 是否具备可用的 HDR 显示能力（HDR10/HLG/DV 任一） */
    fun hasHdrDisplay(context: Context): Boolean = try {
        val dm = context.getSystemService(Context.DISPLAY_SERVICE) as DisplayManager
        val disp = dm.displays.firstOrNull() ?: return false
        val caps = disp.hdrCapabilities ?: return false
        val types = caps.supportedHdrTypes
        types?.any {
            it == Display.HdrCapabilities.HDR_TYPE_HDR10 ||
            it == Display.HdrCapabilities.HDR_TYPE_HLG ||
            it == Display.HdrCapabilities.HDR_TYPE_DOLBY_VISION
        } ?: false
    } catch (_: Throwable) { false }

    /** 平台是否稳定支持 Ultra HDR (JPEG_R) 解码；失败一律视为不支持 */
    fun canDecodeUltraHdr(context: Context, uri: Uri): Boolean = try {
        val src = ImageDecoder.createSource(context.contentResolver, uri)
        ImageDecoder.decodeBitmap(src) { dec, _, _ ->
            dec.allocator = ImageDecoder.ALLOCATOR_HARDWARE
            dec.setOnPartialImageListener { false }
        }.config == Bitmap.Config.RGBA_F16
    } catch (_: Throwable) { false }

    /** 系统是否已经对该内容做了 HDR→SDR 合成（避免应用层再做一次映射） */
    fun systemTonemaps(): Boolean {
        // 多厂差异较大，这里以保守开关控制；线上以远程配置灰度调参
        return true // 默认认为系统可能做了映射，应用内需探测并避免重复
    }
}

选择逻辑（流程图）


flowchart TD
  A[读取媒体] --> B{canDecodeUltraHdr?}
  B -- 否 --> C[解码为 SDR 基底]
  B -- 是 --> D{hasHdrDisplay?}
  D -- 否 --> E[线性重建或稳定近似→单次映射→sRGB]
  D -- 是 --> F{systemTonemaps?}
  F -- 是 --> G[仅色域与 Hue/Sat 保护]
  F -- 否 --> H[线性重建→单次映射]
  C --> I[渲染/导出/分享]
  E --> I
  G --> I
  H --> I

6.2 安全降级与异常兜底

解码异常、增益图不可用、内存压力：立即走高质量 SDR（统一 LUT 曲线），同时写入日志（异常类型、文件名、时间）。二次映射风险：检测到系统已做 HDR→SDR（如相册进程或系统合成），应用内不再做 Tone Mapping，仅保留色域转换与肤色/高光保护。瓦片化失败或帧耗时超阈：自动切换到更小瓦片/更低分辨率并记录一次告警。

可执行降级封装


data class FallbackDecision(
    val useSdrOnly: Boolean,
    val useApproxCurve: Boolean,
    val disableAppTone: Boolean
)

fun decideFallback(ctx: Context, uri: Uri): FallbackDecision {
    val canHdr = DeviceCapability.canDecodeUltraHdr(ctx, uri)
    val hasHdrDisp = DeviceCapability.hasHdrDisplay(ctx)
    val sysTone = DeviceCapability.systemTonemaps()
    return when {
        !canHdr -> FallbackDecision(useSdrOnly = true, useApproxCurve = true, disableAppTone = false)
        canHdr && !hasHdrDisp -> FallbackDecision(useSdrOnly = false, useApproxCurve = false, disableAppTone = false)
        canHdr && hasHdrDisp && sysTone -> FallbackDecision(useSdrOnly = false, useApproxCurve = false, disableAppTone = true)
        else -> FallbackDecision(useSdrOnly = false, useApproxCurve = false, disableAppTone = false)
    }
}

6.3 导出与分享（HDR 优先，自动 SDR 备份）

优先导出/分享 原始 JPEG_R；若目标通道（Intent 接收方）在白/灰名单中被判定不保留 HDR，则附带同曲线 SDR 副本。文件命名：IMG_xxx_UHDR.jpg 与 IMG_xxx_SDR.jpg；分享时优先放 UHDR，SDR 作为 ClipData 第二项。回执记录：收集接收方包名与结果（是否被二次压缩/去元数据），维护能力表。


fun shareWithFallback(context: Context, uhdr: Uri, sdr: Uri, target: String? = null) {
    val clip = ClipData.newUri(context.contentResolver, "UltraHDR", uhdr).apply {
        addItem(ClipData.Item(sdr))
    }
    val intent = Intent(Intent.ACTION_SEND).apply {
        type = "image/jpeg"
        putExtra(Intent.EXTRA_STREAM, uhdr)
        clipData = clip
        addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
        target?.let { setPackage(it) }
    }
    context.startActivity(Intent.createChooser(intent, "Share"))
}

7. 自动化回归与灰度（指标 → Gate → 发布/回滚）

7.1 指标采集与埋点


data class SdrEvalMetrics(
    val deltaE_skin_P95: Double,
    val deltaHue_skin_P95: Double,
    val deltaL_gray_P95: Double,
    val banding: Double,
    val blockiness: Double,
    val histRmse: Double,
    val jankPct: Double,
    val peakMemMB: Int,
    val build: String,
    val device: String
)

object MetricsSink {
    fun log(m: SdrEvalMetrics) {
        android.util.Log.i("SDR_EVAL", com.google.gson.Gson().toJson(m))
        // 可选：写入文件/上传
    }
}

关键指标阈值（与前文一致）

指标	阈值
ΔE00（肤色 P95）	≤ 3.0
Δh°（肤色 P95）	≤ 3.5°
ΔL_rel（灰 P95）	≤ 3%
BandingScore	≤ 0.30
Blockiness	≤ 1.60
直方图 RMSE	≤ 2%
掉帧率（详情滚动）	≤ 2%
峰值内存	≤ 350 MB

7.2 离线 Gate（Python，可直接跑）


# gate_sdr_lowend.py
import json, sys

THR = {
  "deltaE_skin_P95": 3.0,
  "deltaHue_skin_P95": 3.5,
  "deltaL_gray_P95": 0.03,
  "banding": 0.30,
  "blockiness": 1.60,
  "histRmse": 0.02,
  "jankPct": 0.02,
  "peakMemMB": 350
}

def main(path):
    m = json.load(open(path, "r"))
    viol = []
    for k,v in m.items():
        if k not in THR: continue
        if k == "peakMemMB":
            bad = v > THR[k]
        else:
            bad = v > THR[k]
        if bad: viol.append((k, v, THR[k]))
    if viol:
        for k,v,t in viol:
            print(f"[GATE] {k}={v} > {t}")
        sys.exit(2)
    print("[GATE] PASS")

if __name__ == "__main__":
    main(sys.argv[1])

7.3 Macrobenchmark（端侧稳定性）


@RunWith(AndroidJUnit4::class)
class LowEndSdrBenchmark {
  @get:Rule val rule = MacrobenchmarkRule()

  @Test fun galleryScrollStable() = rule.measureRepeated(
    packageName = "com.example.gallery",
    metrics = listOf(FrameTimingMetric(), MemoryCounters()),
    iterations = 5,
    setupBlock = { pressHome(); startActivityAndWait() }
  ) {
    // 模拟瀑布流滑动（L2 缩略 + 某些详情打开）
    device.swipe(device.displayWidth/2, device.displayHeight*3/4,
                 device.displayWidth/2, device.displayHeight/4, 80)
    device.waitForIdle()
  }
}

7.4 灰度与回滚（Mermaid）

远程配置（YAML 示例）


version: "LowEnd-SDR-1.2"
feature_flags:
  sdr_only_on_lowend: true
  system_tone_guard: true
tone_map:
  lut: "tm_lut_v3.bin"
  mid_gray: 0.18
  roll_start: 0.75
  roll_end: 1.15
hue_sat:
  hue_lock_deg: 3.5
  sat_alpha: 0.25
  knee: 0.80
dither:
  blue_noise_lsb: 0.5
perf_limits:
  peak_mem_mb: 350
  detail_jank_pct: 0.02

回滚路径

一键开启 sdr_only_on_lowend=true。退回上版 LUT/参数（tm_lut_v2.bin）。触发率异常时临时将 blue_noise_lsb 提升至 0.6，降低 Banding。

8. 典型案例（定位 → 动作 → 复测）

8.1 案例 A：天空渐变带状明显（低码率基底）

现象：天空大面积色带，BandingScore ≈ 0.41，直方图出现尖峰。定位：SDR 基底 JPEG 质量不高 + 8bit 量化台阶暴露。动作：启用蓝噪抖动 0.5 LSB；Tone LUT 高光段更平缓 roll-off；局部对比 −15%。复测：BandingScore → 0.24，直方图 RMSE 1.6%，ΔE00 天空 2.2，PASS。

8.2 案例 B：人像肤色偏绿（通道偏差 + 高光塑料感）

现象：Δh°（肤色） ≈ 4.8°，ΔC* ≈ 4.6。定位：通道偏差堆叠 + 高光过饱和。动作：hue_lock_deg: 3.0；sat_alpha: 0.25，knee: 0.80；通道收束 ±6%。复测：Δh° → 2.9°，ΔC* → 3.2，ΔE00 肤色 2.5，PASS。

8.3 案例 C：亮度台阶（系统已做映射，又在应用内映射）

现象：ΔL_rel（灰）≈ 5.5%，高光层次被压两次。定位：系统合成已执行 HDR→SDR，应用内再次做 Tone。动作：检测 systemTonemaps=true → 禁用应用层 Tone，仅做色域与 Hue/Sat 保护。复测：ΔL_rel → 2.1%，Hist RMSE 1.7%，PASS。

8.4 案例 D：详情页卡顿与峰值内存过高

现象：详情滚动掉帧 3.8%，峰值内存 ~ 420 MB。定位：全幅 F16 + 大瓦片并发过高。动作：改为 ARGB_8888 管线；瓦片 640→512；并发从 3→2；L2 命中率优化到 92%。复测：掉帧 1.6%，峰值内存 298 MB，PASS。

个人简介
$低端机 Ultra HDR（JPEG\_R）降级渲染与 SDR 一致性$
作者简介：全栈研发，具备端到端系统落地能力，专注人工智能领域。
个人主页：观熵
个人邮箱：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 管理。每一篇都不讲概念空话，只做实战经验沉淀，让你一步步成为真正的模型运营专家。