563 lines
28 KiB
Python
563 lines
28 KiB
Python
# -*- coding: utf-8 -*-
|
||
"""把 S5 41mm(q63) 的 `pressure/measure/Measuring1..100.bin`（480x480）逐帧等长写进
|
||
S5 eSIM(p62lte) `vela_health.bin` 的 `pressure/measure/Measuring1..119.bin`（464x464 I8+RLE）。
|
||
|
||
硬约束（为什么必须"逐字节等长"）
|
||
--------------------------------
|
||
ROMFS 里 `next` / `spec` 全是**绝对偏移**，文件数据又紧随 inode 之后；任何一条负载
|
||
长度变化 1 字节，后面所有文件的偏移就整体平移 → 分区报废。所以：
|
||
|
||
12 B 头 + 12 B 压缩头 + csize 必须 == 原槽位长度
|
||
csize 原样沿用（解码器按 csize 读），usize 原样沿用（= 1024 + 464*464 = 216321）
|
||
|
||
四步流水线
|
||
----------
|
||
1) 解码 q63 帧 → 缩放到 464x464（**缩小**，LANCZOS）
|
||
2) 暗部归零：q63 帧的"黑"其实是一条均匀的 #1a1a1a(26,26,26) 底噪 + 抖动噪声，
|
||
实测占 68% 的像素、熵极高（256 色几乎全糊在暗部，不处理时 RLE 压不动：172 KB）。
|
||
阈值以下的像素一律置 0，背景塌成整行单游程，体积掉到 1/4（~45 KB）。
|
||
3) 量化：按一条**单调质量阶梯**（缩放比例 + 颜色数一起动）挑能塞进 csize 的最高档。
|
||
4) LVGL RLE 压缩 → 先补「重复 N 次」把解码长度做到**正好 usize**，
|
||
再用 `pad_rle_safe` 的合法空指令（00 00 / 80）补齐到 csize。
|
||
|
||
为什么用"质量单参数"而不是逐槽各自最优
|
||
--------------------------------------
|
||
槽位预算从 4.5 KB 到 196 KB 差 40 倍。逐帧各自最优会让相邻帧出现
|
||
「2 色 x0.32」跳到「4 色 x0.80」这种忽大忽小（S4e 那版踩过）。这里把
|
||
(颜色数, 缩放) 绑成一个连续量，先算每槽能撑住的最大档，再从峰值向两侧取
|
||
「运行最小值」—— 曲线单峰且平滑，画面尺寸/色阶随预算连续变化。
|
||
|
||
产出
|
||
----
|
||
.work/anim/vela_health_anim.bin 改后镜像（长度 == 原镜像）
|
||
.work/anim/manifest.json 逐条清单（偏移/长度/映射/降级/保留）
|
||
"""
|
||
import os, sys, json, struct, shutil, hashlib, time
|
||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||
from paths import (PROJ, INPUTS, WORK, TARGET_IMAGE, SOURCE_IMAGE, TARGET_VOLUME,
|
||
DIRP, FACE_W, FACE_H)
|
||
from romfs import Romfs
|
||
import lvgl_bin as L
|
||
from PIL import Image
|
||
import numpy as np
|
||
|
||
OUTDIR = os.path.join(WORK, 'anim')
|
||
PATCHED = os.path.join(OUTDIR, 'vela_health_anim.bin')
|
||
# 设备端解码器要求流解出的字节数**正好** == 头里的 usize。原厂 119 条全是 216321，
|
||
# 比"调色板 + 像素"多 1 字节（解码器只用到前 1024 + 464*464 字节，多出来的 1 字节
|
||
# 落在行外、被 `y < h` 挡掉，所以既安全又是原厂行为）。实测值由 build() 从镜像里读出来，
|
||
# 不在这儿写常量 —— 写错过一次（写成 216320）就被下面的断言当场抓住。
|
||
USIZE = 1024 + FACE_W * FACE_H # 216320：调色板 + 像素；真实值以镜像为准
|
||
TAIL_EXTRA = 1 # 期望的原厂尾部额外字节数
|
||
USIZE_EXTRA = TAIL_EXTRA # 实际值由 build() 从镜像读出来后覆盖
|
||
|
||
# ------------------------------------------------------------------ 暗部归零
|
||
# q63 帧的底噪是 #1a1a1a(26)，球体最暗的实体像素也 >100。取 40 吃掉整片底噪与抖动，
|
||
# 又不动球体本体；56 作为第二档兜底（更狠，留给塞不下的槽位）。
|
||
DARK_LEVELS = (40, 56)
|
||
|
||
# ------------------------------------------------------------------ 固定调色板（低预算兜底）
|
||
# 到 8 色以下时"重新聚类"会把仅剩的颜色浪费在底噪残渣上、球体反而变花；
|
||
# 改用这几套手工调色板（索引 0 一定是黑），画面干净、也更好压。
|
||
FIXED_PALETTES = {
|
||
2: [(0, 0, 0), (92, 132, 255)],
|
||
3: [(0, 0, 0), (40, 60, 190), (120, 190, 255)],
|
||
4: [(0, 0, 0), (28, 40, 150), (70, 120, 245), (140, 220, 210)],
|
||
6: [(0, 0, 0), (18, 26, 110), (44, 66, 200), (80, 130, 250),
|
||
(140, 200, 245), (150, 220, 160)],
|
||
8: [(0, 0, 0), (12, 18, 80), (26, 38, 140), (46, 70, 195), (72, 110, 240),
|
||
(110, 165, 252), (165, 215, 250), (150, 222, 168)],
|
||
}
|
||
|
||
# ------------------------------------------------------------------ 质量阶梯
|
||
# 从「最好」到「最省」单调排列：(缩放, 颜色数, 固定调色板色数|None)
|
||
LADDER = [
|
||
(1.00, 256, None), (1.00, 192, None), (1.00, 128, None), (1.00, 96, None),
|
||
(0.95, 96, None), (0.95, 64, None), (0.90, 64, None),
|
||
(0.85, 64, None), (0.85, 48, None), (0.80, 48, None),
|
||
(0.75, 48, None), (0.75, 32, None), (0.70, 32, None),
|
||
(0.65, 32, None), (0.65, 24, None), (0.60, 24, None),
|
||
(0.55, 24, None), (0.55, 16, None), (0.50, 16, None),
|
||
(0.45, 16, None), (0.45, 12, None), (0.40, 12, None),
|
||
(0.35, 12, None), (0.35, 8, 8), (0.30, 8, 8),
|
||
(0.26, 6, 6), (0.22, 6, 6), (0.19, 4, 4), (0.16, 4, 4),
|
||
(0.13, 3, 3), (0.11, 3, 3), (0.09, 2, 2), (0.07, 2, 2), (0.05, 2, 2),
|
||
]
|
||
CI_KEEP = len(LADDER) # 哨兵：连最省档都塞不下
|
||
# 平滑之后允许比目标档**大**多少缩放：0 表示只许更小。留一点余量是为了让球体尽量顶到
|
||
# 预算上限，同时不给相邻帧制造肉眼可见的尺寸跳变（每档缩放差约 0.05）。
|
||
SCALE_SLACK = 0.02
|
||
|
||
|
||
def num_of(path):
|
||
return int(path.rsplit('Measuring', 1)[-1].replace('.bin', ''))
|
||
|
||
|
||
def collect(rom):
|
||
d = {}
|
||
for p, i in rom.entries():
|
||
if i.type == 1 or not p.startswith(DIRP) or not p.endswith('.bin') or i.size == 0:
|
||
continue
|
||
d[num_of(p)] = (p, i, rom.read(i))
|
||
return d
|
||
|
||
|
||
# ------------------------------------------------------------------ 编码原语
|
||
def palette_bytes(cols):
|
||
"""1024 B BGRA；索引 0 一定是黑，没用的条目留 0 —— 调色板本身也好压。"""
|
||
out = bytearray(1024)
|
||
for k, (r, g, b) in enumerate(cols[:256]):
|
||
out[k * 4:k * 4 + 4] = bytes((b, g, r, 255))
|
||
return bytes(out)
|
||
|
||
|
||
def kill_dark(img, dark):
|
||
a = np.asarray(img.convert('RGB')).copy()
|
||
a[a.max(axis=2) < dark] = 0
|
||
return Image.fromarray(a, 'RGB')
|
||
|
||
|
||
def scale_image(img, sc):
|
||
if sc >= 0.999:
|
||
return img
|
||
s = max(4, int(round(FACE_W * sc)))
|
||
small = img.convert('RGBA').resize((s, s), Image.LANCZOS)
|
||
cv = Image.new('RGBA', (FACE_W, FACE_H), (0, 0, 0, 255))
|
||
cv.paste(small, ((FACE_W - s) // 2, (FACE_H - s) // 2))
|
||
return cv
|
||
|
||
|
||
def quantize_raw(rgb, ncol, fixed):
|
||
"""-> 1024 B 调色板 + w*h 个索引（LVGL I8 的裸像素流）。
|
||
|
||
自己实现量化，不再借 PIL 的调色板 API —— 这里踩过两个坑，留作警钟：
|
||
① 为了"保证索引 0 是黑"，先把图贴到 (W+8)x(H+8) 黑画布上再 quantize，
|
||
然后 `q.tobytes()[:W*H]` 取像素。但 q 是 472 宽的，按 464 宽读就"每行错 8 列"，
|
||
整幅图被剪成斜条纹 —— RLE 流完全正确、解出来也和"量化结果"逐点一致，
|
||
只有拿"量化结果的形状"去比**源图**才抓得住（见 silhouette()）。
|
||
② 改成"循环移位调色板 + convert()/paste()"更糟：`quantize(palette=...)` 会把图重新
|
||
合并成它自己算出来的调色板，`paste()` 又只搬调色板，于是 64 色时整幅图变纯黑。
|
||
与其猜 PIL 的语义，不如把量化写成几行明确的 numpy。
|
||
|
||
现在：黑单独占索引 0（背景因此塌成单游程），其余 ncol-1 个颜色在**非黑像素**上做
|
||
加权 k-means（按出现次数加权，梯度才不会被子像素级的近似黑拖偏）。固定迭代次数 => 确定。
|
||
"""
|
||
src = np.asarray(rgb if rgb.mode == 'RGB' else rgb.convert('RGB'))
|
||
return quantize_arr(src, ncol, fixed)
|
||
|
||
|
||
def quantize_arr(src, ncol, fixed, cache=None, ckey=None):
|
||
"""量化主体。src 是 (H,W,3) uint8；ckey 用来复用同一帧的颜色表。
|
||
|
||
性能关键（第一版在这里把机器跑爆过内存 1.7 GB / CPU 卡死）：
|
||
* 源图有 1.5~2 万个不同颜色、21.5 万个像素。**质心只在"不同颜色"上算**，
|
||
绝不在 21.5 万像素上做 (N, K, 3) 的距离广播
|
||
（那一步就是 N=215296 x K=255 的模式，一个临时数组 1.6 GB）。
|
||
* 像素 -> 索引 走一张**粗查色立方** LUT：先把 RGB 量化到 step 网格
|
||
（step=4 时 64³ = 262144 个格子），只对这 26 万个格子算一次最近邻，
|
||
再让 21.5 万像素直接查表。代价是"近似最近邻"（最大偏 step/2 = 2 个色阶），
|
||
对 8 位调色板完全够用。
|
||
"""
|
||
H, W = src.shape[:2]
|
||
if cache is None:
|
||
cache = {}
|
||
ent = cache.get(ckey)
|
||
if ent is None:
|
||
flat = src.reshape(-1, 3)
|
||
bg = flat.max(axis=1) == 0
|
||
upix, inv = np.unique(flat, axis=0, return_inverse=True)
|
||
upix = np.ascontiguousarray(upix, dtype=np.int32)
|
||
inv = inv.reshape(-1).astype(np.int32)
|
||
fg = np.nonzero(upix.max(axis=1) > 0)[0]
|
||
ent = (upix, inv, fg, bg, flat.shape[0])
|
||
cache[ckey] = ent
|
||
upix, inv, fg, bg, npix = ent
|
||
if len(fg) == 0:
|
||
return palette_bytes([(0, 0, 0)]) + bytes(npix)
|
||
if fixed is not None:
|
||
cols = FIXED_PALETTES[fixed]
|
||
out = _lut_index(upix, cols)[inv]
|
||
out[bg] = 0
|
||
# 背景必须落在索引 0（黑），这样 RLE 才是一条单游程
|
||
if cols[0] != (0, 0, 0):
|
||
raise ValueError('固定调色板的索引 0 必须是黑')
|
||
return palette_bytes(cols) + out.tobytes()
|
||
k = max(1, min(255, int(ncol) - 1))
|
||
ufg = upix[fg]
|
||
uq, cnt = np.unique(ufg, axis=0, return_counts=True)
|
||
if len(uq) <= k:
|
||
centers = uq.astype(np.float64)
|
||
else:
|
||
centers = uq[cnt.argsort()[::-1][:k]].astype(np.float64) # 出现最多的 k 色做种子
|
||
w = cnt.astype(np.float64)
|
||
K = len(centers)
|
||
for _ in range(8):
|
||
lab = _nearest_argmin(uq, centers)
|
||
new = centers.copy()
|
||
for j in range(K):
|
||
sel = lab == j
|
||
if sel.any():
|
||
ww = w[sel][:, None]
|
||
new[j] = (uq[sel] * ww).sum(axis=0) / ww.sum()
|
||
done = np.allclose(new, centers, atol=0.25)
|
||
centers = new
|
||
if done:
|
||
break
|
||
cols = [(0, 0, 0)] + [tuple(int(round(v)) for v in c) for c in centers]
|
||
out = _lut_index(upix, cols)[inv]
|
||
out[bg] = 0
|
||
return palette_bytes(cols) + out.tobytes()
|
||
|
||
|
||
def _nearest_argmin(px, cent):
|
||
"""返回每个 px 最近的 cent 下标；只用 float32（int32 的立方广播会反复申请上百 MB）。"""
|
||
a = np.asarray(px, dtype=np.float32)
|
||
c = np.asarray(cent, dtype=np.float32)
|
||
out = np.empty(len(a), dtype=np.int32)
|
||
chunk = 8192
|
||
for s in range(0, len(a), chunk):
|
||
d = ((a[s:s + chunk, None, :] - c[None, :, :]) ** 2).sum(axis=2)
|
||
out[s:s + chunk] = d.argmin(axis=1)
|
||
return out
|
||
|
||
|
||
_GRID_CACHE = {}
|
||
|
||
|
||
def _cube_grid(step):
|
||
"""粗查色立方的网格代表色（只算一次，全局缓存）。
|
||
|
||
展平顺序是 idx = r*(bins*bins) + g*bins + b —— 与 `meshgrid(indexing='ij')`
|
||
+ `reshape(-1,3)` 完全一致，所以立方体可以直接按这个公式索引。
|
||
★ 轴序写错会静默换色：查表必须用 (R,G,B) 顺序，写成 (B,G,R) 颜色就全串了。
|
||
"""
|
||
g = _GRID_CACHE.get(step)
|
||
if g is None:
|
||
bins = 256 // step + 1
|
||
ax = np.arange(bins, dtype=np.int32) * step
|
||
grid = np.stack(np.meshgrid(ax, ax, ax, indexing='ij'), axis=-1).reshape(-1, 3)
|
||
_GRID_CACHE[step] = (grid, bins)
|
||
return _GRID_CACHE[step]
|
||
return g
|
||
|
||
|
||
def _lut_index(px, cols):
|
||
"""像素 -> 最近调色板项，走粗查色立方 LUT。
|
||
|
||
step=8 → 33³ = 35937 个格子，单通道最大偏差 step/2 = 4 个色阶；
|
||
对这些低对比度、本来就带抖动的画面完全够用（step=4 的 26 万格子慢 8 倍）。
|
||
用 float32 算距离：int32 的 (35937, 256, 3) 中间数组会反复申请 ~100 MB，
|
||
是之前把内存跑到 2.6 GB、整体跑十几分钟的元凶。
|
||
"""
|
||
grid, bins = _cube_grid(8)
|
||
pal = np.asarray(cols, dtype=np.float32)
|
||
best = np.empty(len(grid), dtype=np.uint8)
|
||
gn = grid.astype(np.float32)
|
||
chunk = 8192
|
||
for s in range(0, len(grid), chunk):
|
||
a = gn[s:s + chunk]
|
||
d = ((a[:, None, :] - pal[None, :, :]) ** 2).sum(axis=2)
|
||
best[s:s + chunk] = d.argmin(axis=1).astype(np.uint8)
|
||
q = np.clip((px.astype(np.int32) + 4) >> 3, 0, bins - 1)
|
||
flat = (q[:, 0] * bins + q[:, 1]) * bins + q[:, 2]
|
||
return best[flat]
|
||
|
||
|
||
def pad_to_usize(comp, raw_len):
|
||
"""解码长度必须**正好 == usize**，否则设备端解码器直接判失败、整帧不画。
|
||
|
||
★ 本会话踩过的坑：库里 rle_compress 的输出曾比 usize 少 1 个字节（末尾少一条指令）。
|
||
这里显式补「重复 N 次」token 把长度做满。补出来的余数可能是奇数（原厂 usize 就是
|
||
1024+464*464+1 = 216321，比"调色板+像素"多 1），所以最后允许一条「重复 1 次」的
|
||
2 字节指令；`00 00`（重复 0 次）也是合法空指令。
|
||
"""
|
||
short = USIZE - raw_len
|
||
if short <= 0:
|
||
return comp
|
||
ex = bytearray()
|
||
while short >= 2:
|
||
k = min(short, 127)
|
||
ex += bytes((k, 0))
|
||
short -= k
|
||
if short == 1:
|
||
ex += bytes((1, 0))
|
||
return comp + bytes(ex)
|
||
|
||
|
||
def encode_cell(img, cell, qcache=None, qkey=None):
|
||
"""(缩放, 颜色数, 固定) -> (RLE 流 bytes, 裸像素流 bytes)。不含 24 B 头。
|
||
|
||
qkey 要带上**缩放比例**：同一帧的不同缩放是不同的数组，
|
||
★ 少了这个维度会让"不同颜色的表"永远命中不了缓存，每次都在 21.5 万像素上重算
|
||
（第一版就是这样把内存跑到 1.7 GB、CPU 卡死的）。
|
||
"""
|
||
sc, ncol, fixed = cell
|
||
rgb = scale_image(img, sc).convert('RGB')
|
||
raw = quantize_arr(np.asarray(rgb), ncol, fixed, qcache,
|
||
(qkey, sc) if qkey is not None else None)
|
||
return pad_to_usize(L.rle_compress(raw), len(raw)), raw
|
||
|
||
|
||
def raw_to_rgb(raw):
|
||
"""把裸像素流还原成 RGB 图（用于"解出来的像素 == 量化结果"这条自证）。"""
|
||
pal = bytearray(768)
|
||
for i in range(256):
|
||
pal[i * 3 + 0] = raw[i * 4 + 2]
|
||
pal[i * 3 + 1] = raw[i * 4 + 1]
|
||
pal[i * 3 + 2] = raw[i * 4 + 0]
|
||
im = Image.frombytes('P', (FACE_W, FACE_H), raw[1024:1024 + FACE_W * FACE_H])
|
||
im.putpalette(bytes(pal))
|
||
return im.convert('RGB')
|
||
|
||
|
||
def silhouette(raw):
|
||
"""(非黑像素数, bbox) —— 用来挡住"字节完全自洽、内容却整片错位"这类 bug。
|
||
|
||
★ 这里就是因为只比字节、不比形状，差点放过去一版"斜条纹"图：
|
||
当时 quantize 是按 472 宽取的像素，读成 464 宽 → 每行错 8 列 → 整幅图被剪成斜条纹。
|
||
RLE 流本身完全正确、解出来的像素也和"量化结果"逐点一致，所以只有把
|
||
"量化结果"再和**源图**比形状才抓得住。下面这个函数就是干这个的。
|
||
"""
|
||
a = np.asarray(raw_to_rgb(raw))
|
||
m = a.max(axis=2) > 24
|
||
n = int(m.sum())
|
||
if not n:
|
||
return 0, None
|
||
ys, xs = np.nonzero(m)
|
||
return n, (int(ys.min()), int(xs.min()), int(ys.max()), int(xs.max()))
|
||
|
||
|
||
# ------------------------------------------------------------------ 主流程
|
||
def build():
|
||
t0 = time.time()
|
||
global USIZE, USIZE_EXTRA
|
||
os.makedirs(OUTDIR, exist_ok=True)
|
||
stock, src = Romfs(TARGET_IMAGE), Romfs(SOURCE_IMAGE)
|
||
if stock.volume != TARGET_VOLUME:
|
||
raise SystemExit('目标镜像卷名是 %r，期望 %r —— 拿错分区了？'
|
||
% (stock.volume, TARGET_VOLUME))
|
||
slots, srcs = collect(stock), collect(src)
|
||
tl, sl = sorted(slots), sorted(srcs)
|
||
h0 = L.parse_header(slots[tl[0]][2])
|
||
print('目标槽位 %d 个（Measuring%d..Measuring%d，合计 %.2f MB）' % (
|
||
len(tl), tl[0], tl[-1], sum(len(slots[n][2]) for n in tl) / 1048576))
|
||
print('源帧 %d 个（Measuring%d..Measuring%d，合计 %.2f MB）' % (
|
||
len(sl), sl[0], sl[-1], sum(len(srcs[n][2]) for n in sl) / 1048576))
|
||
print('槽位格式 %dx%d cf=0x%02x flags=0x%02x stride=%d' % (
|
||
h0['w'], h0['h'], h0['cf'], h0['flags'], h0['stride']))
|
||
assert (h0['w'], h0['h']) == (FACE_W, FACE_H), '槽位不是 %dx%d' % (FACE_W, FACE_H)
|
||
assert (h0['cf'], h0['flags']) == (0x0a, 0x08), '槽位不是 I8 + RLE'
|
||
# ★ usize 从镜像里读出来，别写常量：原厂是 1024 + 464*464 + 1 = 216321
|
||
n_usize = {struct.unpack('<III', slots[n][2][12:24])[2] for n in tl}
|
||
print('原厂 usize 取值集合：%s' % sorted(n_usize))
|
||
assert len(n_usize) == 1, '原厂 usize 不唯一：%s' % sorted(n_usize)
|
||
USIZE = n_usize.pop()
|
||
USIZE_EXTRA = USIZE - (1024 + FACE_W * FACE_H)
|
||
print('usize = %d（= 1024 + %d*%d + %d）' % (USIZE, FACE_W, FACE_H, USIZE_EXTRA))
|
||
assert USIZE_EXTRA == TAIL_EXTRA, \
|
||
'尾部额外字节是 %d，与预期的 %d 不符 —— 先确认原厂流到底多几个字节' % (USIZE_EXTRA, TAIL_EXTRA)
|
||
# 原厂 119 条都要真的能解出正好 usize
|
||
bad_stock = [n for n in tl
|
||
if len(L.rle_decompress(slots[n][2][24:24 + struct.unpack('<III', slots[n][2][12:24])[1]],
|
||
1, None)) != USIZE]
|
||
print('原厂 %d 条解码长度 == usize：%s' % (len(tl), not bad_stock))
|
||
assert not bad_stock, '原厂就有解不出 usize 的槽位：%s' % bad_stock[:8]
|
||
|
||
# ---- 逐源帧解码 + 缩放 + 暗部归零（100 帧只做一次）----
|
||
frames = {}
|
||
for n in sl:
|
||
_, im = L.decode_lvgl_bin(srcs[n][2])
|
||
im = im.convert('RGBA').resize((FACE_W, FACE_H), Image.LANCZOS)
|
||
frames[n] = {d: kill_dark(im, d) for d in DARK_LEVELS}
|
||
print('解码 + 缩放 %d 帧：%.1fs' % (len(sl), time.time() - t0))
|
||
|
||
# 映射与 S4e 版一致：第 k 个槽位(k=0..118) <- q63 第 round(k/(119-1)*(100-1))+1 帧
|
||
def qn_for(k):
|
||
return sl[round(k / (len(tl) - 1) * (len(sl) - 1))]
|
||
|
||
cells = {} # (src_n, dark, ci) -> (comp, raw)
|
||
src_sils = {} # (src_n, dark, ci) -> (非黑像素数, bbox)
|
||
qcache = {}
|
||
|
||
def get_cell(src_n, dark, ci):
|
||
key = (src_n, dark, ci)
|
||
v = cells.get(key)
|
||
if v is None:
|
||
v = encode_cell(frames[src_n][dark], LADDER[ci], qcache, (src_n, dark))
|
||
cells[key] = v
|
||
src_sils[key] = silhouette(v[1])
|
||
return v
|
||
|
||
def fits(src_n, dark, ci, csize):
|
||
return len(get_cell(src_n, dark, ci)[0]) <= csize
|
||
|
||
# ---- 第一遍：逐槽量出「能塞进 csize 的最大阶梯档」----
|
||
caps = []
|
||
for k, n in enumerate(tl):
|
||
csize = struct.unpack('<III', slots[n][2][12:24])[1]
|
||
src_n = qn_for(k)
|
||
best = None
|
||
for dark in DARK_LEVELS:
|
||
for ci in range(len(LADDER)):
|
||
if fits(src_n, dark, ci, csize):
|
||
best = (ci, dark)
|
||
break
|
||
if best:
|
||
break
|
||
caps.append(best if best else (CI_KEEP, DARK_LEVELS[0]))
|
||
n_keep = sum(1 for c, _d in caps if c == CI_KEEP)
|
||
print('第一遍完成：%d/%d 槽位能编出 ≤ csize 的流，%d 个连最省档都不行（耗时 %.0fs）'
|
||
% (len(tl) - n_keep, len(tl), n_keep, time.time() - t0))
|
||
|
||
# ---- 平滑：从峰值向两侧取「运行最小值」----
|
||
ordered = [c for c, _d in caps]
|
||
peak = ordered.index(max(ordered))
|
||
sm = list(ordered)
|
||
for i in range(peak - 1, -1, -1):
|
||
sm[i] = min(sm[i], sm[i + 1])
|
||
for i in range(peak + 1, len(sm)):
|
||
sm[i] = min(sm[i], sm[i - 1])
|
||
jumps = [abs(sm[i + 1] - sm[i]) for i in range(len(sm) - 1)]
|
||
print('阶梯曲线（每 6 帧采样）：%s' % ' '.join(str(sm[i]) for i in range(0, len(sm), 6)))
|
||
print('相邻帧最大跳变：%d 档' % (max(jumps) if jumps else 0))
|
||
|
||
# ---- 第二遍：以平滑档位为目标，在预算里挑**画面最大**的那一档；塞不下就往更省的档退 ----
|
||
# 「挑画面最大」而不是「挑第一个能塞下的」：平滑只限制相邻帧的尺寸变化幅度，
|
||
# 不该让它浪费槽位。实测按"第一个能塞下的"走，尾部几帧会把 7~12 万字节的 csize
|
||
# 只用掉一半（全填 00 00 空指令），球体白白小一圈。
|
||
records, degrade, kept, decode_ok, stat = [], [], [], 0, []
|
||
for k, n in enumerate(tl):
|
||
path, ino, blob = slots[n]
|
||
method, csize, usize = struct.unpack('<III', blob[12:24])
|
||
src_n = qn_for(k)
|
||
start = sm[k]
|
||
# 先按档位从优到劣扫一遍，记下所有塞得下的格子，再选缩放最大/颜色最多的那个
|
||
best = None
|
||
if start < CI_KEEP:
|
||
for ci in range(start, len(LADDER)):
|
||
for dark in DARK_LEVELS:
|
||
if fits(src_n, dark, ci, csize):
|
||
# 平滑约束：缩放不能比目标档大太多（否则相邻帧会忽大忽小），
|
||
# 但可以更小；颜色数不受约束（只影响色阶，不影响尺寸）
|
||
if LADDER[ci][0] <= LADDER[start][0] + SCALE_SLACK:
|
||
sc_i, ncol_i, fx_i = LADDER[ci]
|
||
key = (sc_i, ncol_i)
|
||
if best is None or key > best[1]:
|
||
best = ((ci, dark), key)
|
||
rec_name = '%03d_%s_%d' % (len(records), path.rsplit('/', 1)[-1][:-4], n)
|
||
if best is None:
|
||
kept.append((n, csize))
|
||
records.append(dict(name=rec_name, src='measure%d' % src_n, offset=ino.data_off,
|
||
length=len(blob), data=blob, csize=csize, how='保留原厂',
|
||
ci=None, dark=None, scale=1.0, colors=0, pad=0, enc=0))
|
||
print(' !! 槽 %d（csize %d）塞不下 -> 保留原厂' % (n, csize))
|
||
continue
|
||
(ci, dark), _key = best
|
||
comp, raw = get_cell(src_n, dark, ci)
|
||
new = blob[:12] + struct.pack('<III', method, csize, usize) + L.pad_rle_safe(comp, csize)
|
||
assert len(new) == len(blob), (len(new), len(blob))
|
||
# ★ 就地自证三道：
|
||
# ① 解出来正好 usize 字节（少一字节设备端就整帧不画）
|
||
# ② 解出来的像素 == 量化结果（逐点）
|
||
# ③ 量化结果的**形状**和源图在同一量级（挡住"字节自洽但内容错位"的 bug）
|
||
# 第③条的容差：低色阶档位下球体边缘的暗像素会被并到最暗的那一档、显得略小
|
||
# （4 色/2 色时尤其明显），所以只要求非黑像素数在 ±6% 内、bbox 每边差 ≤12 像素；
|
||
# 真正"斜条纹"那种错位会让 bbox 直接铺满全画幅，这条一定抓得住。
|
||
back = L.rle_decompress(new[24:24 + csize], 1, None)
|
||
_, dec = L.decode_lvgl_bin(new)
|
||
same = dec is not None and dec.convert('RGB').tobytes() == raw_to_rgb(raw).tobytes()
|
||
src_sil = src_sils[(src_n, dark, ci)]
|
||
got_sil = silhouette(raw)
|
||
sil_ok = (src_sil[1] is not None and got_sil[1] is not None and
|
||
abs(src_sil[0] - got_sil[0]) <= 0.06 * max(1, src_sil[0]) and
|
||
max(abs(a - b) for a, b in zip(src_sil[1], got_sil[1])) <= 12)
|
||
if len(back) == usize and same and sil_ok:
|
||
decode_ok += 1
|
||
else:
|
||
print(' !! 槽 %d：解码 %d 字节（应 %d），像素一致=%s，形状合理=%s（%s vs %s）'
|
||
% (n, len(back), usize, same, sil_ok, src_sil, got_sil))
|
||
stat.append((n, csize, len(comp), csize - len(comp)))
|
||
sc, ncol, fixed = LADDER[ci]
|
||
how = ('固定%d色' % fixed if fixed is not None else '%d色' % ncol)
|
||
how += '' if sc >= 0.995 else ' 缩放%.2f' % sc
|
||
how += ' 暗部<%d' % dark
|
||
if ci > start:
|
||
degrade.append((n, csize, start, ci, how))
|
||
how += ' [平滑目标第%d档放不下，退到第%d档]' % (start, ci)
|
||
records.append(dict(name=rec_name, src='measure%d' % src_n, offset=ino.data_off,
|
||
length=len(blob), data=new, csize=csize, how=how, ci=ci,
|
||
dark=dark, scale=round(sc, 4), colors=ncol, fixed=fixed,
|
||
pad=csize - len(comp), enc=len(comp), target_ci=start))
|
||
|
||
# ---- 写出镜像 + 清单 ----
|
||
shutil.copyfile(TARGET_IMAGE, PATCHED)
|
||
with open(PATCHED, 'r+b') as f:
|
||
for r in records:
|
||
f.seek(r['offset'])
|
||
f.write(r['data'])
|
||
manifest = dict(
|
||
device='Xiaomi Watch S5 eSIM 46mm (p62lte)',
|
||
partition='vela_health.bin volume=health device node=/dev/health',
|
||
source='Xiaomi Watch S5 41mm (q63, v4.101.020) pressure/measure frames',
|
||
target_dir=DIRP,
|
||
mapping='第 k 个槽位(k=1..%d) <- q63 第 round((k-1)/(%d-1)*(%d-1))+1 帧(1..%d)'
|
||
% (len(tl), len(tl), len(sl), len(sl)),
|
||
face_wh=[FACE_W, FACE_H], slot_count=len(tl), source_count=len(sl), usize=USIZE,
|
||
image_sha256=hashlib.sha256(stock.data).hexdigest(),
|
||
ladder=[dict(ci=i, scale=c[0], colors=c[1], fixed=c[2]) for i, c in enumerate(LADDER)],
|
||
records=[dict(name=r['name'], offset=r['offset'], length=r['length'],
|
||
src=r['src'], how=r['how'], ci=r['ci'], dark=r['dark'],
|
||
scale=r['scale'], colors=r['colors'], fixed=r['fixed'],
|
||
pad=r['pad'], enc=r['enc'], target_ci=r['target_ci'],
|
||
csize=r['csize']) for r in records],
|
||
kept_stock=[dict(n=n, csize=c, name=slots[n][0]) for n, c in kept],
|
||
degraded=[dict(n=n, csize=c, from_ci=a, to_ci=b, how=h) for n, c, a, b, h in degrade])
|
||
json.dump(manifest, open(os.path.join(OUTDIR, 'manifest.json'), 'w', encoding='utf-8'),
|
||
indent=1, ensure_ascii=False)
|
||
|
||
# ---- 汇总 ----
|
||
print('\n阶梯使用情况（颜色数, 缩放, 暗部 -> 帧数）：')
|
||
used = {}
|
||
for r in records:
|
||
if r['ci'] is None:
|
||
continue
|
||
k2 = (r['colors'], r['scale'], r['dark'])
|
||
used[k2] = used.get(k2, 0) + 1
|
||
for kk, v in sorted(used.items(), key=lambda kv: (-kv[0][1], -kv[0][0])):
|
||
print(' %3d 色 缩放%.2f 暗部<%d -> %3d 帧' % (kk[0], kk[1], kk[2], v))
|
||
print(' 保留原厂：%d 帧 %s' % (len(kept), [n for n, _ in kept]))
|
||
print(' 平滑目标档放不下、被迫退档：%d 帧 %s'
|
||
% (len(degrade), [(n, h) for n, _c, _a, _b, h in degrade][:8]))
|
||
pads = [p[3] for p in stat]
|
||
print(' 槽位填充：实际用掉 %.1f%% 的 csize（填充 min %d / max %d / 平均 %.0f B，'
|
||
'全是合法空指令 00 00 / 80）'
|
||
% (100.0 * sum(p[2] for p in stat) / sum(p[1] for p in stat),
|
||
min(pads), max(pads), sum(pads) / len(pads)))
|
||
print(' 回解自证：正好 usize 且像素一致 %d / %d' % (decode_ok, len(records) - len(kept)))
|
||
|
||
# ---- 独立自证 ----
|
||
r2 = Romfs(PATCHED)
|
||
a = [(p, i.off, i.next, i.spec, i.size, i.cksum) for p, i in stock.entries()]
|
||
b = [(p, i.off, i.next, i.spec, i.size, i.cksum) for p, i in r2.entries()]
|
||
print('\ninode 表逐位不变：%s（%d 条）' % (a == b, len(a)))
|
||
print('superblock 一致：%s（size %d / cksum %08x）' % (
|
||
stock.sb_size == r2.sb_size and stock.sb_cksum == r2.sb_cksum,
|
||
r2.sb_size, r2.sb_cksum))
|
||
print('镜像长度一致：%s（%d B）' % (len(stock.data) == len(r2.data), len(r2.data)))
|
||
sh = open(PATCHED, 'rb').read()
|
||
replay = all(sh[r['offset']:r['offset'] + r['length']] == r['data'] for r in records)
|
||
print('回放（改后镜像 == 计划字节）：%s' % replay)
|
||
lens_ok = all(r['length'] == len(slots[int(r['name'].rsplit('_', 1)[1])][2]) for r in records)
|
||
print('每条负载长度 == 原槽位长度：%s' % lens_ok)
|
||
print('\n负载合计 %.2f MB；耗时 %.0fs；写出 %s'
|
||
% (sum(r['length'] for r in records) / 1048576, time.time() - t0,
|
||
os.path.join(OUTDIR, 'manifest.json')))
|
||
return manifest
|
||
|
||
|
||
if __name__ == '__main__':
|
||
only = sys.argv[1] if len(sys.argv) > 1 else 'all'
|
||
if only not in ('all', 'replace', 'restore'):
|
||
raise SystemExit('用法: s5e_anim.py [all|replace|restore]')
|
||
build()
|